[expected.void.monadic]

🔗

template<class F> constexpr auto and_then(F&& f) &;
template<class F> constexpr auto and_then(F&& f) const &;

Mandates: U is a specialization of expected and is_same_v<typename U::error_type, E> is true.

Effects: Equivalent to: if (has_value() return invoke(std::forward<F>(f)); else return U(unexpect, error();

🔗

template<class F> constexpr auto and_then(F&& f) &&;
template<class F> constexpr auto and_then(F&& f) const &&;

Mandates: U is a specialization of expected and is_same_v<typename U::error_type, E> is true.

Effects: Equivalent to: if (has_value() return invoke(std::forward<F>(f)); else return U(unexpect, std::move(error();

🔗

template<class F> constexpr auto or_else(F&& f) &;
template<class F> constexpr auto or_else(F&& f) const &;

Mandates: G is a specialization of expected and is_same_v<typename G::value_type, T> is true.

Effects: Equivalent to: if (has_value() return G(); else return invoke(std::forward<F>(f), error();

🔗

template<class F> constexpr auto or_else(F&& f) &&;
template<class F> constexpr auto or_else(F&& f) const &&;

Let G be remove_cvref_t<invoke_result_t<F, decltype(std::move(error()>.

Mandates: G is a specialization of expected and is_same_v<typename G::value_type, T> is true.

Effects: Equivalent to: if (has_value() return G(); else return invoke(std::forward<F>(f), std::move(error();

🔗

template<class F> constexpr auto transform(F&& f) &;
template<class F> constexpr auto transform(F&& f) const &;

Mandates: U is a valid value type for expected.

If is_void_v<U> is false, the declaration U u(invoke(std::forward<F>(f)); is well-formed.

Effects:

(18.1)
If has_value() is false, returns expected<U, E>(unexpect, error().
(18.2)
Otherwise, if is_void_v<U> is false, returns an expected<U, E> object whose has_val member is true and val member is direct-non-list-initialized with invoke(std::forward<F>(f)).
(18.3)
Otherwise, evaluates invoke(std::forward<F>(f)) and then returns expected<U, E>().

🔗

template<class F> constexpr auto transform(F&& f) &&;
template<class F> constexpr auto transform(F&& f) const &&;

Mandates: U is a valid value type for expected.

If is_void_v<U> is false, the declaration U u(invoke(std::forward<F>(f)); is well-formed.

Effects:

(22.1)
If has_value() is false, returns expected<U, E>(unexpect, std::move(error().
(22.2)
Otherwise, if is_void_v<U> is false, returns an expected<U, E> object whose has_val member is true and val member is direct-non-list-initialized with invoke(std::forward<F>(f)).
(22.3)
Otherwise, evaluates invoke(std::forward<F>(f)) and then returns expected<U, E>().

🔗

template<class F> constexpr auto transform_error(F&& f) &;
template<class F> constexpr auto transform_error(F&& f) const &;

Mandates: G is a valid template argument for unexpected ([expected.un.general]) and the declaration G g(invoke(std::forward<F>(f), error(); is well-formed.

Returns: If has_value() is true, expected<T, G>(); otherwise, an expected<T, G> object whose has_val member is false and unex member is direct-non-list-initialized with invoke(std::forward<F>(f), error().

🔗

template<class F> constexpr auto transform_error(F&& f) &&;
template<class F> constexpr auto transform_error(F&& f) const &&;

Let G be remove_cv_t<invoke_result_t<F, decltype(std::move(error()>.

Mandates: G is a valid template argument for unexpected ([expected.un.general]) and the declaration G g(invoke(std::forward<F>(f), std::move(error(); is well-formed.

22 General utilities library [utilities]

22.8 Expected objects [expected]

22.8.7 Partial specialization of expected for void types [expected.void]

22.8.7.7 Monadic operations [expected.void.monadic]