diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 7c1a556..057d1f8 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -21,7 +21,7 @@ repos:
 
     # CMake linting and formatting
   - repo: https://github.com/BlankSpruce/gersemi-pre-commit
-    rev: 0.27.6
+    rev: 0.27.7
     hooks:
     - id: gersemi
       name: CMake linting
diff --git a/include/beman/expected/expected.hpp b/include/beman/expected/expected.hpp
index 51da38c..e2d429b 100644
--- a/include/beman/expected/expected.hpp
+++ b/include/beman/expected/expected.hpp
@@ -94,8 +94,7 @@ template <class E, class... Args>
 inline constexpr bool unexpect_dangles_v = false;
 
 template <class E, class G>
-inline constexpr bool unexpect_dangles_v<E, G> =
-    std::is_reference_v<E> && reference_constructs_from_temporary_v<E, G>;
+inline constexpr bool unexpect_dangles_v<E, G> = std::is_reference_v<E> && reference_constructs_from_temporary_v<E, G>;
 
 } // namespace detail
 
@@ -157,8 +156,8 @@ class expected {
     // Copy constructor (non-trivial path)
     constexpr expected(const expected& rhs)
         requires(std::is_copy_constructible_v<T> && std::is_copy_constructible_v<unexpected<E>> &&
-                 !(std::is_trivially_copy_constructible_v<T> &&
-                   std::is_trivially_copy_constructible_v<unexpected<E>>));
+                 !(std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_constructible_v<unexpected<E>>))
+    ;
 
     // Move constructor (trivial path)
     constexpr expected(expected&&) noexcept
@@ -169,8 +168,8 @@ class expected {
     constexpr expected(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                                 std::is_nothrow_move_constructible_v<unexpected<E>>)
         requires(std::is_move_constructible_v<T> && std::is_move_constructible_v<unexpected<E>> &&
-                 !(std::is_trivially_move_constructible_v<T> &&
-                   std::is_trivially_move_constructible_v<unexpected<E>>));
+                 !(std::is_trivially_move_constructible_v<T> && std::is_trivially_move_constructible_v<unexpected<E>>))
+    ;
 
     // Converting copy constructor from expected<U, G> — value-E path
     template <class U, class G>
@@ -205,8 +204,7 @@ class expected {
     template <class U, class G>
         requires(std::is_reference_v<E> && std::is_reference_v<G> && std::is_constructible_v<T, U &&> &&
                  std::is_convertible_v<G, E>)
-    constexpr explicit(!std::is_convertible_v<U&&, T> || !std::is_convertible_v<G, E>)
-        expected(expected<U, G>&& rhs);
+    constexpr explicit(!std::is_convertible_v<U&&, T> || !std::is_convertible_v<G, E>) expected(expected<U, G>&& rhs);
 
     // Constructor from value U&&
     template <class U = std::remove_cv_t<T>>
@@ -302,8 +300,7 @@ class expected {
     constexpr expected& operator=(const expected&)
         requires(std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_assignable_v<T> &&
                  std::is_trivially_destructible_v<T> && std::is_trivially_copy_constructible_v<unexpected<E>> &&
-                 std::is_trivially_copy_assignable_v<unexpected<E>> &&
-                 std::is_trivially_destructible_v<unexpected<E>>)
+                 std::is_trivially_copy_assignable_v<unexpected<E>> && std::is_trivially_destructible_v<unexpected<E>>)
     = default;
 
     // Copy assignment (non-trivial path)
@@ -320,14 +317,14 @@ class expected {
     constexpr expected& operator=(expected&&) noexcept
         requires(std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T> &&
                  std::is_trivially_destructible_v<T> && std::is_trivially_move_constructible_v<unexpected<E>> &&
-                 std::is_trivially_move_assignable_v<unexpected<E>> &&
-                 std::is_trivially_destructible_v<unexpected<E>>)
+                 std::is_trivially_move_assignable_v<unexpected<E>> && std::is_trivially_destructible_v<unexpected<E>>)
     = default;
 
     // Move assignment (non-trivial path)
-    constexpr expected& operator=(expected&& rhs) noexcept(
-        std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_assignable_v<T> &&
-        std::is_nothrow_move_constructible_v<unexpected<E>> && std::is_nothrow_move_assignable_v<unexpected<E>>)
+    constexpr expected& operator=(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
+                                                           std::is_nothrow_move_assignable_v<T> &&
+                                                           std::is_nothrow_move_constructible_v<unexpected<E>> &&
+                                                           std::is_nothrow_move_assignable_v<unexpected<E>>)
         requires(std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
                  std::is_move_constructible_v<unexpected<E>> && std::is_move_assignable_v<unexpected<E>> &&
                  (std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<unexpected<E>>) &&
@@ -393,9 +390,10 @@ class expected {
     // [expected.object.swap] Swap
     // -------------------------------------------------------------------------
 
-    constexpr void swap(expected& rhs) noexcept(
-        std::is_nothrow_move_constructible_v<T> && std::is_nothrow_swappable_v<T> &&
-        std::is_nothrow_move_constructible_v<unexpected<E>> && (std::is_reference_v<E> || std::is_nothrow_swappable_v<E>))
+    constexpr void swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
+                                                std::is_nothrow_swappable_v<T> &&
+                                                std::is_nothrow_move_constructible_v<unexpected<E>> &&
+                                                (std::is_reference_v<E> || std::is_nothrow_swappable_v<E>))
         requires(std::is_swappable_v<T> && (std::is_reference_v<E> || std::is_swappable_v<E>) &&
                  std::is_move_constructible_v<T> && std::is_move_constructible_v<unexpected<E>> &&
                  (std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<unexpected<E>>));
@@ -869,9 +867,10 @@ constexpr T& expected<T, E>::emplace(std::initializer_list<U> il, Args&&... args
 // =============================================================================
 
 template <class T, class E>
-constexpr void expected<T, E>::swap(expected& rhs) noexcept(
-    std::is_nothrow_move_constructible_v<T> && std::is_nothrow_swappable_v<T> &&
-    std::is_nothrow_move_constructible_v<unexpected<E>> && (std::is_reference_v<E> || std::is_nothrow_swappable_v<E>))
+constexpr void expected<T, E>::swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
+                                                            std::is_nothrow_swappable_v<T> &&
+                                                            std::is_nothrow_move_constructible_v<unexpected<E>> &&
+                                                            (std::is_reference_v<E> || std::is_nothrow_swappable_v<E>))
     requires(std::is_swappable_v<T> && (std::is_reference_v<E> || std::is_swappable_v<E>) &&
              std::is_move_constructible_v<T> && std::is_move_constructible_v<unexpected<E>> &&
              (std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<unexpected<E>>))
@@ -1175,7 +1174,8 @@ template <class F>
 constexpr auto expected<T, E>::or_else(F&& f) & {
     using G = std::remove_cvref_t<std::invoke_result_t<F, E&>>;
     static_assert(detail::is_expected_specialization<G>::value, "or_else: F must return a specialization of expected");
-    static_assert(std::is_same_v<typename G::value_type, T>, "or_else: F must return expected with the same value_type");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "or_else: F must return expected with the same value_type");
     if (has_val_)
         return G(std::in_place, val_);
     return std::invoke(std::forward<F>(f), unex_.error());
@@ -1187,7 +1187,8 @@ template <class F>
 constexpr auto expected<T, E>::or_else(F&& f) && {
     using G = std::remove_cvref_t<std::invoke_result_t<F, E&&>>;
     static_assert(detail::is_expected_specialization<G>::value, "or_else: F must return a specialization of expected");
-    static_assert(std::is_same_v<typename G::value_type, T>, "or_else: F must return expected with the same value_type");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "or_else: F must return expected with the same value_type");
     if (has_val_)
         return G(std::in_place, std::move(val_));
     return std::invoke(std::forward<F>(f), std::move(unex_).error());
@@ -1199,7 +1200,8 @@ template <class F>
 constexpr auto expected<T, E>::or_else(F&& f) const& {
     using G = std::remove_cvref_t<std::invoke_result_t<F, const E&>>;
     static_assert(detail::is_expected_specialization<G>::value, "or_else: F must return a specialization of expected");
-    static_assert(std::is_same_v<typename G::value_type, T>, "or_else: F must return expected with the same value_type");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "or_else: F must return expected with the same value_type");
     if (has_val_)
         return G(std::in_place, val_);
     return std::invoke(std::forward<F>(f), unex_.error());
@@ -1211,7 +1213,8 @@ template <class F>
 constexpr auto expected<T, E>::or_else(F&& f) const&& {
     using G = std::remove_cvref_t<std::invoke_result_t<F, const E&&>>;
     static_assert(detail::is_expected_specialization<G>::value, "or_else: F must return a specialization of expected");
-    static_assert(std::is_same_v<typename G::value_type, T>, "or_else: F must return expected with the same value_type");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "or_else: F must return expected with the same value_type");
     if (has_val_)
         return G(std::in_place, std::move(val_));
     return std::invoke(std::forward<F>(f), std::move(unex_).error());
@@ -1412,16 +1415,16 @@ class expected<void, E> {
     = default;
 
     constexpr expected(const expected& rhs)
-        requires(std::is_copy_constructible_v<unexpected<E>> &&
-                 !std::is_trivially_copy_constructible_v<unexpected<E>>);
+        requires(std::is_copy_constructible_v<unexpected<E>> && !std::is_trivially_copy_constructible_v<unexpected<E>>)
+    ;
 
     constexpr expected(expected&&) noexcept
         requires std::is_trivially_move_constructible_v<unexpected<E>>
     = default;
 
     constexpr expected(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<unexpected<E>>)
-        requires(std::is_move_constructible_v<unexpected<E>> &&
-                 !std::is_trivially_move_constructible_v<unexpected<E>>);
+        requires(std::is_move_constructible_v<unexpected<E>> && !std::is_trivially_move_constructible_v<unexpected<E>>)
+    ;
 
     // Converting constructor from expected<U, G> where is_void_v<U>. Excludes U,G exactly
     // matching this class's own void,E (the real copy/move constructors already handle that
@@ -1429,8 +1432,8 @@ class expected<void, E> {
     // unexpected<E>'s constructibility from this very class, which some standard library
     // implementations of reference_constructs_from_temporary_v resolve as a circular constraint.
     template <class U, class G>
-        requires(std::is_void_v<U> && !std::is_same_v<G, E> &&
-                 std::is_constructible_v<E, const G&> && !std::is_constructible_v<unexpected<E>, expected<U, G>&> &&
+        requires(std::is_void_v<U> && !std::is_same_v<G, E> && std::is_constructible_v<E, const G&> &&
+                 !std::is_constructible_v<unexpected<E>, expected<U, G>&> &&
                  !std::is_constructible_v<unexpected<E>, expected<U, G> &&> &&
                  !std::is_constructible_v<unexpected<E>, const expected<U, G>&> &&
                  !std::is_constructible_v<unexpected<E>, const expected<U, G> &&>)
@@ -1523,8 +1526,7 @@ class expected<void, E> {
     // Copy assignment (trivial path)
     constexpr expected& operator=(const expected&)
         requires(std::is_trivially_copy_constructible_v<unexpected<E>> &&
-                 std::is_trivially_copy_assignable_v<unexpected<E>> &&
-                 std::is_trivially_destructible_v<unexpected<E>>)
+                 std::is_trivially_copy_assignable_v<unexpected<E>> && std::is_trivially_destructible_v<unexpected<E>>)
     = default;
 
     // Copy assignment (non-trivial path)
@@ -1537,8 +1539,7 @@ class expected<void, E> {
     // Move assignment (trivial path)
     constexpr expected& operator=(expected&&) noexcept
         requires(std::is_trivially_move_constructible_v<unexpected<E>> &&
-                 std::is_trivially_move_assignable_v<unexpected<E>> &&
-                 std::is_trivially_destructible_v<unexpected<E>>)
+                 std::is_trivially_move_assignable_v<unexpected<E>> && std::is_trivially_destructible_v<unexpected<E>>)
     = default;
 
     // Move assignment (non-trivial path)
@@ -1551,8 +1552,7 @@ class expected<void, E> {
 
     // Assignment from unexpected<G> — value-E path.
     template <class G>
-        requires(!std::is_reference_v<E> && std::is_constructible_v<E, const G&> &&
-                 std::is_assignable_v<E&, const G&>)
+        requires(!std::is_reference_v<E> && std::is_constructible_v<E, const G&> && std::is_assignable_v<E&, const G&>)
     constexpr expected& operator=(const unexpected<G>& e);
 
     template <class G>
@@ -1727,8 +1727,8 @@ constexpr expected<void, E>::expected(expected&& rhs) noexcept(std::is_nothrow_m
 
 template <class E>
 template <class U, class G>
-    requires(std::is_void_v<U> && !std::is_same_v<G, E> &&
-             std::is_constructible_v<E, const G&> && !std::is_constructible_v<unexpected<E>, expected<U, G>&> &&
+    requires(std::is_void_v<U> && !std::is_same_v<G, E> && std::is_constructible_v<E, const G&> &&
+             !std::is_constructible_v<unexpected<E>, expected<U, G>&> &&
              !std::is_constructible_v<unexpected<E>, expected<U, G> &&> &&
              !std::is_constructible_v<unexpected<E>, const expected<U, G>&> &&
              !std::is_constructible_v<unexpected<E>, const expected<U, G> &&>)
@@ -1779,7 +1779,6 @@ constexpr expected<void, E>::expected(unexpected<G>&& e) noexcept : has_val_(fal
     std::construct_at(std::addressof(unex_), e.error());
 }
 
-
 template <class E>
 template <class... Args>
     requires(std::is_constructible_v<E, Args...> && !detail::unexpect_dangles_v<E, Args...>)
@@ -2341,7 +2340,8 @@ class expected<T&, E> {
 
     // Copy constructor (non-trivial path)
     constexpr expected(const expected& rhs) noexcept(std::is_nothrow_copy_constructible_v<unexpected<E>>)
-        requires(std::is_copy_constructible_v<unexpected<E>> && !std::is_trivially_copy_constructible_v<unexpected<E>>);
+        requires(std::is_copy_constructible_v<unexpected<E>> && !std::is_trivially_copy_constructible_v<unexpected<E>>)
+    ;
 
     // Move constructor (trivial path)
     constexpr expected(expected&&) noexcept
@@ -2350,7 +2350,8 @@ class expected<T&, E> {
 
     // Move constructor (non-trivial path)
     constexpr expected(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<unexpected<E>>)
-        requires(std::is_move_constructible_v<unexpected<E>> && !std::is_trivially_move_constructible_v<unexpected<E>>);
+        requires(std::is_move_constructible_v<unexpected<E>> && !std::is_trivially_move_constructible_v<unexpected<E>>)
+    ;
 
     // Deleted: no in-place value constructor — T& cannot be constructed in-place
     template <class... Args>
@@ -2362,8 +2363,7 @@ class expected<T&, E> {
                  !std::is_same_v<std::remove_cvref_t<U>, expected<T&, E>> &&
                  !detail::is_unexpected_specialization<std::remove_cvref_t<U>>::value &&
                  std::is_constructible_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U>)
-    constexpr explicit(!std::is_convertible_v<U, T&>) expected(U&& u) noexcept(
-        std::is_nothrow_constructible_v<T&, U>)
+    constexpr explicit(!std::is_convertible_v<U, T&>) expected(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>)
         : has_val_(true) {
         T& r = std::forward<U>(u);
         val_ = std::addressof(r);
@@ -2398,8 +2398,7 @@ class expected<T&, E> {
     template <class U, class G>
         requires(std::is_reference_v<E> && std::is_reference_v<G> && std::is_constructible_v<T&, U&> &&
                  std::is_convertible_v<G, E> && !detail::reference_constructs_from_temporary_v<T&, U&>)
-    constexpr explicit(!std::is_convertible_v<U&, T&> || !std::is_convertible_v<G, E>)
-        expected(expected<U&, G>&& rhs);
+    constexpr explicit(!std::is_convertible_v<U&, T&> || !std::is_convertible_v<G, E>) expected(expected<U&, G>&& rhs);
 
     // Constructor from unexpected<G> const& / && — value-E path
     template <class G>
@@ -2473,8 +2472,7 @@ class expected<T&, E> {
     // Copy assignment (trivial path)
     constexpr expected& operator=(const expected&)
         requires(std::is_trivially_copy_constructible_v<unexpected<E>> &&
-                 std::is_trivially_copy_assignable_v<unexpected<E>> &&
-                 std::is_trivially_destructible_v<unexpected<E>>)
+                 std::is_trivially_copy_assignable_v<unexpected<E>> && std::is_trivially_destructible_v<unexpected<E>>)
     = default;
 
     // Copy assignment (non-trivial path)
@@ -2487,8 +2485,7 @@ class expected<T&, E> {
     // Move assignment (trivial path)
     constexpr expected& operator=(expected&&) noexcept
         requires(std::is_trivially_move_constructible_v<unexpected<E>> &&
-                 std::is_trivially_move_assignable_v<unexpected<E>> &&
-                 std::is_trivially_destructible_v<unexpected<E>>)
+                 std::is_trivially_move_assignable_v<unexpected<E>> && std::is_trivially_destructible_v<unexpected<E>>)
     = default;
 
     // Move assignment (non-trivial path)
@@ -2519,8 +2516,7 @@ class expected<T&, E> {
 
     // Assignment from unexpected<G> — value-E path
     template <class G>
-        requires(!std::is_reference_v<E> && std::is_constructible_v<E, const G&> &&
-                 std::is_assignable_v<E&, const G&>)
+        requires(!std::is_reference_v<E> && std::is_constructible_v<E, const G&> && std::is_assignable_v<E&, const G&>)
     constexpr expected& operator=(const unexpected<G>& e);
 
     template <class G>
@@ -2705,7 +2701,6 @@ constexpr expected<T&, E>::expected(expected&& rhs) noexcept(std::is_nothrow_mov
         std::construct_at(std::addressof(unex_), std::move(rhs.unex_));
 }
 
-
 template <class T, class E>
 template <class U, class G>
     requires(!std::is_reference_v<E> && std::is_constructible_v<T&, U&> && std::is_constructible_v<E, const G&> &&
@@ -2862,7 +2857,6 @@ expected<T&, E>::operator=(expected&& rhs) noexcept(std::is_nothrow_move_constru
     return *this;
 }
 
-
 template <class T, class E>
 template <class G>
     requires(!std::is_reference_v<E> && std::is_constructible_v<E, const G&> && std::is_assignable_v<E&, const G&>)
@@ -2929,8 +2923,9 @@ constexpr T& expected<T&, E>::emplace(U&& u) noexcept(std::is_nothrow_constructi
 // =============================================================================
 
 template <class T, class E>
-constexpr void expected<T&, E>::swap(expected& rhs) noexcept(
-    std::is_nothrow_move_constructible_v<unexpected<E>> && (std::is_reference_v<E> || std::is_nothrow_swappable_v<E>))
+constexpr void expected<T&, E>::swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<unexpected<E>> &&
+                                                             (std::is_reference_v<E> ||
+                                                              std::is_nothrow_swappable_v<E>))
     requires((std::is_reference_v<E> || std::is_swappable_v<E>) && std::is_move_constructible_v<unexpected<E>>)
 {
     if (has_val_ && rhs.has_val_) {
diff --git a/include/beman/expected/unexpected.hpp b/include/beman/expected/unexpected.hpp
index 43516d0..9a269b4 100644
--- a/include/beman/expected/unexpected.hpp
+++ b/include/beman/expected/unexpected.hpp
@@ -125,10 +125,9 @@ class unexpected<E&> {
     // Binds E& directly to the referenced object; deleted below when G would bind to a temporary.
     template <class G = E>
         requires(!std::is_same_v<std::remove_cvref_t<G>, unexpected> &&
-                 !std::is_same_v<std::remove_cvref_t<G>, std::in_place_t> && std::is_constructible_v<E&, G&&> &&
+                 !std::is_same_v<std::remove_cvref_t<G>, std::in_place_t> && std::is_constructible_v<E&, G &&> &&
                  !detail::reference_constructs_from_temporary_v<E&, G>)
-    constexpr explicit unexpected(G&& e) noexcept
-        : ptr_(std::addressof(static_cast<E&>(std::forward<G>(e)))) {}
+    constexpr explicit unexpected(G&& e) noexcept : ptr_(std::addressof(static_cast<E&>(std::forward<G>(e)))) {}
 
     // Deleted: binding would dangle (G materializes a temporary)
     template <class G>
@@ -138,7 +137,7 @@ class unexpected<E&> {
     // Deleted catch-all: neither constructible nor a dangling case
     template <class G>
         requires(!std::is_same_v<std::remove_cvref_t<G>, unexpected> &&
-                 !std::is_same_v<std::remove_cvref_t<G>, std::in_place_t> && !std::is_constructible_v<E&, G&&> &&
+                 !std::is_same_v<std::remove_cvref_t<G>, std::in_place_t> && !std::is_constructible_v<E&, G &&> &&
                  !detail::reference_constructs_from_temporary_v<E&, G>)
     constexpr unexpected(G&&) = delete;
 
@@ -147,7 +146,7 @@ class unexpected<E&> {
     // reference or not. Naturally restricted to arity 1: there is no variadic overload here,
     // and expected only ever calls this when is_constructible_v<E&, Args...> already holds.
     template <class G = E>
-        requires(std::is_constructible_v<E&, G&&> && !detail::reference_constructs_from_temporary_v<E&, G>)
+        requires(std::is_constructible_v<E&, G &&> && !detail::reference_constructs_from_temporary_v<E&, G>)
     constexpr explicit unexpected(std::in_place_t, G&& e) noexcept
         : ptr_(std::addressof(static_cast<E&>(std::forward<G>(e)))) {}
 
diff --git a/papers/wg21-latex/implementation.hpp b/papers/wg21-latex/implementation.hpp
index 1d6aad4..4c73798 100644
--- a/papers/wg21-latex/implementation.hpp
+++ b/papers/wg21-latex/implementation.hpp
@@ -10,9 +10,8 @@ template <class T>
 class optional<T&> {
   public:
     using value_type = T;
-    using iterator =
-        std::contiguous_iterator<T,
-                                 optional>; // see [optionalref.iterators]
+    using iterator   = std::contiguous_iterator<T,
+                                                optional>; // see [optionalref.iterators]
   public:
     // \ref{optionalref.ctor}, constructors
 
@@ -21,13 +20,11 @@ class optional<T&> {
     constexpr optional(const optional& rhs) noexcept = default;
 
     template <class Arg>
-        requires(std::is_constructible_v<T&, Arg> &&
-                 !std::reference_constructs_from_temporary_v<T&, Arg>)
+        requires(std::is_constructible_v<T&, Arg> && !std::reference_constructs_from_temporary_v<T&, Arg>)
     constexpr explicit optional(in_place_t, Arg&& arg);
 
     template <class U>
-        requires(std::is_constructible_v<T&, U> &&
-                 !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
+        requires(std::is_constructible_v<T&, U> && !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
                  !(std::is_same_v<std::remove_cvref_t<U>, optional>) &&
                  !std::reference_constructs_from_temporary_v<T&, U>)
     constexpr explicit(!std::is_convertible_v<U, T&>)
@@ -36,8 +33,7 @@ class optional<T&> {
     }
 
     template <class U>
-        requires(std::is_constructible_v<T&, U> &&
-                 !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
+        requires(std::is_constructible_v<T&, U> && !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
                  !(std::is_same_v<std::remove_cvref_t<U>, optional>) &&
                  std::reference_constructs_from_temporary_v<T&, U>)
     constexpr optional(U&& u) = delete;
@@ -47,66 +43,47 @@ class optional<T&> {
     // allows correct constraints by propagating the value category from the
     // optional to the value within the rhs.
     template <class U>
-        requires(std::is_constructible_v<T&, U&> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 !std::reference_constructs_from_temporary_v<T&, U&>)
-    constexpr explicit(!std::is_convertible_v<U&, T&>) optional(
-        optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, U&>);
+        requires(std::is_constructible_v<T&, U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, U&>)
+    constexpr explicit(!std::is_convertible_v<U&, T&>)
+        optional(optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, U&>);
 
     template <class U>
-        requires(std::is_constructible_v<T&, const U&> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 !std::reference_constructs_from_temporary_v<T&, const U&>)
+        requires(std::is_constructible_v<T&, const U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, const U&>)
     constexpr explicit(!std::is_convertible_v<const U&, T&>)
-        optional(const optional<U>& rhs) noexcept(
-            std::is_nothrow_constructible_v<T&, const U&>);
+        optional(const optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, const U&>);
 
     template <class U>
-        requires(std::is_constructible_v<T&, U> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 !std::reference_constructs_from_temporary_v<T&, U>)
+        requires(std::is_constructible_v<T&, U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, U>)
     constexpr explicit(!std::is_convertible_v<U, T&>)
-        optional(optional<U>&& rhs) noexcept(
-            noexcept(std::is_nothrow_constructible_v<T&, U>));
+        optional(optional<U>&& rhs) noexcept(noexcept(std::is_nothrow_constructible_v<T&, U>));
 
     template <class U>
-        requires(std::is_constructible_v<T&, const U> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 !std::reference_constructs_from_temporary_v<T&, const U>)
+        requires(std::is_constructible_v<T&, const U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, const U>)
     constexpr explicit(!std::is_convertible_v<const U, T&>)
-        optional(const optional<U>&& rhs) noexcept(
-            noexcept(std::is_nothrow_constructible_v<T&, const U>));
+        optional(const optional<U>&& rhs) noexcept(noexcept(std::is_nothrow_constructible_v<T&, const U>));
 
     template <class U>
-        requires(std::is_constructible_v<T&, U&> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 std::reference_constructs_from_temporary_v<T&, U&>)
+        requires(std::is_constructible_v<T&, U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && std::reference_constructs_from_temporary_v<T&, U&>)
     constexpr optional(optional<U>& rhs) = delete;
 
     template <class U>
-        requires(std::is_constructible_v<T&, const U&> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 std::reference_constructs_from_temporary_v<T&, const U&>)
+        requires(std::is_constructible_v<T&, const U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && std::reference_constructs_from_temporary_v<T&, const U&>)
     constexpr optional(const optional<U>& rhs) = delete;
 
     template <class U>
-        requires(std::is_constructible_v<T&, U> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 std::reference_constructs_from_temporary_v<T&, U>)
+        requires(std::is_constructible_v<T&, U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && std::reference_constructs_from_temporary_v<T&, U>)
     constexpr optional(optional<U>&& rhs) = delete;
 
     template <class U>
-        requires(std::is_constructible_v<T&, const U> &&
-                 !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-                 !std::is_same_v<T&, U> &&
-                 std::reference_constructs_from_temporary_v<T&, const U>)
+        requires(std::is_constructible_v<T&, const U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+                 !std::is_same_v<T&, U> && std::reference_constructs_from_temporary_v<T&, const U>)
     constexpr optional(const optional<U>&& rhs) = delete;
 
     // \ref{optionalref.dtor}, destructor
@@ -118,10 +95,8 @@ class optional<T&> {
     constexpr optional& operator=(const optional& rhs) noexcept = default;
 
     template <class U>
-        requires(std::is_constructible_v<T&, U> &&
-                 !std::reference_constructs_from_temporary_v<T&, U>)
-    constexpr T&
-    emplace(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>);
+        requires(std::is_constructible_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, U>)
+    constexpr T& emplace(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>);
 
     // \ref{optionalref.swap}, swap
     constexpr void swap(optional& rhs) noexcept;
@@ -167,8 +142,7 @@ class optional<T&> {
 //  \rSec3[optionalref.ctor]{Constructors}
 template <class T>
 template <class Arg>
-    requires(std::is_constructible_v<T&, Arg> &&
-             !std::reference_constructs_from_temporary_v<T&, Arg>)
+    requires(std::is_constructible_v<T&, Arg> && !std::reference_constructs_from_temporary_v<T&, Arg>)
 constexpr optional<T&>::optional(in_place_t, Arg&& arg) {
     convert_ref_init_val(std::forward<Arg>(arg));
 }
@@ -187,12 +161,9 @@ constexpr optional<T&>::optional(in_place_t, Arg&& arg) {
 
 template <class T>
 template <class U>
-    requires(std::is_constructible_v<T&, U&> &&
-             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-             !std::is_same_v<T&, U> &&
-             !std::reference_constructs_from_temporary_v<T&, U&>)
-constexpr optional<T&>::optional(optional<U>& rhs) noexcept(
-    std::is_nothrow_constructible_v<T&, U&>) {
+    requires(std::is_constructible_v<T&, U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, U&>)
+constexpr optional<T&>::optional(optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, U&>) {
     if (rhs.has_value()) {
         convert_ref_init_val(*rhs);
     }
@@ -200,12 +171,9 @@ constexpr optional<T&>::optional(optional<U>& rhs) noexcept(
 
 template <class T>
 template <class U>
-    requires(std::is_constructible_v<T&, const U&> &&
-             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-             !std::is_same_v<T&, U> &&
-             !std::reference_constructs_from_temporary_v<T&, const U&>)
-constexpr optional<T&>::optional(const optional<U>& rhs) noexcept(
-    std::is_nothrow_constructible_v<T&, const U&>) {
+    requires(std::is_constructible_v<T&, const U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, const U&>)
+constexpr optional<T&>::optional(const optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, const U&>) {
     if (rhs.has_value()) {
         convert_ref_init_val(*rhs);
     }
@@ -213,12 +181,9 @@ constexpr optional<T&>::optional(const optional<U>& rhs) noexcept(
 
 template <class T>
 template <class U>
-    requires(std::is_constructible_v<T&, U> &&
-             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-             !std::is_same_v<T&, U> &&
-             !std::reference_constructs_from_temporary_v<T&, U>)
-constexpr optional<T&>::optional(optional<U>&& rhs) noexcept(
-    noexcept(std::is_nothrow_constructible_v<T&, U>)) {
+    requires(std::is_constructible_v<T&, U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, U>)
+constexpr optional<T&>::optional(optional<U>&& rhs) noexcept(noexcept(std::is_nothrow_constructible_v<T&, U>)) {
     if (rhs.has_value()) {
         convert_ref_init_val(*std::move(rhs));
     }
@@ -226,10 +191,8 @@ constexpr optional<T&>::optional(optional<U>&& rhs) noexcept(
 
 template <class T>
 template <class U>
-    requires(std::is_constructible_v<T&, const U> &&
-             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
-             !std::is_same_v<T&, U> &&
-             !std::reference_constructs_from_temporary_v<T&, const U>)
+    requires(std::is_constructible_v<T&, const U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, const U>)
 constexpr optional<T&>::optional(const optional<U>&& rhs) noexcept(
     noexcept(std::is_nothrow_constructible_v<T&, const U>)) {
     if (rhs.has_value()) {
@@ -246,10 +209,8 @@ constexpr optional<T&>& optional<T&>::operator=(nullopt_t) noexcept {
 
 template <class T>
 template <class U>
-    requires(std::is_constructible_v<T&, U> &&
-             !std::reference_constructs_from_temporary_v<T&, U>)
-constexpr T&
-optional<T&>::emplace(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>) {
+    requires(std::is_constructible_v<T&, U> && !std::reference_constructs_from_temporary_v<T&, U>)
+constexpr T& optional<T&>::emplace(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>) {
     convert_ref_init_val(std::forward<U>(u));
     return *value_;
 }
@@ -301,12 +262,9 @@ constexpr T& optional<T&>::value() const {
 template <class T>
 template <class U>
 constexpr std::remove_cv_t<T> optional<T&>::value_or(U&& u) const {
-    static_assert(std::is_constructible_v<std::remove_cv_t<T>, T&>,
-                  "T must be constructible from a T&");
-    static_assert(std::is_convertible_v<U, std::remove_cv_t<T>>,
-                  "Must be able to convert u to T");
-    return has_value() ? *value_
-                       : static_cast<std::remove_cv_t<T>>(std::forward<U>(u));
+    static_assert(std::is_constructible_v<std::remove_cv_t<T>, T&>, "T must be constructible from a T&");
+    static_assert(std::is_convertible_v<U, std::remove_cv_t<T>>, "Must be able to convert u to T");
+    return has_value() ? *value_ : static_cast<std::remove_cv_t<T>>(std::forward<U>(u));
 }
 
 //   \rSec3[optionalref.monadic]{Monadic operations}
@@ -324,15 +282,11 @@ constexpr auto optional<T&>::and_then(F&& f) const {
 
 template <class T>
 template <class F>
-constexpr optional<std::invoke_result_t<F, T&>>
-optional<T&>::transform(F&& f) const {
+constexpr optional<std::invoke_result_t<F, T&>> optional<T&>::transform(F&& f) const {
     using U = std::invoke_result_t<F, T&>;
-    static_assert(!std::is_same_v<std::remove_cvref_t<U>, in_place_t>,
-                  "Result must not be in_place_t");
-    static_assert(!std::is_same_v<std::remove_cvref_t<U>, nullopt_t>,
-                  "Result must not be nullopt_t");
-    static_assert((std::is_object_v<U> && !std::is_array_v<U>) ||
-                      std::is_lvalue_reference_v<U>,
+    static_assert(!std::is_same_v<std::remove_cvref_t<U>, in_place_t>, "Result must not be in_place_t");
+    static_assert(!std::is_same_v<std::remove_cvref_t<U>, nullopt_t>, "Result must not be nullopt_t");
+    static_assert((std::is_object_v<U> && !std::is_array_v<U>) || std::is_lvalue_reference_v<U>,
                   "Result must be an non-array object or an lvalue reference");
     if (has_value()) {
         return optional<U>{std::invoke(std::forward<F>(f), *value_)};
@@ -345,8 +299,7 @@ template <class T>
 template <class F>
 constexpr optional<T&> optional<T&>::or_else(F&& f) const {
     using U = std::invoke_result_t<F>;
-    static_assert(std::is_same_v<std::remove_cvref_t<U>, optional>,
-                  "Result must be an optional");
+    static_assert(std::is_same_v<std::remove_cvref_t<U>, optional>, "Result must be an optional");
     if (has_value()) {
         return *value_;
     } else {
@@ -364,15 +317,11 @@ constexpr void optional<T&>::reset() noexcept {
 namespace std {
 template <typename T>
     requires requires(T a) {
-        {
-            std::hash<remove_const_t<T>>{}(a)
-        } -> std::convertible_to<std::size_t>;
+        { std::hash<remove_const_t<T>>{}(a) } -> std::convertible_to<std::size_t>;
     }
 struct hash<beman::optional::optional<T>> {
-    static_assert(!is_reference_v<T>,
-                  "hash is not enabled for reference types");
-    size_t operator()(const beman::optional::optional<T>& o) const
-        noexcept(noexcept(hash<remove_const_t<T>>{}(*o))) {
+    static_assert(!is_reference_v<T>, "hash is not enabled for reference types");
+    size_t operator()(const beman::optional::optional<T>& o) const noexcept(noexcept(hash<remove_const_t<T>>{}(*o))) {
         if (o) {
             return std::hash<std::remove_const_t<T>>{}(*o);
         } else {
diff --git a/tests/beman/expected/CMakeLists.txt b/tests/beman/expected/CMakeLists.txt
index 8b9c100..6995659 100644
--- a/tests/beman/expected/CMakeLists.txt
+++ b/tests/beman/expected/CMakeLists.txt
@@ -78,7 +78,10 @@ if(NOT BEMAN_EXPECTED_USING_LIBCXX)
         beman.expected.tests.expected.std
         PRIVATE BEMAN_EXPECTED_TEST_STD
     )
-    target_compile_features(beman.expected.tests.expected.std PRIVATE cxx_std_23)
+    target_compile_features(
+        beman.expected.tests.expected.std
+        PRIVATE cxx_std_23
+    )
     target_include_directories(
         beman.expected.tests.expected.std
         PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/tests
diff --git a/tests/beman/expected/expected_ref.test.cpp b/tests/beman/expected/expected_ref.test.cpp
index 26f6775..e014aaf 100644
--- a/tests/beman/expected/expected_ref.test.cpp
+++ b/tests/beman/expected/expected_ref.test.cpp
@@ -522,8 +522,8 @@ TEST_CASE("expected<T&>: const transform", "[expected_ref]") {
 
 TEST_CASE("expected<T&>: const transform on error - propagates", "[expected_ref]") {
     const expected<int&, int> e(unexpect, 5);
-    bool                       called = false;
-    auto                       r      = e.transform([&](int&) {
+    bool                      called = false;
+    auto                      r      = e.transform([&](int&) {
         called = true;
         return 0;
     });
diff --git a/tests/beman/expected/expected_review_corrections.test.cpp b/tests/beman/expected/expected_review_corrections.test.cpp
index 1852f75..39acb99 100644
--- a/tests/beman/expected/expected_review_corrections.test.cpp
+++ b/tests/beman/expected/expected_review_corrections.test.cpp
@@ -67,7 +67,7 @@ TEST_CASE("reference-error construction from unexpected<E&> binds an external ob
 static_assert(std::is_assignable_v<expected<void, int&>&, unexpected<int&>>);
 static_assert(std::is_assignable_v<expected<int, int&>&, unexpected<int&>>);
 static_assert(std::is_assignable_v<expected<int&, int&>&, unexpected<int&>>);
-static_assert(std::is_assignable_v<expected<int, const int&>&, unexpected<int&>>); // more-const OK
+static_assert(std::is_assignable_v<expected<int, const int&>&, unexpected<int&>>);  // more-const OK
 static_assert(!std::is_assignable_v<expected<int, int&>&, unexpected<int>>);        // value G: deleted
 static_assert(!std::is_assignable_v<expected<int, int&>&, unexpected<const int&>>); // const drop: no overload
 
@@ -80,7 +80,7 @@ TEST_CASE("rebinding assignment from unexpected<E&> repoints the error reference
         REQUIRE(&e.error() == &g2); // rebound to g2
         REQUIRE(g1 == 1);           // previously-referenced object untouched
         g2 = 42;
-        REQUIRE(e.error() == 42);   // sees the new referent
+        REQUIRE(e.error() == 42); // sees the new referent
     }
     SECTION("value -> error transition (expected<int, int&>)") {
         expected<int, int&> e{7};
@@ -89,7 +89,7 @@ TEST_CASE("rebinding assignment from unexpected<E&> repoints the error reference
         REQUIRE(&e.error() == &g2);
     }
     SECTION("both references (expected<int&, int&>)") {
-        int target = 5;
+        int                  target = 5;
         expected<int&, int&> e{target};
         e = unexpected<int&>(g2);
         REQUIRE_FALSE(e.has_value());
@@ -129,9 +129,9 @@ TEST_CASE("value constructor propagates a throwing reference conversion", "[ref]
 }
 
 TEST_CASE("emplace propagates a throwing reference conversion", "[ref][emplace][noexcept]") {
-    int target = 5;
+    int                 target = 5;
     expected<int&, int> e{target};
-    int caught = 0;
+    int                 caught = 0;
     try {
         e.emplace(ThrowingRef{});
     } catch (int v) {
@@ -199,14 +199,14 @@ static_assert(!has_error_or<expected<int&, std::string>&, NotConvertible>);
 
 TEST_CASE("converting from an rvalue reference expected does not steal the referent", "[ref][convert][shallow]") {
     SECTION("value side: expected<string,int> <- expected<string&,int>&&") {
-        std::string                s = "bar";
+        std::string                 s = "bar";
         expected<std::string&, int> r{s};
         expected<std::string, int>  o{std::move(r)};
         REQUIRE(s == "bar"); // referent untouched (copied, not moved)
         REQUIRE(o.value() == "bar");
     }
     SECTION("value side, assignment") {
-        std::string                s = "bar";
+        std::string                 s = "bar";
         expected<std::string&, int> r{s};
         expected<std::string, int>  o{std::in_place, "x"};
         o = std::move(r);
@@ -214,7 +214,7 @@ TEST_CASE("converting from an rvalue reference expected does not steal the refer
         REQUIRE(o.value() == "bar");
     }
     SECTION("error side: expected<int,string> <- expected<int,string&>&&") {
-        std::string                s = "bar";
+        std::string                 s = "bar";
         expected<int, std::string&> r{unexpect, s};
         expected<int, std::string>  o{std::move(r)};
         REQUIRE(s == "bar");
@@ -225,8 +225,8 @@ TEST_CASE("converting from an rvalue reference expected does not steal the refer
 TEST_CASE("constructing/assigning a value error from unexpected<E&> does not steal the referent",
           "[unexpected][convert][shallow]") {
     SECTION("construction") {
-        std::string                 s = "bar";
-        expected<int, std::string>  o{unexpected<std::string&>(s)};
+        std::string                s = "bar";
+        expected<int, std::string> o{unexpected<std::string&>(s)};
         REQUIRE(s == "bar"); // external referent copied, not moved
         REQUIRE(o.error() == "bar");
     }
diff --git a/tests/beman/expected/expected_void_monadic.test.cpp b/tests/beman/expected/expected_void_monadic.test.cpp
index cb480de..fa2a414 100644
--- a/tests/beman/expected/expected_void_monadic.test.cpp
+++ b/tests/beman/expected/expected_void_monadic.test.cpp
@@ -281,7 +281,7 @@ TEST_CASE("or_else rvalue on error calls F", "[expected_void_monadic]") {
 
 TEST_CASE("or_else const rvalue on error calls F", "[expected_void_monadic]") {
     const expected<void, int> e(unexpect, 5);
-    auto                       r = std::move(e).or_else([](int v) -> expected<void, int> { return unexpected(v + 1); });
+    auto                      r = std::move(e).or_else([](int v) -> expected<void, int> { return unexpected(v + 1); });
     REQUIRE(!r.has_value());
     CHECK(r.error() == 6);
 }