std::expected

std::expected<T, E> — тип, хранящий либо успешное значение типа T, либо ошибку типа E, с явной проверкой, что именно там лежит, через has_value(). В отличие от std::optional<T>, который просто говорит "значения нет", expected несёт содержательную информацию о том, почему значения нет — код ошибки, сообщение, произвольный тип.A std::expected<T, E> holds either a successful value of type T or an error of type E, with explicit checking of which one is there via has_value(). Unlike std::optional<T>, which simply says "there's no value," expected carries meaningful information about why there's no value — an error code, a message, an arbitrary type.

double parse_price(std::string_view s) {
    if (s.empty()) throw std::invalid_argument("empty");
    return std::stod(std::string(s));
}
// вызывающий код обязан знать про throw — не видно в сигнатуре// the caller must know about the throw — invisible in the signature

std::expected<double, std::string> parse_price(std::string_view s) {
    if (s.empty()) return std::unexpected("empty");
    return std::stod(std::string(s));
}
// сигнатура сама говорит: может не получиться, вот тип ошибки// the signature itself says: this can fail, here's the error type

Ни исключения, ни существующие до C++23 механизмы не покрывали весь спектр реальных сценариев ошибок:Neither exceptions nor the mechanisms available before C++23 covered the full range of real-world error scenarios:

std::expected<T, E> устроен похоже на std::variant<T, E> — хранит один из двух вариантов в общей области памяти (обычно union-подобно, без дополнительной аллокации кучи для не слишком больших T/E) плюс флаг, какой из вариантов активен. Конструируется из T напрямую (успех) или из std::unexpected(e) — обёртки, явно маркирующей "это ошибка, не значение".A std::expected<T, E> is built similarly to std::variant<T, E> — it stores one of the two alternatives in a shared memory region (typically union-like, with no extra heap allocation for reasonably-sized T/E) plus a flag for which alternative is active. It's constructed from a T directly (success) or from std::unexpected(e) — a wrapper explicitly marking "this is an error, not a value".

std::expected<int, std::string> parse_int(std::string_view s) {
    int value;
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value);
    if (ec != std::errc{}) {
        return std::unexpected(std::format("bad number: {}", s));  // ошибка// error
    }
    return value;  // успех — неявное построение из T// success — implicit construction from T
}

auto result = parse_int("42");
if (result.has_value()) { use(*result); }        // operator* — доступ к значению// operator* — access the value
else                    { log(result.error()); }   // .error() — доступ к ошибке// .error() — access the error

Ключевая особенность API — монадические методы для композиции цепочек операций без ручного разбора каждого промежуточного результата: .and_then(f) (продолжить, только если успех, f сама возвращает expected), .transform(f) (применить f к значению, если успех, обернуть результат обратно в expected), .or_else(f) (обработать ошибку, вернуться к успеху или пробросить другую ошибку), .transform_error(f) (преобразовать тип/содержимое ошибки).A key part of the API is a set of monadic methods for composing chains of operations without manually unpacking every intermediate result: .and_then(f) (continue only on success, f itself returns an expected), .transform(f) (apply f to the value on success, wrap the result back into an expected), .or_else(f) (handle the error, recover to success or propagate a different error), .transform_error(f) (convert the error's type/content).

// цепочка из трёх операций, каждая может вернуть ошибку —// a chain of three operations, each of which may fail —
// без единой ручной проверки has_value() между шагами:// with not a single manual has_value() check between steps:
auto result = parse_int(input)
    .and_then(validate_range)      // int -> expected<int, string>// int -> expected<int, string>
    .transform([](int x) { return x * 2; })  // int -> int, обёртка в expected автоматическая// int -> int, wrapping into expected is automatic
    .or_else([](const std::string& e) { return fallback_value(e); });

• cppreference — std::expected
• WG21 P0323 — std::expected