[libc++] Implement LWG3938 (Cannot use std::expected monadic ops with move-only error_type)

[yronglin]

Summary

Implement LWG3938 (Cannot use std::expected monadic ops with move-only error_type)
https://wg21.link/LWG3938

[Mordante]

Thanks for working on this! A few comments.

libcxx/docs/ReleaseNotes.rst

50 ↗

(On Diff #535886)

We typically don't mention LWG issues in our release notes, unless they have a huge impact.

libcxx/include/__expected/expected.h

705

Can you update this to the Standard wording too? the same for the other places.

761

Please update this one too.

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

7

Please update the or_else and transform test too.

142

Can you make a separate MoveOnly class instead.

[yronglin]

Thanks for your review! @Mordante

libcxx/docs/ReleaseNotes.rst

50 ↗

(On Diff #535886)

Thanks for your tips, I'll remove that.

libcxx/include/__expected/expected.h

705

I tried to keep the same with the std wording, but it compile failed:

error: invalid use of 'this' outside of a non-static member function
  694 |     requires is_constructible_v<_Tp, decltype(**this)>
      |                                                 ^

705

As we talked in discord:

1. *this always produces an LValue

template <class _Func>
  requires is_constructible_v<_Err, const _Err&&>
_LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
  static_assert(std::is_same_v<decltype(*this), const std::expected<_Tp, _Err>&&>);
  static_assert(std::is_same_v<decltype(**this), const _Tp&&>);
  using _Up = remove_cvref_t<invoke_result_t<_Func, decltype(**this)>>;
  static_assert(
      __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
  static_assert(is_same_v<typename _Up::error_type, _Err>,
                "The result of f(std::move(value())) must have the same error_type as this expected");
  if (has_value()) {
    return std::invoke(std::forward<_Func>(__f), std::move(**this));
  }
  return _Up(unexpect, std::move(error()));
}

the two static_assert fails:

static_assert(std::is_same_v<decltype(*this), const std::expected<_Tp, _Err>&&>);
static_assert(std::is_same_v<decltype(**this), const _Tp&&>);

when and_then called by:

#include <expected>
#include <cassert>

struct UnexpectedCRVal {
  std::expected<int, int> operator()(int&)       = delete;
  std::expected<int, int> operator()(const int&) = delete;
  std::expected<int, int> operator()(int&&)      = delete;
  constexpr std::expected<int, int> operator()(const int&&) { return std::expected<int, int>(std::unexpected<int>(5)); }
};

int main() {
    const std::expected<int, int> e{0};
    assert(std::move(e).and_then(UnexpectedCRVal{}).error() == 5);
    return 0;
}

The reason is that: *this always produces an Lvalue http://eel.is/c++draft/expr.unary.op#1.sentence-3 , so the type of decltype(**this) is const _Tp & but not const _Tp &&

2. we can use no-static member function in constraints

std wording: Constraints: is_constructible_v<E, decltype(std​::​move(error()))> is true.
we can't use decltype(std​::​move(error())) outside a non-static member function, and we use const _Err&& as a workaround before.
Also is_constructible_v<decltype(**this)> in constraints has the same issue:

error: invalid use of 'this' outside of a non-static member function
  694 |     requires is_constructible_v<_Tp, decltype(**this)>
          |

[yronglin]

Address comments:

1. Add more tests.
2. Undo the change of ReleaseNotes.rst

[yronglin]

libcxx/include/__expected/expected.h

705

Nit:s/discord/Discord

[yronglin]

Fix ci.

[yronglin]

@Mordante Can we propose to use __union_.__val_, std::as_const(__union_.__val_), std::move(__union_.__val_) and std::move(std::as_const(__union_.__val_)) instead of **this ?

[yronglin]

@Mordante ping~

[yronglin]

This comment was removed by yronglin.

[frederick-vs-ja]

In D154116#4490038, @yronglin wrote:

@Mordante Can we propose to use __union_.__val_, std::as_const(__union_.__val_), std::move(__union_.__val_) and std::move(std::as_const(__union_.__val_)) instead of **this ?

std::as_const is unnecessary because the const on the member functions already makes __union_.__val_ a const lvalue.

I think it's better to use the member access expressions instead of **this, because the latter can be ADL-hijacked. (However, this means the current standard wording is less than ideal and an LWG issue may be needed, see also LWG3969).

libcxx/include/__expected/expected.h

654

It might be better to update the messages in static_assert (also occurs below; I originally suggested here.).

[yronglin]

Address comments

[yronglin]

In D154116#4612494, @frederick-vs-ja wrote:

In D154116#4490038, @yronglin wrote:

@Mordante Can we propose to use __union_.__val_, std::as_const(__union_.__val_), std::move(__union_.__val_) and std::move(std::as_const(__union_.__val_)) instead of **this ?

std::as_const is unnecessary because the const on the member functions already makes __union_.__val_ a const lvalue.

I think it's better to use the member access expressions instead of **this, because the latter can be ADL-hijacked. (However, this means the current standard wording is less than ideal and an LWG issue may be needed, see also LWG3969).

Thanks a lot for your review! I updated to use __union_.__val_. and also update the static_assert message. @Mordante WDYT?

libcxx/include/__expected/expected.h

654

fixed

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

7

fixed.

142

I have added a new MoveOnlyErrorType class

[ldionne]

libcxx/docs/Status/Cxx2cIssues.csv

17

I think this should be 18.0 now.

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

173

Here and for the other monadic operations, I think we should add runtime tests that use a move-only error type. Otherwise, if we had something like

if (error-is-move-only) {
  std::abort();
}

in the implementation of e.g. and_then, the current tests would pass but out implementation would obviously be incorrect. Generally speaking, static_assert tests are really nice in their negative form, to make sure that something is SFINAE friendly. However, just checking that things compile for a positive test is usually insufficient.

[yronglin]

Address comments

[yronglin]

Thanks for your review @ldionne

libcxx/docs/Status/Cxx2cIssues.csv

17

fixed

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

173

Thanks, I have add runtime test for each monadic operations.

[yronglin]

Thanks for the review! @ldionne

libcxx/docs/Status/Cxx2cIssues.csv

 "Issue #","Issue Name","Meeting","Status","First released version","Labels"
 "`2994 <https://wg21.link/LWG2994>`__","Needless UB for ``basic_string`` and ``basic_string_view``","Varna June 2023","|Complete|","5.0",""
 "`3884 <https://wg21.link/LWG3884>`__","``flat_foo`` is missing allocator-extended copy/move constructors","Varna June 2023","","","|flat_containers|"
 "`3885 <https://wg21.link/LWG3885>`__","``op`` should be in [zombie.names]","Varna June 2023","|Nothing To Do|","",""
 "`3887 <https://wg21.link/LWG3887>`__","Version macro for ``allocate_at_least``","Varna June 2023","","",""
 "`3893 <https://wg21.link/LWG3893>`__","LWG 3661 broke ``atomic<shared_ptr<T>> a; a = nullptr;``","Varna June 2023","","",""
 "`3894 <https://wg21.link/LWG3894>`__","``generator::promise_type::yield_value(ranges::elements_of<Rng, Alloc>)`` should not be ``noexcept``","Varna June 2023","","",""
 "`3903 <https://wg21.link/LWG3903>`__","span destructor is redundantly noexcept","Varna June 2023","|Complete|","7.0",""
 "`3904 <https://wg21.link/LWG3904>`__","``lazy_split_view::outer-iterator``'s const-converting constructor isn't setting ``trailing_empty_``","Varna June 2023","","","|ranges|"
 "`3905 <https://wg21.link/LWG3905>`__","Type of ``std::fexcept_t``","Varna June 2023","|Complete|","3.4",""
 "`3912 <https://wg21.link/LWG3912>`__","``enumerate_view::iterator::operator-`` should be ``noexcept``","Varna June 2023","","","|ranges|"
 "`3914 <https://wg21.link/LWG3914>`__","Inconsistent template-head of ``ranges::enumerate_view``","Varna June 2023","","","|ranges|"
 "`3915 <https://wg21.link/LWG3915>`__","Redundant paragraph about expression variations","Varna June 2023","","","|ranges|"
 "`3925 <https://wg21.link/LWG3925>`__","Concept ``formattable``'s definition is incorrect","Varna June 2023","|Complete|","17.0","|format|"
 "`3927 <https://wg21.link/LWG3927>`__","Unclear preconditions for ``operator[]`` for sequence containers","Varna June 2023","|Nothing To Do|","",""
 "`3935 <https://wg21.link/LWG3935>`__","``template<class X> constexpr complex& operator=(const complex<X>&)`` has no specification","Varna June 2023","|Complete|","3.4",""
-"`3938 <https://wg21.link/LWG3938>`__","Cannot use ``std::expected`` monadic ops with move-only ``error_type``","Varna June 2023","","",""
+"`3938 <https://wg21.link/LWG3938>`__","Cannot use ``std::expected`` monadic ops with move-only ``error_type``","Varna June 2023","|Complete|","18.0",""
 "`3940 <https://wg21.link/LWG3940>`__","``std::expected<void, E>::value()`` also needs ``E`` to be copy constructible","Varna June 2023","","",""
 "","","","","",""
 "`3343 <https://wg21.link/LWG3343>`__","Ordering of calls to ``unlock()`` and ``notify_all()`` in Effects element of ``notify_all_at_thread_exit()`` should be reversed","Not Yet Adopted","|Complete|","16.0",""
 "`3892 <https://wg21.link/LWG3892>`__","Incorrect formatting of nested ranges and tuples","Not Yet Adopted","|Complete|","17.0","|format|"
 "","","","","",""

libcxx/include/__expected/expected.h

_LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) && {
     return std::move(error());
   }
 
   // [expected.void.monadic], monadic
   template <class _Func>
     requires is_constructible_v<_Err, _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
     using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
-    static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(value()) must have the same error_type as this expected");
+                  "The result of f(**this) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), value());
+      return std::invoke(std::forward<_Func>(__f), __union_.__val_);
     }
     return _Up(unexpect, error());
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, const _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>;
-    static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(value()) must have the same error_type as this expected");
+                  "The result of f(**this) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), value());
+      return std::invoke(std::forward<_Func>(__f), __union_.__val_);
     }
     return _Up(unexpect, error());
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, _Err&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
     using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>;
     static_assert(
-        __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
+        __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(std::move(value())) must have the same error_type as this expected");
+                  "The result of f(std::move(**this)) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), std::move(value()));
+      return std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_));
     }
     return _Up(unexpect, std::move(error()));
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, const _Err&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>;
     static_assert(
-        __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
+        __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(std::move(value())) must have the same error_type as this expected");
+                  "The result of f(std::move(**this)) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), std::move(value()));
+      return std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_));
     }
     return _Up(unexpect, std::move(error()));
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, _Tp&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & {
     using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&>>;
     static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(error()) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, value());
+      return _Gp(in_place, __union_.__val_);
     }
     return std::invoke(std::forward<_Func>(__f), error());
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, const _Tp&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& {
     using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&>>;
     static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(error()) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, value());
+      return _Gp(in_place, __union_.__val_);
     }
     return std::invoke(std::forward<_Func>(__f), error());
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, _Tp&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && {
     using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&&>>;
     static_assert(
         __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(std::move(error())) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, std::move(value()));
+      return _Gp(in_place, std::move(__union_.__val_));
     }
     return std::invoke(std::forward<_Func>(__f), std::move(error()));
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, const _Tp&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& {
     using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>;
     static_assert(
         __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(std::move(error())) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, std::move(value()));
+      return _Gp(in_place, std::move(__union_.__val_));
     }
     return std::invoke(std::forward<_Func>(__f), std::move(error()));
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
     using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
     if (!has_value()) {
       return expected<_Up, _Err>(unexpect, error());
     }
     if constexpr (!is_void_v<_Up>) {
-      return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), value());
+      return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), __union_.__val_);
     } else {
-      std::invoke(std::forward<_Func>(__f), value());
+      std::invoke(std::forward<_Func>(__f), __union_.__val_);
       return expected<_Up, _Err>();
     }
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, const _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
     using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
     if (!has_value()) {
       return expected<_Up, _Err>(unexpect, error());
     }
     if constexpr (!is_void_v<_Up>) {
-      return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), value());
+      return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), __union_.__val_);
     } else {
-      std::invoke(std::forward<_Func>(__f), value());
+      std::invoke(std::forward<_Func>(__f), __union_.__val_);
       return expected<_Up, _Err>();
     }
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, _Err&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
     using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
     if (!has_value()) {
       return expected<_Up, _Err>(unexpect, std::move(error()));
     }
     if constexpr (!is_void_v<_Up>) {
       return expected<_Up, _Err>(
-          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(__union_.__val_));
     } else {
-      std::invoke(std::forward<_Func>(__f), std::move(value()));
+      std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_));
       return expected<_Up, _Err>();
     }
   }
 
   template <class _Func>
     requires is_constructible_v<_Err, const _Err&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
     using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
     if (!has_value()) {
       return expected<_Up, _Err>(unexpect, std::move(error()));
     }
     if constexpr (!is_void_v<_Up>) {
       return expected<_Up, _Err>(
-          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(__union_.__val_));
     } else {
-      std::invoke(std::forward<_Func>(__f), std::move(value()));
+      std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_));
       return expected<_Up, _Err>();
     }
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, _Tp&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & {
     using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&>>;
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(error()) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, value());
+      return expected<_Tp, _Gp>(in_place, __union_.__val_);
     }
     return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, const _Tp&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& {
     using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&>>;
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(error()) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, value());
+      return expected<_Tp, _Gp>(in_place, __union_.__val_);
     }
     return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, _Tp&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && {
     using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&&>>;
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(std::move(error())) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, std::move(value()));
+      return expected<_Tp, _Gp>(in_place, std::move(__union_.__val_));
     }
     return expected<_Tp, _Gp>(
         __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
   }
 
   template <class _Func>
     requires is_constructible_v<_Tp, const _Tp&&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& {
     using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&&>>;
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(std::move(error())) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, std::move(value()));
+      return expected<_Tp, _Gp>(in_place, std::move(__union_.__val_));
     }
     return expected<_Tp, _Gp>(
         __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
   }
 
   // [expected.object.eq], equality operators
   template <class _T2, class _E2>
     requires(!is_void_v<_T2>)

libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 // Test the mandates
 // template<class F> constexpr auto and_then(F&& f) &;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 // template<class F> constexpr auto and_then(F&& f) const &;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 // template<class F> constexpr auto and_then(F&& f) &&;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 // template<class F> constexpr auto and_then(F&& f) const &&;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 #include <expected>
 #include <utility>
 
 struct NotSameAsInt {};
 
 int lval_return_not_std_expected(int&) { return 0; }

 // clang-format off
 void test() {
   // Test & overload
   {
     // U is not a specialization of std::expected
     {
       std::expected<int, int> f1(1);
       f1.and_then(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(int &)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(**this) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
 
     // !std::is_same_v<U:error_type, E>
     {
       std::expected<int, int> f1(1);
       f1.and_then(lval_error_type_not_same_as_int);  // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(int &)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(**this) must have the same error_type as this expected}}
     }
   }
 
   // Test const& overload
   {
     // U is not a specialization of std::expected
     {
       const std::expected<int, int> f1(1);
       f1.and_then(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(const int &)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(**this) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
 
     // !std::is_same_v<U:error_type, E>
     {
       const std::expected<int, int> f1(1);
       f1.and_then(clval_error_type_not_same_as_int);  // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(const int &)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(**this) must have the same error_type as this expected}}
 
     }
   }
 
   // Test && overload
   {
     // U is not a specialization of std::expected
     {
       std::expected<int, int> f1(1);
       std::move(f1).and_then(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(int &&)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(**this)) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
 
     // !std::is_same_v<U:error_type, E>
     {
       std::expected<int, int> f1(1);
       std::move(f1).and_then(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(int &&)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(**this)) must have the same error_type as this expected}}
     }
   }
 
   // Test const&& overload
   {
     // U is not a specialization of std::expected
     {
       const std::expected<int, int> f1(1);
       std::move(f1).and_then(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(const int &&)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(**this)) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
 
     // !std::is_same_v<U:error_type, E>
     {
       const std::expected<int, int> f1(1);
       std::move(f1).and_then(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(const int &&)>' requested here}}
-      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(**this)) must have the same error_type as this expected}}
     }
   }
 }
 // clang-format on

libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 // <expected>
 
 // template<class F> constexpr auto and_then(F&& f) &;
 // template<class F> constexpr auto and_then(F&& f) const &;
 // template<class F> constexpr auto and_then(F&& f) &&;
 // template<class F> constexpr auto and_then(F&& f) const &&;
 
 #include <cassert>
 #include <concepts>
 #include <expected>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
+#include "../../types.h"
+
 struct LVal {
   constexpr std::expected<int, int> operator()(int&) { return 1; }
   std::expected<int, int> operator()(const int&)  = delete;
   std::expected<int, int> operator()(int&&)       = delete;
   std::expected<int, int> operator()(const int&&) = delete;
 };
 
 struct CLVal {
struct UnexpectedRVCRefQual {
   std::expected<int, int> operator()(int) const& = delete;
   std::expected<int, int> operator()(int) &&     = delete;
   constexpr std::expected<int, int> operator()(int) const&& { return std::expected<int, int>(std::unexpected<int>(5)); }
 };
 
 struct NonCopyable {
   constexpr NonCopyable(int) {}
   NonCopyable(const NonCopyable&) = delete;
 };
 
 struct NonMovable {
   constexpr NonMovable(int) {}
   NonMovable(NonMovable&&) = delete;
 };
 
 struct NonConst {
   std::expected<int, int> non_const() { return 1; }
 };
 
 template <class E, class F>
 concept has_and_then = requires(E&& e, F&& f) {
   {std::forward<E>(e).and_then(std::forward<F>(f))};
 };
 
+// clang-format off
 static_assert( has_and_then<std::expected<int, int>&, std::expected<int, int>(int&)>);
 static_assert(!has_and_then<std::expected<int, NonCopyable>&, std::expected<int, NonCopyable>(int&)>);
 static_assert( has_and_then<const std::expected<int, int>&, std::expected<int, int>(const int&)>);
 static_assert(!has_and_then<const std::expected<int, NonCopyable>&, std::expected<int, NonCopyable>(const int&)>);
 static_assert( has_and_then<std::expected<int, int>&&, std::expected<int, int>(int)>);
 static_assert(!has_and_then<std::expected<int, NonMovable>&&, std::expected<int, NonMovable>(int)>);
 static_assert( has_and_then<const std::expected<int, int>&&, std::expected<int, int>(const int)>);
 static_assert(!has_and_then<const std::expected<int, NonMovable>&&, std::expected<int, NonMovable>(const int)>);
 
 // [LWG 3877] https://cplusplus.github.io/LWG/issue3877, check constraint failing but not compile error inside the function body.
 static_assert(!has_and_then<const std::expected<int, std::unique_ptr<int>>&, int()>);
 static_assert(!has_and_then<const std::expected<int, std::unique_ptr<int>>&&, int()>);
 
-// clang-format off
+// [LWG 3983] https://cplusplus.github.io/LWG/issue3938, check std::expected monadic ops well-formed with move-only error_type.
+// There are no effects for `&` and `const &` overload, because the constraints requires is_constructible_v<E, decltype(error())> is true.
+static_assert(has_and_then<std::expected<int, MoveOnlyErrorType>&&, std::expected<int, MoveOnlyErrorType>(int)>);
+static_assert(has_and_then<const std::expected<int, MoveOnlyErrorType>&&, std::expected<int, MoveOnlyErrorType>(const int)>);
+
 constexpr void test_val_types() {
   // Test & overload
   {
     // Without & qualifier on F's operator()
     {
       std::expected<int, int> e{0};
       std::same_as<std::expected<int, int>> decltype(auto) val = e.and_then(LVal{});
       assert(val == 1);

 // check that the lambda body is not instantiated during overload resolution
 constexpr void test_sfinae() {
   std::expected<NonConst, int> e(std::unexpected<int>(2));
   auto l = [](auto&& x) { return x.non_const(); };
   e.and_then(l);
   std::move(e).and_then(l);
 }
 
+constexpr void test_move_only_error_type() {
+  // Test &&
+  {
+    std::expected<int, MoveOnlyErrorType> e;
+    auto l = [](int) { return std::expected<int, MoveOnlyErrorType>{}; };
+    std::move(e).and_then(l);
+  }
+
+  // Test const&&
+  {
+    const std::expected<int, MoveOnlyErrorType> e;
+    auto l = [](const int) { return std::expected<int, MoveOnlyErrorType>{}; };
+    std::move(e).and_then(l);
+  }
+}
+
 constexpr bool test() {
   test_sfinae();
   test_val_types();
+  test_move_only_error_type();
 
   std::expected<int, int> e(std::unexpected<int>(1));
   const auto& ce = e;
 
   const auto never_called = [](int) {
     assert(false);
     return std::expected<int, int>();
   };

libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp

 
 #include <cassert>
 #include <concepts>
 #include <expected>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
+#include "../../types.h"
+
 struct LVal {
   constexpr std::expected<int, int> operator()(int&) { return 1; }
   std::expected<int, int> operator()(const int&)  = delete;
   std::expected<int, int> operator()(int&&)       = delete;
   std::expected<int, int> operator()(const int&&) = delete;
 };
 
 struct CLVal {
struct RVCRefQual {
   constexpr std::expected<int, int> operator()(int) const&& { return 1; }
 };
 
 template <class E, class F>
 concept has_or_else =
     requires(E&& e, F&& f) {
       { std::forward<E>(e).or_else(std::forward<F>(f)) };
     };
-
+// clang-format off
 // [LWG 3877] https://cplusplus.github.io/LWG/issue3877, check constraint failing but not compile error inside the function body.
 static_assert(!has_or_else<const std::expected<std::unique_ptr<int>, int>&, int()>);
 static_assert(!has_or_else<const std::expected<std::unique_ptr<int>, int>&&, int()>);
 
-// clang-format off
+// [LWG 3983] https://cplusplus.github.io/LWG/issue3938, check std::expected monadic ops well-formed with move-only error_type.
+static_assert(has_or_else<std::expected<int, MoveOnlyErrorType>&, std::expected<int, int>(MoveOnlyErrorType &)>);
+static_assert(has_or_else<const std::expected<int, MoveOnlyErrorType>&, std::expected<int, int>(const MoveOnlyErrorType &)>);
+static_assert(has_or_else<std::expected<int, MoveOnlyErrorType>&&, std::expected<int, int>(MoveOnlyErrorType&&)>);
+static_assert(has_or_else<const std::expected<int, MoveOnlyErrorType>&&, std::expected<int, int>(const MoveOnlyErrorType&&)>);
+
 constexpr void test_val_types() {
   // Test & overload
   {
     // Without & qualifier on F's operator()
     {
       std::expected<int, int> e(std::unexpected<int>(0));
       std::same_as<std::expected<int, int>> decltype(auto) val = e.or_else(LVal{});
       assert(val == 1);

 // check that the lambda body is not instantiated during overload resolution
 constexpr void test_sfinae() {
   std::expected<int, NonConst> e{1};
   auto l = [](auto&& x) { return x.non_const(); };
   e.or_else(l);
   std::move(e).or_else(l);
 }
 
+constexpr void test_move_only_error_type() {
+  // Test &
+  {
+      std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](MoveOnlyErrorType&) { return std::expected<int, int>{}; };
+      e.or_else(l);
+  }
+
+  // Test const&
+  {
+      const std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](const MoveOnlyErrorType&) { return std::expected<int, int>{}; };
+      e.or_else(l);
+  }
+
+  // Test &&
+  {
+      std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](MoveOnlyErrorType&&) { return std::expected<int, int>{}; };
+      std::move(e).or_else(l);
+  }
+
+  // Test const&&
+  {
+      const std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](const MoveOnlyErrorType&&) { return std::expected<int, int>{}; };
+      std::move(e).or_else(l);
+  }
+}
+
 constexpr bool test() {
   test_sfinae();
   test_val_types();
+  test_move_only_error_type();
 
   std::expected<int, int> e(1);
   const auto& ce = e;
 
   const auto never_called = [](int) {
     assert(false);
     return std::expected<int, int>();
   };

libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp

 
 #include <expected>
 #include <concepts>
 #include <cassert>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
+#include "../../types.h"
+
 struct LVal {
   constexpr int operator()(int&) { return 1; }
   int operator()(const int&)  = delete;
   int operator()(int&&)       = delete;
   int operator()(const int&&) = delete;
 };
 
 struct CLVal {

 };
 
 template <class E, class F>
 concept has_transform =
     requires(E&& e, F&& f) {
       { std::forward<E>(e).transform(std::forward<F>(f)) };
     };
 
+// clang-format off
 // [LWG 3877] https://cplusplus.github.io/LWG/issue3877, check constraint failing but not compile error inside the function body.
 static_assert(!has_transform<const std::expected<int, std::unique_ptr<int>>&, int()>);
 static_assert(!has_transform<const std::expected<int, std::unique_ptr<int>>&&, int()>);
 
-// clang-format off
+// [LWG 3983] https://cplusplus.github.io/LWG/issue3938, check std::expected monadic ops well-formed with move-only error_type.
+// There are no effects for `&` and `const &` overload, because the constraints requires is_constructible_v<E, decltype(error())> is true.
+static_assert(has_transform<std::expected<int, MoveOnlyErrorType>&&, int(int)>);
+static_assert(has_transform<const std::expected<int, MoveOnlyErrorType>&&, int(const int)>);
+
 constexpr void test_val_types() {
   // Test & overload
   {
     // Without & qualifier on F's operator()
     {
       std::expected<int, int> e(0);
       std::same_as<std::expected<int, int>> decltype(auto) val = e.transform(LVal{});
       assert(val == 1);
constexpr void test_sfinae() {
   };
 
   e1.transform(never_called);
   std::move(e1).transform(never_called);
   ce1.and_then(never_called);
   std::move(ce1).transform(never_called);
 }
 
+constexpr void test_move_only_error_type() {
+  // Test &&
+  {
+      std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](int) { return 0; };
+      std::move(e).transform(l);
+  }
+
+  // Test const&&
+  {
+      const std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](const int) { return 0; };
+      std::move(e).transform(l);
+  }
+}
+
 constexpr bool test() {
   test_sfinae();
   test_val_types();
   test_direct_non_list_init();
+  test_move_only_error_type();
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp

 
 #include <expected>
 #include <concepts>
 #include <cassert>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
+#include "../../types.h"
+
 struct LVal {
   constexpr int operator()(int&) { return 1; }
   int operator()(const int&)  = delete;
   int operator()(int&&)       = delete;
   int operator()(const int&&) = delete;
 };
 
 struct CLVal {

 };
 
 template <class E, class F>
 concept has_transform_error =
     requires(E&& e, F&& f) {
       { std::forward<E>(e).transform_error(std::forward<F>(f)) };
     };
 
+// clang-format off
 // [LWG 3877] https://cplusplus.github.io/LWG/issue3877, check constraint failing but not compile error inside the function body.
 static_assert(!has_transform_error<const std::expected<std::unique_ptr<int>, int>&, int()>);
 static_assert(!has_transform_error<const std::expected<std::unique_ptr<int>, int>&&, int()>);
 
-// clang-format off
+// [LWG 3983] https://cplusplus.github.io/LWG/issue3938, check std::expected monadic ops well-formed with move-only error_type.
+static_assert(has_transform_error<std::expected<int, MoveOnlyErrorType>&, int(MoveOnlyErrorType &)>);
+static_assert(has_transform_error<const std::expected<int, MoveOnlyErrorType>&, int(const MoveOnlyErrorType &)>);
+static_assert(has_transform_error<std::expected<int, MoveOnlyErrorType>&&, int(MoveOnlyErrorType&&)>);
+static_assert(has_transform_error<const std::expected<int, MoveOnlyErrorType>&&, int(const MoveOnlyErrorType&&)>);
+
 constexpr void test_val_types() {
   // Test & overload
   {
     // Without & qualifier on F's operator()
     {
       std::expected<int, int> e(std::unexpected<int>(0));
       std::same_as<std::expected<int, int>> decltype(auto) val = e.transform_error(LVal{});
       assert(val.error() == 1);
constexpr void test_sfinae() {
   };
 
   e1.transform_error(never_called);
   std::move(e1).transform_error(never_called);
   ce1.transform_error(never_called);
   std::move(ce1).transform_error(never_called);
 }
 
+constexpr void test_move_only_error_type() {
+  // Test &
+  {
+      std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](MoveOnlyErrorType&) { return 0; };
+      e.transform_error(l);
+  }
+
+  // Test const&
+  {
+      const std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](const MoveOnlyErrorType&) { return 0; };
+      e.transform_error(l);
+  }
+
+  // Test &&
+  {
+      std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](MoveOnlyErrorType&&) { return 0; };
+      std::move(e).transform_error(l);
+  }
+
+  // Test const&&
+  {
+      const std::expected<int, MoveOnlyErrorType> e;
+      auto l = [](const MoveOnlyErrorType&&) { return 0; };
+      std::move(e).transform_error(l);
+  }
+}
+
 constexpr bool test() {
   test_sfinae();
   test_val_types();
   test_direct_non_list_init();
+  test_move_only_error_type();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/expected/types.h

~ThrowOnMove() {
     if (destroyed) {
       *destroyed = true;
     }
   }
 };
 
 #endif // TEST_HAS_NO_EXCEPTIONS
 
+struct MoveOnlyErrorType {
+  constexpr MoveOnlyErrorType(int) {}
+  MoveOnlyErrorType(MoveOnlyErrorType&&) {}
+  MoveOnlyErrorType(const MoveOnlyErrorType&&) {}
+  MoveOnlyErrorType(const MoveOnlyErrorType&)            = delete;
+  MoveOnlyErrorType& operator=(const MoveOnlyErrorType&) = delete;
+};
+
 #endif // TEST_STD_UTILITIES_EXPECTED_TYPES_H