22 General utilities library [utilities]

22.8 Expected objects [expected]

22.8.6 Class template expected [expected.expected]

22.8.6.7 Monadic operations [expected.object.monadic]

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

Let U be remove_cvref_t<invoke_result_t<F, decltype(value())>>.

Constraints: is_constructible_v<E, decltype(error())> is true.

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

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

🔗

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

Let U be remove_cvref_t<invoke_result_t<F, decltype(std::move(value()))>>.

Constraints: is_constructible_v<E, decltype(std::move(error()))> is true.

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

Effects: Equivalent to: if (has_value()) return invoke(std::forward<F>(f), std::move(value())); 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 &;

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

Constraints: is_constructible_v<T, decltype(value())> is true.

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

Effects: Equivalent to: if (has_value()) return G(in_place, value()); 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()))>>.

Constraints: is_constructible_v<T, decltype(std::move(value()))> is true.

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

Effects: Equivalent to: if (has_value()) return G(in_place, std::move(value())); 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 &;

Let U be remove_cv_t<invoke_result_t<F, decltype(value())>>.

Constraints: is_constructible_v<E, decltype(error())> is true.

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), value())); is well-formed.

Effects:

(20.1)
If has_value() is false, returns expected<U, E>(unexpect, error()).
(20.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), value()).
(20.3)
Otherwise, evaluates invoke(std::forward<F>(f), value()) and then returns expected<U, E>().

🔗

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

Let U be remove_cv_t<invoke_result_t<F, decltype(std::move(value()))>>.

Constraints: is_constructible_v<E, decltype(std::move(error()))> is true.

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), std::move(value()))); is well-formed for some invented variable u.

Effects:

(24.1)
If has_value() is false, returns expected<U, E>(unexpect, std::move(error())).
(24.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), std::move(value())).
(24.3)
Otherwise, evaluates invoke(std::forward<F>(f), std::move(value())) 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 &;

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

Constraints: is_constructible_v<T, decltype(value())> is true.

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>(in_place, value()); 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()))>>.

Constraints: is_constructible_v<T, decltype(std::move(value()))> is true.

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.

Returns: If has_value() is true, expected<T, G>(in_place, std::move(value())); 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), std::move(error())).