# expected<T, E...>

## Synopsis

    // unexpected_

    template<class... E> using unexpected_ = variant<E...>;

    // bad_expected_access

    template<class E = void> class bad_expected_access;

    template<> class bad_expected_access<void>: public std::exception
    {
    public:

        bad_expected_access() noexcept;
        char const * what() const noexcept;
    };

    template<class E> class bad_expected_access: public bad_expected_access<void>
    {
    public:

        explicit bad_expected_access( E const& e );
        E error() const;
    };

    // throw_on_unexpected

    template<class E> void throw_on_unexpected( E const& e );
    void throw_on_unexpected( std::error_code const& e );
    void throw_on_unexpected( std::exception_ptr const& e );

    // expected

    template<class T, class... E> class expected
    {
    public:

        // value constructors

        constexpr expected() noexcept( /*see below*/ );

        constexpr expected( T const& t ) noexcept( /*see below*/ );
        constexpr expected( T&& t ) noexcept( /*see below*/ );

        // unexpected constructor

        template<class... E2>
        constexpr expected( unexpected_<E2...> const& x );

        template<class... E2>
        constexpr expected( unexpected_<E2...>&& x );

        // conversion constructor

        template<class... E2>
        constexpr expected( expected<T, E2...> const& x );

        template<class... E2>
        constexpr expected( expected<T, E2...>&& x );

        // emplace

        template<class... A> void emplace( A&&... a );
        template<class V, class... A> void emplace( std::initializer_list<V> il, A&&... a );

        // swap

        void swap( expected& r ) noexcept( /*see below*/ );

        // value queries

        constexpr bool has_value() const noexcept;
        constexpr explicit operator bool() const noexcept;

        // checked value access

        constexpr T& value() &;
        constexpr T const& value() const&;
        constexpr T&& value() &&;
        constexpr T const&& value() const&&;

        // unchecked value access

        T* operator->() noexcept;
        T const* operator->() const noexcept;

        T& operator*() & noexcept;
        T const& operator*() const & noexcept;
        T&& operator*() && noexcept;
        T const&& operator*() const && noexcept;

        // error queries

        template<class E2> constexpr bool has_error() const noexcept;
        constexpr bool has_error() const noexcept;

        // error access

        unexpected_<E...> unexpected() const;

        template<class E2> constexpr E2 error() const noexcept;
        constexpr /*see below*/ error() const noexcept;

        // error mapping

        template<class F> /*see below*/ remap_errors( F&& f ) const;
        expected<T, std::error_code> remap_errors() const;

        // then

        template<class F> /*see below*/ operator>>( F&& f ) const;
    };

    template<class T, class... E>
    inline constexpr bool operator==( expected<T, E...> const& x1, expected<T, E...> const& x2 );
    
    template<class T, class... E>
    inline constexpr bool operator!=( expected<T, E...> const& x1, expected<T, E...> const& x2 );

    template<class T, class... E>
    inline void swap( expected<T, E...>& x1, expected<T, E...>& x2 ) noexcept( /*see below*/ );

    // is_expected

    template<class T> struct is_expected;

    } // namespace variant2
    } // namespace boost

## Reference

...