C++20 and C++23 Highlights

C++20 language features

• Concepts
• Ranges
• Coroutines
• consteval, constinit
• Designated initializers
• Three-way comparison (<=>)
• Modules

Fast interpretation

• concepts: make template requirements explicit
• ranges: compose sequence operations lazily
• coroutines: suspend and resume async or generator workflows
• <=>: default comparison for value types
• modules: improve build boundaries beyond textual includes

C++20 library features

• std::span
• std::jthread
• std::format
• std::source_location
• Calendar and timezone library

void process(std::span<const int> values);
std::jthread worker([](std::stop_token) {});
auto line = std::format("value = {}", 42);

C++23 highlights

• std::expected
• std::print
• std::mdspan
• Monadic helpers for std::optional
• More ranges adaptors and views

These additions continue the same direction: stronger vocabulary types, better formatting, and more expressive range composition.

Example: concepts

template <typename T>
concept Incrementable = requires(T x) {
    ++x;
};

Example: std::span

void process(std::span<const int> values);

Adoption advice

• Prefer features that improve readability first.
• Introduce concepts, std::span, and ranges early.
• Adopt modules only when your toolchain and build system support them well.

Good first upgrades for existing code

• pointer-plus-size APIs -> std::span
• status code plus out parameter -> std::expected
• raw std::thread ownership -> std::jthread
• repetitive stream formatting -> std::format

Error-handling vocabulary types

std::optional<int> maybe_port;
std::variant<int, std::string> result;
std::expected<std::string, Error> loaded_name;

• std::optional<T>: a value may be absent.
• std::variant<...>: one of several closed alternatives.
• std::expected<T, E>: either a value or a typed error.

std::expected<int, std::string> parse_port(std::string_view text);

Modules and coroutines in one glance

export module math;
export int add(int a, int b) { return a + b; }

task<int> compute() {
    co_return 42;
}

• Modules reduce header parsing and can improve build hygiene.
• Coroutines help express async flows and generators, but usually need library support around the raw language machinery.

Quick rollout order

1. std::span, std::string_view, [[nodiscard]]
2. concepts, ranges, std::format
3. std::jthread, std::expected
4. modules and coroutines when tooling is ready

Fast wins for real codebases

• Adopt [[nodiscard]] for error-prone APIs.
• Use <=> for value objects with natural ordering.
• Prefer std::span, std::string_view, std::expected, and std::jthread in new code when they match the design.