diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76788888..7de1a05b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,3 +1,6 @@
+# /CMakeLists.txt -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 cmake_minimum_required(VERSION 3.10)
 
 project(beman_optional26 VERSION 0.0.0 LANGUAGES CXX)
diff --git a/Makefile b/Makefile
index b7083a8f..f675d76b 100755
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,6 @@
 #! /usr/bin/make -f
-# -*-makefile-*-
+# /Makefile -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 INSTALL_PREFIX?=.install/
 PROJECT?=$(shell basename $(CURDIR))
diff --git a/README.md b/README.md
index f2c77a56..8ec56989 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,16 @@
 # Beman.Optional26: C++26 Extensions for std::optional
 
+<!--
+SPDX-License-Identifier: 2.0 license with LLVM exceptions
+-->
+
 This implementation incorporates the C++26 extensions added for `std::optional`. The `Beman.Optional26` library aims to evaluate the stability, the usability, and the performance of these proposed changes before they are officially adopted by WG21 into the C++ Working Draft. Additionally, it allows developers to use these new features before they are implemented in major standard library compilers.
 
 **Implements**:
+* [Give *std::optional* Range Support (P3168R1)](https://wg21.link/P3168R1)
 * [`std::optional<T&>` (P2988R5)](https://wg21.link/P2988R5)
-* [Give *std::optional* Range Support (P3168R1)](https://wg21.link/P3168R1).
 
+## License
 
 Source is licensed with the Apache 2.0 license with LLVM exceptions
 
@@ -21,8 +26,74 @@ The README itself is licesed with CC0 1.0 Universal. Copy the contents and incor
 
 // SPDX-License-Identifier: CC0-1.0
 
+## Examples
+
+Full runable examples can be found in `examples/` - please check [./examples/README.md](./examples/README.md).
+
+### range_loop
+
+The next code snippet shows optional range support added in [Give *std::optional* Range Support (P3168R1)](https://wg21.link/P3168R1):
+
+```cpp
+#include <Beman/Optional26/optional.hpp>
+...
+
+// Example from P3168R1: basic range loop over C++26 optional.
+
+beman::optional26::optional<int> empty_opt{};
+for ([[maybe_unused]] const auto& i : empty_opt) {
+    // Should not see this in console.
+    std::cout << "\"for each loop\" over C++26 optional: empty_opt\n";
+}
+
+beman::optional26::optional<int> opt{26};
+for (const auto& i : opt) {
+    // Should see this in console.
+    std::cout << "\"for each loop\" over C++26 optional: opt = " << i << "\n";
+}
+```
+
+Full code can be found in [./examples/range_loop.cpp](./examples/range_loop.cpp). Build and run instructions in [./examples/README.md](./examples/README.md).
+
+### optional_ref
+
+The next code snippet shows optional reference support added in [`std::optional<T&>` (P2988R5)](https://wg21.link/P2988R5):
+
+```cpp
+#include <Beman/Optional26/optional.hpp>
+...
+
+{
+    // Empty optional example.
+    std::optional<int>             std_empty_opt;
+    beman::optional26::optional<int> beman_empty_opt;
+    assert(!std_empty_opt.has_value() &&
+            !beman_empty_opt.has_value()); // or assert(!std_empty_opt && !beman_empty_opt);
+    std::cout << "std_vs_beman: .has_value() matches?: "
+              << (std_empty_opt.has_value() == beman_empty_opt.has_value() ? "yes" : "no") << "\n";
+}
+
+{
+    // Optional with value example.
+    std::optional<int>             std_opt   = 26;
+    beman::optional26::optional<int> beman_opt = 26;
+    assert(std_opt.has_value() && beman_opt.has_value()); // or assert(std_opt && beman_opt);
+    assert(std_opt.value() == beman_opt.value());         // or assert(*std_opt == *beman_opt);
+    std::cout << "std_vs_beman: .value() matches?: " << (std_opt.value() == beman_opt.value() ? "yes" : "no")
+              << "\n";
+}
+```
+
+Full code can be found in [./examples/optional_ref.cpp](./examples/optional_ref.cpp). Build and run instructions in [./examples/README.md](./examples/README.md).
+
 ## How to Build
 
+### Compiler Support
+
+This is a modern C++ project which can be compiled with the latest C++ standards (**C++20 or later**).
+
+Default build: `C++23`. Please check `etc/${compiler}-flags.cmake`.
+
 ### Dependencies
 
 This project is mainly tested on `Ubuntu 22.04` and `Ubuntu 24.04`, but it should be as portable as CMake is. This project has zero C or C++ dependencies.
@@ -52,6 +123,8 @@ This project strives to be as normal and simple a CMake project as possible. Thi
 
 ```shell
 cmake --workflow --preset gcc-14
+cmake --workflow --preset clang-18
+cmake --workflow --preset systems # uses c++ set tool
 ```
 
 This should build and run the tests with GCC 14 with the address and undefined behavior sanitizers enabled.
@@ -69,6 +142,14 @@ The makefile will use your system compiler, `c++`, if no toolchain name is provi
 ## Papers
 
 Latest revision(s) of the papers can be built / found at:
-* [./papers/P2988/README.md](./papers/P2988/README.md) for `std::optional<T&> (P2988)`.
 * [give-std-optional-range-support](https://github.com/neatudarius/give-std-optional-range-support/) for `Give *std::optional* Range Support (P3168)`
-
+    * issue: [#1831](https://github.com/cplusplus/papers/issues/1831)
+  * LEWG:
+    * Reviewed in Tokyo 2024.
+    * Forwarded by LEWG April electronic poll to LWG.
+  * LWG:
+    * To be reviewed in Saint Louis 2024.
+* [./papers/P2988/README.md](./papers/P2988/README.md) for `std::optional<T&> (P2988)`.
+    * issue: [#1661](https://github.com/cplusplus/papers/issues/1661)
+    * LEWG:
+      * Reviewed in Tokyo 2024.
diff --git a/cmake/Config.cmake.in b/cmake/Config.cmake.in
index 38bbde7b..050aedbf 100644
--- a/cmake/Config.cmake.in
+++ b/cmake/Config.cmake.in
@@ -1,3 +1,6 @@
+# cmake/Config.cmake.in -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 @PACKAGE_INIT@
 
 include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
diff --git a/etc/gcc-flags.cmake b/etc/gcc-flags.cmake
index 3ada9762..60d6f634 100644
--- a/etc/gcc-flags.cmake
+++ b/etc/gcc-flags.cmake
@@ -3,7 +3,7 @@ include_guard(GLOBAL)
 set(CMAKE_CXX_STANDARD 23)
 
 set(CMAKE_CXX_FLAGS
-   "-Wall -Wextra "
+   "-std=c++23 -Wall -Wextra "
 CACHE STRING "CXX_FLAGS" FORCE)
 
 set(CMAKE_CXX_FLAGS_DEBUG "-O0 -fno-inline -g3" CACHE STRING "C++ DEBUG Flags" FORCE)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index aff0f99f..f1781006 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,12 +1,17 @@
+# examples/CMakeLists.txt -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 set(BEMAN_OPTIONAL26_LIBRARY "beman_optional26")
 
 include(GNUInstallDirs)
 
 # List of all buildable examples.
 set(EXAMPLES
-  sample
-  range_loop
   optional_ref
+  pythagorean_triples
+  range_loop
+  sample
+  std_vs_beman
 )
 
 foreach(EXAMPLE ${EXAMPLES})
diff --git a/examples/README.md b/examples/README.md
index b43db0be..a8b6827a 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,7 +1,26 @@
 # Beman.Optional26 Examples
 
+<!--
+SPDX-License-Identifier: 2.0 license with LLVM exceptions
+-->
+
 List of usage examples for `Beman.Optional26`.
 
+## License
+Source is licensed with the Apache 2.0 license with LLVM exceptions
+
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+Documentation and associated papers are licensed with the Creative Commons Attribution 4.0 International license.
+
+// SPDX-License-Identifier: CC-BY-4.0
+
+The intent is that the source and documentation are available for use by people implementing their own optional types as well as people using the optional presented here as-is.
+
+The README itself is licesed with CC0 1.0 Universal. Copy the contents and incorporate in your own work as you see fit.
+
+// SPDX-License-Identifier: CC0-1.0
+
 ## Sample
 
 Check [sample](sample.cpp) for basic `Beman.Optional26` library usage.
@@ -11,28 +30,48 @@ Build and run instructions:
 # build
 $ cmake --workflow --preset gcc-14
 
-# run sample
+# run sample.cpp
 $ .build/gcc-14/examples/RelWithDebInfo/sample
 empty_opt is empty!
 opt = 26
+
+# run std_vs_beman.cpp
+$ .build/gcc-14/examples/RelWithDebInfo/std_vs_beman
+std_vs_beman: .has_value() matches?: yes
+std_vs_beman: .value() matches?: yes
 ```
 
 ## Range Support (P3168R1)
 
 Range support added in [*Give std::optional Range Support* (P3168R1)](https://wg21.link/P3168R1) examples:
 * [./range_loop.cpp](./range_loop.cpp)
+* [./pythagorean_triples.cpp](./pythagorean_triples.cpp)
 
 
 Build and run instructions:
 
 ```shell
-# build
-$ cmake --workflow --preset gcc-14
 
-# run range_loop
+
+# run range_loop.cpp
 $ .build/gcc-14/examples/RelWithDebInfo/range_loop
                                                # note: 1st log (empty_opt) is missing from console!
 "for each loop" over C++26 optional: opt = 26  # 2nd log (non empty opt)
+
+# run pythagorean_triples.cpp
+$ .build/gcc-14/examples/RelWithDebInfo/pythagorean_triples
+First 10 Pythagorean triples:
+(3, 4, 5)
+(6, 8, 10)
+(5, 12, 13)
+(9, 12, 15)
+(8, 15, 17)
+(12, 16, 20)
+(7, 24, 25)
+(15, 20, 25)
+(10, 24, 26)
+(20, 21, 29)
+100th Pythagorean triple (x, y, z <= 200): (26, 168, 170)
 ```
 
 ## Optional Reference (P2988R5)
@@ -40,3 +79,13 @@ $ .build/gcc-14/examples/RelWithDebInfo/range_loop
 Reference support added in [*std::optional<T&>*(P2988R5)](https://wg21.link/P2988R5) examples:
 
 * [./optional_ref.cpp](./optional_ref.cpp)
+
+Build and run instructions:
+
+```shell
+# build
+$ cmake --workflow --preset gcc-14
+
+# run optional_ref.cpp
+$ .build/gcc-14/examples/RelWithDebInfo/optional_ref
+```
diff --git a/examples/optional_ref.cpp b/examples/optional_ref.cpp
index aaa25dfc..e29d2de4 100644
--- a/examples/optional_ref.cpp
+++ b/examples/optional_ref.cpp
@@ -1,34 +1,59 @@
+// examples/optional_ref.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 
 #include <string>
 
-using beman::optional::optional;
-
 struct Cat {
     int catalog_index{0};
 };
 
-auto find_cat_old(std::string) -> Cat* { return nullptr; }
+namespace std17 {
+
+// Prior to C++26, the code would look like this.
+// Using raw pointers to represent optional references.
+// Note: Using smart pointers would also be a choice, but it involves ownership semantics.
 
-auto find_cat_new(std::string) -> optional<Cat&> { return optional<Cat&>{}; }
+Cat* find_cat(std::string) { return nullptr; }
 
-Cat*           doit_old(Cat& cat) { return &cat; }
-optional<Cat&> doit(Cat& cat) { return optional<Cat&>{cat}; }
+Cat* do_it(Cat& cat) { return &cat; }
 
-Cat* before1() {
-    Cat* cat = find_cat_old("Fido");
+Cat* api() {
+    Cat* cat = find_cat("Fido");
     if (cat != nullptr) {
-        return doit_old(*cat);
+        return do_it(*cat);
     }
     return nullptr;
 }
 
-optional<Cat&> after1() {
-    optional<Cat&> cat = find_cat_new("Fido");
-    return cat.and_then(doit);
+} // namespace std17
+
+namespace std26 {
+// After C++26 with P2988R5, the code would look like this.
+// Using directly optional to represent optional references.
+
+beman::optional26::optional<Cat&> find_cat(std::string) { return {}; }
+
+beman::optional26::optional<Cat&> do_it(Cat& cat) { return {cat}; }
+
+beman::optional26::optional<Cat&> api() {
+    beman::optional26::optional<Cat&> cat = find_cat("Fido");
+    return cat.and_then(do_it);
 }
 
+} // namespace std26
+
 int main() {
-    Cat*           cat_p = before1();
-    optional<Cat&> cat_r = after1();
+    // Example from P2988R5: optional reference.
+    [[maybe_unused]] Cat*                              old_cat = std17::api();
+    [[maybe_unused]] beman::optional26::optional<Cat&> new_cat = std26::api();
+
+    return 0;
 }
+
+// # build example:
+// $ cmake --workflow --preset gcc-14
+//
+// # run example:
+// $ .build/gcc-14/examples/RelWithDebInfo/optional_ref
diff --git a/examples/pythagorean_triples.cpp b/examples/pythagorean_triples.cpp
new file mode 100644
index 00000000..ce4b508b
--- /dev/null
+++ b/examples/pythagorean_triples.cpp
@@ -0,0 +1,105 @@
+// examples/pythagorean_triples.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <Beman/Optional26/optional.hpp>
+
+#include <cassert>
+#include <concepts>
+#include <iostream>
+#include <ranges>
+
+int main() {
+    // Example from P3168R1: generate an infinite sequence of Pythagorean triples.
+    // (x, y, z) is a Pythagorean triple if 1 <= x <= y <= z and x^2 + y^2 = z^2.
+    constexpr auto yield_if = []<class T>(bool b, T x) -> beman::optional26::optional<T> {
+        return b ? beman::optional26::optional<T>{std::move(x)} : beman::optional26::nullopt;
+    };
+    constexpr auto and_then = []<class T>(T&& r, auto fun) {
+        return decltype(r)(r) | std::views::transform(std::move(fun)) | std::views::join;
+    };
+    auto triples = and_then(std::views::iota(1), [=](int z) {
+        return and_then(std::views::iota(1, z + 1), [=](int x) {
+            return and_then(std::views::iota(x, z + 1),
+                            [=](int y) { return yield_if(x * x + y * y == z * z, std::make_tuple(x, y, z)); });
+        });
+    });
+
+    {
+        // Generate first 10 Pythagorean triples.
+        // https://mathworld.wolfram.com/PythagoreanTriple.html
+        [[maybe_unused]] auto&& r = triples | std::views::take(10);
+        assert(std::ranges::equal(r,
+                                  std::vector{
+                                      std::tuple{3, 4, 5},
+                                      std::tuple{6, 8, 10},
+                                      std::tuple{5, 12, 13},
+                                      std::tuple{9, 12, 15},
+                                      std::tuple{8, 15, 17},
+                                      std::tuple{12, 16, 20},
+                                      std::tuple{7, 24, 25},
+                                      std::tuple{15, 20, 25},
+                                      std::tuple{10, 24, 26},
+                                      std::tuple{20, 21, 29},
+                                  }));
+
+        std::cout << "First 10 Pythagorean triples:\n";
+        for (const auto& [x, y, z] : r) {
+            std::cout << "(" << x << ", " << y << ", " << z << ")\n";
+        }
+    }
+
+    {
+        // Generate the nth Pythagorean triple (x, y, z) where:
+        // 1 <= x <= y <= z <= max_value and x^2 + y^2 = z^2
+
+        // Generate the nth Pythagorean triple with brute force.
+        [[maybe_unused]] auto bruteforce_generate_nth = [](int n, int max_value) -> std::tuple<int, int, int> {
+            int count = 0; // Count the number of Pythagorean triples.
+            for (int z = 1; z <= max_value; ++z) {
+                for (int x = 1; x <= max_value; ++x) {
+                    for (int y = 1; y <= max_value; ++y) {
+                        if (!(x <= y && y <= z) || x * x + y * y != z * z) {
+                            continue;
+                        }
+
+                        if (++count == n) {
+                            return std::make_tuple(x, y, z);
+                        }
+                    }
+                }
+            }
+
+            return {}; // Should not reach here.
+        };
+        [[maybe_unused]] constexpr const std::tuple k100th_triple = {
+            26, 168, 170}; // The 100th Pythagorean triple with x, y, z <= 200.
+        assert(bruteforce_generate_nth(100, 200) == k100th_triple);
+
+        // Generate the 100th Pythagorean triple with ranges.
+        [[maybe_unused]] auto&& r = triples | std::views::drop(99) | std::views::take(1);
+        assert(std::ranges::equal(r, std::vector{k100th_triple}));
+
+        const auto& [x100, y100, z100] = *std::ranges::begin(r);
+        std::cout << "100th Pythagorean triple (x, y, z <= 200): (" << x100 << ", " << y100 << ", " << z100 << ")\n";
+    }
+
+    return 0;
+}
+
+// # build example:
+// $ cmake --workflow --preset gcc-14
+//
+// # run example:
+// $ .build/gcc-14/examples/RelWithDebInfo/pythagorean_triples
+// First 10 Pythagorean triples:
+// (3, 4, 5)
+// (6, 8, 10)
+// (5, 12, 13)
+// (9, 12, 15)
+// (8, 15, 17)
+// (12, 16, 20)
+// (7, 24, 25)
+// (15, 20, 25)
+// (10, 24, 26)
+// (20, 21, 29)
+// 100th Pythagorean triple (x, y, z <= 200): (26, 168, 170)
diff --git a/examples/range_loop.cpp b/examples/range_loop.cpp
index 27a827a2..6830a183 100644
--- a/examples/range_loop.cpp
+++ b/examples/range_loop.cpp
@@ -1,17 +1,31 @@
+// examples/range_loop.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 #include <iostream>
 
 int main() {
-    beman::optional::optional<int> empty_opt{};
+    // Example from P3168R1: basic range loop over C++26 optional.
+
+    beman::optional26::optional<int> empty_opt{};
     for ([[maybe_unused]] const auto& i : empty_opt) {
         // Should not see this in console.
         std::cout << "\"for each loop\" over C++26 optional: empty_opt\n";
     }
 
-    beman::optional::optional<int> opt{26};
+    beman::optional26::optional<int> opt{26};
     for (const auto& i : opt) {
         // Should see this in console.
         std::cout << "\"for each loop\" over C++26 optional: opt = " << i << "\n";
     }
+
     return 0;
 }
+
+// # build example:
+// $ cmake --workflow --preset gcc-14
+//
+// # run example:
+// $ .build/gcc-14/examples/RelWithDebInfo/range_loop
+//                                                # note: 1st log (empty_opt) is missing from console!
+// "for each loop" over C++26 optional: opt = 26  # 2nd log (non empty opt)
diff --git a/examples/sample.cpp b/examples/sample.cpp
index 3d3499bb..e0766288 100644
--- a/examples/sample.cpp
+++ b/examples/sample.cpp
@@ -1,16 +1,27 @@
+// examples/sample.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 #include <iostream>
 
 int main() {
-    beman::optional::optional<int> empty_opt{};
+    beman::optional26::optional<int> empty_opt{};
     if (!empty_opt) {
         std::cout << "empty_opt is empty!\n";
     }
 
-    beman::optional::optional<int> opt{26};
+    beman::optional26::optional<int> opt{26};
     if (opt) {
         std::cout << "opt = " << *opt << "\n";
     }
 
     return 0;
 }
+
+// # build example:
+// $ cmake --workflow --preset gcc-14
+//
+// # run example:
+// $ .build/gcc-14/examples/RelWithDebInfo/sample
+// empty_opt is empty!
+// opt = 26
diff --git a/examples/std_vs_beman.cpp b/examples/std_vs_beman.cpp
new file mode 100644
index 00000000..2485ea62
--- /dev/null
+++ b/examples/std_vs_beman.cpp
@@ -0,0 +1,43 @@
+// examples/std_vs_beman.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <optional>
+#include <Beman/Optional26/optional.hpp>
+
+#include <cassert>
+#include <iostream>
+
+int main() {
+    {
+        // Empty optional example.
+        std::optional<int>               std_empty_opt;
+        beman::optional26::optional<int> beman_empty_opt;
+        assert(!std_empty_opt.has_value() &&
+               !beman_empty_opt.has_value()); // or assert(!std_empty_opt && !beman_empty_opt);
+        std::cout << "std_vs_beman: .has_value() matches?: "
+                  << (std_empty_opt.has_value() == beman_empty_opt.has_value() ? "yes" : "no") << "\n";
+    }
+
+    {
+        // Optional with value example.
+        std::optional<int>               std_opt   = 26;
+        beman::optional26::optional<int> beman_opt = 26;
+        assert(std_opt.has_value() && beman_opt.has_value()); // or assert(std_opt && beman_opt);
+        assert(std_opt.value() == beman_opt.value());         // or assert(*std_opt == *beman_opt);
+        std::cout << "std_vs_beman: .value() matches?: " << (std_opt.value() == beman_opt.value() ? "yes" : "no")
+                  << "\n";
+    }
+
+    // Note: std_empty_opt == beman_empty_opt and std_opt == beman_opt won't compile
+    // (no implementation of operator== for std::optional and beman::optional26::optional).
+
+    return 0;
+}
+
+// # build example:
+// $ cmake --workflow --preset gcc-14
+//
+// # run example:
+// $ .build/gcc-14/examples/RelWithDebInfo/std_vs_beman
+// std_vs_beman: .has_value() matches?: yes
+// std_vs_beman: .value() matches?: yes
diff --git a/extern/CMakeLists.txt b/extern/CMakeLists.txt
index a2177fb3..d9c9f462 100644
--- a/extern/CMakeLists.txt
+++ b/extern/CMakeLists.txt
@@ -1 +1,4 @@
+# extern/CMakeLists.txt -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 add_subdirectory(googletest EXCLUDE_FROM_ALL)
diff --git a/include/Beman/Optional26/detail/iterator.hpp b/include/Beman/Optional26/detail/iterator.hpp
new file mode 100644
index 00000000..98ac581e
--- /dev/null
+++ b/include/Beman/Optional26/detail/iterator.hpp
@@ -0,0 +1,65 @@
+// include/Beman/Optional26/detail/iterator.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef BEMAN_OPTIONAL26_DETAIL_ITERATOR_HPP
+#define BEMAN_OPTIONAL26_DETAIL_ITERATOR_HPP
+
+#include <Beman/Optional26/detail/stl_interfaces/iterator_interface.hpp>
+
+#include <concepts>
+#include <iterator>
+
+namespace beman::optional26::detail {
+
+// Forward declaration.
+template <class T, class Container>
+struct contiguous_iterator;
+
+// Base class for contiguous iterator types with Boost stl_interfaces library.
+// Current implementation based on P2727R4: std::iterator_interface.
+template <class T, class Container>
+using base_contiguous_iterator = stl_interfaces::iterator_interface<
+#if !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+    contiguous_iterator<T, Container>, // Required for P2727R4 to work with C++20/C++23. TODO: Do more experiments.
+#endif
+    std::contiguous_iterator_tag,
+    T>;
+
+// This is a minimal contiguous iterator.  It uses stl_interfaces library from Boost
+// (current implementation based on https://wg21.link/P2727R4).
+//
+// TODO: Change this to use the stl_interfaces library from Beman if/when available.
+//
+// @tparam T - The type of the elements the iterator points to.
+// @tparam Container - The type of the container the iterator points to. This parameter exists solely so that different
+// containers using this template can instantiate different types, even if the T parameter is the same.
+template <class T, class Container>
+struct contiguous_iterator : public base_contiguous_iterator<T, Container> {
+    // Alias for the base class.
+    using base_type = base_contiguous_iterator<T, Container>;
+    // Alias for types from the base class.
+    using typename base_type::difference_type;
+    using typename base_type::pointer;
+    using typename base_type::reference;
+
+    // Default constructor.
+    contiguous_iterator() noexcept : m_current() {}
+
+    // Pointer to iterator constructor.
+    contiguous_iterator(pointer it) noexcept : m_current(it) {}
+
+    // As per P2727R4, for contiguous iterator we only need to provide operator*, operator+= and operator-.
+    reference operator*() const noexcept { return *m_current; }
+    auto&     operator+=(difference_type pos) noexcept {
+        m_current += pos;
+        return *this;
+    }
+    difference_type operator-(contiguous_iterator other) const noexcept { return m_current - other.m_current; }
+
+  private:
+    T* m_current;
+};
+
+} // namespace beman::optional26::detail
+
+#endif // BEMAN_OPTIONAL26_DETAIL_ITERATOR_HPP
diff --git a/include/Beman/Optional26/detail/stl_interfaces/config.hpp b/include/Beman/Optional26/detail/stl_interfaces/config.hpp
new file mode 100644
index 00000000..e48ac01f
--- /dev/null
+++ b/include/Beman/Optional26/detail/stl_interfaces/config.hpp
@@ -0,0 +1,49 @@
+// include/Beman/Optional26/detail/stl_interfaces/config.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright (C) 2020 T. Zachary Laine
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONFIG_HPP
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONFIG_HPP
+
+// Included for definition of __cpp_lib_concepts.
+#include <iterator>
+
+#if defined(__cpp_lib_concepts) && defined(__cpp_lib_ranges) && \
+    !defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DISABLE_CONCEPTS)
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS 1
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS 0
+#endif
+
+#if defined(__cpp_explicit_this_parameter) && BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS && \
+    !defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DISABLE_DEDUCED_THIS)
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS 1
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS 0
+#endif
+
+// The inline namespaces v1, v2, and v3 represent C++14, C++20, and C++23 and
+// later, respectively.  v1 is inline for standards before C++20, and v2 is
+// inline for C++20 and later.  Note that this only applies to code for which
+// multiple vI namespace alternatives exist.  For example, some instances of
+// the v1 namespace may still be inline, if there is no v2 version of its
+// contents.
+#if !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS && !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 inline namespace v1
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 namespace v2
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 namespace v3
+#elif BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS && !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 namespace v1
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 inline namespace v2
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 namespace v3
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 namespace v1
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 namespace v2
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 inline namespace v3
+#endif
+
+#endif
diff --git a/include/Beman/Optional26/detail/stl_interfaces/fwd.hpp b/include/Beman/Optional26/detail/stl_interfaces/fwd.hpp
new file mode 100644
index 00000000..da0f1ab5
--- /dev/null
+++ b/include/Beman/Optional26/detail/stl_interfaces/fwd.hpp
@@ -0,0 +1,88 @@
+// include/Beman/Optional26/detail/stl_interfaces/fwd.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright (C) 2019 T. Zachary Laine
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_FWD_HPP
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_FWD_HPP
+
+#include <Beman/Optional26/detail/stl_interfaces/config.hpp>
+
+#if BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+#include <ranges>
+#endif
+#if defined(__cpp_lib_three_way_comparison)
+#include <compare>
+#endif
+
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+
+#if defined(_MSC_VER) || defined(__GNUC__) && __GNUC__ < 8
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NO_HIDDEN_FRIEND_CONSTEXPR
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR constexpr
+#endif
+
+#if defined(__GNUC__) && __GNUC__ < 9
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONCEPT concept bool
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONCEPT concept
+#endif
+
+#endif
+
+namespace beman::optional26::detail {
+namespace stl_interfaces {
+
+/** An enumeration used to indicate whether the underlying data have a
+    contiguous or discontiguous layout when instantiating `view_interface`
+    and `sequence_container_interface`. */
+enum class element_layout : bool { discontiguous = false, contiguous = true };
+
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 {
+
+    namespace v1_dtl {
+    template <typename... T>
+    using void_t = void;
+
+    template <typename Iter>
+    using iter_difference_t = typename std::iterator_traits<Iter>::difference_type;
+
+    template <typename Range, typename = void>
+    struct iterator;
+    template <typename Range>
+    struct iterator<Range, void_t<decltype(std::declval<Range&>().begin())>> {
+        using type = decltype(std::declval<Range&>().begin());
+    };
+    template <typename Range>
+    using iterator_t = typename iterator<Range>::type;
+
+    template <typename Range, typename = void>
+    struct sentinel;
+    template <typename Range>
+    struct sentinel<Range, void_t<decltype(std::declval<Range&>().end())>> {
+        using type = decltype(std::declval<Range&>().end());
+    };
+    template <typename Range>
+    using sentinel_t = typename sentinel<Range>::type;
+
+    template <typename Range>
+    using range_difference_t = iter_difference_t<iterator_t<Range>>;
+
+    template <typename Range>
+    using common_range = std::is_same<iterator_t<Range>, sentinel_t<Range>>;
+
+    template <typename Range, typename = void>
+    struct decrementable_sentinel : std::false_type {};
+    template <typename Range>
+    struct decrementable_sentinel<Range, void_t<decltype(--std::declval<sentinel_t<Range>&>())>> : std::true_type {};
+    } // namespace v1_dtl
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#endif
diff --git a/include/Beman/Optional26/detail/stl_interfaces/iterator_interface.hpp b/include/Beman/Optional26/detail/stl_interfaces/iterator_interface.hpp
new file mode 100644
index 00000000..534dc566
--- /dev/null
+++ b/include/Beman/Optional26/detail/stl_interfaces/iterator_interface.hpp
@@ -0,0 +1,986 @@
+// include/Beman/Optional26/detail/stl_interfaces/iterator_interface.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright (C) 2019 T. Zachary Laine
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_ITERATOR_INTERFACE_HPP
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_ITERATOR_INTERFACE_HPP
+
+#include <Beman/Optional26/detail/stl_interfaces/fwd.hpp>
+
+#include <utility>
+#include <type_traits>
+#if defined(__cpp_lib_three_way_comparison)
+#include <compare>
+#endif
+
+namespace beman::optional26::detail {
+namespace stl_interfaces {
+
+/** A type for granting access to the private members of an iterator
+    derived from `iterator_interface`. */
+struct access {
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+
+    template <typename D>
+    static constexpr auto base(D& d) noexcept -> decltype(d.base_reference()) {
+        return d.base_reference();
+    }
+    template <typename D>
+    static constexpr auto base(const D& d) noexcept -> decltype(d.base_reference()) {
+        return d.base_reference();
+    }
+
+#endif
+};
+
+/** The return type of `operator->()` in a proxy iterator.
+
+    This template is used as the default `Pointer` template parameter in
+    the `proxy_iterator_interface` template alias.  Note that the use of
+    this template implies a copy or move of the underlying object of type
+    `T`. */
+template <typename T>
+#if defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+// clang-format off
+        requires std::is_object_v<T>
+#endif
+    struct proxy_arrow_result
+// clang-format on
+{
+    constexpr proxy_arrow_result(const T& value) noexcept(noexcept(T(value))) : value_(value) {}
+    constexpr proxy_arrow_result(T&& value) noexcept(noexcept(T(std::move(value)))) : value_(std::move(value)) {}
+
+    constexpr const T* operator->() const noexcept { return &value_; }
+    constexpr T*       operator->() noexcept { return &value_; }
+
+  private:
+    T value_;
+};
+
+namespace detail {
+template <typename Pointer, typename Reference, typename T>
+auto make_pointer(T&& value,
+                  std::enable_if_t<std::is_pointer<Pointer>::value && std::is_reference<Reference>::value, int> = 0)
+    -> decltype(std::addressof(value)) {
+    return std::addressof(value);
+}
+
+template <typename Pointer, typename Reference, typename T>
+auto make_pointer(T&& value,
+                  std::enable_if_t<!std::is_pointer<Pointer>::value && !std::is_same<Pointer, void>::value &&
+                                       std::is_reference<Reference>::value,
+                                   int> = 0) {
+    return Pointer(std::forward<T>(value));
+}
+
+template <typename Pointer, typename IteratorConcept>
+struct pointer {
+    using type = Pointer;
+};
+template <typename Pointer>
+struct pointer<Pointer, std::output_iterator_tag> {
+    using type = void;
+};
+template <typename Pointer, typename IteratorConcept>
+using pointer_t = typename pointer<Pointer, IteratorConcept>::type;
+
+template <typename T, typename U>
+using interoperable =
+    std::integral_constant<bool, (std::is_convertible<T, U>::value || std::is_convertible<U, T>::value)>;
+
+template <typename T, typename U>
+using common_t = std::conditional_t<std::is_convertible<T, U>::value, U, T>;
+
+template <typename T>
+using use_base = decltype(access::base(std::declval<T&>()));
+
+template <typename... T>
+using void_t = void;
+
+template <typename AlwaysVoid, template <class...> class Template, typename... Args>
+struct detector : std::false_type {};
+
+template <template <class...> class Template, typename... Args>
+struct detector<void_t<Template<Args...>>, Template, Args...> : std::true_type {};
+
+template <typename T, typename U, bool UseBase = detector<void, use_base, T>::value>
+struct common_eq {
+    static constexpr auto call(T lhs, U rhs) {
+        return static_cast<common_t<T, U>>(lhs).derived() == static_cast<common_t<T, U>>(rhs).derived();
+    }
+};
+template <typename T, typename U>
+struct common_eq<T, U, true> {
+    static constexpr auto call(T lhs, U rhs) { return access::base(lhs) == access::base(rhs); }
+};
+
+template <typename T, typename U>
+constexpr auto
+common_diff(T lhs, U rhs) noexcept(noexcept(static_cast<common_t<T, U>>(lhs) - static_cast<common_t<T, U>>(rhs)))
+    -> decltype(static_cast<common_t<T, U>>(lhs) - static_cast<common_t<T, U>>(rhs)) {
+    return static_cast<common_t<T, U>>(lhs) - static_cast<common_t<T, U>>(rhs);
+}
+} // namespace detail
+
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+namespace beman::optional26::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 {
+
+    /** A CRTP template that one may derive from to make defining iterators
+        easier.
+
+        The template parameter `D` for `iterator_interface` may be an
+        incomplete type.  Before any member of the resulting specialization of
+        `iterator_interface` other than special member functions is
+        referenced, `D` shall be complete, and model
+        `std::derived_from<iterator_interface<D>>`. */
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType&,
+              typename Pointer        = ValueType*,
+              typename DifferenceType = std::ptrdiff_t
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+              ,
+              typename E = std::enable_if_t<std::is_class<Derived>::value &&
+                                            std::is_same<Derived, std::remove_cv_t<Derived>>::value>
+#endif
+              >
+    struct iterator_interface;
+
+    namespace v1_dtl {
+    template <typename Iterator, typename = void>
+    struct ra_iter : std::false_type {};
+    template <typename Iterator>
+    struct ra_iter<Iterator, void_t<typename Iterator::iterator_concept>>
+        : std::integral_constant<
+              bool,
+              std::is_base_of<std::random_access_iterator_tag, typename Iterator::iterator_concept>::value> {};
+
+    template <typename Iterator, typename DifferenceType, typename = void>
+    struct plus_eq : std::false_type {};
+    template <typename Iterator, typename DifferenceType>
+    struct plus_eq<Iterator,
+                   DifferenceType,
+                   void_t<decltype(std::declval<Iterator&>() += std::declval<DifferenceType>())>> : std::true_type {};
+
+    template <typename D,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference,
+              typename Pointer,
+              typename DifferenceType>
+    void
+    derived_iterator(const iterator_interface<D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType>&);
+    } // namespace v1_dtl
+
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference,
+              typename Pointer,
+              typename DifferenceType
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+              ,
+              typename E
+#endif
+              >
+    struct iterator_interface {
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+      private:
+        constexpr Derived&       derived() noexcept { return static_cast<Derived&>(*this); }
+        constexpr const Derived& derived() const noexcept { return static_cast<const Derived&>(*this); }
+
+        template <typename T, typename U, bool UseBase>
+        friend struct detail::common_eq;
+#endif
+
+      public:
+        using iterator_concept  = IteratorConcept;
+        using iterator_category = iterator_concept;
+        using value_type        = std::remove_const_t<ValueType>;
+        using reference         = Reference;
+        using pointer           = detail::pointer_t<Pointer, iterator_concept>;
+        using difference_type   = DifferenceType;
+
+        template <typename D = Derived>
+        constexpr auto operator*() noexcept(noexcept(*access::base(std::declval<D&>())))
+            -> decltype(*access::base(std::declval<D&>())) {
+            return *access::base(derived());
+        }
+        template <typename D = Derived>
+        constexpr auto operator*() const noexcept(noexcept(*access::base(std::declval<const D&>())))
+            -> decltype(*access::base(std::declval<const D&>())) {
+            return *access::base(derived());
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator->() noexcept(noexcept(detail::make_pointer<pointer, reference>(*std::declval<D&>())))
+            -> decltype(detail::make_pointer<pointer, reference>(*std::declval<D&>())) {
+            return detail::make_pointer<pointer, reference>(*derived());
+        }
+        template <typename D = Derived>
+        constexpr auto operator->() const
+            noexcept(noexcept(detail::make_pointer<pointer, reference>(*std::declval<const D&>())))
+            -> decltype(detail::make_pointer<pointer, reference>(*std::declval<const D&>())) {
+            return detail::make_pointer<pointer, reference>(*derived());
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator[](difference_type i) const
+            noexcept(noexcept(D(std::declval<const D&>()), std::declval<D&>() += i, *std::declval<D&>()))
+                -> decltype(std::declval<D&>() += i, *std::declval<D&>()) {
+            D retval = derived();
+            retval += i;
+            return *retval;
+        }
+
+        template <typename D      = Derived,
+                  typename Enable = std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>>
+        constexpr auto operator++() noexcept(noexcept(++access::base(std::declval<D&>())))
+            -> decltype(++access::base(std::declval<D&>()), std::declval<D&>()) {
+            ++access::base(derived());
+            return derived();
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator++() noexcept(noexcept(std::declval<D&>() += difference_type(1)))
+            -> decltype(std::declval<D&>() += difference_type(1), std::declval<D&>()) {
+            derived() += difference_type(1);
+            return derived();
+        }
+        template <typename D = Derived>
+        constexpr auto operator++(int) noexcept(noexcept(D(std::declval<D&>()), ++std::declval<D&>()))
+            -> std::remove_reference_t<decltype(D(std::declval<D&>()), ++std::declval<D&>(), std::declval<D&>())> {
+            D retval = derived();
+            ++derived();
+            return retval;
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator+=(difference_type n) noexcept(noexcept(access::base(std::declval<D&>()) += n))
+            -> decltype(access::base(std::declval<D&>()) += n, std::declval<D&>()) {
+            access::base(derived()) += n;
+            return derived();
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator+(difference_type i) const noexcept(noexcept(D(std::declval<D&>()),
+                                                                            std::declval<D&>() += i))
+            -> std::remove_reference_t<decltype(D(std::declval<D&>()), std::declval<D&>() += i, std::declval<D&>())> {
+            D retval = derived();
+            retval += i;
+            return retval;
+        }
+        friend BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR Derived operator+(difference_type i,
+                                                                                                Derived it) noexcept {
+            return it + i;
+        }
+
+        template <typename D      = Derived,
+                  typename Enable = std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>>
+        constexpr auto operator--() noexcept(noexcept(--access::base(std::declval<D&>())))
+            -> decltype(--access::base(std::declval<D&>()), std::declval<D&>()) {
+            --access::base(derived());
+            return derived();
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator--() noexcept(noexcept(D(std::declval<D&>()),
+                                                      std::declval<D&>() += -difference_type(1)))
+            -> decltype(std::declval<D&>() += -difference_type(1), std::declval<D&>()) {
+            derived() += -difference_type(1);
+            return derived();
+        }
+        template <typename D = Derived>
+        constexpr auto operator--(int) noexcept(noexcept(D(std::declval<D&>()), --std::declval<D&>()))
+            -> std::remove_reference_t<decltype(D(std::declval<D&>()), --std::declval<D&>(), std::declval<D&>())> {
+            D retval = derived();
+            --derived();
+            return retval;
+        }
+
+        template <typename D = Derived>
+        constexpr D& operator-=(difference_type i) noexcept {
+            derived() += -i;
+            return derived();
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator-(D other) const
+            noexcept(noexcept(access::base(std::declval<const D&>()) - access::base(other)))
+                -> decltype(access::base(std::declval<const D&>()) - access::base(other)) {
+            return access::base(derived()) - access::base(other);
+        }
+
+        friend BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR Derived
+        operator-(Derived it, difference_type i) noexcept {
+            Derived retval = it;
+            retval += -i;
+            return retval;
+        }
+    };
+
+    /** Implementation of `operator==()`, implemented in terms of the iterator
+        underlying IteratorInterface, for all iterators derived from
+        `iterator_interface`, except those with an iterator category derived
+        from `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1,
+              typename IteratorInterface2,
+              typename Enable = std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value>>
+    constexpr auto operator==(IteratorInterface1 lhs, IteratorInterface2 rhs) noexcept
+        -> decltype(access::base(std::declval<IteratorInterface1&>()) ==
+                    access::base(std::declval<IteratorInterface2&>())) {
+        return access::base(lhs) == access::base(rhs);
+    }
+
+    /** Implementation of `operator==()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1,
+              typename IteratorInterface2,
+              typename Enable = std::enable_if_t<v1_dtl::ra_iter<IteratorInterface1>::value>>
+    constexpr auto operator==(IteratorInterface1 lhs,
+                              IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) == 0) {
+        return detail::common_diff(lhs, rhs) == 0;
+    }
+
+    /** Implementation of `operator!=()` for all iterators derived from
+        `iterator_interface`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator!=(IteratorInterface1 lhs, IteratorInterface2 rhs) noexcept(noexcept(!(lhs == rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), !(lhs == rhs)) {
+        return !(lhs == rhs);
+    }
+
+    /** Implementation of `operator<()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator<(IteratorInterface1 lhs,
+                             IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) < 0) {
+        return detail::common_diff(lhs, rhs) < 0;
+    }
+
+    /** Implementation of `operator<=()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator<=(IteratorInterface1 lhs,
+                              IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) <= 0) {
+        return detail::common_diff(lhs, rhs) <= 0;
+    }
+
+    /** Implementation of `operator>()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator>(IteratorInterface1 lhs,
+                             IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) > 0) {
+        return detail::common_diff(lhs, rhs) > 0;
+    }
+
+    /** Implementation of `operator>=()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator>=(IteratorInterface1 lhs,
+                              IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) >= 0) {
+        return detail::common_diff(lhs, rhs) >= 0;
+    }
+
+    /** A template alias useful for defining proxy iterators.  \see
+        `iterator_interface`. */
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType,
+              typename DifferenceType = std::ptrdiff_t>
+    using proxy_iterator_interface = iterator_interface<Derived,
+                                                        IteratorConcept,
+                                                        ValueType,
+                                                        Reference,
+                                                        proxy_arrow_result<Reference>,
+                                                        DifferenceType>;
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#if defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+
+namespace beman::optional26::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 {
+
+    namespace v2_dtl {
+    template <typename Iterator>
+    struct iter_concept;
+
+    template <typename Iterator>
+        requires requires { typename std::iterator_traits<Iterator>::iterator_concept; }
+    struct iter_concept<Iterator> {
+        using type = typename std::iterator_traits<Iterator>::iterator_concept;
+    };
+
+    template <typename Iterator>
+        requires(
+            !requires { typename std::iterator_traits<Iterator>::iterator_concept; } &&
+            requires { typename std::iterator_traits<Iterator>::iterator_category; })
+    struct iter_concept<Iterator> {
+        using type = typename std::iterator_traits<Iterator>::iterator_category;
+    };
+
+    template <typename Iterator>
+        requires(
+            !requires { typename std::iterator_traits<Iterator>::iterator_concept; } &&
+            !requires { typename std::iterator_traits<Iterator>::iterator_category; })
+    struct iter_concept<Iterator> {
+        using type = std::random_access_iterator_tag;
+    };
+
+    template <typename Iterator>
+    struct iter_concept {};
+
+    template <typename Iterator>
+    using iter_concept_t = typename iter_concept<Iterator>::type;
+
+    template <typename D, typename DifferenceType>
+    // clang-format off
+        concept plus_eq = requires (D d) { d += DifferenceType(1); };
+    // clang-format on
+
+    template <typename D, typename D2 = D>
+    // clang-format off
+        concept base_3way =
+#if defined(__cpp_impl_three_way_comparison)
+            requires (D d, D2 d2) { access::base(d) <=> access::base(d2); };
+#else
+            false;
+#endif
+    // clang-format on
+
+    template <typename D1, typename D2 = D1>
+    // clang-format off
+        concept base_eq =
+            requires (D1 d1, D2 d2) { access::base(d1) == access::base(d2); };
+    // clang-format on
+
+    template <typename D, typename D2 = D>
+    // clang-format off
+        concept iter_sub = requires (D d, D2 d2) {
+            typename D::difference_type;
+            {d - d2} -> std::convertible_to<typename D::difference_type>;
+        };
+    // clang-format on
+
+    // This iterator concept -> category mapping scheme follows the one
+    // from zip_transform_view; see
+    // https://eel.is/c++draft/range.zip.transform.iterator#1.
+
+    template <typename IteratorConcept, typename ReferenceType>
+    constexpr auto category_tag() {
+        if constexpr (std::is_base_of_v<std::forward_iterator_tag, IteratorConcept>) {
+            if constexpr (!std::is_reference_v<ReferenceType>) {
+                return std::input_iterator_tag{};
+            } else if constexpr (std::is_base_of_v<std::random_access_iterator_tag, IteratorConcept>) {
+                return std::random_access_iterator_tag{};
+            } else if constexpr (std::is_base_of_v<std::bidirectional_iterator_tag, IteratorConcept>) {
+                return std::bidirectional_iterator_tag{};
+            } else {
+                return std::forward_iterator_tag{};
+            }
+        } else {
+            return 0; // int means "no tag"
+        }
+    }
+    template <typename IteratorConcept,
+              typename ReferenceType,
+              typename IteratorCategory = decltype(v2_dtl::category_tag<IteratorConcept, ReferenceType>())>
+    struct iterator_category_base {
+        using iterator_category = IteratorCategory;
+    };
+
+    template <typename IteratorConcept, typename ReferenceType>
+    struct iterator_category_base<IteratorConcept, ReferenceType, int> {};
+
+    template <typename IteratorConcept, typename ReferenceType>
+    constexpr bool non_input_tag() {
+        if (std::same_as<IteratorConcept, std::input_iterator_tag>)
+            return false;
+        using tag_t = decltype(v2_dtl::category_tag<IteratorConcept, ReferenceType>());
+        return !std::same_as<tag_t, std::input_iterator_tag>;
+    }
+    } // namespace v2_dtl
+
+    // clang-format off
+
+    /** A CRTP template that one may derive from to make defining iterators
+        easier.
+
+        The template parameter `D` for `iterator_interface` may be an
+        incomplete type.  Before any member of the resulting specialization of
+        `iterator_interface` other than special member functions is
+        referenced, `D` shall be complete, and model
+        `std::derived_from<iterator_interface<D>>`. */
+    template<
+      typename D,
+      typename IteratorConcept,
+      typename ValueType,
+      typename Reference = ValueType &,
+      typename Pointer = ValueType *,
+      typename DifferenceType = std::ptrdiff_t>
+      requires std::is_class_v<D> && std::same_as<D, std::remove_cv_t<D>>
+    struct iterator_interface
+        : v2_dtl::iterator_category_base<IteratorConcept, Reference>
+    {
+    private:
+      constexpr D& derived() noexcept {
+        return static_cast<D&>(*this);
+      }
+      constexpr const D& derived() const noexcept {
+        return static_cast<const D&>(*this);
+      }
+
+    public:
+      using iterator_concept = IteratorConcept;
+      using value_type = std::remove_const_t<ValueType>;
+      using reference = Reference;
+      using pointer = detail::pointer_t<Pointer, iterator_concept>;
+      using difference_type = DifferenceType;
+
+      constexpr decltype(auto) operator*()
+        requires requires (D d) { *access::base(d); } {
+          return *access::base(derived());
+        }
+      constexpr decltype(auto) operator*() const
+        requires requires (D const d) { *access::base(d); } {
+          return *access::base(derived());
+        }
+
+      constexpr auto operator->()
+        requires (!std::same_as<pointer, void> && std::is_reference_v<reference> &&
+                  requires (D d) { *d; }) {
+          return detail::make_pointer<pointer, reference>(*derived());
+        }
+      constexpr auto operator->() const
+        requires (!std::same_as<pointer, void> && std::is_reference_v<reference> &&
+                  requires (D const d) { *d; }) {
+          return detail::make_pointer<pointer, reference>(*derived());
+        }
+
+      constexpr decltype(auto) operator[](difference_type n) const
+        requires requires (D const d) { d + n; } {
+        D retval = derived();
+        retval += n;
+        return *retval;
+      }
+
+      constexpr decltype(auto) operator++()
+        requires requires (D d) { ++access::base(d); } &&
+          (!v2_dtl::plus_eq<D, difference_type>) {
+            ++access::base(derived());
+            return derived();
+          }
+      constexpr decltype(auto) operator++()
+        requires requires (D d) { d += difference_type(1); } {
+          return derived() += difference_type(1);
+        }
+      constexpr auto operator++(int) requires requires (D d) { ++d; } {
+        if constexpr (std::is_same_v<IteratorConcept, std::input_iterator_tag>){
+          ++derived();
+        } else {
+          D retval = derived();
+          ++derived();
+          return retval;
+        }
+      }
+      constexpr decltype(auto) operator+=(difference_type n)
+        requires requires (D d) { access::base(d) += n; } {
+          access::base(derived()) += n;
+          return derived();
+        }
+
+      constexpr decltype(auto) operator--()
+        requires requires (D d) { --access::base(d); } &&
+          (!v2_dtl::plus_eq<D, difference_type>) {
+            --access::base(derived());
+            return derived();
+          }
+      constexpr decltype(auto) operator--()
+        requires requires (D d) { d += -difference_type(1); } {
+          return derived() += -difference_type(1);
+        }
+      constexpr auto operator--(int) requires requires (D d) { --d; } {
+        D retval = derived();
+        --derived();
+        return retval;
+      }
+      constexpr decltype(auto) operator-=(difference_type n)
+        requires requires (D d) { d += -n; } {
+          return derived() += -n;
+        }
+    };
+
+    namespace v2_dtl {
+        template<
+            typename D,
+            typename IteratorConcept,
+            typename ValueType,
+            typename Reference,
+            typename Pointer,
+            typename DifferenceType>
+        void derived_iterator(v2::iterator_interface<
+                              D,
+                              IteratorConcept,
+                              ValueType,
+                              Reference,
+                              Pointer,
+                              DifferenceType> const &);
+
+        template<typename D>
+        concept derived_iter = requires (D d) { v2_dtl::derived_iterator(d); };
+    }
+
+    template<typename D>
+      constexpr auto operator+(D it, typename D::difference_type n)
+        requires v2_dtl::derived_iter<D> && requires { it += n; }
+          { return it += n; }
+    template<typename D>
+      constexpr auto operator+(typename D::difference_type n, D it)
+        requires v2_dtl::derived_iter<D> && requires { it += n; }
+          { return it += n; }
+
+    template<typename D1, typename D2>
+      constexpr auto operator-(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> &&
+                 requires { access::base(lhs) - access::base(rhs); }
+          { return access::base(lhs) - access::base(rhs); }
+    template<typename D>
+      constexpr auto operator-(D it, typename D::difference_type n)
+        requires v2_dtl::derived_iter<D> && requires { it += -n; }
+          { return it += -n; }
+
+#if defined(__cpp_lib_three_way_comparison)
+    template<typename D1, typename D2>
+      constexpr auto operator<=>(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> &&
+        (v2_dtl::base_3way<D1, D2> || v2_dtl::iter_sub<D1, D2>) {
+        if constexpr (v2_dtl::base_3way<D1, D2>) {
+            return access::base(lhs) <=> access::base(rhs);
+          } else {
+            using diff_type = typename D1::difference_type;
+            diff_type const diff = rhs - lhs;
+            return diff < diff_type(0) ? std::strong_ordering::less :
+              diff_type(0) < diff ? std::strong_ordering::greater :
+              std::strong_ordering::equal;
+          }
+        }
+#endif
+    template<typename D1, typename D2>
+      constexpr bool operator<(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> && v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) < typename D1::difference_type(0); }
+    template<typename D1, typename D2>
+      constexpr bool operator<=(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> && v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) <= typename D1::difference_type(0); }
+    template<typename D1, typename D2>
+      constexpr bool operator>(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> && v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) > typename D1::difference_type(0); }
+    template<typename D1, typename D2>
+      constexpr bool operator>=(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> && v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) >= typename D1::difference_type(0); }
+
+    template<typename D1, typename D2>
+      constexpr bool operator==(D1 lhs, D2 rhs)
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2> &&
+                 detail::interoperable<D1, D2>::value &&
+        (v2_dtl::base_eq<D1, D2> || v2_dtl::iter_sub<D1, D2>) {
+        if constexpr (v2_dtl::base_eq<D1, D2>) {
+          return (access::base(lhs) == access::base(rhs));
+        } else if constexpr (v2_dtl::iter_sub<D1, D2>) {
+          return (lhs - rhs) == typename D1::difference_type(0);
+        }
+      }
+
+    template<typename D1, typename D2>
+      constexpr auto operator!=(D1 lhs, D2 rhs) -> decltype(!(lhs == rhs))
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2>
+          { return !(lhs == rhs); }
+
+    // clang-format on
+
+    /** A template alias useful for defining proxy iterators.  \see
+        `iterator_interface`. */
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType,
+              typename DifferenceType = std::ptrdiff_t>
+    using proxy_iterator_interface = iterator_interface<Derived,
+                                                        IteratorConcept,
+                                                        ValueType,
+                                                        Reference,
+                                                        proxy_arrow_result<Reference>,
+                                                        DifferenceType>;
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#endif
+
+#if defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+
+namespace beman::optional26::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 {
+
+    // clang-format off
+
+    /** A base template that one may derive from to make defining iterators
+        easier. */
+    template<
+      typename IteratorConcept,
+      typename ValueType,
+      typename Reference = ValueType &,
+      typename Pointer = ValueType *,
+      typename DifferenceType = std::ptrdiff_t>
+    struct iterator_interface
+        : v2::v2_dtl::iterator_category_base<IteratorConcept, Reference>
+    {
+      using iterator_concept = IteratorConcept;
+      using value_type = std::remove_const_t<ValueType>;
+      using reference = Reference;
+      using pointer = detail::pointer_t<Pointer, iterator_concept>;
+      using difference_type = DifferenceType;
+
+      constexpr decltype(auto) operator*(this auto&& self)
+          requires requires { *access::base(self); } {
+          return *access::base(self);
+      }
+
+      constexpr auto operator->(this auto&& self)
+        requires (!std::same_as<pointer, void>) && std::is_reference_v<reference> && requires { *self; } {
+          return detail::make_pointer<pointer, reference>(*self);
+        }
+
+      constexpr decltype(auto) operator[](this auto const& self, difference_type n)
+        requires requires { self + n; } {
+        auto retval = self;
+        retval = retval + n;
+        return *retval;
+      }
+
+      constexpr decltype(auto) operator++(this auto& self)
+        requires requires { ++access::base(self); } && (!requires { self += difference_type(1); }) {
+          ++access::base(self);
+          return self;
+        }
+      constexpr decltype(auto) operator++(this auto& self)
+        requires requires { self += difference_type(1); } {
+          return self += difference_type(1);
+        }
+      constexpr auto operator++(this auto& self, int) requires requires { ++self; } {
+        if constexpr (std::is_same_v<IteratorConcept, std::input_iterator_tag>){
+          ++self;
+        } else {
+          auto retval = self;
+          ++self;
+          return retval;
+        }
+      }
+      constexpr decltype(auto) operator+=(this auto& self, difference_type n)
+        requires requires { access::base(self) += n; } {
+          access::base(self) += n;
+          return self;
+        }
+
+      constexpr decltype(auto) operator--(this auto& self)
+          requires requires { --access::base(self); } && (!requires { self += difference_type(1); }) {
+            --access::base(self);
+            return self;
+          }
+      constexpr decltype(auto) operator--(this auto& self)
+        requires requires { self += -difference_type(1); } {
+          return self += -difference_type(1);
+        }
+      constexpr auto operator--(this auto& self, int) requires requires { --self; } {
+        auto retval = self;
+        --self;
+        return retval;
+      }
+      constexpr decltype(auto) operator-=(this auto& self, difference_type n)
+        requires requires { self += -n; } {
+          return self += -n;
+        }
+    };
+
+    namespace v3_dtl {
+        template<
+            typename IteratorConcept,
+            typename ValueType,
+            typename Reference,
+            typename Pointer,
+            typename DifferenceType>
+        void derived_iterator(v3::iterator_interface<
+                              IteratorConcept,
+                              ValueType,
+                              Reference,
+                              Pointer,
+                              DifferenceType> const &);
+
+        template<typename D>
+        concept derived_iter = requires (D d) { v3_dtl::derived_iterator(d); };
+    }
+
+    template<typename D>
+      constexpr auto operator+(D it, typename D::difference_type n)
+        requires v3_dtl::derived_iter<D> && requires { it += n; }
+          { return it += n; }
+    template<typename D>
+      constexpr auto operator+(typename D::difference_type n, D it)
+        requires v3_dtl::derived_iter<D> && requires { it += n; }
+          { return it += n; }
+
+    template<typename D1, typename D2>
+      constexpr auto operator-(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> &&
+                 requires { access::base(lhs) - access::base(rhs); }
+          { return access::base(lhs) - access::base(rhs); }
+    template<typename D>
+      constexpr auto operator-(D it, typename D::difference_type n)
+        requires v3_dtl::derived_iter<D> && requires { it += -n; }
+          { return it += -n; }
+
+#if defined(__cpp_lib_three_way_comparison)
+    template<typename D1, typename D2>
+      constexpr auto operator<=>(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> &&
+        (v2::v2_dtl::base_3way<D1, D2> || v2::v2_dtl::iter_sub<D1, D2>) {
+        if constexpr (v2::v2_dtl::base_3way<D1, D2>) {
+            return access::base(lhs) <=> access::base(rhs);
+          } else {
+            using diff_type = typename D1::difference_type;
+            diff_type const diff = rhs - lhs;
+            return diff < diff_type(0) ? std::strong_ordering::less :
+              diff_type(0) < diff ? std::strong_ordering::greater :
+              std::strong_ordering::equal;
+          }
+        }
+#endif
+    template<typename D1, typename D2>
+      constexpr bool operator<(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> && v2::v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) < typename D1::difference_type(0); }
+    template<typename D1, typename D2>
+      constexpr bool operator<=(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> && v2::v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) <= typename D1::difference_type(0); }
+    template<typename D1, typename D2>
+      constexpr bool operator>(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> && v2::v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) > typename D1::difference_type(0); }
+    template<typename D1, typename D2>
+      constexpr bool operator>=(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> && v2::v2_dtl::iter_sub<D1, D2>
+          { return (lhs - rhs) >= typename D1::difference_type(0); }
+
+    template<typename D1, typename D2>
+      constexpr bool operator==(D1 lhs, D2 rhs)
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2> &&
+                 detail::interoperable<D1, D2>::value &&
+        (v2::v2_dtl::base_eq<D1, D2> || v2::v2_dtl::iter_sub<D1, D2>) {
+        if constexpr (v2::v2_dtl::base_eq<D1, D2>) {
+          return (access::base(lhs) == access::base(rhs));
+        } else if constexpr (v2::v2_dtl::iter_sub<D1, D2>) {
+          return (lhs - rhs) == typename D1::difference_type(0);
+        }
+      }
+
+    template<typename D1, typename D2>
+      constexpr auto operator!=(D1 lhs, D2 rhs) -> decltype(!(lhs == rhs))
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2>
+          { return !(lhs == rhs); }
+
+    // clang-format on
+
+    /** A template alias useful for defining proxy iterators.  \see
+        `iterator_interface`. */
+    template <typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType,
+              typename DifferenceType = std::ptrdiff_t>
+    using proxy_iterator_interface =
+        iterator_interface<IteratorConcept, ValueType, Reference, proxy_arrow_result<Reference>, DifferenceType>;
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#endif
+
+#ifdef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+
+/** `static_asserts` that type `type` models concept `concept_name`.  This is
+    useful for checking that an iterator, view, etc. that you write using one
+    of the *`_interface` templates models the right C++ concept.
+
+    For example: `BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(my_iter,
+    std::input_iterator)`.
+
+    \note This macro expands to nothing when `__cpp_lib_concepts` is not
+    defined. */
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(type, concept_name)
+
+/** `static_asserts` that the types of all typedefs in
+    `std::iterator_traits<iter>` match the remaining macro parameters.  This
+    is useful for checking that an iterator you write using
+    `iterator_interface` has the correct iterator traits.
+
+    For example: `BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(my_iter,
+    std::input_iterator_tag, std::input_iterator, int, int &, int *, std::ptrdiff_t)`.
+
+    \note This macro ignores the `concept` parameter when `__cpp_lib_concepts`
+    is not defined. */
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS( \
+    iter, category, concept, value_type, reference, pointer, difference_type)
+
+#else
+
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(type, concept_name) \
+    static_assert(concept_name<type>, "");
+
+#if BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(iter, concept_name) \
+    BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(iter, concept_name)
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(iter, concept_name)
+#endif
+
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL(                    \
+    iter, category, value_t, ref, ptr, diff_t)                                                        \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::value_type, value_t>::value, ""); \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::reference, ref>::value, "");      \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::pointer, ptr>::value, "");        \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::difference_type, diff_t>::value, "");
+
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(  \
+    iter, category, concept, value_type, reference, pointer, difference_type)  \
+    BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL( \
+        iter, category, value_type, reference, pointer, difference_type)
+#endif
+
+#endif
diff --git a/include/Beman/Optional26/optional.hpp b/include/Beman/Optional26/optional.hpp
index 4758632a..c715c3c6 100644
--- a/include/Beman/Optional26/optional.hpp
+++ b/include/Beman/Optional26/optional.hpp
@@ -1,4 +1,6 @@
-// include/Beman/Optional26/optional.hpp                                            -*-C++-*-
+// include/Beman/Optional26/optional.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #ifndef BEMAN_OPTIONAL26_OPTIONAL_HPP
 #define BEMAN_OPTIONAL26_OPTIONAL_HPP
 
@@ -165,6 +167,7 @@ namespace std {
 */
 
 #include <compare>
+#include <concepts>
 #if defined(__cpp_lib_format_ranges)
 #include <format>
 #endif
@@ -173,7 +176,9 @@ namespace std {
 #include <type_traits>
 #include <utility>
 
-namespace beman::optional {
+#include <Beman/Optional26/detail/iterator.hpp>
+
+namespace beman::optional26 {
 
 class monostate {};
 
@@ -204,26 +209,26 @@ template <class T>
     requires(!std::is_same_v<T, in_place_t>) && (!std::is_same_v<std::decay_t<T>, nullopt_t>)
 class optional;
 
-} // namespace beman::optional
+} // namespace beman::optional26
 
 namespace std {
 // Since P3168R1: Give std::optional Range Support.
 template <typename T>
-inline constexpr bool ranges::enable_view<beman::optional::optional<T>> = true;
+inline constexpr bool ranges::enable_view<beman::optional26::optional<T>> = true;
 
 // TODO: document why this is needed.
 template <typename T>
-inline constexpr bool ranges::enable_borrowed_range<beman::optional::optional<T&>> = true;
+inline constexpr bool ranges::enable_borrowed_range<beman::optional26::optional<T&>> = true;
 
 // Since P3168R1: Give std::optional Range Support.
 #if defined(__cpp_lib_format_ranges)
 template <class T>
-inline constexpr auto format_kind<beman::optional::optional<T>> = range_format::disabled;
+inline constexpr auto format_kind<beman::optional26::optional<T>> = range_format::disabled;
 #endif
 
 } // namespace std
 
-namespace beman::optional {
+namespace beman::optional26 {
 template <class T>
 concept is_derived_from_optional = requires(const T& t) { []<class U>(const optional<U>&) {}(t); };
 
@@ -314,8 +319,8 @@ class optional {
   public:
     using value_type = T;
     // Since P3168R1: Give std::optional Range Support.
-    using iterator       = T*;       // see [optional.iterators]
-    using const_iterator = const T*; // see [optional.iterators]
+    using iterator       = detail::contiguous_iterator<T, optional>;       // see [optional.iterators]
+    using const_iterator = detail::contiguous_iterator<const T, optional>; // see [optional.iterators]
 
     constexpr optional() noexcept
         requires std::is_default_constructible_v<T>
@@ -685,8 +690,10 @@ class optional {
 
     // Since P3168R1: Give std::optional Range Support.
     // [optional.iterators], iterator support
-    constexpr iterator       begin() noexcept { return has_value() ? std::addressof(value_) : nullptr; };
-    constexpr const_iterator begin() const noexcept { return has_value() ? std::addressof(value_) : nullptr; };
+    constexpr iterator       begin() noexcept { return iterator(has_value() ? std::addressof(value_) : nullptr); }
+    constexpr const_iterator begin() const noexcept {
+        return const_iterator(has_value() ? std::addressof(value_) : nullptr);
+    }
     constexpr iterator       end() noexcept { return begin() + has_value(); }
     constexpr const_iterator end() const noexcept { return begin() + has_value(); }
 
@@ -936,8 +943,8 @@ class optional<T&> {
     // Note: P3168 and P2988 may have different flows inside LEWG/LWG.
     // Implementation of the range support for optional<T&> reflects P3168R1 for now.
     // [optional.iterators], iterator support
-    using iterator       = T*;       // see [optional.iterators]
-    using const_iterator = const T*; // see [optional.iterators]
+    using iterator       = detail::contiguous_iterator<T, optional>;       // see [optional.iterators]
+    using const_iterator = detail::contiguous_iterator<const T, optional>; // see [optional.iterators]
 
     // [optional.ctor], constructors
     //    constexpr optional() noexcept;
@@ -1071,8 +1078,8 @@ class optional<T&> {
     // Note: P3168 and P2988 may have different flows inside LEWG/LWG.
     // Implementation of the range support for optional<T&> reflects P3168R1 for now.
     // [optional.iterators], iterator support
-    constexpr iterator       begin() noexcept { return has_value() ? value_ : nullptr; };
-    constexpr const_iterator begin() const noexcept { return has_value() ? value_ : nullptr; };
+    constexpr iterator       begin() noexcept { return iterator(has_value() ? value_ : nullptr); };
+    constexpr const_iterator begin() const noexcept { return const_iterator(has_value() ? value_ : nullptr); };
     constexpr iterator       end() noexcept { return begin() + has_value(); }
     constexpr const_iterator end() const noexcept { return begin() + has_value(); }
 
@@ -1121,6 +1128,7 @@ class optional<T&> {
 
     constexpr void reset() noexcept { value_ = nullptr; }
 };
-} // namespace beman::optional
+
+} // namespace beman::optional26
 
 #endif // BEMAN_OPTIONAL26_OPTIONAL_HPP
diff --git a/papers/P2988/README.md b/papers/P2988/README.md
index a91cd07e..b328d7c2 100644
--- a/papers/P2988/README.md
+++ b/papers/P2988/README.md
@@ -1,5 +1,9 @@
 # P2988
 
+<!--
+SPDX-License-Identifier: 2.0 license with LLVM exceptions
+-->
+
 ## Building P2988
 
 Compiling the paper requires a working LaTeX installation. See instructions for configuring your system at [C++ Standard Draft Sources](https://github.com/cplusplus/draft/blob/main/README.rst)
diff --git a/src/Beman/CMakeLists.txt b/src/Beman/CMakeLists.txt
index ade4beba..cd84ac80 100644
--- a/src/Beman/CMakeLists.txt
+++ b/src/Beman/CMakeLists.txt
@@ -1 +1,4 @@
+# src/Beman/CMakeLists.txt -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 add_subdirectory(Optional26)
diff --git a/src/Beman/Optional26/CMakeLists.txt b/src/Beman/Optional26/CMakeLists.txt
index 82942f2a..9e2fe392 100644
--- a/src/Beman/Optional26/CMakeLists.txt
+++ b/src/Beman/Optional26/CMakeLists.txt
@@ -1,3 +1,6 @@
+# src/Beman/Optional26/CMakeLists.txt -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 set(TARGET_LIBRARY "beman_optional26")
 
 add_library("${TARGET_LIBRARY}" STATIC "")
@@ -6,9 +9,11 @@ target_sources(
   "${TARGET_LIBRARY}"
   PRIVATE
   optional.cpp
+  detail/iterator.cpp
 )
 
 include(GNUInstallDirs)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 target_include_directories("${TARGET_LIBRARY}" PUBLIC
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../../include>
@@ -26,7 +31,7 @@ string(TOLOWER ${CMAKE_PROJECT_NAME} CMAKE_LOWER_PROJECT_NAME)
 install(
   DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${CMAKE_LOWER_PROJECT_NAME}
-  FILES_MATCHING PATTERN "*.h"
+  FILES_MATCHING PATTERN "*.hpp"
 )
 
 target_link_libraries("${TARGET_LIBRARY}")
@@ -42,6 +47,7 @@ target_sources(
   tests/optional_monadic.t.cpp
   tests/optional_range_support.t.cpp
   tests/optional_ref_monadic.t.cpp
+  tests/detail/iterator.t.cpp
 )
 
 target_link_libraries(optional_test "${TARGET_LIBRARY}")
diff --git a/src/Beman/Optional26/detail/iterator.cpp b/src/Beman/Optional26/detail/iterator.cpp
new file mode 100644
index 00000000..c43fa9e0
--- /dev/null
+++ b/src/Beman/Optional26/detail/iterator.cpp
@@ -0,0 +1,4 @@
+// src/Beman/Optional26/detail/iterator.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <Beman/Optional26/detail/iterator.hpp>
diff --git a/src/Beman/Optional26/optional.cpp b/src/Beman/Optional26/optional.cpp
index f9a0eeb8..90cadcac 100644
--- a/src/Beman/Optional26/optional.cpp
+++ b/src/Beman/Optional26/optional.cpp
@@ -1 +1,4 @@
+// src/Beman/Optional26/optional.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
diff --git a/src/Beman/Optional26/tests/detail/iterator.t.cpp b/src/Beman/Optional26/tests/detail/iterator.t.cpp
new file mode 100644
index 00000000..d2789240
--- /dev/null
+++ b/src/Beman/Optional26/tests/detail/iterator.t.cpp
@@ -0,0 +1,174 @@
+// src/Beman/Optional26/tests/detail/iterator.t.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+/**
+ * This file contains tests for beman::optional26::detail::contiguous_iterator.
+ */
+#include <Beman/Optional26/detail/iterator.hpp>
+
+#include <gtest/gtest.h>
+#include <tests/test_types.hpp>
+
+#include <concepts>
+#include <type_traits>
+#include <set>
+#include <vector>
+
+namespace beman::optional26::test {
+
+// Dummy containers helper.
+struct container {};
+
+} // namespace beman::optional26::test
+
+using namespace beman::optional26::test;
+
+TEST(IteratorTest, IteratorConcepts) {
+    const auto test = [](auto&& it) {
+        // The iterator type of it.
+        using iterator = typename std::remove_reference_t<decltype(it)>;
+
+        // Check std::contiguous_iterator concept.
+        // Note: Check each sub-concept to get the less verbose error message first!
+        static_assert(std::input_iterator<iterator>);
+        static_assert(std::forward_iterator<iterator>);
+        static_assert(std::bidirectional_iterator<iterator>);
+        static_assert(std::random_access_iterator<iterator>);
+        static_assert(std::contiguous_iterator<iterator>);
+    };
+
+    // non-const iterators
+    test(beman::optional26::detail::contiguous_iterator<int, container>{});
+    test(beman::optional26::detail::contiguous_iterator<empty, container>{});
+    test(beman::optional26::detail::contiguous_iterator<no_default_ctor, container>{});
+    test(beman::optional26::detail::contiguous_iterator<base, container>{});
+    test(beman::optional26::detail::contiguous_iterator<derived, container>{});
+
+    // const iterators
+    test(beman::optional26::detail::contiguous_iterator<const int, container>{});
+    test(beman::optional26::detail::contiguous_iterator<const empty, container>{});
+    test(beman::optional26::detail::contiguous_iterator<const no_default_ctor, container>{});
+    test(beman::optional26::detail::contiguous_iterator<const base, container>{});
+    test(beman::optional26::detail::contiguous_iterator<const derived, container>{});
+}
+
+TEST(IteratorTest, DereferenceOperator) {
+    std::vector<int> v{10, 20, 30, 40, 50};
+    auto             it = beman::optional26::detail::contiguous_iterator<int, decltype(v)>{v.data()};
+
+    EXPECT_EQ(*it, 10);
+    *it = 100;
+    EXPECT_EQ(*it, 100);
+
+    it += 2;
+    EXPECT_EQ(*it, 30);
+
+    *it = 300;
+    EXPECT_EQ(*it, 300);
+}
+
+TEST(IteratorTest, ForwardIterator) {
+    std::vector<int>       v{10, 20, 30, 40, 50};
+    const std::vector<int> cv{10, 20, 30, 40, 50};
+
+    const auto test = [](auto&& it) {
+        EXPECT_EQ(*it, 10);
+
+        ++it; // prefixed increment
+        EXPECT_EQ(*it, 20);
+
+        it++; // postfixed increment
+        EXPECT_EQ(*it, 30);
+
+        it++;
+        EXPECT_EQ(*it, 40);
+
+        ++it;
+        EXPECT_EQ(*it, 50);
+    };
+
+    test(beman::optional26::detail::contiguous_iterator<int, decltype(v)>{v.data()});
+    test(beman::optional26::detail::contiguous_iterator<const int, decltype(v)>{cv.data()});
+}
+
+TEST(IteratorTest, BidirectionalIterator) {
+    std::vector<int>       v{10, 20, 30, 40, 50};
+    const std::vector<int> cv{10, 20, 30, 40, 50};
+    const auto             test = [](auto&& it) {
+        it++;
+        it++;
+        EXPECT_EQ(*it, 30);
+
+        --it; // prefixed decrement
+        EXPECT_EQ(*it, 20);
+
+        it--; // postfixed decrement
+        EXPECT_EQ(*it, 10);
+    };
+
+    test(beman::optional26::detail::contiguous_iterator<int, decltype(v)>{v.data()});
+    test(beman::optional26::detail::contiguous_iterator<const int, decltype(v)>{cv.data()});
+}
+
+TEST(IteratorTest, RandomAccessIterator) {
+    std::vector<int>       v{10, 20, 30, 40, 50};
+    const std::vector<int> cv{10, 20, 30, 40, 50};
+    const auto             test = [](auto&& it) {
+        EXPECT_EQ(it[0], 10);
+        EXPECT_EQ(it[1], 20);
+        EXPECT_EQ(it[2], 30);
+        EXPECT_EQ(it[3], 40);
+        EXPECT_EQ(it[4], 50);
+
+        it += 2;
+        EXPECT_EQ(*it, 30);
+
+        it -= 1;
+        EXPECT_EQ(*it, 20);
+
+        it = it + 2;
+        EXPECT_EQ(*it, 40);
+
+        it = it - 1;
+        EXPECT_EQ(*it, 30);
+    };
+
+    test(beman::optional26::detail::contiguous_iterator<int, decltype(v)>{v.data()});
+    test(beman::optional26::detail::contiguous_iterator<const int, decltype(v)>{cv.data()});
+}
+
+TEST(IteratorTest, ContainerType) {
+    // Test for equality.
+    constexpr const auto test_eq = [](auto&& container1, auto&& container2) {
+        // The container types.
+        using containter_type1 = typename std::remove_reference_t<decltype(container1)>;
+        using containter_type2 = typename std::remove_reference_t<decltype(container2)>;
+
+        auto it1 = beman::optional26::detail::contiguous_iterator<int*, containter_type1>{};
+        auto it2 = beman::optional26::detail::contiguous_iterator<int*, containter_type2>{};
+
+        static_assert(std::is_same_v<decltype(it1), decltype(it2)>);
+    };
+
+    test_eq(container{}, container{});
+    test_eq(std::vector<int>{}, std::vector<int>{});
+    test_eq(std::set<int>{}, std::set<int>{});
+
+    // Test for inequality.
+    constexpr const auto test_neq = [](auto&& container1, auto&& container2) {
+        // The container types.
+        using containter_type1 = typename std::remove_reference_t<decltype(container1)>;
+        using containter_type2 = typename std::remove_reference_t<decltype(container2)>;
+        using pointer_type1    = typename containter_type1::pointer;
+        using pointer_type2    = typename containter_type2::pointer;
+
+        auto it1 = beman::optional26::detail::contiguous_iterator<pointer_type1, containter_type1>{};
+        auto it2 = beman::optional26::detail::contiguous_iterator<pointer_type2, containter_type2>{};
+
+        static_assert(!std::is_same_v<decltype(it1), decltype(it2)>);
+    };
+
+    test_neq(std::vector<int>{}, std::vector<double>{});
+    test_neq(std::vector<int>{}, std::set<int>{});
+    test_neq(std::set<int>{}, std::vector<int>{});
+}
diff --git a/src/Beman/Optional26/tests/optional.t.cpp b/src/Beman/Optional26/tests/optional.t.cpp
index e29ff4ea..d3f834f0 100644
--- a/src/Beman/Optional26/tests/optional.t.cpp
+++ b/src/Beman/Optional26/tests/optional.t.cpp
@@ -1,3 +1,6 @@
+// src/Beman/Optional26/tests/optional.t.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 
 #include <Beman/Optional26/optional.hpp> // test 2nd include OK
@@ -18,7 +21,7 @@ struct no_default {
     no_default(no_default&&)                 = default;
     no_default& operator=(const no_default&) = default;
     no_default& operator=(no_default&&)      = default;
-    no_default(empty){};
+    no_default(empty) {};
 };
 
 struct base {
@@ -35,88 +38,87 @@ struct derived : public base {
 } // namespace
 
 TEST(OptionalTest, Constructors) {
-    beman::optional::optional<int> i1;
-    beman::optional::optional<int> i2{beman::optional::nullopt};
+    beman::optional26::optional<int> i1;
+    beman::optional26::optional<int> i2{beman::optional26::nullopt};
 
-    int                          i  = 0;
-    beman::optional::optional<int> i3 = i;
+    int                              i  = 0;
+    beman::optional26::optional<int> i3 = i;
     (void)i3;
 
-    beman::optional::optional<empty> e1;
-    beman::optional::optional<int>   e2{beman::optional::nullopt};
+    beman::optional26::optional<empty> e1;
+    beman::optional26::optional<int>   e2{beman::optional26::nullopt};
 
-    empty                          e{};
-    beman::optional::optional<empty> e3 = e;
+    empty                              e{};
+    beman::optional26::optional<empty> e3 = e;
     (void)e3;
 }
 
-
 TEST(OptionalTest, Constructors2) {
-    beman::optional::optional<int> o1;
+    beman::optional26::optional<int> o1;
     EXPECT_TRUE(!o1);
 
-    beman::optional::optional<int> o2 = beman::optional::nullopt;
+    beman::optional26::optional<int> o2 = beman::optional26::nullopt;
     EXPECT_TRUE(!o2);
 
-    beman::optional::optional<int> o3 = 42;
+    beman::optional26::optional<int> o3 = 42;
     EXPECT_TRUE(*o3 == 42);
 
-    beman::optional::optional<int> o4 = o3;
+    beman::optional26::optional<int> o4 = o3;
     EXPECT_TRUE(*o4 == 42);
 
-    beman::optional::optional<int> o5 = o1;
+    beman::optional26::optional<int> o5 = o1;
     EXPECT_TRUE(!o5);
 
-    beman::optional::optional<int> o6 = std::move(o3);
+    beman::optional26::optional<int> o6 = std::move(o3);
     EXPECT_TRUE(*o6 == 42);
 
-    beman::optional::optional<short> o7 = 42;
+    beman::optional26::optional<short> o7 = 42;
     EXPECT_TRUE(*o7 == 42);
 
-    beman::optional::optional<int> o8 = o7;
+    beman::optional26::optional<int> o8 = o7;
     EXPECT_TRUE(*o8 == 42);
 
-    beman::optional::optional<int> o9 = std::move(o7);
+    beman::optional26::optional<int> o9 = std::move(o7);
     EXPECT_TRUE(*o9 == 42);
 
     {
-        beman::optional::optional<int&> o;
+        beman::optional26::optional<int&> o;
         EXPECT_TRUE(!o);
 
-        beman::optional::optional<int&> oo = o;
+        beman::optional26::optional<int&> oo = o;
         EXPECT_TRUE(!oo);
     }
 
     {
-        auto                                    i = 42;
-        beman::optional::optional<int&> o = i;
+        auto                              i = 42;
+        beman::optional26::optional<int&> o = i;
         EXPECT_TRUE(o);
         EXPECT_TRUE(*o == 42);
 
-        beman::optional::optional<int&> oo = o;
+        beman::optional26::optional<int&> oo = o;
         EXPECT_TRUE(oo);
         EXPECT_TRUE(*oo == 42);
     }
 
     std::vector<base> v;
     v.emplace_back();
-    beman::optional::optional<std::vector<base>> ov = std::move(v);
+    beman::optional26::optional<std::vector<base>> ov = std::move(v);
     EXPECT_TRUE(ov->size() == 1);
 }
 
 TEST(OptionalTest, Constructors3) {
-    beman::optional::optional<int> ie;
-    beman::optional::optional<int> i4 = ie;
+    beman::optional26::optional<int> ie;
+    beman::optional26::optional<int> i4 = ie;
     EXPECT_FALSE(i4);
 
-    base                           b{1};
-    derived                        d(1, 2);
-    beman::optional::optional<base> b1{b};
-    beman::optional::optional<base> b2{d};
+    base                              b{1};
+    derived                           d(1, 2);
+    beman::optional26::optional<base> b1{b};
+    beman::optional26::optional<base> b2{d};
 
-    beman::optional::optional<derived> d2{d};
-    beman::optional::optional<base>    b3 = d2;
-    beman::optional::optional<base>    b4{d2};
+    beman::optional26::optional<derived> d2{d};
+    beman::optional26::optional<base>    b3 = d2;
+    beman::optional26::optional<base>    b4{d2};
 }
 
 namespace {
@@ -129,15 +131,15 @@ class NoDefault {
 } // namespace
 
 TEST(OptionalTest, NonDefaultConstruct) {
-    NoDefault                          i = 7;
-    beman::optional::optional<NoDefault> v1{};
-    beman::optional::optional<NoDefault> v2{i};
+    NoDefault                              i = 7;
+    beman::optional26::optional<NoDefault> v1{};
+    beman::optional26::optional<NoDefault> v2{i};
 }
 
 TEST(OptionalTest, AssignmentValue) {
-    beman::optional::optional<int> o1 = 42;
-    beman::optional::optional<int> o2 = 12;
-    beman::optional::optional<int> o3;
+    beman::optional26::optional<int> o1 = 42;
+    beman::optional26::optional<int> o2 = 12;
+    beman::optional26::optional<int> o3;
 
     o1 = o1;
     EXPECT_TRUE(*o1 == 42);
@@ -151,13 +153,13 @@ TEST(OptionalTest, AssignmentValue) {
     o1 = 42;
     EXPECT_TRUE(*o1 == 42);
 
-    o1 = beman::optional::nullopt;
+    o1 = beman::optional26::nullopt;
     EXPECT_TRUE(!o1);
 
     o1 = std::move(o2);
     EXPECT_TRUE(*o1 == 12);
 
-    beman::optional::optional<short> o4 = 42;
+    beman::optional26::optional<short> o4 = 42;
 
     o1 = o4;
     EXPECT_TRUE(*o1 == 42);
@@ -167,16 +169,11 @@ TEST(OptionalTest, AssignmentValue) {
 }
 
 TEST(OptionalTest, Triviality) {
-    EXPECT_TRUE(std::is_trivially_copy_constructible<
-                beman::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_trivially_copy_assignable<
-                beman::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_trivially_move_constructible<
-                beman::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_trivially_move_assignable<
-                beman::optional::optional<int>>::value);
-    EXPECT_TRUE(
-        std::is_trivially_destructible<beman::optional::optional<int>>::value);
+    EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_trivially_destructible<beman::optional26::optional<int>>::value);
 
     {
         struct T {
@@ -186,47 +183,35 @@ TEST(OptionalTest, Triviality) {
             T& operator=(T&&)      = default;
             ~T()                   = default;
         };
-        EXPECT_TRUE(std::is_trivially_copy_constructible<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(std::is_trivially_copy_assignable<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(std::is_trivially_move_constructible<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(std::is_trivially_move_assignable<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_trivially_destructible<beman::optional::optional<T>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_trivially_destructible<beman::optional26::optional<T>>::value);
     }
 
     {
         struct T {
             T(const T&) {}
-            T(T&&){};
+            T(T&&) {};
             T& operator=(const T&) { return *this; }
             T& operator=(T&&) { return *this; };
             ~T() {}
         };
-        EXPECT_TRUE(!std::is_trivially_copy_constructible<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(!std::is_trivially_copy_assignable<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(!std::is_trivially_move_constructible<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(!std::is_trivially_move_assignable<
-                    beman::optional::optional<T>>::value);
-        EXPECT_TRUE(!std::is_trivially_destructible<
-                    beman::optional::optional<T>>::value);
+        EXPECT_TRUE(!std::is_trivially_copy_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_trivially_copy_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_trivially_move_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_trivially_move_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_trivially_destructible<beman::optional26::optional<T>>::value);
     }
 }
 
 TEST(OptionalTest, Deletion) {
-    EXPECT_TRUE(
-        std::is_copy_constructible<beman::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<int>>::value);
-    EXPECT_TRUE(
-        std::is_move_constructible<beman::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_destructible<beman::optional::optional<int>>::value);
+    EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<int>>::value);
+    EXPECT_TRUE(std::is_destructible<beman::optional26::optional<int>>::value);
 
     {
         struct T {
@@ -236,15 +221,11 @@ TEST(OptionalTest, Deletion) {
             T& operator=(T&&)      = default;
             ~T()                   = default;
         };
-        EXPECT_TRUE(
-            std::is_copy_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_copy_assignable<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_move_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_move_assignable<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(std::is_destructible<beman::optional::optional<T>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_destructible<beman::optional26::optional<T>>::value);
     }
 
     {
@@ -254,14 +235,10 @@ TEST(OptionalTest, Deletion) {
             T& operator=(const T&) = delete;
             T& operator=(T&&)      = delete;
         };
-        EXPECT_TRUE(
-            !std::is_copy_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            !std::is_copy_assignable<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            !std::is_move_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            !std::is_move_assignable<beman::optional::optional<T>>::value);
+        EXPECT_TRUE(!std::is_copy_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_copy_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_move_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_move_assignable<beman::optional26::optional<T>>::value);
     }
 
     {
@@ -271,14 +248,10 @@ TEST(OptionalTest, Deletion) {
             T& operator=(const T&) = delete;
             T& operator=(T&&)      = default;
         };
-        EXPECT_TRUE(
-            !std::is_copy_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            !std::is_copy_assignable<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_move_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_move_assignable<beman::optional::optional<T>>::value);
+        EXPECT_TRUE(!std::is_copy_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(!std::is_copy_assignable<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<T>>::value);
     }
 
     {
@@ -288,10 +261,8 @@ TEST(OptionalTest, Deletion) {
             T& operator=(const T&) = default;
             T& operator=(T&&)      = delete;
         };
-        EXPECT_TRUE(
-            std::is_copy_constructible<beman::optional::optional<T>>::value);
-        EXPECT_TRUE(
-            std::is_copy_assignable<beman::optional::optional<T>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<T>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<T>>::value);
     }
 }
 
@@ -299,35 +270,31 @@ struct takes_init_and_variadic {
     std::vector<int>     v;
     std::tuple<int, int> t;
     template <class... Args>
-    takes_init_and_variadic(std::initializer_list<int> l, Args&&... args)
-        : v(l), t(std::forward<Args>(args)...) {}
+    takes_init_and_variadic(std::initializer_list<int> l, Args&&... args) : v(l), t(std::forward<Args>(args)...) {}
 };
 
 TEST(OptionalTest, InPlace) {
-    beman::optional::optional<int> o1{beman::optional::in_place};
-    beman::optional::optional<int> o2(beman::optional::in_place);
+    beman::optional26::optional<int> o1{beman::optional26::in_place};
+    beman::optional26::optional<int> o2(beman::optional26::in_place);
     EXPECT_TRUE(o1);
     EXPECT_TRUE(o1 == 0);
     EXPECT_TRUE(o2);
     EXPECT_TRUE(o2 == 0);
 
-    beman::optional::optional<int> o3(beman::optional::in_place, 42);
+    beman::optional26::optional<int> o3(beman::optional26::in_place, 42);
     EXPECT_TRUE(o3 == 42);
 
-    beman::optional::optional<std::tuple<int, int>> o4(
-        beman::optional::in_place, 0, 1);
+    beman::optional26::optional<std::tuple<int, int>> o4(beman::optional26::in_place, 0, 1);
     EXPECT_TRUE(o4);
     EXPECT_TRUE(std::get<0>(*o4) == 0);
     EXPECT_TRUE(std::get<1>(*o4) == 1);
 
-    beman::optional::optional<std::vector<int>> o5(beman::optional::in_place,
-                                                 {0, 1});
+    beman::optional26::optional<std::vector<int>> o5(beman::optional26::in_place, {0, 1});
     EXPECT_TRUE(o5);
     EXPECT_TRUE((*o5)[0] == 0);
     EXPECT_TRUE((*o5)[1] == 1);
 
-    beman::optional::optional<takes_init_and_variadic> o6(
-        beman::optional::in_place, {0, 1}, 2, 3);
+    beman::optional26::optional<takes_init_and_variadic> o6(beman::optional26::in_place, {0, 1}, 2, 3);
     EXPECT_TRUE(o6->v[0] == 0);
     EXPECT_TRUE(o6->v[1] == 1);
     EXPECT_TRUE(std::get<0>(o6->t) == 2);
@@ -335,57 +302,52 @@ TEST(OptionalTest, InPlace) {
 }
 
 TEST(OptionalTest, MakeOptional) {
-    auto o1 = beman::optional::make_optional(42);
-    auto o2 = beman::optional::optional<int>(42);
+    auto o1 = beman::optional26::make_optional(42);
+    auto o2 = beman::optional26::optional<int>(42);
 
-    constexpr bool is_same =
-        std::is_same<decltype(o1), beman::optional::optional<int>>::value;
+    constexpr bool is_same = std::is_same<decltype(o1), beman::optional26::optional<int>>::value;
     EXPECT_TRUE(is_same);
     EXPECT_TRUE(o1 == o2);
 
-    auto o3 = beman::optional::make_optional<std::tuple<int, int, int, int>>(
-        0, 1, 2, 3);
+    auto o3 = beman::optional26::make_optional<std::tuple<int, int, int, int>>(0, 1, 2, 3);
     EXPECT_TRUE(std::get<0>(*o3) == 0);
     EXPECT_TRUE(std::get<1>(*o3) == 1);
     EXPECT_TRUE(std::get<2>(*o3) == 2);
     EXPECT_TRUE(std::get<3>(*o3) == 3);
 
-    auto o4 = beman::optional::make_optional<std::vector<int>>({0, 1, 2, 3});
+    auto o4 = beman::optional26::make_optional<std::vector<int>>({0, 1, 2, 3});
     EXPECT_TRUE(o4.value()[0] == 0);
     EXPECT_TRUE(o4.value()[1] == 1);
     EXPECT_TRUE(o4.value()[2] == 2);
     EXPECT_TRUE(o4.value()[3] == 3);
 
-    auto o5 =
-        beman::optional::make_optional<takes_init_and_variadic>({0, 1}, 2, 3);
+    auto o5 = beman::optional26::make_optional<takes_init_and_variadic>({0, 1}, 2, 3);
     EXPECT_TRUE(o5->v[0] == 0);
     EXPECT_TRUE(o5->v[1] == 1);
     EXPECT_TRUE(std::get<0>(o5->t) == 2);
     EXPECT_TRUE(std::get<1>(o5->t) == 3);
 
     auto i  = 42;
-    auto o6 = beman::optional::make_optional<int&>(i);
-    static_assert(std::is_same<decltype(o6), beman::optional::optional<int>>::value);
+    auto o6 = beman::optional26::make_optional<int&>(i);
+    static_assert(std::is_same<decltype(o6), beman::optional26::optional<int>>::value);
 
-    EXPECT_TRUE(
-        (std::is_same<decltype(o6), beman::optional::optional<int>>::value));
+    EXPECT_TRUE((std::is_same<decltype(o6), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o6);
     EXPECT_TRUE(*o6 == 42);
 }
 
 TEST(OptionalTest, Nullopt) {
-    beman::optional::optional<int> o1 = beman::optional::nullopt;
-    beman::optional::optional<int> o2{beman::optional::nullopt};
-    beman::optional::optional<int> o3(beman::optional::nullopt);
-    beman::optional::optional<int> o4 = {beman::optional::nullopt};
+    beman::optional26::optional<int> o1 = beman::optional26::nullopt;
+    beman::optional26::optional<int> o2{beman::optional26::nullopt};
+    beman::optional26::optional<int> o3(beman::optional26::nullopt);
+    beman::optional26::optional<int> o4 = {beman::optional26::nullopt};
 
     EXPECT_TRUE(!o1);
     EXPECT_TRUE(!o2);
     EXPECT_TRUE(!o3);
     EXPECT_TRUE(!o4);
 
-    EXPECT_TRUE(
-        !std::is_default_constructible<beman::optional::nullopt_t>::value);
+    EXPECT_TRUE(!std::is_default_constructible<beman::optional26::nullopt_t>::value);
 }
 
 struct move_detector {
@@ -395,9 +357,9 @@ struct move_detector {
 };
 
 TEST(OptionalTest, Observers) {
-    beman::optional::optional<int>       o1 = 42;
-    beman::optional::optional<int>       o2;
-    const beman::optional::optional<int> o3 = 42;
+    beman::optional26::optional<int>       o1 = 42;
+    beman::optional26::optional<int>       o2;
+    const beman::optional26::optional<int> o3 = 42;
 
     EXPECT_TRUE(*o1 == 42);
     EXPECT_TRUE(*o1 == o1.value());
@@ -410,16 +372,16 @@ TEST(OptionalTest, Observers) {
     success = std::is_same<decltype(std::move(o1).value()), int&&>::value;
     EXPECT_TRUE(success);
 
-    beman::optional::optional<move_detector> o4{beman::optional::in_place};
-    move_detector                          o5 = std::move(o4).value();
+    beman::optional26::optional<move_detector> o4{beman::optional26::in_place};
+    move_detector                              o5 = std::move(o4).value();
     EXPECT_TRUE(o4->been_moved);
     EXPECT_TRUE(!o5.been_moved);
 }
 
 TEST(OptionalTest, RelationalOps) {
-    beman::optional::optional<int> o1{4};
-    beman::optional::optional<int> o2{42};
-    beman::optional::optional<int> o3{};
+    beman::optional26::optional<int> o1{4};
+    beman::optional26::optional<int> o2{42};
+    beman::optional26::optional<int> o3{};
 
     //  SECTION("self simple")
     {
@@ -438,31 +400,31 @@ TEST(OptionalTest, RelationalOps) {
     }
     //  SECTION("nullopt simple")
     {
-        EXPECT_TRUE(!(o1 == beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt == o1));
-        EXPECT_TRUE(o1 != beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt != o1);
-        EXPECT_TRUE(!(o1 < beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt < o1);
-        EXPECT_TRUE(o1 > beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt > o1));
-        EXPECT_TRUE(!(o1 <= beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt <= o1);
-        EXPECT_TRUE(o1 >= beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt >= o1));
-
-        EXPECT_TRUE(o3 == beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o1 == beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt == o1));
+        EXPECT_TRUE(o1 != beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt != o1);
+        EXPECT_TRUE(!(o1 < beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt < o1);
+        EXPECT_TRUE(o1 > beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt > o1));
+        EXPECT_TRUE(!(o1 <= beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt <= o1);
+        EXPECT_TRUE(o1 >= beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt >= o1));
+
+        EXPECT_TRUE(o3 == beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt >= o3);
     }
     //  SECTION("with T simple")
     {
@@ -492,8 +454,8 @@ TEST(OptionalTest, RelationalOps) {
         EXPECT_TRUE(o1 >= 4);
         EXPECT_TRUE(4 >= o1);
     }
-    beman::optional::optional<std::string> o4{"hello"};
-    beman::optional::optional<std::string> o5{"xyz"};
+    beman::optional26::optional<std::string> o4{"hello"};
+    beman::optional26::optional<std::string> o5{"xyz"};
 
     //  SECTION("self complex")
     {
@@ -512,31 +474,31 @@ TEST(OptionalTest, RelationalOps) {
     }
     //  SECTION("nullopt complex")
     {
-        EXPECT_TRUE(!(o4 == beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt == o4));
-        EXPECT_TRUE(o4 != beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt != o4);
-        EXPECT_TRUE(!(o4 < beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt < o4);
-        EXPECT_TRUE(o4 > beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt > o4));
-        EXPECT_TRUE(!(o4 <= beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt <= o4);
-        EXPECT_TRUE(o4 >= beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt >= o4));
-
-        EXPECT_TRUE(o3 == beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o4 == beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt == o4));
+        EXPECT_TRUE(o4 != beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt != o4);
+        EXPECT_TRUE(!(o4 < beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt < o4);
+        EXPECT_TRUE(o4 > beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt > o4));
+        EXPECT_TRUE(!(o4 <= beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt <= o4);
+        EXPECT_TRUE(o4 >= beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt >= o4));
+
+        EXPECT_TRUE(o3 == beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt >= o3);
     }
 
     //  SECTION("with T complex")
@@ -570,36 +532,32 @@ TEST(OptionalTest, RelationalOps) {
 }
 
 TEST(OptionalTest, SwapValue) {
-    beman::optional::optional<int> o1 = 42;
-    beman::optional::optional<int> o2 = 12;
+    beman::optional26::optional<int> o1 = 42;
+    beman::optional26::optional<int> o2 = 12;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 12);
     EXPECT_EQ(o2.value(), 42);
 }
 
 TEST(OptionalTest, SwapWNull) {
-    beman::optional::optional<int> o1 = 42;
-    beman::optional::optional<int> o2 = beman::optional::nullopt;
+    beman::optional26::optional<int> o1 = 42;
+    beman::optional26::optional<int> o2 = beman::optional26::nullopt;
     o1.swap(o2);
     EXPECT_TRUE(!o1.has_value());
     EXPECT_EQ(o2.value(), 42);
 }
 
 TEST(OptionalTest, SwapNullIntializedWithValue) {
-    beman::optional::optional<int> o1 = beman::optional::nullopt;
-    beman::optional::optional<int> o2 = 42;
+    beman::optional26::optional<int> o1 = beman::optional26::nullopt;
+    beman::optional26::optional<int> o2 = 42;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 42);
     EXPECT_TRUE(!o2.has_value());
 }
 
 TEST(OptionalTest, Emplace) {
-    beman::optional::optional<
-        std::pair<std::pair<int, int>, std::pair<double, double>>>
-        i;
-    i.emplace(std::piecewise_construct,
-              std::make_tuple(0, 2),
-              std::make_tuple(3, 4));
+    beman::optional26::optional<std::pair<std::pair<int, int>, std::pair<double, double>>> i;
+    i.emplace(std::piecewise_construct, std::make_tuple(0, 2), std::make_tuple(3, 4));
     EXPECT_TRUE(i->first.first == 0);
     EXPECT_TRUE(i->first.second == 2);
     EXPECT_TRUE(i->second.first == 3);
@@ -611,19 +569,19 @@ struct A {
 };
 
 TEST(OptionalTest, EmplaceWithExceptionThrown) {
-    beman::optional::optional<A> a;
+    beman::optional26::optional<A> a;
     EXPECT_ANY_THROW(a.emplace());
 }
 
 TEST(OptionalTest, RangeTest) {
-    beman::optional::optional<int> o1 = beman::optional::nullopt;
-    beman::optional::optional<int> o2 = 42;
+    beman::optional26::optional<int> o1 = beman::optional26::nullopt;
+    beman::optional26::optional<int> o2 = 42;
     EXPECT_EQ(*o2, 42);
-    for(auto k : o1) {
+    for (auto k : o1) {
         (void)k;
         EXPECT_TRUE(false);
     }
-    for(auto k : o2) {
+    for (auto k : o2) {
         EXPECT_EQ(k, 42);
     }
 }
@@ -633,55 +591,54 @@ TEST(ViewMaybeTest, Constructors) {
     std::ranges::single_view<std::optional<int>> s2{s};
     std::ranges::single_view<std::optional<int>> s3{std::optional<int>{}};
 
-    beman::optional::optional<std::optional<int>> n;
-    beman::optional::optional<std::optional<int>> n2{n};
-    beman::optional::optional<std::optional<int>> n3{std::optional<int>{}};
+    beman::optional26::optional<std::optional<int>> n;
+    beman::optional26::optional<std::optional<int>> n2{n};
+    beman::optional26::optional<std::optional<int>> n3{std::optional<int>{}};
 }
 
-
 TEST(ViewMaybeTest, ConceptCheckRef) {
-    static_assert(std::ranges::range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::view<beman::optional::optional<int&>>);
-    static_assert(std::ranges::input_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::forward_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::bidirectional_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::contiguous_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::common_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::viewable_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::borrowed_range<beman::optional::optional<int&>>);
-    static_assert(std::ranges::random_access_range<beman::optional::optional<int&>>);
-
-    static_assert(std::ranges::range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::view<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::input_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::forward_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::bidirectional_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::contiguous_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::common_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::viewable_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::borrowed_range<beman::optional::optional<int*&>>);
-    static_assert(std::ranges::random_access_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::view<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::input_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::forward_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::contiguous_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::common_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::viewable_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::borrowed_range<beman::optional26::optional<int&>>);
+    static_assert(std::ranges::random_access_range<beman::optional26::optional<int&>>);
+
+    static_assert(std::ranges::range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::view<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::input_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::forward_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::contiguous_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::common_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::viewable_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::borrowed_range<beman::optional26::optional<int*&>>);
+    static_assert(std::ranges::random_access_range<beman::optional26::optional<int*&>>);
 
     using ref = std::reference_wrapper<int>&;
-    static_assert(std::ranges::range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::view<beman::optional::optional<ref>>);
-    static_assert(std::ranges::input_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::forward_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::bidirectional_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::contiguous_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::common_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::viewable_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::borrowed_range<beman::optional::optional<ref>>);
-    static_assert(std::ranges::random_access_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::view<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::input_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::forward_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::contiguous_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::common_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::viewable_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::borrowed_range<beman::optional26::optional<ref>>);
+    static_assert(std::ranges::random_access_range<beman::optional26::optional<ref>>);
 }
 
 TEST(ViewMaybeTest, BreathingTest) {
-    beman::optional::optional<int> m;
+    beman::optional26::optional<int> m;
     // ASSERT_TRUE(m.empty());
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m.data() == nullptr);
 
-    beman::optional::optional<int> m1{1};
+    beman::optional26::optional<int> m1{1};
     // ASSERT_TRUE(!m1.empty());
     // ASSERT_TRUE(m1.size() == 1);
     // ASSERT_TRUE(m1.data() != nullptr);
@@ -694,10 +651,10 @@ TEST(ViewMaybeTest, BreathingTest) {
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m1.size() == 1);
 
-    beman::optional::optional<double> d0{0};
+    beman::optional26::optional<double> d0{0};
     // ASSERT_TRUE(!d0.empty());
 
-    beman::optional::optional<double> d1{1};
+    beman::optional26::optional<double> d1{1};
     // ASSERT_TRUE(!d1.empty());
 
     d0 = d1;
@@ -705,13 +662,13 @@ TEST(ViewMaybeTest, BreathingTest) {
 }
 
 TEST(ViewMaybeTest, BreathingTestRef) {
-    beman::optional::optional<int&> m;
+    beman::optional26::optional<int&> m;
     // ASSERT_TRUE(m.empty());
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m.data() == nullptr);
 
-    int              one = 1;
-    beman::optional::optional<int&> m1{one};
+    int                               one = 1;
+    beman::optional26::optional<int&> m1{one};
     // ASSERT_TRUE(!m1.empty());
     // ASSERT_TRUE(m1.size() == 1);
     // ASSERT_TRUE(m1.data() != nullptr);
@@ -724,12 +681,12 @@ TEST(ViewMaybeTest, BreathingTestRef) {
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m1.size() == 1);
 
-    double              zero = 0.0;
-    beman::optional::optional<double&> d0{zero};
+    double                               zero = 0.0;
+    beman::optional26::optional<double&> d0{zero};
     // ASSERT_TRUE(!d0.empty());
 
-    double              one_d = 1.0;
-    beman::optional::optional<double&> d1{one_d};
+    double                               one_d = 1.0;
+    beman::optional26::optional<double&> d1{one_d};
     // ASSERT_TRUE(!d1.empty());
 
     d0 = d1;
@@ -737,10 +694,10 @@ TEST(ViewMaybeTest, BreathingTestRef) {
 }
 
 TEST(ViewMaybe, CompTest) {
-    beman::optional::optional<int> m;
-    beman::optional::optional<int> m0{0};
-    beman::optional::optional<int> m1{1};
-    beman::optional::optional<int> m1a{1};
+    beman::optional26::optional<int> m;
+    beman::optional26::optional<int> m0{0};
+    beman::optional26::optional<int> m1{1};
+    beman::optional26::optional<int> m1a{1};
 
     ASSERT_EQ(m, m);
     ASSERT_EQ(m0, m0);
@@ -757,13 +714,13 @@ TEST(ViewMaybe, CompTest) {
 }
 
 TEST(ViewMaybe, CompTestRef) {
-    beman::optional::optional<int&> m;
-    int              zero  = 0;
-    int              one   = 1;
-    int              one_a = 1;
-    beman::optional::optional<int&> m0{zero};
-    beman::optional::optional<int&> m1{one};
-    beman::optional::optional<int&> m1a{one_a};
+    beman::optional26::optional<int&> m;
+    int                               zero  = 0;
+    int                               one   = 1;
+    int                               one_a = 1;
+    beman::optional26::optional<int&> m0{zero};
+    beman::optional26::optional<int&> m1{one};
+    beman::optional26::optional<int&> m1a{one_a};
 
     ASSERT_EQ(m, m);
     ASSERT_EQ(m0, m0);
@@ -787,27 +744,21 @@ TEST(ViewMaybe, CompTestRef) {
 // (This uses one syntax for constrained lambdas
 // in C++20.)
 inline constexpr auto and_then = [](auto&& r, auto fun) {
-    return decltype(r)(r) | std::views::transform(std::move(fun)) |
-           std::views::join;
+    return decltype(r)(r) | std::views::transform(std::move(fun)) | std::views::join;
 };
 
 // "yield_if" takes a bool and a value and
 // returns a view of zero or one elements.
 inline constexpr auto yield_if = []<class T>(bool b, T x) {
-    return b ?
-           beman::optional::optional<T>{move(x)} :
-           beman::optional::nullopt;
+    return b ? beman::optional26::optional<T>{move(x)} : beman::optional26::nullopt;
 };
 
-
 TEST(ViewMaybeTest, PythTripleTest) {
     using std::views::iota;
     auto triples = and_then(iota(1), [](int z) {
         return and_then(iota(1, z + 1), [=](int x) {
-            return and_then(iota(x, z + 1), [=](int y) {
-                return yield_if(x * x + y * y == z * z,
-                                std::make_tuple(x, y, z));
-            });
+            return and_then(iota(x, z + 1),
+                            [=](int y) { return yield_if(x * x + y * y == z * z, std::make_tuple(x, y, z)); });
         });
     });
 
@@ -817,21 +768,20 @@ TEST(ViewMaybeTest, PythTripleTest) {
 using namespace beman;
 
 TEST(ViewMaybeTest, ValueBase) {
-    int             i = 7;
-    beman::optional::optional<int> v1{};
+    int                              i = 7;
+    beman::optional26::optional<int> v1{};
     // ASSERT_TRUE(v1.size() == 0);
 
-    beman::optional::optional<int> v2{i};
+    beman::optional26::optional<int> v2{i};
     // ASSERT_TRUE(v2.size() == 1);
     for (auto i : v1)
         ASSERT_TRUE(i != i); // tautology so i is used and not warned
 
-
     for (auto i : v2)
         ASSERT_EQ(i, 7);
 
-//     ASSERT_EQ(v2[0], 7);  // no match for operator[]
-//    auto x = v2[1000];
+    //     ASSERT_EQ(v2[0], 7);  // no match for operator[]
+    //    auto x = v2[1000];
 
     // int s = 4;
     // for (auto&& i : views::maybe(s)) {
@@ -845,7 +795,7 @@ TEST(ViewMaybeTest, ValueBase) {
 TEST(ViewMaybeTest, RefWrapper) {
     int i = 7;
 
-    beman::optional::optional<int> v2{std::ref(i)};
+    beman::optional26::optional<int> v2{std::ref(i)};
 
     for (auto i : v2)
         ASSERT_EQ(i, 7);
@@ -859,19 +809,18 @@ TEST(ViewMaybeTest, RefWrapper) {
     // ASSERT_EQ(s, 9);
 }
 
-
 TEST(ViewMaybeTest, ValueNonDefaultConstruct) {
-    NoDefault             i = 7;
-    beman::optional::optional<NoDefault> v1{};
-    beman::optional::optional<NoDefault> v2{i};
+    NoDefault                              i = 7;
+    beman::optional26::optional<NoDefault> v1{};
+    beman::optional26::optional<NoDefault> v2{i};
 }
 
 TEST(ViewMaybeTest, RefBase) {
-    int              i = 7;
-    beman::optional::optional<int&> v1{};
+    int                               i = 7;
+    beman::optional26::optional<int&> v1{};
     // ASSERT_TRUE(v1.size() == 0);
 
-    beman::optional::optional<int&> v2{i};
+    beman::optional26::optional<int&> v2{i};
     // ASSERT_TRUE(v2.size() == 1);
     for (auto i : v1)
         ASSERT_TRUE(i != i); // tautology so i is used and not warned
@@ -898,7 +847,7 @@ TEST(ViewMaybeTest, RefBase) {
     // }
     // ASSERT_EQ(s, 4);
 
-    for (auto&& i : beman::optional::optional<int&>(s)) {
+    for (auto&& i : beman::optional26::optional<int&>(s)) {
         ASSERT_EQ(i, 4);
         i = 9;
         ASSERT_EQ(i, 9);
@@ -907,8 +856,8 @@ TEST(ViewMaybeTest, RefBase) {
 }
 
 // TEST(ViewMaybeTest, MonadicAndThen) {
-//     beman::optional::optional<int> mv{40};
-//     auto            r = mv.and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     beman::optional26::optional<int> mv{40};
+//     auto            r = mv.and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
 //     ASSERT_TRUE(r.data() != nullptr);
@@ -916,28 +865,28 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     auto r2 = mv.and_then([](int) { return beman::optional::optional<int>{}; });
+//     auto r2 = mv.and_then([](int) { return beman::optional26::optional<int>{}; });
 //     ASSERT_TRUE(r2.empty());
 //     ASSERT_TRUE(r2.size() == 0);
 //     ASSERT_TRUE(r2.data() == nullptr);
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     beman::optional::optional<int> empty{};
+//     beman::optional26::optional<int> empty{};
 
-//     auto r3 = empty.and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     auto r3 = empty.and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(r3.empty());
 //     ASSERT_TRUE(r3.size() == 0);
 //     ASSERT_TRUE(r3.data() == nullptr);
 //     ASSERT_TRUE(empty.empty());
 
-//     auto r4 = mv.and_then([](double d) { return beman::optional::optional{d + 2}; });
+//     auto r4 = mv.and_then([](double d) { return beman::optional26::optional{d + 2}; });
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 42.0);
-//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional26::optional<double>>);
 
-//     auto r5 = std::move(mv).and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     auto r5 = std::move(mv).and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r5.empty());
 //     ASSERT_TRUE(r5.size() == 1);
 //     ASSERT_TRUE(r5.data() != nullptr);
@@ -948,7 +897,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     auto r6 = std::move(mv).and_then([](int&& i) {
 //         int k = i;
 //         i     = 0;
-//         return beman::optional::optional{k + 2};
+//         return beman::optional26::optional{k + 2};
 //     });
 //     ASSERT_TRUE(!r6.empty());
 //     ASSERT_TRUE(r6.size() == 1);
@@ -957,8 +906,8 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 0);
 
-//     const beman::optional::optional<int> cmv{40};
-//     auto r7 = cmv.and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     const beman::optional26::optional<int> cmv{40};
+//     auto r7 = cmv.and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r7.empty());
 //     ASSERT_TRUE(r7.size() == 1);
 //     ASSERT_TRUE(r7.data() != nullptr);
@@ -966,7 +915,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!cmv.empty());
 //     ASSERT_TRUE(*(cmv.data()) == 40);
 
-//     auto r8 = std::move(cmv).and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     auto r8 = std::move(cmv).and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r8.empty());
 //     ASSERT_TRUE(r8.size() == 1);
 //     ASSERT_TRUE(r8.data() != nullptr);
@@ -976,7 +925,7 @@ TEST(ViewMaybeTest, RefBase) {
 // }
 
 // TEST(MaybeView, MonadicTransform) {
-//     beman::optional::optional<int> mv{40};
+//     beman::optional26::optional<int> mv{40};
 //     auto            r = mv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
@@ -996,7 +945,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 42);
 
-//     beman::optional::optional<int> empty{};
+//     beman::optional26::optional<int> empty{};
 
 //     auto r3 = empty.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(r3.empty());
@@ -1008,7 +957,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 44.0);
-//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional26::optional<double>>);
 
 //     auto r5 = std::move(mv).transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r5.empty());
@@ -1030,7 +979,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 0);
 
-//     const beman::optional::optional<int> cmv{40};
+//     const beman::optional26::optional<int> cmv{40};
 //     auto                  r7 = cmv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r7.empty());
 //     ASSERT_TRUE(r7.size() == 1);
@@ -1049,25 +998,25 @@ TEST(ViewMaybeTest, RefBase) {
 // }
 
 // TEST(MaybeView, MonadicOrElse) {
-//     beman::optional::optional<int> o1(42);
-//     auto            r = o1.or_else([] { return beman::optional::optional<int>(13); });
+//     beman::optional26::optional<int> o1(42);
+//     auto            r = o1.or_else([] { return beman::optional26::optional<int>(13); });
 //     ASSERT_TRUE(*(r.data()) == 42);
 
-//     beman::optional::optional<int> o2;
-//     ASSERT_TRUE(*(o2.or_else([] { return beman::optional::optional<int>(13); })).data() ==
+//     beman::optional26::optional<int> o2;
+//     ASSERT_TRUE(*(o2.or_else([] { return beman::optional26::optional<int>(13); })).data() ==
 //                 13);
 
-//     auto r2 = std::move(o1).or_else([] { return beman::optional::optional<int>(13); });
+//     auto r2 = std::move(o1).or_else([] { return beman::optional26::optional<int>(13); });
 //     ASSERT_TRUE(*(r2.data()) == 42);
 
-//     auto r3 = std::move(o2).or_else([] { return beman::optional::optional<int>(13); });
+//     auto r3 = std::move(o2).or_else([] { return beman::optional26::optional<int>(13); });
 //     ASSERT_TRUE(*(r3.data()) == 13);
 // }
 
 // TEST(ViewMaybeTest, MonadicAndThenRef) {
 //     int              forty{40};
-//     beman::optional::optional<int&> mv{forty};
-//     auto             r = mv.and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     beman::optional26::optional<int&> mv{forty};
+//     auto             r = mv.and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
 //     ASSERT_TRUE(r.data() != nullptr);
@@ -1075,28 +1024,28 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     auto r2 = mv.and_then([](int) { return beman::optional::optional<int&>{}; });
+//     auto r2 = mv.and_then([](int) { return beman::optional26::optional<int&>{}; });
 //     ASSERT_TRUE(r2.empty());
 //     ASSERT_TRUE(r2.size() == 0);
 //     ASSERT_TRUE(r2.data() == nullptr);
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     beman::optional::optional<int&> empty{};
+//     beman::optional26::optional<int&> empty{};
 
-//     auto r3 = empty.and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     auto r3 = empty.and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(r3.empty());
 //     ASSERT_TRUE(r3.size() == 0);
 //     ASSERT_TRUE(r3.data() == nullptr);
 //     ASSERT_TRUE(empty.empty());
 
-//     auto r4 = mv.and_then([](double d) { return beman::optional::optional{d + 2}; });
+//     auto r4 = mv.and_then([](double d) { return beman::optional26::optional{d + 2}; });
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 42.0);
-//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional26::optional<double>>);
 
-//     auto r5 = std::move(mv).and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     auto r5 = std::move(mv).and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r5.empty());
 //     ASSERT_TRUE(r5.size() == 1);
 //     ASSERT_TRUE(r5.data() != nullptr);
@@ -1107,7 +1056,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     auto r6 = std::move(mv).and_then([](int&& i) {
 //         int k = i;
 //         i     = 0;
-//         return beman::optional::optional{k + 2};
+//         return beman::optional26::optional{k + 2};
 //     });
 //     ASSERT_TRUE(!r6.empty());
 //     ASSERT_TRUE(r6.size() == 1);
@@ -1118,8 +1067,8 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_EQ(forty, 0);
 //     forty = 40;
 
-//     const beman::optional::optional<int&> cmv{forty};
-//     auto r7 = cmv.and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     const beman::optional26::optional<int&> cmv{forty};
+//     auto r7 = cmv.and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r7.empty());
 //     ASSERT_TRUE(r7.size() == 1);
 //     ASSERT_TRUE(r7.data() != nullptr);
@@ -1127,7 +1076,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!cmv.empty());
 //     ASSERT_TRUE(*(cmv.data()) == 40);
 
-//     auto r8 = std::move(cmv).and_then([](int i) { return beman::optional::optional{i + 2}; });
+//     auto r8 = std::move(cmv).and_then([](int i) { return beman::optional26::optional{i + 2}; });
 //     ASSERT_TRUE(!r8.empty());
 //     ASSERT_TRUE(r8.size() == 1);
 //     ASSERT_TRUE(r8.data() != nullptr);
@@ -1138,7 +1087,7 @@ TEST(ViewMaybeTest, RefBase) {
 
 // TEST(MaybeView, MonadicTransformRef) {
 //     int              forty{40};
-//     beman::optional::optional<int&> mv{forty};
+//     beman::optional26::optional<int&> mv{forty};
 //     auto             r = mv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
@@ -1147,7 +1096,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     beman::optional::optional<int&> empty{};
+//     beman::optional26::optional<int&> empty{};
 
 //     auto r3 = empty.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(r3.empty());
@@ -1159,7 +1108,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 42.0);
-//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional26::optional<double>>);
 
 //     auto r5 = std::move(mv).transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r5.empty());
@@ -1183,7 +1132,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_EQ(forty, 0);
 //     forty = 40;
 
-//     const beman::optional::optional<int&> cmv{forty};
+//     const beman::optional26::optional<int&> cmv{forty};
 //     ASSERT_EQ(*(cmv.data()), 40);
 //     auto r7 = cmv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r7.empty());
@@ -1223,20 +1172,20 @@ TEST(ViewMaybeTest, RefBase) {
 // TEST(MaybeView, MonadicOrElseRef) {
 //     int              fortytwo{42};
 //     int              thirteen{13};
-//     beman::optional::optional<int&> o1(fortytwo);
-//     auto r = o1.or_else([&thirteen] { return beman::optional::optional<int&>(thirteen); });
+//     beman::optional26::optional<int&> o1(fortytwo);
+//     auto r = o1.or_else([&thirteen] { return beman::optional26::optional<int&>(thirteen); });
 //     ASSERT_TRUE(*(r.data()) == 42);
 
-//     beman::optional::optional<int&> o2;
+//     beman::optional26::optional<int&> o2;
 //     ASSERT_TRUE(*(o2.or_else([&thirteen] {
-//                      return beman::optional::optional<int&>(thirteen);
+//                      return beman::optional26::optional<int&>(thirteen);
 //                  })).data() == 13);
 
 //     auto r2 = std::move(o1).or_else(
-//         [&thirteen] { return beman::optional::optional<int&>(thirteen); });
+//         [&thirteen] { return beman::optional26::optional<int&>(thirteen); });
 //     ASSERT_TRUE(*(r2.data()) == 42);
 
 //     auto r3 = std::move(o2).or_else(
-//         [&thirteen] { return beman::optional::optional<int&>(thirteen); });
+//         [&thirteen] { return beman::optional26::optional<int&>(thirteen); });
 //     ASSERT_TRUE(*(r3.data()) == 13);
 // }
diff --git a/src/Beman/Optional26/tests/optional_monadic.t.cpp b/src/Beman/Optional26/tests/optional_monadic.t.cpp
index 79a1c6a7..b30e65c0 100644
--- a/src/Beman/Optional26/tests/optional_monadic.t.cpp
+++ b/src/Beman/Optional26/tests/optional_monadic.t.cpp
@@ -1,311 +1,302 @@
+// src/Beman/Optional26/tests/optional_monadic.t.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 
 #include <gtest/gtest.h>
 
-constexpr int get_int(int) { return 42; }
-constexpr beman::optional::optional<int> get_opt_int(int) { return 42; }
-
+constexpr int                              get_int(int) { return 42; }
+constexpr beman::optional26::optional<int> get_opt_int(int) { return 42; }
 
 TEST(OptionalMonadicTest, Transform) {
     // lhs is empty
-    beman::optional::optional<int> o1;
-    auto o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int> o1;
+    auto                             o1r = o1.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o1r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
-    beman::optional::optional<int> o2 = 40;
-    auto o2r = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int> o2  = 40;
+    auto                             o2r = o2.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o2r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o2r.value() == 42);
 
     struct rval_call_transform {
-      double operator()(int) && { return 42.0; };
+        double operator()(int) && { return 42.0; };
     };
 
     // ensure that function object is forwarded
-    beman::optional::optional<int> o3 = 42;
-    auto o3r = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
+    beman::optional26::optional<int> o3  = 42;
+    auto                             o3r = o3.transform(rval_call_transform{});
+    static_assert((std::is_same<decltype(o3r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o3r.value() == 42);
 
     // ensure that lhs is forwarded
-    beman::optional::optional<int> o4 = 40;
-    auto o4r = std::move(o4).transform([](int &&i) { return i + 2; });
-    static_assert((std::is_same<decltype(o4r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int> o4  = 40;
+    auto                             o4r = std::move(o4).transform([](int&& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o4r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o4r.value() == 42);
 
     // ensure that lhs is const-propagated
-    const beman::optional::optional<int> o5 = 40;
-    auto o5r = o5.transform([](const int &i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
+    const beman::optional26::optional<int> o5  = 40;
+    auto                                   o5r = o5.transform([](const int& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o5r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
-
     // test each overload in turn
-    beman::optional::optional<int> o8 = 42;
-    auto o8r = o8.transform([](int) { return 42; });
+    beman::optional26::optional<int> o8  = 42;
+    auto                             o8r = o8.transform([](int) { return 42; });
     EXPECT_TRUE(*o8r == 42);
 
-    beman::optional::optional<int> o12 = 42;
-    auto o12r = std::move(o12).transform([](int) { return 42; });
+    beman::optional26::optional<int> o12  = 42;
+    auto                             o12r = std::move(o12).transform([](int) { return 42; });
     EXPECT_TRUE(*o12r == 42);
 
-    const beman::optional::optional<int> o16 = 42;
-    auto o16r = o16.transform([](int) { return 42; });
+    const beman::optional26::optional<int> o16  = 42;
+    auto                                   o16r = o16.transform([](int) { return 42; });
     EXPECT_TRUE(*o16r == 42);
 
-    const beman::optional::optional<int> o20 = 42;
-    auto o20r = std::move(o20).transform([](int) { return 42; });
+    const beman::optional26::optional<int> o20  = 42;
+    auto                                   o20r = std::move(o20).transform([](int) { return 42; });
     EXPECT_TRUE(*o20r == 42);
 
-    beman::optional::optional<int> o24 = beman::optional::nullopt;
-    auto o24r = o24.transform([](int) { return 42; });
+    beman::optional26::optional<int> o24  = beman::optional26::nullopt;
+    auto                             o24r = o24.transform([](int) { return 42; });
     EXPECT_TRUE(!o24r);
 
-    beman::optional::optional<int> o28 = beman::optional::nullopt;
-    auto o28r = std::move(o28).transform([](int) { return 42; });
+    beman::optional26::optional<int> o28  = beman::optional26::nullopt;
+    auto                             o28r = std::move(o28).transform([](int) { return 42; });
     EXPECT_TRUE(!o28r);
 
-    const beman::optional::optional<int> o32 = beman::optional::nullopt;
-    auto o32r = o32.transform([](int) { return 42; });
+    const beman::optional26::optional<int> o32  = beman::optional26::nullopt;
+    auto                                   o32r = o32.transform([](int) { return 42; });
     EXPECT_TRUE(!o32r);
 
-    const beman::optional::optional<int> o36 = beman::optional::nullopt;
-    auto o36r = std::move(o36).transform([](int) { return 42; });
+    const beman::optional26::optional<int> o36  = beman::optional26::nullopt;
+    auto                                   o36r = std::move(o36).transform([](int) { return 42; });
     EXPECT_TRUE(!o36r);
 
     // callable which returns a reference
-    beman::optional::optional<int> o38 = 42;
-    auto o38r = o38.transform([](int &i) -> const int & { return i; });
+    beman::optional26::optional<int> o38  = 42;
+    auto                             o38r = o38.transform([](int& i) -> const int& { return i; });
     EXPECT_TRUE(o38r);
     EXPECT_TRUE(*o38r == 42);
+}
 
-  }
-
-  TEST(OptionalMonadicTest, TransformConstexpr) {
-      // test each overload in turn
-      constexpr beman::optional::optional<int> o16  = 42;
-      constexpr auto                           o16r = o16.transform(get_int);
-      static_assert(*o16r == 42);
-
-      constexpr beman::optional::optional<int> o20  = 42;
-      constexpr auto                           o20r = std::move(o20).transform(get_int);
-      static_assert(*o20r == 42);
-
-      constexpr beman::optional::optional<int> o32  = beman::optional::nullopt;
-      constexpr auto                           o32r = o32.transform(get_int);
-      static_assert(!o32r);
-      constexpr beman::optional::optional<int> o36  = beman::optional::nullopt;
-      constexpr auto                           o36r = std::move(o36).transform(get_int);
-      static_assert(!o36r);
-  }
+TEST(OptionalMonadicTest, TransformConstexpr) {
+    // test each overload in turn
+    constexpr beman::optional26::optional<int> o16  = 42;
+    constexpr auto                             o16r = o16.transform(get_int);
+    static_assert(*o16r == 42);
+
+    constexpr beman::optional26::optional<int> o20  = 42;
+    constexpr auto                             o20r = std::move(o20).transform(get_int);
+    static_assert(*o20r == 42);
+
+    constexpr beman::optional26::optional<int> o32  = beman::optional26::nullopt;
+    constexpr auto                             o32r = o32.transform(get_int);
+    static_assert(!o32r);
+    constexpr beman::optional26::optional<int> o36  = beman::optional26::nullopt;
+    constexpr auto                             o36r = std::move(o36).transform(get_int);
+    static_assert(!o36r);
+}
 
 TEST(OptionalMonadicTest, Transform2) {
     // lhs is empty
-    beman::optional::optional<int> o1;
-    auto o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int> o1;
+    auto                             o1r = o1.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o1r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
-    beman::optional::optional<int> o2 = 40;
-    auto o2r = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int> o2  = 40;
+    auto                             o2r = o2.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o2r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o2r.value() == 42);
 
     struct rval_call_transform {
-      double operator()(int) && { return 42.0; };
+        double operator()(int) && { return 42.0; };
     };
 
     // ensure that function object is forwarded
-    beman::optional::optional<int> o3 = 42;
-    auto o3r = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
+    beman::optional26::optional<int> o3  = 42;
+    auto                             o3r = o3.transform(rval_call_transform{});
+    static_assert((std::is_same<decltype(o3r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o3r.value() == 42);
 
     // ensure that lhs is forwarded
-    beman::optional::optional<int> o4 = 40;
-    auto o4r = std::move(o4).transform([](int&& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o4r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int> o4  = 40;
+    auto                             o4r = std::move(o4).transform([](int&& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o4r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o4r.value() == 42);
 
     // ensure that lhs is const-propagated
-    const beman::optional::optional<int> o5 = 40;
-    auto o5r = o5.transform([](const int& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
+    const beman::optional26::optional<int> o5  = 40;
+    auto                                   o5r = o5.transform([](const int& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o5r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // test each overload in turn
-    beman::optional::optional<int> o8 = 42;
-    auto o8r = o8.transform([](int) { return 42; });
+    beman::optional26::optional<int> o8  = 42;
+    auto                             o8r = o8.transform([](int) { return 42; });
     EXPECT_TRUE(*o8r == 42);
 
-    beman::optional::optional<int> o12 = 42;
-    auto o12r = std::move(o12).transform([](int) { return 42; });
+    beman::optional26::optional<int> o12  = 42;
+    auto                             o12r = std::move(o12).transform([](int) { return 42; });
     EXPECT_TRUE(*o12r == 42);
 
-    const beman::optional::optional<int> o16 = 42;
-    auto o16r = o16.transform([](int) { return 42; });
+    const beman::optional26::optional<int> o16  = 42;
+    auto                                   o16r = o16.transform([](int) { return 42; });
     EXPECT_TRUE(*o16r == 42);
 
-    const beman::optional::optional<int> o20 = 42;
-    auto o20r = std::move(o20).transform([](int) { return 42; });
+    const beman::optional26::optional<int> o20  = 42;
+    auto                                   o20r = std::move(o20).transform([](int) { return 42; });
     EXPECT_TRUE(*o20r == 42);
 
-    beman::optional::optional<int> o24 = beman::optional::nullopt;
-    auto o24r = o24.transform([](int) { return 42; });
+    beman::optional26::optional<int> o24  = beman::optional26::nullopt;
+    auto                             o24r = o24.transform([](int) { return 42; });
     EXPECT_TRUE(!o24r);
 
-    beman::optional::optional<int> o28 = beman::optional::nullopt;
-    auto o28r = std::move(o28).transform([](int) { return 42; });
+    beman::optional26::optional<int> o28  = beman::optional26::nullopt;
+    auto                             o28r = std::move(o28).transform([](int) { return 42; });
     EXPECT_TRUE(!o28r);
 
-    const beman::optional::optional<int> o32 = beman::optional::nullopt;
-    auto o32r = o32.transform([](int) { return 42; });
+    const beman::optional26::optional<int> o32  = beman::optional26::nullopt;
+    auto                                   o32r = o32.transform([](int) { return 42; });
     EXPECT_TRUE(!o32r);
 
-    const beman::optional::optional<int> o36 = beman::optional::nullopt;
-    auto o36r = std::move(o36).transform([](int) { return 42; });
+    const beman::optional26::optional<int> o36  = beman::optional26::nullopt;
+    auto                                   o36r = std::move(o36).transform([](int) { return 42; });
     EXPECT_TRUE(!o36r);
-  }
-
-  TEST(OptionalMonadicTest, TransformConstxpr) {
-      // test each overload in turn
-      constexpr beman::optional::optional<int> o16  = 42;
-      constexpr auto                           o16r = o16.transform(get_int);
-      static_assert(*o16r == 42);
-
-      constexpr beman::optional::optional<int> o20  = 42;
-      constexpr auto                           o20r = std::move(o20).transform(get_int);
-      static_assert(*o20r == 42);
-
-      constexpr beman::optional::optional<int> o32  = beman::optional::nullopt;
-      constexpr auto                           o32r = o32.transform(get_int);
-      static_assert(!o32r);
-      constexpr beman::optional::optional<int> o36  = beman::optional::nullopt;
-      constexpr auto                           o36r = std::move(o36).transform(get_int);
-      static_assert(!o36r);
-  }
-
-TEST(OptionalMonadicTest, and_then)
- {
+}
+
+TEST(OptionalMonadicTest, TransformConstxpr) {
+    // test each overload in turn
+    constexpr beman::optional26::optional<int> o16  = 42;
+    constexpr auto                             o16r = o16.transform(get_int);
+    static_assert(*o16r == 42);
+
+    constexpr beman::optional26::optional<int> o20  = 42;
+    constexpr auto                             o20r = std::move(o20).transform(get_int);
+    static_assert(*o20r == 42);
+
+    constexpr beman::optional26::optional<int> o32  = beman::optional26::nullopt;
+    constexpr auto                             o32r = o32.transform(get_int);
+    static_assert(!o32r);
+    constexpr beman::optional26::optional<int> o36  = beman::optional26::nullopt;
+    constexpr auto                             o36r = std::move(o36).transform(get_int);
+    static_assert(!o36r);
+}
+
+TEST(OptionalMonadicTest, and_then) {
     // lhs is empty
-    beman::optional::optional<int> o1;
-    auto o1r = o1.and_then([](int) { return beman::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o1r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int> o1;
+    auto                             o1r = o1.and_then([](int) { return beman::optional26::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o1r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
-    beman::optional::optional<int> o2 = 12;
-    auto o2r = o2.and_then([](int) { return beman::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o2r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int> o2  = 12;
+    auto                             o2r = o2.and_then([](int) { return beman::optional26::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o2r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(o2r.value() == 42.f);
 
     // lhs is empty, rhs returns empty
-    beman::optional::optional<int> o3;
-    auto o3r = o3.and_then([](int) { return beman::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o3r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int> o3;
+    auto                             o3r = o3.and_then([](int) { return beman::optional26::optional<float>{}; });
+    static_assert((std::is_same<decltype(o3r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(!o3r);
 
     // rhs returns empty
-    beman::optional::optional<int> o4 = 12;
-    auto o4r = o4.and_then([](int) { return beman::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o4r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int> o4  = 12;
+    auto                             o4r = o4.and_then([](int) { return beman::optional26::optional<float>{}; });
+    static_assert((std::is_same<decltype(o4r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(!o4r);
 
     struct rval_call_and_then {
-      beman::optional::optional<double> operator()(int) && {
-        return beman::optional::optional<double>(42.0);
-      };
+        beman::optional26::optional<double> operator()(int) && { return beman::optional26::optional<double>(42.0); };
     };
 
     // ensure that function object is forwarded
-    beman::optional::optional<int> o5 = 42;
-    auto o5r = o5.and_then(rval_call_and_then{});
-    static_assert((std::is_same<decltype(o5r), beman::optional::optional<double>>::value));
+    beman::optional26::optional<int> o5  = 42;
+    auto                             o5r = o5.and_then(rval_call_and_then{});
+    static_assert((std::is_same<decltype(o5r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // ensure that lhs is forwarded
-    beman::optional::optional<int> o6 = 42;
-    auto o6r =
-        std::move(o6).and_then([](int &&i) { return beman::optional::optional<double>(i); });
-    static_assert((std::is_same<decltype(o6r), beman::optional::optional<double>>::value));
+    beman::optional26::optional<int> o6 = 42;
+    auto o6r = std::move(o6).and_then([](int&& i) { return beman::optional26::optional<double>(i); });
+    static_assert((std::is_same<decltype(o6r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o6r.value() == 42);
 
     // ensure that function object is const-propagated
-    const beman::optional::optional<int> o7 = 42;
-    auto o7r =
-        o7.and_then([](const int &i) { return beman::optional::optional<double>(i); });
-    static_assert((std::is_same<decltype(o7r), beman::optional::optional<double>>::value));
+    const beman::optional26::optional<int> o7 = 42;
+    auto o7r = o7.and_then([](const int& i) { return beman::optional26::optional<double>(i); });
+    static_assert((std::is_same<decltype(o7r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o7r.value() == 42);
 
     // test each overload in turn
-    beman::optional::optional<int> o8 = 42;
-    auto o8r = o8.and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int> o8  = 42;
+    auto                             o8r = o8.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o8r == 42);
 
-    beman::optional::optional<int> o9 = 42;
-    auto o9r =
-        std::move(o9).and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int> o9 = 42;
+    auto o9r = std::move(o9).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o9r == 42);
 
-    const beman::optional::optional<int> o10 = 42;
-    auto o10r = o10.and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int> o10 = 42;
+    auto o10r = o10.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o10r == 42);
 
-    const beman::optional::optional<int> o11 = 42;
-    auto o11r =
-        std::move(o11).and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int> o11 = 42;
+    auto o11r = std::move(o11).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o11r == 42);
 
-    beman::optional::optional<int> o16 = beman::optional::nullopt;
-    auto o16r = o16.and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int> o16  = beman::optional26::nullopt;
+    auto                             o16r = o16.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o16r);
 
-    beman::optional::optional<int> o17 = beman::optional::nullopt;
-    auto o17r =
-        std::move(o17).and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int> o17 = beman::optional26::nullopt;
+    auto o17r = std::move(o17).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o17r);
 
-    const beman::optional::optional<int> o18 = beman::optional::nullopt;
-    auto o18r = o18.and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int> o18 = beman::optional26::nullopt;
+    auto o18r = o18.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o18r);
 
-    const beman::optional::optional<int> o19 = beman::optional::nullopt;
-    auto o19r = std::move(o19).and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int> o19 = beman::optional26::nullopt;
+    auto o19r = std::move(o19).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o19r);
 
-    int i = 3;
-    beman::optional::optional<int&> o20{i};
-    std::move(o20).and_then([](int& r){return beman::optional::optional<int&>{++r};});
+    int                               i = 3;
+    beman::optional26::optional<int&> o20{i};
+    std::move(o20).and_then([](int& r) { return beman::optional26::optional<int&>{++r}; });
     EXPECT_TRUE(o20);
     EXPECT_TRUE(i == 4);
-  }
+}
 
-TEST(OptionalMonadicTest, Constexpr_and_then)
-{
-    constexpr beman::optional::optional<int> o10 = 42;
-    constexpr auto o10r = o10.and_then(get_opt_int);
+TEST(OptionalMonadicTest, Constexpr_and_then) {
+    constexpr beman::optional26::optional<int> o10  = 42;
+    constexpr auto                             o10r = o10.and_then(get_opt_int);
     EXPECT_TRUE(*o10r == 42);
 
-    constexpr beman::optional::optional<int> o11 = 42;
-    constexpr auto o11r = std::move(o11).and_then(get_opt_int);
+    constexpr beman::optional26::optional<int> o11  = 42;
+    constexpr auto                             o11r = std::move(o11).and_then(get_opt_int);
     EXPECT_TRUE(*o11r == 42);
 
-    constexpr beman::optional::optional<int> o18 = beman::optional::nullopt;
-    constexpr auto o18r = o18.and_then(get_opt_int);
+    constexpr beman::optional26::optional<int> o18  = beman::optional26::nullopt;
+    constexpr auto                             o18r = o18.and_then(get_opt_int);
     EXPECT_TRUE(!o18r);
 
-    constexpr beman::optional::optional<int> o19 = beman::optional::nullopt;
-    constexpr auto o19r = std::move(o19).and_then(get_opt_int);
+    constexpr beman::optional26::optional<int> o19  = beman::optional26::nullopt;
+    constexpr auto                             o19r = std::move(o19).and_then(get_opt_int);
     EXPECT_TRUE(!o19r);
-  }
+}
 
-TEST(OptionalMonadicTest, or_else){
-    beman::optional::optional<int> o1 = 42;
-    EXPECT_TRUE(*(o1.or_else([] { return beman::optional::make_optional(13); })) == 42);
+TEST(OptionalMonadicTest, or_else) {
+    beman::optional26::optional<int> o1 = 42;
+    EXPECT_TRUE(*(o1.or_else([] { return beman::optional26::make_optional(13); })) == 42);
 
-    beman::optional::optional<int> o2;
-    EXPECT_EQ(*(o2.or_else([] { return beman::optional::make_optional(13); })),  13);
-  }
+    beman::optional26::optional<int> o2;
+    EXPECT_EQ(*(o2.or_else([] { return beman::optional26::make_optional(13); })), 13);
+}
diff --git a/src/Beman/Optional26/tests/optional_range_support.t.cpp b/src/Beman/Optional26/tests/optional_range_support.t.cpp
index b58d4c39..8093bb84 100644
--- a/src/Beman/Optional26/tests/optional_range_support.t.cpp
+++ b/src/Beman/Optional26/tests/optional_range_support.t.cpp
@@ -1,3 +1,6 @@
+// src/Beman/Optional26/tests/optional_range_support.t.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 /**
  * This file contains tests for the range support. Check P3168R1: "Give std::optional Range Support".
  *
@@ -7,7 +10,13 @@
  */
 #include <Beman/Optional26/optional.hpp>
 
+#include <gtest/gtest.h>
+
+#include <Beman/Optional26/detail/iterator.hpp>
+#include <tests/test_types.hpp>
+
 #include <algorithm>
+#include <concepts>
 #if defined(__cpp_lib_format_ranges)
 #include <format>
 #endif
@@ -15,212 +24,182 @@
 #include <ranges>
 #include <tuple>
 #include <optional>
+#include <type_traits>
 #include <unordered_set>
 #include <vector>
-#include <gtest/gtest.h>
 
-namespace test {
-/**
- * Empty class helper.
- **/
-struct empty {};
+using namespace beman::optional26::test;
+
+TEST(RangeSupportTest, RangeConcepts) {
+    const auto test = [](auto&& opt) {
+        // The optional type is the opt type without the reference.
+        using optional = std::remove_reference_t<decltype(opt)>;
+
+        // Check std::ranges::range concept.
+        static_assert(std::ranges::range<optional>);
+        static_assert(std::ranges::view<optional>);
+        static_assert(std::ranges::input_range<optional>);
+        static_assert(std::ranges::forward_range<optional>);
+        static_assert(std::ranges::bidirectional_range<optional>);
+        static_assert(std::ranges::contiguous_range<optional>);
+        static_assert(std::ranges::common_range<optional>);
+        static_assert(std::ranges::viewable_range<optional>);
+        static_assert(!std::ranges::borrowed_range<optional>);
+        static_assert(std::ranges::random_access_range<optional>);
+        static_assert(std::ranges::sized_range<optional>);
+    };
 
-/**
- * No default constructor class helper.
- **/
-struct no_default_ctor {
-    no_default_ctor()                                  = delete;
-    no_default_ctor(const no_default_ctor&)            = default;
-    no_default_ctor(no_default_ctor&&)                 = default;
-    no_default_ctor& operator=(const no_default_ctor&) = default;
-    no_default_ctor& operator=(no_default_ctor&&)      = default;
-    no_default_ctor(empty) {};
-};
+    test(beman::optional26::optional<int>{});
+    test(beman::optional26::optional<int*>{});
+    test(beman::optional26::optional<empty>{});
+    test(beman::optional26::optional<no_default_ctor>{});
+    test(beman::optional26::optional<base>{});
+    test(beman::optional26::optional<derived>{});
+}
 
-/**
- * Base class helper.
- **/
-struct base {
-    int i_;
-    base() : i_(0) {}
-    base(int i) : i_(i) {}
-};
+TEST(RangeSupportTest, IteratorConcepts) {
+    const auto test = [](auto&& opt) {
+        // The iterator type is the same as the iterator of the optional.
+        // e.g. iterator = optional<T>::iterator if opt is optional<T>
+        using iterator = typename std::remove_reference_t<decltype(opt)>::iterator;
+        // e.g. const_iterator = optional<T>::const_iterator if opt is optional<T>
+        using const_iterator = typename std::remove_reference_t<decltype(opt)>::const_iterator;
+
+        // Check std::contiguous_iterator concept.
+        // Note: Check each sub-concept to get the less verbose error message first!
+        static_assert(std::input_iterator<iterator>);
+        static_assert(std::forward_iterator<iterator>);
+        static_assert(std::bidirectional_iterator<iterator>);
+        static_assert(std::random_access_iterator<iterator>);
+        static_assert(std::contiguous_iterator<iterator>);
+
+        // Check std::contiguous_iterator concept.
+        // Note: Check each sub-concept to get the less verbose error message first!
+        static_assert(std::input_iterator<const_iterator>);
+        static_assert(std::forward_iterator<const_iterator>);
+        static_assert(std::bidirectional_iterator<const_iterator>);
+        static_assert(std::random_access_iterator<const_iterator>);
+        static_assert(std::contiguous_iterator<const_iterator>);
+    };
 
-/**
- * Derived class helper.
- **/
-struct derived : public base {
-    int j_;
-    derived() : base(0), j_(0) {}
-    derived(int i, int j) : base(i), j_(j) {}
-};
-} // namespace test
+    test(beman::optional26::optional<int>{});
+    test(beman::optional26::optional<int*>{});
+    test(beman::optional26::optional<empty>{});
+    test(beman::optional26::optional<no_default_ctor>{});
+    test(beman::optional26::optional<base>{});
+    test(beman::optional26::optional<derived>{});
+}
 
 TEST(RangeSupportTest, BeginOnEmptyOptional) {
-    EXPECT_EQ(beman::optional::optional<int>{}.begin(), nullptr);
-
-    EXPECT_EQ(beman::optional::optional<test::empty>{}.begin(), nullptr);
+    const auto test = [](auto&& opt) {
+        // The iterator type is the same as the iterator of the optional.
+        // e.g. iterator = optional<T>::iterator if opt is optional<T>
+        using iterator = typename std::remove_reference_t<decltype(opt)>::iterator;
+        // e.g. const_iterator = optional<T>::const_iterator if opt is optional<T>
+        using const_iterator = typename std::remove_reference_t<decltype(opt)>::const_iterator;
 
-    EXPECT_EQ(beman::optional::optional<test::no_default_ctor>{}.begin(), nullptr);
+        EXPECT_EQ(opt.begin(), iterator());
 
-    EXPECT_EQ(beman::optional::optional<test::base>{}.begin(), nullptr);
+        const auto& const_opt = opt;
+        EXPECT_EQ(const_opt.begin(), const_iterator());
+    };
 
-    EXPECT_EQ(beman::optional::optional<test::derived>{}.begin(), nullptr);
+    test(beman::optional26::optional<int>{});
+    test(beman::optional26::optional<int*>{});
+    test(beman::optional26::optional<empty>{});
+    test(beman::optional26::optional<no_default_ctor>{});
+    test(beman::optional26::optional<base>{});
+    test(beman::optional26::optional<derived>{});
 }
 
 TEST(RangeSupportTest, BeginOnNonEmptyOptional) {
-    beman::optional::optional<int> opt_int = 26;
-    EXPECT_EQ(opt_int.begin(), &*opt_int);
-
-    beman::optional::optional<test::empty> opt_empty = test::empty{};
-    EXPECT_EQ(opt_empty.begin(), &*opt_empty);
+    const auto test = [](auto&& opt) {
+        // The iterator type is the same as the iterator of the optional.
+        // e.g. iterator = optional<T>::iterator if opt is optional<T>
+        using iterator = typename std::remove_reference_t<decltype(opt)>::iterator;
+        // e.g. const_iterator = optional<T>::const_iterator if opt is optional<T>
+        using const_iterator = typename std::remove_reference_t<decltype(opt)>::const_iterator;
 
-    beman::optional::optional<test::no_default_ctor> opt_no_default_ctor = test::no_default_ctor{test::empty{}};
-    EXPECT_EQ(opt_no_default_ctor.begin(), &*opt_no_default_ctor);
+        EXPECT_EQ(opt.begin(), iterator(&*opt));
 
-    beman::optional::optional<test::base> opt_base = test::base{};
-    EXPECT_EQ(opt_base.begin(), &*opt_base);
+        const auto& const_opt = opt;
+        EXPECT_EQ(const_opt.begin(), const_iterator(&*opt));
+    };
 
-    beman::optional::optional<test::derived> opt_derived = test::derived{};
-    EXPECT_EQ(opt_derived.begin(), &*opt_derived);
+    test(beman::optional26::optional<int>{26});
+    test(beman::optional26::optional<int*>{reinterpret_cast<int*>(0XCAFEBABE)});
+    test(beman::optional26::optional<empty>{empty{}});
+    test(beman::optional26::optional<no_default_ctor>{no_default_ctor{empty{}}});
+    test(beman::optional26::optional<base>{base{}});
+    test(beman::optional26::optional<derived>{derived{}});
 }
 
 TEST(RangeSupportTest, EndOnEmptyOptional) {
-    EXPECT_EQ(beman::optional::optional<int>{}.end(), nullptr);
-
-    EXPECT_EQ(beman::optional::optional<test::empty>{}.end(), nullptr);
+    const auto test = [](auto&& opt) {
+        // The iterator type is the same as the iterator of the optional.
+        // e.g. iterator = optional<T>::iterator if opt is optional<T>
+        using iterator = typename std::remove_reference_t<decltype(opt)>::iterator;
+        // e.g. const_iterator = optional<T>::const_iterator if opt is optional<T>
+        using const_iterator = typename std::remove_reference_t<decltype(opt)>::const_iterator;
 
-    EXPECT_EQ(beman::optional::optional<test::no_default_ctor>{}.end(), nullptr);
+        EXPECT_EQ(opt.end(), iterator());
 
-    EXPECT_EQ(beman::optional::optional<test::base>{}.end(), nullptr);
+        const auto& const_opt = opt;
+        EXPECT_EQ(const_opt.end(), const_iterator());
+    };
 
-    EXPECT_EQ(beman::optional::optional<test::derived>{}.end(), nullptr);
+    test(beman::optional26::optional<int>{});
+    test(beman::optional26::optional<int*>{});
+    test(beman::optional26::optional<empty>{});
+    test(beman::optional26::optional<no_default_ctor>{});
+    test(beman::optional26::optional<base>{});
+    test(beman::optional26::optional<derived>{});
 }
 
 TEST(RangeSupportTest, EndOnNonEmptyOptional) {
-    beman::optional::optional<int> opt_int = 0XCAFEBABE;
-    EXPECT_EQ(opt_int.end(), opt_int.begin() + 1);
-
-    beman::optional::optional<test::empty> opt_empty = test::empty{};
-    EXPECT_EQ(opt_empty.end(), opt_empty.begin() + 1);
-
-    beman::optional::optional<test::no_default_ctor> opt_no_default_ctor = test::no_default_ctor{test::empty{}};
-    EXPECT_EQ(opt_no_default_ctor.end(), opt_no_default_ctor.begin() + 1);
+    const auto test = [](auto&& opt) {
+        // The iterator type is the same as the iterator of the optional.
+        // e.g. iterator = optional<T>::iterator if opt is optional<T>
+        using iterator = typename std::remove_reference_t<decltype(opt)>::iterator;
+        // e.g. const_iterator = optional<T>::const_iterator if opt is optional<T>
+        using const_iterator = typename std::remove_reference_t<decltype(opt)>::const_iterator;
 
-    beman::optional::optional<test::base> opt_base = test::base{};
-    EXPECT_EQ(opt_base.end(), opt_base.begin() + 1);
+        EXPECT_EQ(opt.end(), iterator(&*opt + 1));
 
-    beman::optional::optional<test::derived> opt_derived = test::derived{};
-    EXPECT_EQ(opt_derived.end(), opt_derived.begin() + 1);
-}
-
-TEST(RangeSupportTest, RangeConceptsCheck) {
-    {
-        // std::optional is not (yet) a range.
-        static_assert(!std::ranges::range<std::optional<int>>);
-    }
-
-    {
-        // beman::optional::optional<int> is a range.
-        static_assert(std::ranges::range<beman::optional::optional<int>>);
-        static_assert(std::ranges::view<beman::optional::optional<int>>);
-        static_assert(std::ranges::input_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::forward_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::bidirectional_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::contiguous_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::common_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::viewable_range<beman::optional::optional<int>>);
-        static_assert(!std::ranges::borrowed_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::random_access_range<beman::optional::optional<int>>);
-        static_assert(std::ranges::sized_range<beman::optional::optional<int>>);
-    }
-
-    {
-        // beman::optional::optional<int*> is a range.
-        static_assert(std::ranges::range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::view<beman::optional::optional<int*>>);
-        static_assert(std::ranges::input_range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::forward_range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::bidirectional_range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::contiguous_range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::common_range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::viewable_range<beman::optional::optional<int*>>);
-        static_assert(!std::ranges::borrowed_range<beman::optional::optional<int*>>);
-        static_assert(std::ranges::random_access_range<beman::optional::optional<int*>>);
-    }
-
-    {
-        using ref = std::reference_wrapper<int>;
-        // beman::optional::optional<ref> is a range.
-        static_assert(std::ranges::range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::view<beman::optional::optional<ref>>);
-        static_assert(std::ranges::input_range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::forward_range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::bidirectional_range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::contiguous_range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::common_range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::viewable_range<beman::optional::optional<ref>>);
-        static_assert(!std::ranges::borrowed_range<beman::optional::optional<ref>>);
-        static_assert(std::ranges::random_access_range<beman::optional::optional<ref>>);
-    }
-}
-
-TEST(RangeSupportTest, IteratorConceptsCheck) {
-    {
-        // beman::optional::optional<int>::iterator is an iterator type.
-        static_assert(std::input_iterator<beman::optional::optional<int>::iterator>);
-        static_assert(std::forward_iterator<beman::optional::optional<int>::iterator>);
-        static_assert(std::bidirectional_iterator<beman::optional::optional<int>::iterator>);
-        static_assert(std::random_access_iterator<beman::optional::optional<int>::iterator>);
-        static_assert(std::contiguous_iterator<beman::optional::optional<int>::iterator>);
-
-        // beman::optional::optional<int>::const_iterator is an iterator type.
-        static_assert(std::input_iterator<beman::optional::optional<int>::const_iterator>);
-        static_assert(std::forward_iterator<beman::optional::optional<int>::const_iterator>);
-        static_assert(std::bidirectional_iterator<beman::optional::optional<int>::const_iterator>);
-        static_assert(std::random_access_iterator<beman::optional::optional<int>::const_iterator>);
-        static_assert(std::contiguous_iterator<beman::optional::optional<int>::const_iterator>);
-    }
+        const auto& const_opt = opt;
+        EXPECT_EQ(const_opt.end(), const_iterator(&*opt + 1));
+    };
 
-    {
-        // beman::optional::optional<int*>::iterator is an iterator type.
-        static_assert(std::input_iterator<beman::optional::optional<int*>::iterator>);
-        static_assert(std::forward_iterator<beman::optional::optional<int*>::iterator>);
-        static_assert(std::bidirectional_iterator<beman::optional::optional<int*>::iterator>);
-        static_assert(std::random_access_iterator<beman::optional::optional<int*>::iterator>);
-        static_assert(std::contiguous_iterator<beman::optional::optional<int*>::iterator>);
-
-        // beman::optional::optional<int*>::const_iterator is an iterator type.
-        static_assert(std::input_iterator<beman::optional::optional<int*>::const_iterator>);
-        static_assert(std::forward_iterator<beman::optional::optional<int*>::const_iterator>);
-        static_assert(std::bidirectional_iterator<beman::optional::optional<int*>::const_iterator>);
-        static_assert(std::random_access_iterator<beman::optional::optional<int*>::const_iterator>);
-        static_assert(std::contiguous_iterator<beman::optional::optional<int*>::const_iterator>);
-    }
+    test(beman::optional26::optional<int>{26});
+    test(beman::optional26::optional<int*>{reinterpret_cast<int*>(0XCAFEBABE)});
+    test(beman::optional26::optional<empty>{empty{}});
+    test(beman::optional26::optional<no_default_ctor>{no_default_ctor{empty{}}});
+    test(beman::optional26::optional<base>{base{}});
+    test(beman::optional26::optional<derived>{derived{}});
 }
 
 TEST(RangeSupportTest, FormatOptionalIsStillDisabled) {
 // TODO: Always enable when all major compilers implement P2585R1: "Improve default container formatting".
 #if defined(__cpp_lib_format_ranges)
-    EXPECT_EQ(std::format_kind<beman::optional::optional<int>>, std::range_format::disabled);
+    EXPECT_EQ(std::format_kind<beman::optional26::optional<int>>, std::range_format::disabled);
 
     // Next line shold not compile: formatter is not defined for optional.
-    // EXPECT_EQ(std::format("{}", beman::optional::optional<int> {}), "[]");
+    // EXPECT_EQ(std::format("{}", beman::optional26::optional<int> {}), "[]");
 #endif
 }
 
 TEST(RangeSupportTest, LoopOverEmptyRange) {
-    beman::optional::optional<int> empty;
+    beman::optional26::optional<int> empty;
     ASSERT_FALSE(empty.has_value());
 
-    for (auto _ : empty) {
+    for ([[maybe_unused]] auto _ : empty) {
         ASSERT_TRUE(false) << "Should not be reached: expected not to loop over empty optional";
     }
 }
 
 TEST(RangeSupportTest, LoopOverNonEmptyRange) {
-    const auto                     expected_value = 0xCAFEBABE;
-    beman::optional::optional<int> empty{expected_value};
+    const auto                       expected_value = 0xCAFEBABE;
+    beman::optional26::optional<int> empty{expected_value};
     ASSERT_TRUE(empty.has_value());
 
     bool entered_loop = false;
@@ -234,7 +213,7 @@ TEST(RangeSupportTest, LoopOverNonEmptyRange) {
 TEST(RangeSupportTest, LoopOptionalAccess) {
     // Example from P3168R1: should access the value from an optional object.
     const int  expected_value = 0xCAFEBABE;
-    const auto get_optional   = [&]() -> beman::optional::optional<int> { return expected_value; };
+    const auto get_optional   = [&]() -> beman::optional26::optional<int> { return expected_value; };
     ASSERT_TRUE(get_optional().has_value());
 
     for (auto&& opt : get_optional()) {
@@ -246,7 +225,7 @@ TEST(RangeSupportTest, LoopOptionalAssignment) {
     // Example from P3168R1: should mutate the value from an optional object.
     const int  initial_expected_value = 0xCAFEBABE;
     const int  expected_value         = 0xDEADBEEF;
-    const auto get_optional           = [&]() -> beman::optional::optional<int> { return initial_expected_value; };
+    const auto get_optional           = [&]() -> beman::optional26::optional<int> { return initial_expected_value; };
     ASSERT_TRUE(get_optional().has_value());
     ASSERT_TRUE(get_optional().value() == initial_expected_value);
 
@@ -262,7 +241,7 @@ TEST(RangeSupportTest, LoopOptionalAssignment) {
 TEST(RangeSupportTest, RangeChainExample) {
     // Example from P3168R1: start from a set of values, apply multiple range operations involving optional values.
     std::unordered_set<int> s{1, 3, 7, 9};
-    const auto              flt = [&](int i) -> beman::optional::optional<int> {
+    const auto              flt = [&](int i) -> beman::optional26::optional<int> {
         if (s.contains(i)) {
             return i;
         } else {
@@ -284,8 +263,8 @@ TEST(RangeSupportTest, RangeChainExample) {
 TEST(RangeSupportTest, PythagoreanTriples) {
     // Example from P3168R1: generate an infinite sequence of Pythagorean triples.
     // (x, y, z) is a Pythagorean triple if 1 <= x <= y <= z and x^2 + y^2 = z^2.
-    constexpr auto yield_if = []<class T>(bool b, T x) -> beman::optional::optional<T> {
-        return b ? beman::optional::optional<T>{std::move(x)} : beman::optional::nullopt;
+    constexpr auto yield_if = []<class T>(bool b, T x) -> beman::optional26::optional<T> {
+        return b ? beman::optional26::optional<T>{std::move(x)} : beman::optional26::nullopt;
     };
     constexpr auto and_then = []<class T>(T&& r, auto fun) {
         return decltype(r)(r) | std::views::transform(std::move(fun)) | std::views::join;
diff --git a/src/Beman/Optional26/tests/optional_ref.t.cpp b/src/Beman/Optional26/tests/optional_ref.t.cpp
index 3591256b..5a128df3 100644
--- a/src/Beman/Optional26/tests/optional_ref.t.cpp
+++ b/src/Beman/Optional26/tests/optional_ref.t.cpp
@@ -1,3 +1,6 @@
+// src/Beman/Optional26/tests/optional_ref.t.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 
 #include <gtest/gtest.h>
@@ -12,7 +15,7 @@ struct no_default {
     no_default(no_default&&)                 = default;
     no_default& operator=(const no_default&) = default;
     no_default& operator=(no_default&&)      = default;
-    no_default(empty){};
+    no_default(empty) {};
 };
 
 struct base {
@@ -29,54 +32,54 @@ struct derived : public base {
 } // namespace
 
 TEST(OptionalRefTest, Constructors) {
-    beman::optional::optional<int&> i1;
-    beman::optional::optional<int&> i2{beman::optional::nullopt};
+    beman::optional26::optional<int&> i1;
+    beman::optional26::optional<int&> i2{beman::optional26::nullopt};
     (void)i1;
     (void)i2;
 
-    int                           i  = 0;
-    beman::optional::optional<int&> i3 = i;
+    int                               i  = 0;
+    beman::optional26::optional<int&> i3 = i;
     (void)i3;
 
-    beman::optional::optional<empty&> e1;
-    beman::optional::optional<empty&> e2{beman::optional::nullopt};
+    beman::optional26::optional<empty&> e1;
+    beman::optional26::optional<empty&> e2{beman::optional26::nullopt};
     (void)e1;
     (void)e2;
 
-    empty                           e{};
-    beman::optional::optional<empty&> e3 = e;
+    empty                               e{};
+    beman::optional26::optional<empty&> e3 = e;
     (void)e3;
 
-    beman::optional::optional<no_default&> nd1;
-    beman::optional::optional<no_default&> nd2{beman::optional::nullopt};
+    beman::optional26::optional<no_default&> nd1;
+    beman::optional26::optional<no_default&> nd2{beman::optional26::nullopt};
     (void)nd1;
     (void)nd2;
 
     no_default nd{e};
 
-    beman::optional::optional<no_default&> nd3 = nd;
+    beman::optional26::optional<no_default&> nd3 = nd;
     (void)nd3;
 
-    beman::optional::optional<int&> ie;
-    beman::optional::optional<int&> i4 = ie;
+    beman::optional26::optional<int&> ie;
+    beman::optional26::optional<int&> i4 = ie;
     EXPECT_FALSE(i4);
 
-    base                           b{1};
-    derived                        d(1, 2);
-    beman::optional::optional<base&> b1 = b;
-    beman::optional::optional<base&> b2 = d;
+    base                               b{1};
+    derived                            d(1, 2);
+    beman::optional26::optional<base&> b1 = b;
+    beman::optional26::optional<base&> b2 = d;
 
-    beman::optional::optional<derived&> d2 = d;
-    beman::optional::optional<base&>    b3 = d2;
-    beman::optional::optional<base&>    b4{d2};
+    beman::optional26::optional<derived&> d2 = d;
+    beman::optional26::optional<base&>    b3 = d2;
+    beman::optional26::optional<base&>    b4{d2};
 
-    beman::optional::optional<derived&> empty;
-    beman::optional::optional<base&> fromEmpty(empty);
-    beman::optional::optional<base&> fromEmpty2 = empty;
+    beman::optional26::optional<derived&> empty;
+    beman::optional26::optional<base&>    fromEmpty(empty);
+    beman::optional26::optional<base&>    fromEmpty2 = empty;
 }
 
 TEST(OptionalRefTest, Assignment) {
-    beman::optional::optional<int&> i1;
+    beman::optional26::optional<int&> i1;
     EXPECT_FALSE(i1);
     int i = 5;
     i1    = i;
@@ -86,13 +89,13 @@ TEST(OptionalRefTest, Assignment) {
 
     double d;
     // i1 = d;  // ill-formed by mandate
-    beman::optional::optional<double&> d1 = d;
+    beman::optional26::optional<double&> d1 = d;
     // i1 = d1; // ill-formed by mandate
-    beman::optional::optional<int&> i2 = i1;
+    beman::optional26::optional<int&> i2 = i1;
     EXPECT_TRUE(i2);
     EXPECT_TRUE(*i2 = 7);
 
-    beman::optional::optional<int&> empty;
+    beman::optional26::optional<int&> empty;
     EXPECT_FALSE(empty);
     i2 = empty;
     EXPECT_FALSE(i2);
@@ -103,11 +106,11 @@ TEST(OptionalRefTest, Assignment) {
 }
 
 TEST(OptionalRefTest, RelationalOps) {
-    int                           i1 = 4;
-    int                           i2 = 42;
-    beman::optional::optional<int&> o1{i1};
-    beman::optional::optional<int&> o2{i2};
-    beman::optional::optional<int&> o3{};
+    int                               i1 = 4;
+    int                               i2 = 42;
+    beman::optional26::optional<int&> o1{i1};
+    beman::optional26::optional<int&> o2{i2};
+    beman::optional26::optional<int&> o3{};
 
     //  SECTION("self simple")
     {
@@ -126,31 +129,31 @@ TEST(OptionalRefTest, RelationalOps) {
     }
     //  SECTION("nullopt simple")
     {
-        EXPECT_TRUE(!(o1 == beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt == o1));
-        EXPECT_TRUE(o1 != beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt != o1);
-        EXPECT_TRUE(!(o1 < beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt < o1);
-        EXPECT_TRUE(o1 > beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt > o1));
-        EXPECT_TRUE(!(o1 <= beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt <= o1);
-        EXPECT_TRUE(o1 >= beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt >= o1));
-
-        EXPECT_TRUE(o3 == beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o1 == beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt == o1));
+        EXPECT_TRUE(o1 != beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt != o1);
+        EXPECT_TRUE(!(o1 < beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt < o1);
+        EXPECT_TRUE(o1 > beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt > o1));
+        EXPECT_TRUE(!(o1 <= beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt <= o1);
+        EXPECT_TRUE(o1 >= beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt >= o1));
+
+        EXPECT_TRUE(o3 == beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt >= o3);
     }
     //  SECTION("with T simple")
     {
@@ -180,10 +183,10 @@ TEST(OptionalRefTest, RelationalOps) {
         EXPECT_TRUE(o1 >= 4);
         EXPECT_TRUE(4 >= o1);
     }
-    std::string                           s4 = "hello";
-    std::string                           s5 = "xyz";
-    beman::optional::optional<std::string&> o4{s4};
-    beman::optional::optional<std::string&> o5{s5};
+    std::string                               s4 = "hello";
+    std::string                               s5 = "xyz";
+    beman::optional26::optional<std::string&> o4{s4};
+    beman::optional26::optional<std::string&> o5{s5};
 
     //  SECTION("self complex")
     {
@@ -202,31 +205,31 @@ TEST(OptionalRefTest, RelationalOps) {
     }
     //  SECTION("nullopt complex")
     {
-        EXPECT_TRUE(!(o4 == beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt == o4));
-        EXPECT_TRUE(o4 != beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt != o4);
-        EXPECT_TRUE(!(o4 < beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt < o4);
-        EXPECT_TRUE(o4 > beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt > o4));
-        EXPECT_TRUE(!(o4 <= beman::optional::nullopt));
-        EXPECT_TRUE(beman::optional::nullopt <= o4);
-        EXPECT_TRUE(o4 >= beman::optional::nullopt);
-        EXPECT_TRUE(!(beman::optional::nullopt >= o4));
-
-        EXPECT_TRUE(o3 == beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
-        EXPECT_TRUE(!(beman::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= beman::optional::nullopt);
-        EXPECT_TRUE(beman::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o4 == beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt == o4));
+        EXPECT_TRUE(o4 != beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt != o4);
+        EXPECT_TRUE(!(o4 < beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt < o4);
+        EXPECT_TRUE(o4 > beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt > o4));
+        EXPECT_TRUE(!(o4 <= beman::optional26::nullopt));
+        EXPECT_TRUE(beman::optional26::nullopt <= o4);
+        EXPECT_TRUE(o4 >= beman::optional26::nullopt);
+        EXPECT_TRUE(!(beman::optional26::nullopt >= o4));
+
+        EXPECT_TRUE(o3 == beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional26::nullopt));
+        EXPECT_TRUE(!(beman::optional26::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional26::nullopt);
+        EXPECT_TRUE(beman::optional26::nullopt >= o3);
     }
 
     //  SECTION("with T complex")
@@ -260,11 +263,11 @@ TEST(OptionalRefTest, RelationalOps) {
 }
 
 TEST(OptionalRefTest, Triviality) {
-    EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_destructible<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_destructible<beman::optional26::optional<int&>>::value);
 
     {
         struct T {
@@ -274,35 +277,35 @@ TEST(OptionalRefTest, Triviality) {
             T& operator=(T&&)      = default;
             ~T()                   = default;
         };
-        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_destructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_destructible<beman::optional26::optional<T&>>::value);
     }
 
     {
         struct T {
             T(const T&) {}
-            T(T&&){};
+            T(T&&) {};
             T& operator=(const T&) { return *this; }
             T& operator=(T&&) { return *this; };
             ~T() {}
         };
-        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_destructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_destructible<beman::optional26::optional<T&>>::value);
     }
 }
 
 TEST(OptionalRefTest, Deletion) {
-    EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_destructible<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<int&>>::value);
+    EXPECT_TRUE(std::is_destructible<beman::optional26::optional<int&>>::value);
 
     {
         struct T {
@@ -312,11 +315,11 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(T&&)      = default;
             ~T()                   = default;
         };
-        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_destructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_destructible<beman::optional26::optional<T&>>::value);
     }
 
     {
@@ -326,10 +329,10 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(const T&) = delete;
             T& operator=(T&&)      = delete;
         };
-        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<T&>>::value);
     }
 
     {
@@ -339,10 +342,10 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(const T&) = delete;
             T& operator=(T&&)      = default;
         };
-        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional26::optional<T&>>::value);
     }
 
     {
@@ -352,8 +355,8 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(const T&) = default;
             T& operator=(T&&)      = delete;
         };
-        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional26::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional26::optional<T&>>::value);
     }
 }
 
@@ -366,55 +369,55 @@ struct takes_init_and_variadic {
 
 TEST(OptionalRefTest, MakeOptional) {
     int  var{42};
-    auto o1 = beman::optional::make_optional<int&>(var);
-    auto o2 = beman::optional::optional<int&>(var);
+    auto o1 = beman::optional26::make_optional<int&>(var);
+    auto o2 = beman::optional26::optional<int&>(var);
 
-    constexpr bool is_same = std::is_same<decltype(o1), beman::optional::optional<int>>::value;
+    constexpr bool is_same = std::is_same<decltype(o1), beman::optional26::optional<int>>::value;
     EXPECT_TRUE(is_same);
     EXPECT_TRUE(o1 == o2);
 
     std::tuple<int, int, int, int> tvar{0, 1, 2, 3};
-    auto o3 = beman::optional::make_optional<std::tuple<int, int, int, int>&>(tvar);
+    auto                           o3 = beman::optional26::make_optional<std::tuple<int, int, int, int>&>(tvar);
     EXPECT_TRUE(std::get<0>(*o3) == 0);
     EXPECT_TRUE(std::get<1>(*o3) == 1);
     EXPECT_TRUE(std::get<2>(*o3) == 2);
     EXPECT_TRUE(std::get<3>(*o3) == 3);
 
     std::vector<int> ivec{0, 1, 2, 3};
-    auto o4 = beman::optional::make_optional<std::vector<int>&>(ivec);
+    auto             o4 = beman::optional26::make_optional<std::vector<int>&>(ivec);
     EXPECT_TRUE(o4.value()[0] == 0);
     EXPECT_TRUE(o4.value()[1] == 1);
     EXPECT_TRUE(o4.value()[2] == 2);
     EXPECT_TRUE(o4.value()[3] == 3);
 
     takes_init_and_variadic tiv{{0, 1}, 2, 3};
-    auto o5 = beman::optional::make_optional<takes_init_and_variadic&>(tiv);
+    auto                    o5 = beman::optional26::make_optional<takes_init_and_variadic&>(tiv);
     EXPECT_TRUE(o5->v[0] == 0);
     EXPECT_TRUE(o5->v[1] == 1);
     EXPECT_TRUE(std::get<0>(o5->t) == 2);
     EXPECT_TRUE(std::get<1>(o5->t) == 3);
 
     auto i  = 42;
-    auto o6 = beman::optional::make_optional<int&>(i);
-    static_assert(std::is_same_v<decltype(o6), beman::optional::optional<int>>);
+    auto o6 = beman::optional26::make_optional<int&>(i);
+    static_assert(std::is_same_v<decltype(o6), beman::optional26::optional<int>>);
 
-    EXPECT_TRUE((std::is_same_v<decltype(o6), beman::optional::optional<int>>));
+    EXPECT_TRUE((std::is_same_v<decltype(o6), beman::optional26::optional<int>>));
     EXPECT_TRUE(o6);
     EXPECT_TRUE(*o6 == 42);
 }
 
 TEST(OptionalRefTest, Nullopt) {
-    beman::optional::optional<int&> o1 = beman::optional::nullopt;
-    beman::optional::optional<int&> o2{beman::optional::nullopt};
-    beman::optional::optional<int&> o3(beman::optional::nullopt);
-    beman::optional::optional<int&> o4 = {beman::optional::nullopt};
+    beman::optional26::optional<int&> o1 = beman::optional26::nullopt;
+    beman::optional26::optional<int&> o2{beman::optional26::nullopt};
+    beman::optional26::optional<int&> o3(beman::optional26::nullopt);
+    beman::optional26::optional<int&> o4 = {beman::optional26::nullopt};
 
     EXPECT_TRUE(!o1);
     EXPECT_TRUE(!o2);
     EXPECT_TRUE(!o3);
     EXPECT_TRUE(!o4);
 
-    EXPECT_TRUE(!std::is_default_constructible<beman::optional::nullopt_t>::value);
+    EXPECT_TRUE(!std::is_default_constructible<beman::optional26::nullopt_t>::value);
 }
 
 struct move_detector {
@@ -424,13 +427,13 @@ struct move_detector {
 };
 
 TEST(OptionalRefTest, Observers) {
-    int                                 var = 42;
-    beman::optional::optional<int&>       o1  = var;
-    beman::optional::optional<int&>       o2;
-    const beman::optional::optional<int&> o3 = var;
-    const beman::optional::optional<int&> o4;
-    int var2 = 42;
-    int var3 = 6*9;
+    int                                     var = 42;
+    beman::optional26::optional<int&>       o1  = var;
+    beman::optional26::optional<int&>       o2;
+    const beman::optional26::optional<int&> o3 = var;
+    const beman::optional26::optional<int&> o4;
+    int                                     var2 = 42;
+    int                                     var3 = 6 * 9;
     EXPECT_TRUE(*o1 == 42);
     EXPECT_TRUE(*o1 == o1.value());
     EXPECT_TRUE(o2.value_or(var2) == 42);
@@ -442,21 +445,28 @@ TEST(OptionalRefTest, Observers) {
     // o4.value_or(j) = 88;
     // EXPECT_TRUE(j == 88);
     int var99 = 99;
-    j = 88;
-    EXPECT_TRUE([&](){beman::optional::optional<int&> o(j);return o; }().value_or(var99) == 88);
-
-    EXPECT_TRUE([&](){beman::optional::optional<int&> o;return o; }().value_or(var99) == 99);
-
-
-    EXPECT_TRUE(o3.value_or([&]()->int&{return var3;}()) == 42);
-    EXPECT_TRUE(o4.value_or([&]()->int&{return var3;}()) == 54);
-
-    std::string meow{"meow"};
-    std::string bark{"bark"};
-    beman::optional::optional<std::string&> so1;
-    beman::optional::optional<std::string&> so2{meow};
-    auto t1 = so1.value_or(bark);
-    auto t2 = so2.value_or(bark);
+    j         = 88;
+    EXPECT_TRUE([&]() {
+        beman::optional26::optional<int&> o(j);
+        return o;
+    }()
+                    .value_or(var99) == 88);
+
+    EXPECT_TRUE([&]() {
+        beman::optional26::optional<int&> o;
+        return o;
+    }()
+                    .value_or(var99) == 99);
+
+    EXPECT_TRUE(o3.value_or([&]() -> int& { return var3; }()) == 42);
+    EXPECT_TRUE(o4.value_or([&]() -> int& { return var3; }()) == 54);
+
+    std::string                               meow{"meow"};
+    std::string                               bark{"bark"};
+    beman::optional26::optional<std::string&> so1;
+    beman::optional26::optional<std::string&> so2{meow};
+    auto                                      t1 = so1.value_or(bark);
+    auto                                      t2 = so2.value_or(bark);
     // auto t3 = so1.value_or("bark");
     // auto t4 = so2.value_or("bark");
     // std::tuple<const std::string&> t("meow");
@@ -500,12 +510,14 @@ TEST(OptionalRefTest, Observers) {
     static_assert(std::is_same<decltype(std::move(o1).operator->()), int*>::value);
     EXPECT_TRUE(success);
 
-    struct int_box {int i_;};
-    int_box i1{3};
-    beman::optional::optional<int_box&>       ob1  = i1;
-    beman::optional::optional<int_box&>       ob2;
-    const beman::optional::optional<int_box&> ob3 = i1;
-    success = std::is_same<decltype(ob1->i_), int>::value;
+    struct int_box {
+        int i_;
+    };
+    int_box                                     i1{3};
+    beman::optional26::optional<int_box&>       ob1 = i1;
+    beman::optional26::optional<int_box&>       ob2;
+    const beman::optional26::optional<int_box&> ob3 = i1;
+    success                                         = std::is_same<decltype(ob1->i_), int>::value;
     static_assert(std::is_same<decltype(ob1->i_), int>::value);
     EXPECT_TRUE(success);
     success = std::is_same<decltype(ob2->i_), int>::value;
@@ -517,24 +529,22 @@ TEST(OptionalRefTest, Observers) {
     success = std::is_same<decltype(std::move(ob1)->i_), int>::value;
     static_assert(std::is_same<decltype(std::move(ob1)->i_), int>::value);
     EXPECT_TRUE(success);
-
 }
 
 TEST(OptionalRefTest, MoveCheck) {
-    int x = 0;
-    int& y =  std::move(beman::optional::optional<int&>(x)).value();
+    int  x = 0;
+    int& y = std::move(beman::optional26::optional<int&>(x)).value();
     EXPECT_EQ(&y, &x);
 
-    int& z =  *std::move(beman::optional::optional<int&>(x));
+    int& z = *std::move(beman::optional26::optional<int&>(x));
     EXPECT_EQ(&z, &x);
-
 }
 
 TEST(OptionalRefTest, SwapValue) {
-    int                           var    = 42;
-    int                           twelve = 12;
-    beman::optional::optional<int&> o1     = var;
-    beman::optional::optional<int&> o2     = twelve;
+    int                               var    = 42;
+    int                               twelve = 12;
+    beman::optional26::optional<int&> o1     = var;
+    beman::optional26::optional<int&> o2     = twelve;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 12);
     EXPECT_EQ(o2.value(), 42);
@@ -543,17 +553,17 @@ TEST(OptionalRefTest, SwapValue) {
 TEST(OptionalRefTest, SwapWNull) {
     int var = 42;
 
-    beman::optional::optional<int&> o1 = var;
-    beman::optional::optional<int&> o2 = beman::optional::nullopt;
+    beman::optional26::optional<int&> o1 = var;
+    beman::optional26::optional<int&> o2 = beman::optional26::nullopt;
     o1.swap(o2);
     EXPECT_TRUE(!o1.has_value());
     EXPECT_EQ(o2.value(), 42);
 }
 
 TEST(OptionalRefTest, SwapNullIntializedWithValue) {
-    int                           var = 42;
-    beman::optional::optional<int&> o1  = beman::optional::nullopt;
-    beman::optional::optional<int&> o2  = var;
+    int                               var = 42;
+    beman::optional26::optional<int&> o1  = beman::optional26::nullopt;
+    beman::optional26::optional<int&> o2  = var;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 42);
     EXPECT_TRUE(!o2.has_value());
diff --git a/src/Beman/Optional26/tests/optional_ref_monadic.t.cpp b/src/Beman/Optional26/tests/optional_ref_monadic.t.cpp
index 9d9f9fda..d68ba6a0 100644
--- a/src/Beman/Optional26/tests/optional_ref_monadic.t.cpp
+++ b/src/Beman/Optional26/tests/optional_ref_monadic.t.cpp
@@ -1,25 +1,28 @@
+// src/Beman/Optional26/tests/optional_ref_monadic.t.cpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 #include <Beman/Optional26/optional.hpp>
 
 #include <gtest/gtest.h>
 
 namespace {
-inline constexpr int                          constexpr_fortytwo = 42;
-constexpr int                                 get_int(int) { return constexpr_fortytwo; }
-constexpr beman::optional::optional<const int&> get_opt_int(int) { return constexpr_fortytwo; }
+inline constexpr int                              constexpr_fortytwo = 42;
+constexpr int                                     get_int(int) { return constexpr_fortytwo; }
+constexpr beman::optional26::optional<const int&> get_opt_int(int) { return constexpr_fortytwo; }
 } // namespace
 
 TEST(OptionalRefMonadicTest, Transform) {
     // lhs is empty
-    beman::optional::optional<int&> o1;
-    auto                          o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int&> o1;
+    auto                              o1r = o1.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o1r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
-    int                           forty = 40;
-    beman::optional::optional<int&> o2    = forty;
-    auto                          o2r   = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
+    int                               forty = 40;
+    beman::optional26::optional<int&> o2    = forty;
+    auto                              o2r   = o2.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o2r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o2r.value() == 42);
 
     struct rval_call_transform {
@@ -27,63 +30,63 @@ TEST(OptionalRefMonadicTest, Transform) {
     };
 
     // ensure that function object is forwarded
-    int                           fortytwo = 42;
-    beman::optional::optional<int&> o3       = fortytwo;
-    auto                          o3r      = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
+    int                               fortytwo = 42;
+    beman::optional26::optional<int&> o3       = fortytwo;
+    auto                              o3r      = o3.transform(rval_call_transform{});
+    static_assert((std::is_same<decltype(o3r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o3r.value() == 42);
 
     // // ensure that lhs is forwarded
     // forty = 40;
-    // beman::optional::optional<int&> o4 = forty;
+    // beman::optional26::optional<int&> o4 = forty;
     // auto o4r = std::move(o4).transform([](int &&i) { return i + 2; });
-    // static_assert((std::is_same<decltype(o4r), beman::optional::optional<int&>>::value));
+    // static_assert((std::is_same<decltype(o4r), beman::optional26::optional<int&>>::value));
     // EXPECT_TRUE(o4r.value() == 42);
 
     // ensure that lhs is const-propagated
-    forty                                   = 40;
-    const beman::optional::optional<int&> o5  = forty;
-    auto                                o5r = o5.transform([](const int& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
+    forty                                       = 40;
+    const beman::optional26::optional<int&> o5  = forty;
+    auto                                    o5r = o5.transform([](const int& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o5r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // test each overload in turn
-    fortytwo                          = 42;
-    beman::optional::optional<int&> o8  = fortytwo;
-    auto                          o8r = o8.transform([](int) { return 42; });
+    fortytwo                              = 42;
+    beman::optional26::optional<int&> o8  = fortytwo;
+    auto                              o8r = o8.transform([](int) { return 42; });
     EXPECT_TRUE(*o8r == 42);
 
-    beman::optional::optional<int&> o12  = fortytwo;
-    auto                          o12r = std::move(o12).transform([](int) { return 42; });
+    beman::optional26::optional<int&> o12  = fortytwo;
+    auto                              o12r = std::move(o12).transform([](int) { return 42; });
     EXPECT_TRUE(*o12r == 42);
 
-    const beman::optional::optional<int&> o16  = fortytwo;
-    auto                                o16r = o16.transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o16  = fortytwo;
+    auto                                    o16r = o16.transform([](int) { return 42; });
     EXPECT_TRUE(*o16r == 42);
 
-    const beman::optional::optional<int&> o20  = fortytwo;
-    auto                                o20r = std::move(o20).transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o20  = fortytwo;
+    auto                                    o20r = std::move(o20).transform([](int) { return 42; });
     EXPECT_TRUE(*o20r == 42);
 
-    beman::optional::optional<int&> o24  = beman::optional::nullopt;
-    auto                          o24r = o24.transform([](int) { return 42; });
+    beman::optional26::optional<int&> o24  = beman::optional26::nullopt;
+    auto                              o24r = o24.transform([](int) { return 42; });
     EXPECT_TRUE(!o24r);
 
-    beman::optional::optional<int&> o28  = beman::optional::nullopt;
-    auto                          o28r = std::move(o28).transform([](int) { return 42; });
+    beman::optional26::optional<int&> o28  = beman::optional26::nullopt;
+    auto                              o28r = std::move(o28).transform([](int) { return 42; });
     EXPECT_TRUE(!o28r);
 
-    const beman::optional::optional<int&> o32  = beman::optional::nullopt;
-    auto                                o32r = o32.transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o32  = beman::optional26::nullopt;
+    auto                                    o32r = o32.transform([](int) { return 42; });
     EXPECT_TRUE(!o32r);
 
-    const beman::optional::optional<int&> o36  = beman::optional::nullopt;
-    auto                                o36r = std::move(o36).transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o36  = beman::optional26::nullopt;
+    auto                                    o36r = std::move(o36).transform([](int) { return 42; });
     EXPECT_TRUE(!o36r);
 
     // callable which returns a reference
-    beman::optional::optional<int&> o38  = fortytwo;
-    auto                          o38r = o38.transform([](int& i) -> const int& { return i; });
+    beman::optional26::optional<int&> o38  = fortytwo;
+    auto                              o38r = o38.transform([](int& i) -> const int& { return i; });
     EXPECT_TRUE(o38r);
     EXPECT_TRUE(*o38r == 42);
 }
@@ -91,34 +94,34 @@ TEST(OptionalRefMonadicTest, Transform) {
 TEST(OptionalRefMonadicTest, TransformConstexpr) {
 
     // test each overload in turn
-    constexpr beman::optional::optional<const int&> o16  = constexpr_fortytwo;
-    constexpr auto                                o16r = o16.transform(get_int);
+    constexpr beman::optional26::optional<const int&> o16  = constexpr_fortytwo;
+    constexpr auto                                    o16r = o16.transform(get_int);
     static_assert(*o16r == 42);
 
-    constexpr beman::optional::optional<const int&> o20  = constexpr_fortytwo;
-    constexpr auto                                o20r = std::move(o20).transform(get_int);
+    constexpr beman::optional26::optional<const int&> o20  = constexpr_fortytwo;
+    constexpr auto                                    o20r = std::move(o20).transform(get_int);
     static_assert(*o20r == 42);
 
-    constexpr beman::optional::optional<int&> o32  = beman::optional::nullopt;
-    constexpr auto                          o32r = o32.transform(get_int);
+    constexpr beman::optional26::optional<int&> o32  = beman::optional26::nullopt;
+    constexpr auto                              o32r = o32.transform(get_int);
     static_assert(!o32r);
-    constexpr beman::optional::optional<int&> o36  = beman::optional::nullopt;
-    constexpr auto                          o36r = std::move(o36).transform(get_int);
+    constexpr beman::optional26::optional<int&> o36  = beman::optional26::nullopt;
+    constexpr auto                              o36r = std::move(o36).transform(get_int);
     static_assert(!o36r);
 }
 
 TEST(OptionalRefMonadicTest, Transform2) {
     // lhs is empty
-    beman::optional::optional<int&> o1;
-    auto                          o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
+    beman::optional26::optional<int&> o1;
+    auto                              o1r = o1.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o1r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
-    int                           forty = 40;
-    beman::optional::optional<int&> o2    = forty;
-    auto                          o2r   = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
+    int                               forty = 40;
+    beman::optional26::optional<int&> o2    = forty;
+    auto                              o2r   = o2.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o2r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o2r.value() == 42);
 
     struct rval_call_transform {
@@ -126,193 +129,193 @@ TEST(OptionalRefMonadicTest, Transform2) {
     };
 
     // ensure that function object is forwarded
-    int                           fortytwo = 42;
-    beman::optional::optional<int&> o3       = fortytwo;
-    auto                          o3r      = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
+    int                               fortytwo = 42;
+    beman::optional26::optional<int&> o3       = fortytwo;
+    auto                              o3r      = o3.transform(rval_call_transform{});
+    static_assert((std::is_same<decltype(o3r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o3r.value() == 42);
 
     // // ensure that lhs is forwarded
     // int forty = 40;
-    // beman::optional::optional<int&> o4 = forty;
+    // beman::optional26::optional<int&> o4 = forty;
     // auto o4r = std::move(o4).transform([](int&& i) { return i + 2; });
-    // static_assert((std::is_same<decltype(o4r), beman::optional::optional<int&>>::value));
+    // static_assert((std::is_same<decltype(o4r), beman::optional26::optional<int&>>::value));
     // EXPECT_TRUE(o4r.value() == 42);
 
     // ensure that lhs is const-propagated
-    forty                                   = 40;
-    const beman::optional::optional<int&> o5  = forty;
-    auto                                o5r = o5.transform([](const int& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
+    forty                                       = 40;
+    const beman::optional26::optional<int&> o5  = forty;
+    auto                                    o5r = o5.transform([](const int& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o5r), beman::optional26::optional<int>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // test each overload in turn
-    fortytwo                          = 42;
-    beman::optional::optional<int&> o8  = fortytwo;
-    auto                          o8r = o8.transform([](int) { return 42; });
+    fortytwo                              = 42;
+    beman::optional26::optional<int&> o8  = fortytwo;
+    auto                              o8r = o8.transform([](int) { return 42; });
     EXPECT_TRUE(*o8r == 42);
 
-    beman::optional::optional<int&> o12  = fortytwo;
-    auto                          o12r = std::move(o12).transform([](int) { return 42; });
+    beman::optional26::optional<int&> o12  = fortytwo;
+    auto                              o12r = std::move(o12).transform([](int) { return 42; });
     EXPECT_TRUE(*o12r == 42);
 
-    const beman::optional::optional<int&> o16  = fortytwo;
-    auto                                o16r = o16.transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o16  = fortytwo;
+    auto                                    o16r = o16.transform([](int) { return 42; });
     EXPECT_TRUE(*o16r == 42);
 
-    const beman::optional::optional<int&> o20  = fortytwo;
-    auto                                o20r = std::move(o20).transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o20  = fortytwo;
+    auto                                    o20r = std::move(o20).transform([](int) { return 42; });
     EXPECT_TRUE(*o20r == 42);
 
-    beman::optional::optional<int&> o24  = beman::optional::nullopt;
-    auto                          o24r = o24.transform([](int) { return 42; });
+    beman::optional26::optional<int&> o24  = beman::optional26::nullopt;
+    auto                              o24r = o24.transform([](int) { return 42; });
     EXPECT_TRUE(!o24r);
 
-    beman::optional::optional<int&> o28  = beman::optional::nullopt;
-    auto                          o28r = std::move(o28).transform([](int) { return 42; });
+    beman::optional26::optional<int&> o28  = beman::optional26::nullopt;
+    auto                              o28r = std::move(o28).transform([](int) { return 42; });
     EXPECT_TRUE(!o28r);
 
-    const beman::optional::optional<int&> o32  = beman::optional::nullopt;
-    auto                                o32r = o32.transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o32  = beman::optional26::nullopt;
+    auto                                    o32r = o32.transform([](int) { return 42; });
     EXPECT_TRUE(!o32r);
 
-    const beman::optional::optional<int&> o36  = beman::optional::nullopt;
-    auto                                o36r = std::move(o36).transform([](int) { return 42; });
+    const beman::optional26::optional<int&> o36  = beman::optional26::nullopt;
+    auto                                    o36r = std::move(o36).transform([](int) { return 42; });
     EXPECT_TRUE(!o36r);
 }
 
 TEST(OptionalRefMonadicTest, TransformConstxpr) {
     // test each overload in turn
-    constexpr beman::optional::optional<const int&> o16  = constexpr_fortytwo;
-    constexpr auto                                o16r = o16.transform(get_int);
+    constexpr beman::optional26::optional<const int&> o16  = constexpr_fortytwo;
+    constexpr auto                                    o16r = o16.transform(get_int);
     static_assert(*o16r == 42);
 
-    constexpr beman::optional::optional<const int&> o20  = constexpr_fortytwo;
-    constexpr auto                                o20r = std::move(o20).transform(get_int);
+    constexpr beman::optional26::optional<const int&> o20  = constexpr_fortytwo;
+    constexpr auto                                    o20r = std::move(o20).transform(get_int);
     static_assert(*o20r == 42);
 
-    constexpr beman::optional::optional<const int&> o32  = beman::optional::nullopt;
-    constexpr auto                                o32r = o32.transform(get_int);
+    constexpr beman::optional26::optional<const int&> o32  = beman::optional26::nullopt;
+    constexpr auto                                    o32r = o32.transform(get_int);
     static_assert(!o32r);
-    constexpr beman::optional::optional<int&> o36  = beman::optional::nullopt;
-    constexpr auto                          o36r = std::move(o36).transform(get_int);
+    constexpr beman::optional26::optional<int&> o36  = beman::optional26::nullopt;
+    constexpr auto                              o36r = std::move(o36).transform(get_int);
     static_assert(!o36r);
 }
 
 TEST(OptionalRefMonadicTest, and_then) {
     // lhs is empty
-    beman::optional::optional<int&> o1;
-    auto                          o1r = o1.and_then([](int) { return beman::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o1r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int&> o1;
+    auto                              o1r = o1.and_then([](int) { return beman::optional26::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o1r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
-    int                           twelve = 12;
-    beman::optional::optional<int&> o2     = twelve;
-    auto                          o2r    = o2.and_then([](int) { return beman::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o2r), beman::optional::optional<float>>::value));
+    int                               twelve = 12;
+    beman::optional26::optional<int&> o2     = twelve;
+    auto                              o2r    = o2.and_then([](int) { return beman::optional26::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o2r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(o2r.value() == 42.f);
 
     // lhs is empty, rhs returns empty
-    beman::optional::optional<int&> o3;
-    auto                          o3r = o3.and_then([](int) { return beman::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o3r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int&> o3;
+    auto                              o3r = o3.and_then([](int) { return beman::optional26::optional<float>{}; });
+    static_assert((std::is_same<decltype(o3r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(!o3r);
 
     // rhs returns empty
-    beman::optional::optional<int&> o4  = twelve;
-    auto                          o4r = o4.and_then([](int) { return beman::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o4r), beman::optional::optional<float>>::value));
+    beman::optional26::optional<int&> o4  = twelve;
+    auto                              o4r = o4.and_then([](int) { return beman::optional26::optional<float>{}; });
+    static_assert((std::is_same<decltype(o4r), beman::optional26::optional<float>>::value));
     EXPECT_TRUE(!o4r);
 
     struct rval_call_and_then {
-        beman::optional::optional<double> operator()(int) && { return beman::optional::optional<double>(42.0); };
+        beman::optional26::optional<double> operator()(int) && { return beman::optional26::optional<double>(42.0); };
     };
 
     // ensure that function object is forwarded
-    int                           fortytwo = 42;
-    beman::optional::optional<int&> o5       = fortytwo;
-    auto                          o5r      = o5.and_then(rval_call_and_then{});
-    static_assert((std::is_same<decltype(o5r), beman::optional::optional<double>>::value));
+    int                               fortytwo = 42;
+    beman::optional26::optional<int&> o5       = fortytwo;
+    auto                              o5r      = o5.and_then(rval_call_and_then{});
+    static_assert((std::is_same<decltype(o5r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // // ensure that lhs is forwarded
-    // beman::optional::optional<int&> o6 = fortytwo;
+    // beman::optional26::optional<int&> o6 = fortytwo;
     // auto o6r =
-    //     std::move(o6).and_then([](int &&i) { return beman::optional::optional<double>(i); });
-    // static_assert((std::is_same<decltype(o6r), beman::optional::optional<double>>::value));
+    //     std::move(o6).and_then([](int &&i) { return beman::optional26::optional<double>(i); });
+    // static_assert((std::is_same<decltype(o6r), beman::optional26::optional<double>>::value));
     // EXPECT_TRUE(o6r.value() == 42);
 
     // ensure that function object is const-propagated
-    const beman::optional::optional<int&> o7 = fortytwo;
-    auto o7r = o7.and_then([](const int& i) { return beman::optional::optional<double>(i); });
-    static_assert((std::is_same<decltype(o7r), beman::optional::optional<double>>::value));
+    const beman::optional26::optional<int&> o7 = fortytwo;
+    auto o7r = o7.and_then([](const int& i) { return beman::optional26::optional<double>(i); });
+    static_assert((std::is_same<decltype(o7r), beman::optional26::optional<double>>::value));
     EXPECT_TRUE(o7r.value() == 42);
 
     // test each overload in turn
-    beman::optional::optional<int&> o8  = fortytwo;
-    auto                          o8r = o8.and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int&> o8  = fortytwo;
+    auto                              o8r = o8.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o8r == 42);
 
-    beman::optional::optional<int&> o9  = fortytwo;
-    auto                          o9r = std::move(o9).and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int&> o9 = fortytwo;
+    auto o9r = std::move(o9).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o9r == 42);
 
-    const beman::optional::optional<int&> o10  = fortytwo;
-    auto                                o10r = o10.and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int&> o10 = fortytwo;
+    auto o10r = o10.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o10r == 42);
 
-    const beman::optional::optional<int&> o11 = fortytwo;
-    auto o11r = std::move(o11).and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int&> o11 = fortytwo;
+    auto o11r = std::move(o11).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(*o11r == 42);
 
-    beman::optional::optional<int&> o16  = beman::optional::nullopt;
-    auto                          o16r = o16.and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int&> o16  = beman::optional26::nullopt;
+    auto                              o16r = o16.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o16r);
 
-    beman::optional::optional<int&> o17  = beman::optional::nullopt;
-    auto                          o17r = std::move(o17).and_then([](int) { return beman::optional::make_optional(42); });
+    beman::optional26::optional<int&> o17 = beman::optional26::nullopt;
+    auto o17r = std::move(o17).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o17r);
 
-    const beman::optional::optional<int&> o18  = beman::optional::nullopt;
-    auto                                o18r = o18.and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int&> o18 = beman::optional26::nullopt;
+    auto o18r = o18.and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o18r);
 
-    const beman::optional::optional<int&> o19 = beman::optional::nullopt;
-    auto o19r = std::move(o19).and_then([](int) { return beman::optional::make_optional(42); });
+    const beman::optional26::optional<int&> o19 = beman::optional26::nullopt;
+    auto o19r = std::move(o19).and_then([](int) { return beman::optional26::make_optional(42); });
     EXPECT_TRUE(!o19r);
 
-    int                           i = 3;
-    beman::optional::optional<int&> o20{i};
-    std::move(o20).and_then([](int& r) { return beman::optional::optional<int&>{++r}; });
+    int                               i = 3;
+    beman::optional26::optional<int&> o20{i};
+    std::move(o20).and_then([](int& r) { return beman::optional26::optional<int&>{++r}; });
     EXPECT_TRUE(o20);
     EXPECT_TRUE(i == 4);
 }
 
 TEST(OptionalRefMonadicTest, Constexpr_and_then) {
-    constexpr beman::optional::optional<const int&> o10  = constexpr_fortytwo;
-    constexpr auto                                o10r = o10.and_then(get_opt_int);
+    constexpr beman::optional26::optional<const int&> o10  = constexpr_fortytwo;
+    constexpr auto                                    o10r = o10.and_then(get_opt_int);
     EXPECT_TRUE(*o10r == 42);
 
-    constexpr beman::optional::optional<const int&> o11  = constexpr_fortytwo;
-    constexpr auto                                o11r = std::move(o11).and_then(get_opt_int);
+    constexpr beman::optional26::optional<const int&> o11  = constexpr_fortytwo;
+    constexpr auto                                    o11r = std::move(o11).and_then(get_opt_int);
     EXPECT_TRUE(*o11r == 42);
 
-    constexpr beman::optional::optional<int&> o18  = beman::optional::nullopt;
-    constexpr auto                          o18r = o18.and_then(get_opt_int);
+    constexpr beman::optional26::optional<int&> o18  = beman::optional26::nullopt;
+    constexpr auto                              o18r = o18.and_then(get_opt_int);
     EXPECT_TRUE(!o18r);
 
-    constexpr beman::optional::optional<int&> o19  = beman::optional::nullopt;
-    constexpr auto                          o19r = std::move(o19).and_then(get_opt_int);
+    constexpr beman::optional26::optional<int&> o19  = beman::optional26::nullopt;
+    constexpr auto                              o19r = std::move(o19).and_then(get_opt_int);
     EXPECT_TRUE(!o19r);
 }
 
 TEST(OptionalRefMonadicTest, or_else) {
-    int                           fortytwo = 42;
-    int                           thirteen = 13;
-    beman::optional::optional<int&> o1       = fortytwo;
-    EXPECT_TRUE(*(o1.or_else([&] { return beman::optional::optional<int&>(thirteen); })) == 42);
+    int                               fortytwo = 42;
+    int                               thirteen = 13;
+    beman::optional26::optional<int&> o1       = fortytwo;
+    EXPECT_TRUE(*(o1.or_else([&] { return beman::optional26::optional<int&>(thirteen); })) == 42);
 
-    beman::optional::optional<int&> o2;
-    EXPECT_EQ(*(o2.or_else([&] { return beman::optional::optional<int&>(thirteen); })), 13);
+    beman::optional26::optional<int&> o2;
+    EXPECT_EQ(*(o2.or_else([&] { return beman::optional26::optional<int&>(thirteen); })), 13);
 }
diff --git a/src/Beman/Optional26/tests/test_types.hpp b/src/Beman/Optional26/tests/test_types.hpp
new file mode 100644
index 00000000..ce894117
--- /dev/null
+++ b/src/Beman/Optional26/tests/test_types.hpp
@@ -0,0 +1,39 @@
+// src/Beman/Optional26/tests/test_types.h -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef BEMAN_OPTIONAL26_TESTS_TEST_TYPES_HPP
+#define BEMAN_OPTIONAL26_TESTS_TEST_TYPES_HPP
+
+namespace beman::optional26::test {
+// Classes used in the tests.
+
+// Empty class helper.
+struct empty {};
+
+// No default constructor class helper.
+struct no_default_ctor {
+    no_default_ctor()                                  = delete;
+    no_default_ctor(const no_default_ctor&)            = default;
+    no_default_ctor(no_default_ctor&&)                 = default;
+    no_default_ctor& operator=(const no_default_ctor&) = default;
+    no_default_ctor& operator=(no_default_ctor&&)      = default;
+    no_default_ctor(empty) {};
+};
+
+// Base class helper.
+struct base {
+    int m_i;
+    base() : m_i(0) {}
+    base(int i) : m_i(i) {}
+};
+
+// Derived class helper.
+struct derived : public base {
+    int m_j;
+    derived() : base(), m_j(0) {}
+    derived(int i, int j) : base(i), m_j(j) {}
+};
+
+} // namespace beman::optional26::test
+
+#endif // BEMAN_OPTIONAL26_TESTS_TEST_TYPES_HPP
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3a085d51..7be65236 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1 +1,4 @@
+# src/CMakeLists.txt -*-makefile-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
 add_subdirectory(Beman)