Proposed resolution:

This wording is relative to N4958.

1. Modify [expected.object.monadic] as indicated:

   [Drafting note: Effectively replace all occurrences of **this by val, except for decltype.]

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

   -1- Let U be remove_cvref_t<invoke_result_t<F, decltype(**this(val))>>.

   -2- […]

   -3- […]

   -4- Effects: Equivalent to:

   if (has_value())
     return invoke(std::forward<F>(f), **thisval);
   else
     return U(unexpect, error());
   

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

   -5- Let U be remove_cvref_t<invoke_result_t<F, decltype((std::move(**thisval))>>.

   -6- […]

   -7- […]

   -8- Effects: Equivalent to:

   if (has_value())
     return invoke(std::forward<F>(f), std::move(**thisval));
   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 &;
   

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

   -10- Constraints: is_constructible_v<T, decltype(**this(val))> is true.

   -11- […]

   -12- Effects: Equivalent to:

   if (has_value())
     return G(in_place, **thisval);
   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 &&;
   

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

   -14- Constraints: is_constructible_v<T, decltype(std::move(**thisval))> is true.

   -15- […]

   -16- Effects: Equivalent to:

   if (has_value())
     return G(in_place, std::move(**thisval));
   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 &;
   

   -17- Let U be remove_cvref_t<invoke_result_t<F, decltype(**this(val))>>.

   -18- […]

   -19- 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), **thisval));
   

   is well-formed.

   -20- Effects:

   1. (20.1) — […]

   2. (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), **thisval).

   3. (20.3) — Otherwise, evaluates invoke(std::forward<F>(f), **thisval) and then returns expected<U, E>().

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

   -21- Let U be remove_cvref_t<invoke_result_t<F, decltype(std::move(**thisval))>>.

   -22- […]

   -23- 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(**thisval)));
   

   is well-formed.

   -24- Effects:

   1. (24.1) — […]

   2. (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(**thisval)).

   3. (24.3) — Otherwise, evaluates invoke(std::forward<F>(f), std::move(**thisval)) 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 &;
   

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

   -26- Constraints: is_constructible_v<T, decltype(**this(val))> is true.

   -27- Mandates: […]

   -28- Returns: If has_value() is true, expected<T, G>(in_place, **thisval); 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 &&;
   

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

   -30- Constraints: is_constructible_v<T, decltype(std::move(**thisval))> is true.

   -31- Mandates: […]

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

2. Modify [optional.monadic] as indicated:

   [Drafting note: Effectively replace all occurrences of value() by *val.]

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

   -1- Let U be invoke_result_t<F, decltype(value()*val)>.

   -2- […]

   -3- Effects: Equivalent to:

   if (*this) {
     return invoke(std::forward<F>(f), value()*val);
   } else {
     return remove_cvref_t<U>();
   }
   

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

   -4- Let U be invoke_result_t<F, decltype(std::move(value()*val))>.

   -5- […]

   -6- Effects: Equivalent to:

   if (*this) {
     return invoke(std::forward<F>(f), std::move(value()*val));
   } else {
     return remove_cvref_t<U>();
   }
   

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

   -7- Let U be remove_cv_t<invoke_result_t<F, decltype(value()*val)>>.

   -8- Mandates: U is a non-array object type other than in_place_t or nullopt_t. The declaration

   U u(invoke(std::forward<F>(f), value()*val));
   

   is well-formed for some invented variable u.

   […]

   -9- Returns: If *this contains a value, an optional<U> object whose contained value is direct-non-list-initialized with invoke(std::forward<F>(f), value()*val); otherwise, optional<U>().

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

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

   -11- Mandates: U is a non-array object type other than in_place_t or nullopt_t. The declaration

   U u(invoke(std::forward<F>(f), std::move(value()*val)));
   

   is well-formed for some invented variable u.

   […]

   -12- Returns: If *this contains a value, an optional<U> object whose contained value is direct-non-list-initialized with invoke(std::forward<F>(f), std::move(value()*val)); otherwise, optional<U>().

[ 2023-11-11 Approved at November 2023 meeting in Kona. Status changed: Voting → WP. ]

[ 2023-10-30; Reflector poll ]

Set status to Tentatively Ready after five votes in favour during reflector poll.

[ 2023-09-19; Wording update ]

Several people preferred to replace operator*() by the corresponding union members, so this part of the proposed wording has been adjusted, which is a rather mechanical replacement.

LWG 3938 switched to use **this to access the value stored in std::expected. However, as shown in LWG 3969, **this can trigger ADL and find an unwanted overload, and thus may caused unintended behavior.

Current implementations behave correctly (Godbolt link): they don't direct use **this, but use the name of the union member instead.

Moreover, P2407R5 will change the monadic operations of std::optional to use **this, which is also problematic.