[libcxx] adds std::ranges::swap, std::swappable, and std::swappable_with

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

Depends on D96742

[cjdb]

I'm committing swappable independently from swappable_with so that I can get movable, copyable, semiregular and regular out first (all of which are arguably more important than swappable_with).

[cjdb]

fixes lambdas that weren't called

[miscco]

I find the tests really hard to read and follow. I think giving the lambdas an explicit name would be really beneficial.

libcxx/include/concepts

270

I think this is already covered by the explicit _Size parameter

298

I *think* this should not be done. We would lose a tone of throughput due to the additional checking done inside ranges::swap_ranges.

Is there a measurable benefit in using ranges::swap_ranges

309

While this is what the standard says, it boils down to the conventional swap implementation, which is better known. So should we simply avoid the function call and directly open code swap?

314

This *think* this must be inside another inline namespace _meow I tend to happily forget the exact reason

In general I would say we should put the whole CPO into the ranges namespace and then use an inline namespace here. It is a bit strange that the CPO itself lives outside of ranges

libcxx/test/std/concepts/lang/swappable.pass.cpp

39–40

I find this supper hard to read I think we should enforce some linebreaks with //

68

Please wrap this into a separate function with a descriptive name

[cjdb]

rebases to activate CI

[cjdb]

• applies @miscco's feedback
• adds std::swappable_with

[• Quuxplusone]

Not a real review, just a couple drive-by comments. I'm unlikely to do a real review. :)

libcxx/include/concepts

309

IMO yes; and also std::move should be _VSTD::move.

314

One thing that might be affected by this comment, and should certainly be tested, is whether swap itself is swappable:

decltype(std::ranges::swap) s1, s2;
std::ranges::swap(s1, s2);

I don't know whether it should be or not, but ISTR that this was the trouble spot for range-v3 swap a couple years ago.

[cjdb]

libcxx/include/concepts

270

Nice catch :-)

298

http://eel.is/c++draft/concept.swappable#2.2 explicitly mentions it as the call, but if we can skip the call, I'm all for it.

309

I'd prefer to faithfully follow the standard and trust an optimising compiler will deal with this appropriately :-)

314

The type lives in namespace std::ranges::__swap. I don't see any wording in [[customization.point.object]][1] or [[concepts.swappable]][2] that mandates this, though I do recall that range-v3 (and possibly cmcstl2) needed to do this in C++14 mode since there weren't inline variables at the time.

[1]: http://eel.is/c++draft/customization.point.object
[2]: http://eel.is/c++draft/concepts.swappable

libcxx/test/std/concepts/lang/swappable.pass.cpp

39–40

clang-format, why you do dis?

[tcanens]

libcxx/include/concepts

314

[concepts.syn] mandates it.

This is required because otherwise you can't declare hidden friend swaps for anything in namespace ranges; the same namespace member can't be both a variable and a function, even if the function is otherwise invisible to ordinary lookup.

[cjdb]

puts ranges::swap in an inline sub-namespace

[cjdb]

adds test to see if ranges::swap is swappable

[cjdb]

libcxx/include/concepts

314

Yep, makes sense, done.

314

Test added.

[cjdb]

s/std::move/_VSTD::move/

[cjdb]

libcxx/include/concepts

309

_VSTD::move done, but I'd still prefer to follow the standard wording.

[miscco]

Not a maintainer, but this looks good to me

libcxx/include/concepts

314

Note, that this does not really make sense, as the standard requires, that there is only a single instance of each CPO, but It definitly does not hurt

[cjdb]

libcxx/include/concepts

314

as the standard requires, that there is only a single instance of each CPO

Where does it say that? [customization.point.object]/3 says that all instances must be equal, but that doesn't preclude having a two of the same CPO (not being allowed to copy would make passing CPOs to algorithms illegal).

It's still a good idea to test, since we need to check that the CPO satisfies semiregular.

[EricWF]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

564 ↗

(On Diff #328032)

Why are these commented out?

[EricWF]

LGTM assuming the inline comments get addressed.

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

593 ↗

(On Diff #328032)

Can we write these tests in a way that makes them non-threading dependent.

[ldionne]

libcxx/include/concepts

298

I don't understand Michael's comment about the loss of throughput for using swap_ranges here. It seems to me like that would be the correct way of implementing this. Why reinvent the wheel?

311

// end namespace ranges::__swap

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

593 ↗

(On Diff #328032)

I don't think so since he's explicitly trying to exercise these types, which aren't provided when _LIBCPP_HAS_NO_THREADS. Better would be to have a test-suite version of the macro (to express the fact that the test suite supports being used when threads are not available), but that's for a different patch.

[ldionne]

libcxx/include/concepts

298

Thinking further, obviously we can't use ranges::swap_ranges before it has been implemented. I think we should add a TODO and come fix it later once it's implemented so that we are in line with the spec.

[cjdb]

adds union to definition (and tests), uncomments tests, adds TODO

[cjdb]

Will commit tomorrow.

libcxx/include/concepts

311

Also for the namespace below.

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

564 ↗

(On Diff #328032)

Uncommented.

593 ↗

(On Diff #328032)

How about I do that patch just before announcing P0898 is implemented?

[cjdb]

fixes union swap

[• Quuxplusone]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

593 ↗

(On Diff #328032)

Peanut gallery says: Other alternatives include

• test a made-up struct Immobile instead of specifically std::mutex; we can assume that std::mutex is equally immobile

• move tests of std::mutex's own properties into test/std/thread/thread.mutex/ (because if someone were somehow to break the immobility of std::mutex, I'd hope that it's the mutex tests that fail, not some random concept's tests)

But I have no particular stake in the outcome.

[cjdb]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

593 ↗

(On Diff #328032)

Reason for having std::mutex over immobile is because @ldionne asked if I could test some standard types too, and I couldn't think of any non-thread based nonmovable types at the time. @EricWF and I agreed to change the mutex ones to some streams.

[cjdb]

replaces std::mutex and std::lock_guard with std::ios_base and std::basic_ios

[cjdb]

CI sanity check before submitting (hopefully a flake)

[ldionne]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

593 ↗

(On Diff #328032)

I think you'll have the same problem with _LIBCPP_HAS_NO_LOCALIZATION now, unless I'm mistaken. You could move the test to the mutex tests instead if you wanted. Or remove those - they do provide nice testing coverage but they're not worth creating a ruckus over IMO!

[cjdb]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

593 ↗

(On Diff #328032)

Okay, so that's why CI failed this time, thanks for the clarity there :-)

In that case, I'll take Arthur's suggestion and make an immobile type, and in a later patch, make a test for thread and stream types.

[cjdb]

replaces immovable types

libcxx/include/concepts

 template<class _Lhs, class _Rhs>
 concept assignable_from =
   is_lvalue_reference_v<_Lhs> &&
   common_reference_with<const remove_reference_t<_Lhs>&, const remove_reference_t<_Rhs>&> &&
   requires (_Lhs __lhs, _Rhs&& __rhs) {
     { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
   };
 
+// [concept.swappable] under [concept.moveconstructible]
+
 // [concept.destructible]
 
 template<class _Tp>
 concept destructible = _VSTD::is_nothrow_destructible_v<_Tp>;
 
 // [concept.constructible]
 template<class _Tp, class... _Args>
 concept constructible_from =
     destructible<_Tp> && _VSTD::is_constructible_v<_Tp, _Args...>;
 
 // [concept.default.init]
 
 template<class _Tp>
 concept __default_initializable = requires { ::new _Tp; };
 
 template<class _Tp>
 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
 template<class _Tp>
 concept move_constructible =
   constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
+// [concept.swappable]
+namespace ranges::__swap {
+  // Deleted to inhibit ADL
+  template<class _Tp>
+  void swap(_Tp&, _Tp&) = delete;
+
+  template<class _Tp>
+  concept __class_or_enum = is_class_v<_Tp> || is_enum_v<_Tp>;
+
+  // [1]
+  template<class _Tp, class _Up>
+  concept __unqualified_swappable_with =
+    (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
+    requires(_Tp&& __t, _Up&& __u) {
+      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+    };
+
+  struct __fn;
+
+  template<class _Tp, class _Up, size_t _Size>
+  concept __swappable_arrays =
+    !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
+    extent_v<_Tp> == extent_v<_Up> &&
+    requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
+      __swap(__t[0], __u[0]);
+    };
+
+  template<class _Tp>
+  concept __exchangeable =
+    !__unqualified_swappable_with<_Tp&, _Tp&> &&
+    move_constructible<_Tp> &&
+    assignable_from<_Tp&, _Tp>;
+
+  struct __fn {
+    // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
+    // *The name `swap` is used here unqualified.
+    template<class _Tp, class _Up>
+    requires __unqualified_swappable_with<_Tp, _Up>
+    constexpr void operator()(_Tp&& __t, _Up&& __u) const
+    noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
+    {
+      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+    }
+
+    // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
+    template<class _Tp, class _Up, size_t _Size>
+    requires __swappable_arrays<_Tp, _Up, _Size>
+    constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
+    noexcept(noexcept((*this)(*__t, *__u)))
+    {
+      // FIXME(cjdb): replace loop with ranges::swap_ranges.
+      for (size_t __i = 0; __i < _Size; ++__i) {
+        (*this)(__t[__i], __u[__i]);
+      }
+    }
+
+    // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
+    template<__exchangeable _Tp>
+    constexpr void operator()(_Tp& __x, _Tp& __y) const
+    noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
+    {
+      __y = _VSTD::exchange(__x, std::move(__y));
+    }
+  };
+}
+
+namespace ranges {
+  inline constexpr auto swap = __swap::__fn{};
+}
+
+template<class _Tp>
+concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
+
 // [concept.copyconstructible]
 template<class _Tp>
 concept copy_constructible =
   move_constructible<_Tp> &&
   constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
 

libcxx/test/std/concepts/lang/arithmetic.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++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept integral = // see below
 
 // template<class T>
 // concept signed_integral = // see below
 

libcxx/test/std/concepts/lang/swappable.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_STD_CONCEPTS_LANG_SWAPPABLE_H
+#define TEST_STD_CONCEPTS_LANG_SWAPPABLE_H
+
+#include <concepts>
+
+// `adl_swappable` indicates it's been swapped using ADL by maintaining a pointer to itself that
+// isn't a part of the exchange. This is well-formed since we say that two `adl_swappable` objects
+// are equal only if their respective `value` subobjects are equal and their respective `this`
+// subobjects store the addresses of those respective `adl_swappable` objects.
+class lvalue_adl_swappable {
+public:
+  lvalue_adl_swappable() = default;
+
+  constexpr lvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr lvalue_adl_swappable(lvalue_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr lvalue_adl_swappable(lvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr lvalue_adl_swappable&
+  operator=(lvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(lvalue_adl_swappable& x,
+                             lvalue_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool operator==(lvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  lvalue_adl_swappable* this_ = this;
+};
+
+class lvalue_rvalue_adl_swappable_with {
+public:
+  lvalue_rvalue_adl_swappable_with() = default;
+
+  constexpr lvalue_rvalue_adl_swappable_with(int value) noexcept
+      : value_(value) {}
+
+  constexpr lvalue_rvalue_adl_swappable_with(
+      lvalue_rvalue_adl_swappable_with&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr lvalue_rvalue_adl_swappable_with(
+      lvalue_rvalue_adl_swappable_with const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr lvalue_rvalue_adl_swappable_with&
+  operator=(lvalue_rvalue_adl_swappable_with other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(lvalue_rvalue_adl_swappable_with& x,
+                             lvalue_rvalue_adl_swappable_with&& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(lvalue_rvalue_adl_swappable_with const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  lvalue_rvalue_adl_swappable_with* this_ = this;
+};
+
+class rvalue_lvalue_adl_swappable_with {
+public:
+  rvalue_lvalue_adl_swappable_with() = default;
+
+  constexpr rvalue_lvalue_adl_swappable_with(int value) noexcept
+      : value_(value) {}
+
+  constexpr rvalue_lvalue_adl_swappable_with(
+      rvalue_lvalue_adl_swappable_with&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr rvalue_lvalue_adl_swappable_with(
+      rvalue_lvalue_adl_swappable_with const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr rvalue_lvalue_adl_swappable_with&
+  operator=(rvalue_lvalue_adl_swappable_with other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(rvalue_lvalue_adl_swappable_with&& x,
+                             rvalue_lvalue_adl_swappable_with& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(rvalue_lvalue_adl_swappable_with const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  rvalue_lvalue_adl_swappable_with* this_ = this;
+};
+
+class rvalue_adl_swappable_with {
+public:
+  rvalue_adl_swappable_with() = default;
+
+  constexpr rvalue_adl_swappable_with(int value) noexcept : value_(value) {}
+
+  constexpr
+  rvalue_adl_swappable_with(rvalue_adl_swappable_with&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr
+  rvalue_adl_swappable_with(rvalue_adl_swappable_with const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr rvalue_adl_swappable_with&
+  operator=(rvalue_adl_swappable_with other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(rvalue_adl_swappable_with&& x,
+                             rvalue_adl_swappable_with&& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(rvalue_adl_swappable_with const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  rvalue_adl_swappable_with* this_ = this;
+};
+
+class non_move_constructible_adl_swappable {
+public:
+  non_move_constructible_adl_swappable() = default;
+
+  constexpr non_move_constructible_adl_swappable(int value) noexcept
+      : value_(value) {}
+
+  constexpr non_move_constructible_adl_swappable(
+      non_move_constructible_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr non_move_constructible_adl_swappable(
+      non_move_constructible_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr non_move_constructible_adl_swappable&
+  operator=(non_move_constructible_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(non_move_constructible_adl_swappable& x,
+                             non_move_constructible_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(non_move_constructible_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  non_move_constructible_adl_swappable* this_ = this;
+};
+
+class non_move_assignable_adl_swappable {
+public:
+  non_move_assignable_adl_swappable() = default;
+
+  constexpr non_move_assignable_adl_swappable(int value) noexcept
+      : value_(value) {}
+
+  non_move_assignable_adl_swappable(non_move_assignable_adl_swappable&& other) =
+      delete;
+
+  constexpr non_move_assignable_adl_swappable(
+      non_move_assignable_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr non_move_assignable_adl_swappable&
+  operator=(non_move_assignable_adl_swappable&& other) noexcept = delete;
+
+  constexpr friend void swap(non_move_assignable_adl_swappable& x,
+                             non_move_assignable_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(non_move_assignable_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  non_move_assignable_adl_swappable* this_ = this;
+};
+
+class throwable_adl_swappable {
+public:
+  throwable_adl_swappable() = default;
+
+  constexpr throwable_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr throwable_adl_swappable(throwable_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr
+  throwable_adl_swappable(throwable_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr throwable_adl_swappable&
+  operator=(throwable_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(throwable_adl_swappable& X,
+                             throwable_adl_swappable& Y) noexcept(false) {
+    std::ranges::swap(X.value_, Y.value_);
+  }
+
+  constexpr bool
+  operator==(throwable_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  throwable_adl_swappable* this_ = this;
+};
+
+#endif // TEST_STD_CONCEPTS_LANG_SWAPPABLE_H

libcxx/test/std/concepts/lang/swappable.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
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept swappable = // see below
+
+#include <concepts>
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <map>
+#include <memory>
+#include <string>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include "test_macros.h"
+#include "swappable.h"
+
+template <class T>
+struct expected {
+  T x;
+  T y;
+};
+
+// Checks [concept.swappable]/2.1
+template <class T, class U>
+requires std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U> >&&
+    std::swappable<std::remove_cvref_t<T> >
+        constexpr bool check_swap_21(T&& x, U&& y) {
+  expected<std::remove_cvref_t<T> > const e{y, x};
+  std::ranges::swap(std::forward<T>(x), std::forward<U>(y));
+  return x == e.x && y == e.y;
+}
+
+// Checks [concept.swappable]/2.2
+template <std::swappable T, std::size_t N>
+constexpr bool check_swap_22(T (&x)[N], T (&y)[N]) {
+  expected<T[N]> e;
+  std::copy(y, y + N, e.x);
+  std::copy(x, x + N, e.y);
+
+  std::ranges::swap(x, y);
+  return std::equal(x, x + N, e.x, e.x + N) &&
+         std::equal(y, y + N, e.y, e.y + N);
+}
+
+// Checks [concept.swappable]/2.3
+template <std::swappable T>
+requires std::copy_constructible<std::remove_cvref_t<T> > constexpr bool
+check_swap_23(T x, T y) {
+  expected<std::remove_cvref_t<T> > const e{y, x};
+  std::ranges::swap(x, y);
+  return x == e.x && y == e.y;
+}
+
+static_assert([] {
+  auto x = lvalue_adl_swappable(0);
+  auto y = lvalue_adl_swappable(1);
+  return check_swap_21(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  return check_swap_21(rvalue_adl_swappable_with(0),
+                       rvalue_adl_swappable_with(1)) &&
+         noexcept(std::ranges::swap(rvalue_adl_swappable_with(0),
+                                    rvalue_adl_swappable_with(1)));
+}());
+static_assert([] {
+  auto x = lvalue_rvalue_adl_swappable_with(0);
+  return check_swap_21(x, lvalue_rvalue_adl_swappable_with(1)) &&
+         noexcept(std::ranges::swap(x, lvalue_rvalue_adl_swappable_with(1)));
+});
+static_assert([] {
+  auto x = rvalue_lvalue_adl_swappable_with(0);
+  return check_swap_21(rvalue_lvalue_adl_swappable_with(1), x) &&
+         noexcept(std::ranges::swap(rvalue_lvalue_adl_swappable_with(1), x));
+});
+static_assert([] {
+  auto x = throwable_adl_swappable{0};
+  auto y = throwable_adl_swappable{1};
+  return check_swap_21(x, y) && !noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  auto x = non_move_constructible_adl_swappable{0};
+  auto y = non_move_constructible_adl_swappable{1};
+  return check_swap_21(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  auto x = non_move_assignable_adl_swappable{0};
+  auto y = non_move_assignable_adl_swappable{1};
+  return check_swap_21(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+
+namespace swappable_namespace {
+enum unscoped { hello, world };
+void swap(unscoped&, unscoped&);
+
+enum class scoped { hello, world };
+void swap(scoped&, scoped&);
+} // namespace swappable_namespace
+
+static_assert(std::swappable<swappable_namespace::unscoped>);
+static_assert(std::swappable<swappable_namespace::scoped>);
+
+static_assert([] {
+  int x[] = {0, 1, 2, 3, 4};
+  int y[] = {5, 6, 7, 8, 9};
+  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  int x[] = {5, 6, 7, 8, 9};
+  int y[] = {0, 1, 2, 3, 4};
+  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  lvalue_adl_swappable x[] = {{0}, {1}, {2}, {3}};
+  lvalue_adl_swappable y[] = {{4}, {5}, {6}, {7}};
+  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  throwable_adl_swappable x[] = {{0}, {1}, {2}, {3}};
+  throwable_adl_swappable y[] = {{4}, {5}, {6}, {7}};
+  return check_swap_22(x, y) && !noexcept(std::ranges::swap(x, y));
+}());
+
+inline auto global_x = 0;
+static_assert(check_swap_23(0, 0) &&
+              noexcept(std::ranges::swap(global_x, global_x)));
+static_assert(check_swap_23(0, 1) &&
+              noexcept(std::ranges::swap(global_x, global_x)));
+static_assert(check_swap_23(1, 0) &&
+              noexcept(std::ranges::swap(global_x, global_x)));
+
+static_assert([] {
+  int x = 42;
+  int y = 64;
+  return check_swap_23<int&>(x, y) && noexcept(std::ranges::swap(x, y));
+}());
+static_assert([] {
+  char const* x = "hello";
+  return check_swap_23<char const*>(x, nullptr) &&
+         noexcept(std::ranges::swap(x, x));
+}());
+
+// All tests for std::swappable<T> are implicitly confirmed by `check_swap`, so we only need to
+// sanity check for a few positive cases.
+static_assert(std::swappable<int&&>);
+static_assert(std::swappable<int (*)()>);
+static_assert(std::swappable<int rvalue_adl_swappable_with::*>);
+static_assert(std::swappable<int (rvalue_adl_swappable_with::*)()>);
+static_assert(std::swappable<std::unique_ptr<int> >);
+
+static_assert(!std::swappable<void>);
+static_assert(!std::swappable<int (&)()>);
+
+struct non_move_constructible {
+  non_move_constructible(non_move_constructible&&) = delete;
+  non_move_constructible& operator=(non_move_constructible&&);
+};
+static_assert(!std::move_constructible<non_move_constructible>);
+static_assert(
+    std::assignable_from<non_move_constructible&, non_move_constructible>);
+static_assert(!std::swappable<non_move_constructible>);
+
+struct non_move_assignable {
+  non_move_assignable(non_move_assignable&&);
+  non_move_assignable& operator=(non_move_assignable&&) = delete;
+};
+static_assert(std::move_constructible<non_move_assignable>);
+static_assert(!std::assignable_from<non_move_assignable&, non_move_assignable>);
+static_assert(!std::swappable<non_move_assignable>);
+
+template <bool is_noexcept, std::swappable T>
+void check_swap(expected<T> const& e) {
+  auto a = e.y;
+  auto b = e.x;
+
+  std::ranges::swap(a, b);
+  assert(a == e.x);
+  assert(b == e.y);
+
+  std::ranges::swap(a, b);
+  assert(a == e.y);
+  assert(b == e.x);
+
+  static_assert(noexcept(std::ranges::swap(a, b)) == is_noexcept);
+}
+
+int main(int, char**) {
+  {
+    auto const e = expected<std::deque<int> >{
+        .x = {6, 7, 8, 9},
+        .y = {0, 1, 2, 3, 4, 5},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::map<int, std::string> >{
+        .x = {{0, "whole"}, {1, "cashews"}},
+        .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::string>{
+        .x = "hello there",
+        .y = "general kenobi",
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::optional<lvalue_adl_swappable> >{
+        .x = {10},
+        .y = {20},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::optional<throwable_adl_swappable> >{
+        .x = {10},
+        .y = {20},
+    };
+    check_swap</*is_noexcept=*/false>(e);
+  }
+  {
+    auto const e = expected<std::unordered_map<int, std::string> >{
+        .x = {{0, "whole"}, {1, "cashews"}},
+        .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::vector<int> >{
+        .x = {0, 1, 2, 3, 4, 5},
+        .y = {6, 7, 8, 9},
+    };
+
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  return 0;
+}