Standard library header  (C++23) (original) (raw)

This header is part of the general utility library.

[edit] Synopsis

// mostly freestanding namespace std { // class template unexpected template class unexpected;   // class template bad_expected_access template class bad_expected_access;   // specialization for void template<> class bad_expected_access;   // in-place construction of unexpected values struct unexpect_t { explicit unexpect_t() = default; }; inline constexpr unexpect_t unexpect{};   // class template expected template<class T, class E> class expected; // partially freestanding   // partial specialization of expected for void types template<class T, class E> requires is_void_v class expected<T, E>; // partially freestanding }

[edit] Class template std::unexpected

namespace std { template class unexpected { public: // constructors constexpr unexpected(const unexpected&) = default; constexpr unexpected(unexpected&&) = default; template constexpr explicit unexpected(Err&&); template<class... Args> constexpr explicit unexpected(in_place_t, Args&&...); template<class U, class... Args> constexpr explicit unexpected(in_place_t, initializer_list, Args&&...);   constexpr unexpected& operator=(const unexpected&) = default; constexpr unexpected& operator=(unexpected&&) = default;   constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept;   constexpr void swap(unexpected& other) noexcept(/* see description */);   template friend constexpr bool operator==(const unexpected&, const unexpected&);   friend constexpr void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y)));   private: E /unex/; // exposition-only };   template unexpected(E) -> unexpected; }

[edit] Class template std::bad_expected_access

namespace std { template class bad_expected_access : public bad_expected_access { public: constexpr explicit bad_expected_access(E); constexpr const char* what() const noexcept override; constexpr E& error() & noexcept; constexpr const E& error() const& noexcept; constexpr E&& error() && noexcept; constexpr const E&& error() const&& noexcept;   private: E /unex/; // exposition-only }; }

[edit] Class template specialization std::bad_expected_access

namespace std { template<> class bad_expected_access : public exception { protected: constexpr bad_expected_access() noexcept; constexpr bad_expected_access(const bad_expected_access&) noexcept; constexpr bad_expected_access(bad_expected_access&&) noexcept; constexpr bad_expected_access& operator=(const bad_expected_access&) noexcept; constexpr bad_expected_access& operator=(bad_expected_access&&) noexcept; constexpr ~bad_expected_access();   public: constexpr const char* what() const noexcept override; }; }

[edit] Class template std::expected

namespace std { template<class T, class E> class expected { public: using value_type = T; using error_type = E; using unexpected_type = unexpected;   template using rebind = expected<U, error_type>;   // constructors constexpr expected(); constexpr expected(const expected&); constexpr expected(expected&&) noexcept(/* see description /); template<class U, class G> constexpr explicit(/ see description /) expected(const expected<U, G>&); template<class U, class G> constexpr explicit(/ see description /) expected(expected<U, G>&&);   template<class U = remove_cv_t> constexpr explicit(/ see description /) expected(U&& v);   template constexpr explicit(/ see description /) expected(const unexpected&); template constexpr explicit(/ see description /) expected(unexpected&&);   template<class... Args> constexpr explicit expected(in_place_t, Args&&...); template<class U, class... Args> constexpr explicit expected(in_place_t, initializer_list, Args&&...); template<class... Args> constexpr explicit expected(unexpect_t, Args&&...); template<class U, class... Args> constexpr explicit expected(unexpect_t, initializer_list, Args&&...);   // destructor constexpr ~expected();   // assignment constexpr expected& operator=(const expected&); constexpr expected& operator=(expected&&) noexcept(/ see description /); template<class U = remove_cv_t> constexpr expected& operator=(U&&); template constexpr expected& operator=(const unexpected&); template constexpr expected& operator=(unexpected&&);   template<class... Args> constexpr T& emplace(Args&&...) noexcept; template<class U, class... Args> constexpr T& emplace(initializer_list, Args&&...) noexcept;   // swap constexpr void swap(expected&) noexcept(/ see description /); friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y)));   // observers constexpr const T operator->() const noexcept; constexpr T* operator->() noexcept; constexpr const T& operator*() const& noexcept; constexpr T& operator*() & noexcept; constexpr const T&& operator*() const&& noexcept; constexpr T&& operator*() && noexcept; constexpr explicit operator bool() const noexcept; constexpr bool has_value() const noexcept; constexpr const T& value() const&; // freestanding-deleted constexpr T& value() &; // freestanding-deleted constexpr const T&& value() const&&; // freestanding-deleted constexpr T&& value() &&; // freestanding-deleted constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept; template<class U = remove_cv_t> constexpr T value_or(U&&) const&; template<class U = remove_cv_t> constexpr T value_or(U&&) &&; template constexpr E error_or(G&&) const&; template constexpr E error_or(G&&) &&;   // monadic operations template constexpr auto and_then(F&& f) &; template constexpr auto and_then(F&& f) &&; template constexpr auto and_then(F&& f) const&; template constexpr auto and_then(F&& f) const&&; template constexpr auto or_else(F&& f) &; template constexpr auto or_else(F&& f) &&; template constexpr auto or_else(F&& f) const&; template constexpr auto or_else(F&& f) const&&; template constexpr auto transform(F&& f) &; template constexpr auto transform(F&& f) &&; template constexpr auto transform(F&& f) const&; template constexpr auto transform(F&& f) const&&; template constexpr auto transform_error(F&& f) &; template constexpr auto transform_error(F&& f) &&; template constexpr auto transform_error(F&& f) const&; template constexpr auto transform_error(F&& f) const&&;   // equality operators template<class T2, class E2> requires(!is_void_v) friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y); template friend constexpr bool operator==(const expected&, const T2&); template friend constexpr bool operator==(const expected&, const unexpected&);   private: bool /has-val/; // exposition-only union { T /val/; // exposition-only E /unex/; // exposition-only }; }; }

[edit] Partial specialization of std::expected for void types

template<class T, class E> requires is_void_v class expected<T, E> { public: using value_type = T; using error_type = E; using unexpected_type = unexpected;   template using rebind = expected<U, error_type>;   // constructors constexpr expected() noexcept; constexpr expected(const expected&); constexpr expected(expected&&) noexcept(/* see description /); template<class U, class G> constexpr explicit(/ see description /) expected(const expected<U, G>&); template<class U, class G> constexpr explicit(/ see description /) expected(expected<U, G>&&);   template constexpr explicit(/ see description /) expected(const unexpected&); template constexpr explicit(/ see description /) expected(unexpected&&);   constexpr explicit expected(in_place_t) noexcept; template<class... Args> constexpr explicit expected(unexpect_t, Args&&...); template<class U, class... Args> constexpr explicit expected(unexpect_t, initializer_list, Args&&...);   // destructor constexpr ~expected();   // assignment constexpr expected& operator=(const expected&); constexpr expected& operator=(expected&&) noexcept(/ see description /); template constexpr expected& operator=(const unexpected&); template constexpr expected& operator=(unexpected&&); constexpr void emplace() noexcept;   // swap constexpr void swap(expected&) noexcept(/ see description /); friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y)));   // observers constexpr explicit operator bool() const noexcept; constexpr bool has_value() const noexcept; constexpr void operator() const noexcept; constexpr void value() const&; // freestanding-deleted constexpr void value() &&; // freestanding-deleted constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept; template constexpr E error_or(G&&) const&; template constexpr E error_or(G&&) &&;   // monadic operations template constexpr auto and_then(F&& f) &; template constexpr auto and_then(F&& f) &&; template constexpr auto and_then(F&& f) const&; template constexpr auto and_then(F&& f) const&&; template constexpr auto or_else(F&& f) &; template constexpr auto or_else(F&& f) &&; template constexpr auto or_else(F&& f) const&; template constexpr auto or_else(F&& f) const&&; template constexpr auto transform(F&& f) &; template constexpr auto transform(F&& f) &&; template constexpr auto transform(F&& f) const&; template constexpr auto transform(F&& f) const&&; template constexpr auto transform_error(F&& f) &; template constexpr auto transform_error(F&& f) &&; template constexpr auto transform_error(F&& f) const&; template constexpr auto transform_error(F&& f) const&&;   // equality operators template<class T2, class E2> requires is_void_v friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y); template friend constexpr bool operator==(const expected&, const unexpected&);   private: bool /has-val/; // exposition-only union { E /unex/; // exposition-only }; };