diff --git a/.beman-tidy.yaml b/.beman-tidy.yaml
index 7a0cc01..30b0ebf 100644
--- a/.beman-tidy.yaml
+++ b/.beman-tidy.yaml
@@ -7,3 +7,4 @@
 disabled_rules: []
 ignored_paths:
   - infra/
+  - include/beman/optional/detail/stl_interfaces/
diff --git a/include/beman/inplace_vector/inplace_vector.hpp b/include/beman/inplace_vector/inplace_vector.hpp
index 20ce557..e4b3560 100644
--- a/include/beman/inplace_vector/inplace_vector.hpp
+++ b/include/beman/inplace_vector/inplace_vector.hpp
@@ -4,6 +4,7 @@
 #define BEMAN_INPLACE_VECTOR_INPLACE_VECTOR_HPP
 
 #include <beman/inplace_vector/config.hpp>
+#include <beman/optional/optional.hpp>
 
 #include <algorithm> // for rotate...
 #include <array>
@@ -327,18 +328,20 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
     return this->back();
   }
 
-  template <class... Args> constexpr T *try_emplace_back(Args &&...args) {
+  template <class... Args>
+  constexpr beman::optional::optional<T &> try_emplace_back(Args &&...args) {
     if (size() == capacity()) [[unlikely]]
-      return nullptr;
-    return &unchecked_emplace_back(std::forward<Args>(args)...);
+      return beman::optional::nullopt;
+    return beman::optional::optional<T &>(
+        unchecked_emplace_back(std::forward<Args>(args)...));
   }
 
-  constexpr T *try_push_back(const T &x)
+  constexpr beman::optional::optional<T &> try_push_back(const T &x)
     requires(std::constructible_from<T, const T &>)
   {
     return try_emplace_back(x);
   }
-  constexpr T *try_push_back(T &&x)
+  constexpr beman::optional::optional<T &> try_push_back(T &&x)
     requires(std::constructible_from<T, T &&>)
   {
     return try_emplace_back(std::forward<T &&>(x));
diff --git a/include/beman/optional/CMakeLists.txt b/include/beman/optional/CMakeLists.txt
new file mode 100644
index 0000000..a27526b
--- /dev/null
+++ b/include/beman/optional/CMakeLists.txt
@@ -0,0 +1,15 @@
+# include/beman/optional/CMakeLists.txt                             -*-cmake-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+target_sources(
+    beman.optional
+    PUBLIC
+        FILE_SET beman_optional_headers
+            TYPE HEADERS
+            FILES
+                optional.hpp
+                detail/iterator.hpp
+                detail/stl_interfaces/config.hpp
+                detail/stl_interfaces/fwd.hpp
+                detail/stl_interfaces/iterator_interface.hpp
+)
diff --git a/include/beman/optional/detail/iterator.hpp b/include/beman/optional/detail/iterator.hpp
new file mode 100644
index 0000000..de11bc0
--- /dev/null
+++ b/include/beman/optional/detail/iterator.hpp
@@ -0,0 +1,71 @@
+// include/beman/optional/detail/iterator.hpp                         -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef BEMAN_OPTIONAL_DETAIL_ITERATOR_HPP
+#define BEMAN_OPTIONAL_DETAIL_ITERATOR_HPP
+
+#include <beman/optional/detail/stl_interfaces/iterator_interface.hpp>
+
+#include <concepts>
+#include <iterator>
+
+namespace beman::optional::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_OPTIONAL_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.
+  constexpr contiguous_iterator() noexcept : m_current() {}
+
+  // Pointer to iterator constructor.
+  constexpr contiguous_iterator(pointer it) noexcept : m_current(it) {}
+
+  // As per P2727R4, for contiguous iterator we only need to provide operator*,
+  // operator+= and operator-.
+  constexpr reference operator*() const noexcept { return *m_current; }
+  constexpr auto &operator+=(difference_type pos) noexcept {
+    m_current += pos;
+    return *this;
+  }
+  constexpr difference_type
+  operator-(contiguous_iterator other) const noexcept {
+    return m_current - other.m_current;
+  }
+
+private:
+  T *m_current;
+};
+
+} // namespace beman::optional::detail
+
+#endif // BEMAN_OPTIONAL_DETAIL_ITERATOR_HPP
diff --git a/include/beman/optional/detail/stl_interfaces/config.hpp b/include/beman/optional/detail/stl_interfaces/config.hpp
new file mode 100644
index 0000000..8fa7633
--- /dev/null
+++ b/include/beman/optional/detail/stl_interfaces/config.hpp
@@ -0,0 +1,51 @@
+// include/beman/optional/detail/stl_interfaces/config.hpp            -*-C++-*-
+
+// 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_OPTIONAL_DETAIL_STL_INTERFACES_CONFIG_HPP
+#define BEMAN_OPTIONAL_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_OPTIONAL_DETAIL_STL_INTERFACES_DISABLE_CONCEPTS)
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS 1
+#else
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS 0
+#endif
+
+#if defined(__cpp_explicit_this_parameter) &&                                  \
+    BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS &&                       \
+    !defined(BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_DISABLE_DEDUCED_THIS)
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS 1
+#else
+#define BEMAN_OPTIONAL_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_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS &&                      \
+    !BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V1 inline namespace v1
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V2 namespace v2
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V3 namespace v3
+#elif BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS &&                     \
+    !BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V1 namespace v1
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V2 inline namespace v2
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V3 namespace v3
+#else
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V1 namespace v1
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V2 namespace v2
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NAMESPACE_V3 inline namespace v3
+#endif
+
+#endif
diff --git a/include/beman/optional/detail/stl_interfaces/fwd.hpp b/include/beman/optional/detail/stl_interfaces/fwd.hpp
new file mode 100644
index 0000000..14a7647
--- /dev/null
+++ b/include/beman/optional/detail/stl_interfaces/fwd.hpp
@@ -0,0 +1,85 @@
+// include/beman/optional/detail/stl_interfaces/fwd.hpp               -*-C++-*-
+
+// 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_OPTIONAL_DETAIL_STL_INTERFACES_FWD_HPP
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_FWD_HPP
+
+#include <beman/optional/detail/stl_interfaces/config.hpp>
+
+#if BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS
+#include <ranges>
+#endif
+#if defined(__cpp_lib_three_way_comparison)
+#include <compare>
+#endif
+
+#ifndef BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN
+
+#if defined(_MSC_VER) || defined(__GNUC__) && __GNUC__ < 8
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_NO_HIDDEN_FRIEND_CONSTEXPR
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR
+#else
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR constexpr
+#endif
+
+#if defined(__GNUC__) && __GNUC__ < 9
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_CONCEPT concept bool
+#else
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_CONCEPT concept
+#endif
+
+#endif
+
+namespace beman::optional::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_OPTIONAL_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::optional::detail
+
+#endif
diff --git a/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp b/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp
new file mode 100644
index 0000000..deda3f6
--- /dev/null
+++ b/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp
@@ -0,0 +1,1056 @@
+// include/beman/optional/detail/stl_interfaces/iterator_interface.hpp -*-C++-*-
+
+// 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_OPTIONAL_DETAIL_STL_INTERFACES_ITERATOR_INTERFACE_HPP
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_ITERATOR_INTERFACE_HPP
+
+#include <beman/optional/detail/stl_interfaces/fwd.hpp>
+
+#include <type_traits>
+#include <utility>
+#if defined(__cpp_lib_three_way_comparison)
+#include <compare>
+#endif
+
+namespace beman::optional::detail {
+namespace stl_interfaces {
+
+/** A type for granting access to the private members of an iterator
+    derived from `iterator_interface`. */
+struct access {
+#ifndef BEMAN_OPTIONAL_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_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN) ||                   \
+    BEMAN_OPTIONAL_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::optional::detail
+
+namespace beman::optional::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL_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_OPTIONAL_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_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN
+            ,
+            typename E
+#endif
+            >
+  struct iterator_interface {
+#ifndef BEMAN_OPTIONAL_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_OPTIONAL_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_OPTIONAL_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::optional::detail
+
+#if defined(BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN) ||                   \
+    BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS
+
+namespace beman::optional::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL_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::optional::detail
+
+#endif
+
+#if defined(BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN) ||                   \
+    BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+
+namespace beman::optional::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL_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::optional::detail
+
+#endif
+
+#ifdef BEMAN_OPTIONAL_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_OPTIONAL_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_OPTIONAL_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_OPTIONAL_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_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(    \
+    iter, category, concept, value_type, reference, pointer, difference_type)
+
+#else
+
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL( \
+    type, concept_name)                                                           \
+  static_assert(concept_name<type>, "");
+
+#if BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(            \
+    iter, concept_name)                                                        \
+  BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(    \
+      iter, concept_name)
+#else
+#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(            \
+    iter, concept_name)
+#endif
+
+#define BEMAN_OPTIONAL_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_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(    \
+    iter, category, concept, value_type, reference, pointer, difference_type)  \
+  BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL(     \
+      iter, category, value_type, reference, pointer, difference_type)
+#endif
+
+#endif
diff --git a/include/beman/optional/optional.hpp b/include/beman/optional/optional.hpp
new file mode 100644
index 0000000..2e14de2
--- /dev/null
+++ b/include/beman/optional/optional.hpp
@@ -0,0 +1,2240 @@
+// include/beman/optional/optional.hpp                                -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef BEMAN_OPTIONAL_OPTIONAL_HPP
+#define BEMAN_OPTIONAL_OPTIONAL_HPP
+
+#include <compare>
+#include <concepts>
+#include <version>
+#if defined(__cpp_lib_format_ranges)
+#include <format>
+#endif
+#include <functional>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include <beman/optional/detail/iterator.hpp>
+
+namespace beman::optional {
+
+namespace detail {
+template <typename T, typename U>
+concept optional_eq_rel = requires(const T &t, const U &u) {
+  { t == u } -> std::convertible_to<bool>;
+};
+
+template <typename T, typename U>
+concept optional_ne_rel = requires(const T &t, const U &u) {
+  { t != u } -> std::convertible_to<bool>;
+};
+
+template <typename T, typename U>
+concept optional_lt_rel = requires(const T &t, const U &u) {
+  { t < u } -> std::convertible_to<bool>;
+};
+
+template <typename T, typename U>
+concept optional_gt_rel = requires(const T &t, const U &u) {
+  { t > u } -> std::convertible_to<bool>;
+};
+
+template <typename T, typename U>
+concept optional_le_rel = requires(const T &t, const U &u) {
+  { t <= u } -> std::convertible_to<bool>;
+};
+
+template <typename T, typename U>
+concept optional_ge_rel = requires(const T &t, const U &u) {
+  { t >= u } -> std::convertible_to<bool>;
+};
+
+struct from_function_t {
+  explicit from_function_t() = default;
+};
+
+inline constexpr from_function_t from_function{};
+} // namespace detail
+
+/**
+ *
+ * @brief Tag type for in-place construction
+ */
+struct in_place_t {
+  explicit in_place_t() = default;
+};
+
+/**
+ * @brief Tag for in-place construction
+ */
+inline constexpr in_place_t in_place{};
+
+} // namespace beman::optional
+
+namespace beman::optional {
+template <class T> class optional; // partially freestanding
+} // namespace beman::optional
+
+// Since P3168R2: Give std::optional Range Support.
+template <class T>
+inline constexpr bool std::ranges::enable_view<beman::optional::optional<T>> =
+    true;
+
+// Iterators for optional<T&> have lifetimes that are not tied to the optional.
+template <class T>
+inline constexpr bool
+    std::ranges::enable_borrowed_range<beman::optional::optional<T &>> = true;
+
+// Since P3168R2: Give std::optional Range Support.
+#if defined(__cpp_lib_format_ranges)
+template <class T>
+inline constexpr auto std::format_kind<beman::optional::optional<T>> =
+    range_format::disabled;
+#endif
+
+namespace beman::optional {
+namespace detail {
+template <typename T> inline constexpr bool is_optional = false;
+template <typename T> inline constexpr bool is_optional<optional<T>> = true;
+} // namespace detail
+/**
+ * @brief Concept for checking if derived from optional.
+ */
+template <class T>
+concept is_derived_from_optional = requires(const T &t) { // exposition only
+  []<class U>(const optional<U> &) {}(t);
+};
+
+// \ref{optional.nullopt}, no-value state indicator
+/**
+ * @brief Tag type for empty optional construction
+ */
+struct nullopt_t {
+  /** @enum Tag
+   * @brief Tag enum for nullopt_t construction
+   */
+  enum class Tag { tag /**< the tag value for nullopt_t::Tag */ };
+
+  /**
+   * @brief Construct a new nullopt_t object
+   * @arg Tag
+   * @details constexpr for nullopt_t to be literal.
+   */
+  explicit constexpr nullopt_t(Tag) noexcept {}
+
+private:
+  friend constexpr bool operator==(nullopt_t, nullopt_t) noexcept {
+    return true;
+  }
+
+  friend constexpr std::strong_ordering operator<=>(nullopt_t,
+                                                    nullopt_t) noexcept {
+    return std::strong_ordering::equivalent;
+  }
+};
+
+/// Tag to disengage optional objects.
+inline constexpr nullopt_t nullopt{nullopt_t::Tag::tag};
+
+// \ref{optional.bad.access}, class bad_optional_access
+class bad_optional_access;
+
+// \ref{optional.relops}, relational operators
+template <typename T, typename U>
+constexpr bool operator==(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_eq_rel<T, U>;
+template <typename T, typename U>
+constexpr bool operator!=(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_ne_rel<T, U>;
+template <typename T, typename U>
+constexpr bool operator<(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_lt_rel<T, U>;
+template <typename T, typename U>
+constexpr bool operator>(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_gt_rel<T, U>;
+template <typename T, typename U>
+constexpr bool operator<=(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_le_rel<T, U>;
+template <typename T, typename U>
+constexpr bool operator>=(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_ge_rel<T, U>;
+template <class T, std::three_way_comparable_with<T> U>
+constexpr std::compare_three_way_result_t<T, U>
+operator<=>(const optional<T> &, const optional<U> &);
+
+// \ref{optional.nullops}, comparison with \tcode{nullopt}
+template <class T>
+constexpr bool operator==(const optional<T> &, nullopt_t) noexcept;
+template <class T>
+constexpr std::strong_ordering operator<=>(const optional<T> &,
+                                           nullopt_t) noexcept;
+
+// \ref{optional.comp.with.t}, comparison with \tcode{T}
+template <typename T, typename U>
+constexpr bool operator==(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_eq_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator==(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_eq_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator!=(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_ne_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator!=(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_ne_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator<(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_lt_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator<(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_lt_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator>(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_gt_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator>(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_gt_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator<=(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_le_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator<=(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_le_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator>=(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_ge_rel<T, U>;
+
+template <typename T, typename U>
+constexpr bool operator>=(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_ge_rel<T, U>;
+
+template <typename T, typename U>
+  requires(!is_derived_from_optional<U>) && std::three_way_comparable_with<T, U>
+constexpr std::compare_three_way_result_t<T, U>
+operator<=>(const optional<T> &x, const U &v);
+
+// \ref{optional.specalg}, specialized algorithms
+/**
+ * @brief Swap
+ */
+template <class T>
+constexpr void swap(optional<T> &x,
+                    optional<T> &y) noexcept(noexcept(x.swap(y)))
+  requires std::is_move_constructible_v<T> && std::is_swappable_v<T>;
+
+/**
+ * @brief Make an optional
+ */
+template <int = 0, class T>
+constexpr optional<std::decay_t<T>> make_optional(T &&) noexcept(
+    std::is_nothrow_constructible_v<optional<std::decay_t<T>>, T>)
+  requires std::is_constructible_v<std::decay_t<T>, T>;
+
+template <class T, class... Args>
+constexpr optional<T> make_optional(Args &&...args) noexcept(
+    std::is_nothrow_constructible_v<T, Args...>)
+  requires std::is_constructible_v<T, Args...>;
+
+template <class T, class U, class... Args>
+constexpr optional<T>
+make_optional(std::initializer_list<U> il, Args &&...args) noexcept(
+    std::is_nothrow_constructible_v<T, std::initializer_list<U> &, Args...>)
+  requires std::is_constructible_v<T, std::initializer_list<U> &, Args...>;
+
+// \ref{optional.hash}, hash support
+/* We are not actually in ::std, don't declare beman::optional::hash.
+template <class T>
+struct hash;
+template <class T>
+struct hash<optional<T>>;
+*/
+/// END [optional.syn]
+
+namespace detail {
+template <class T, class U>
+concept enable_forward_value = !std::is_same_v<std::decay_t<U>, optional<T>> &&
+                               !std::is_same_v<std::decay_t<U>, in_place_t> &&
+                               std::is_constructible_v<T, U &&>;
+
+template <class T, class U, class Other>
+concept enable_from_other =
+    !std::is_same_v<T, U> &&                             //
+    std::is_constructible_v<T, Other> &&                 //
+    !std::is_constructible_v<T, optional<U> &> &&        //
+    !std::is_constructible_v<T, optional<U> &&> &&       //
+    !std::is_constructible_v<T, const optional<U> &> &&  //
+    !std::is_constructible_v<T, const optional<U> &&> && //
+    !std::is_convertible_v<optional<U> &, T> &&          //
+    !std::is_convertible_v<optional<U> &&, T> &&         //
+    !std::is_convertible_v<const optional<U> &, T> &&    //
+    !std::is_convertible_v<const optional<U> &&, T>;
+
+template <class T, class U>
+concept enable_assign_forward =
+    !std::is_same_v<optional<T>, std::decay_t<U>> &&
+    !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::decay_t<U>>> &&
+    std::is_constructible_v<T, U> && std::is_assignable_v<T &, U>;
+
+template <class T, class U, class Other>
+concept enable_assign_from_other =
+    std::is_constructible_v<T, Other> && std::is_assignable_v<T &, Other> &&
+    !std::is_constructible_v<T, optional<U> &> &&
+    !std::is_constructible_v<T, optional<U> &&> &&
+    !std::is_constructible_v<T, const optional<U> &> &&
+    !std::is_constructible_v<T, const optional<U> &&> &&
+    !std::is_convertible_v<optional<U> &, T> &&
+    !std::is_convertible_v<optional<U> &&, T> &&
+    !std::is_convertible_v<const optional<U> &, T> &&
+    !std::is_convertible_v<const optional<U> &&, T> &&
+    !std::is_assignable_v<T &, optional<U> &> &&
+    !std::is_assignable_v<T &, optional<U> &&> &&
+    !std::is_assignable_v<T &, const optional<U> &> &&
+    !std::is_assignable_v<T &, const optional<U> &&>;
+} // namespace detail
+
+// 22.5.3.1 General[optional.optional.general]
+
+/**
+ *
+ * @brief Optional Objects
+ */
+template <class T> class optional {
+  static_assert((!std::is_same_v<T, std::remove_cv_t<in_place_t>>) &&
+                (!std::is_same_v<std::remove_cv_t<T>, nullopt_t>));
+  static_assert(std::is_object_v<T> && !std::is_array_v<T>);
+
+public:
+  /**
+   * @brief Type alias for the value type contained in the optional.
+   *
+   */
+  using value_type = T;
+
+  /**
+   * @brief Type alias for the iterator type of the optional.
+   *
+   * @details Since P3168R2: Give std::optional Range Support.
+   */
+  using iterator =
+      detail::contiguous_iterator<T,
+                                  optional>; // see~\ref{optional.iterators}
+  /**
+   * @brief Type alias for the const iterator type of the optional.
+   *
+   * @details Since P3168R2: Give std::optional Range Support.
+   */
+  using const_iterator =
+      detail::contiguous_iterator<const T,
+                                  optional>; // see~\ref{optional.iterators}
+
+  // \ref{optional.ctor}, constructors
+  /**
+   * @brief Default constructs an empty optional.
+   *
+   */
+  constexpr optional() noexcept;
+
+  /**
+   * @brief Constructs an empty optional.
+   *
+   */
+  constexpr optional(nullopt_t) noexcept;
+
+  /**
+   * @brief   Copy constructs the value from \p rhs if it has one.
+   *
+   */
+  constexpr optional(const optional &rhs)
+    requires std::is_copy_constructible_v<T> &&
+             (!std::is_trivially_copy_constructible_v<T>);
+  /**
+   * @brief Copy constructs the value from \p rhs if it has one.
+   * @details Defaulted if T is trivially copy constructible.
+   */
+  constexpr optional(const optional &)
+    requires std::is_copy_constructible_v<T> &&
+                 std::is_trivially_copy_constructible_v<T>
+  = default;
+  /**
+   *  @brief Move constructs the value from \p rhs if it has one.
+   */
+  constexpr optional(optional &&rhs) noexcept(
+      std::is_nothrow_move_constructible_v<T>)
+    requires std::is_move_constructible_v<T> &&
+             (!std::is_trivially_move_constructible_v<T>);
+  /**
+   * @brief Move constructs the value from \p rhs if it has one.
+   * @details Defaulted if T is trivially move constructible.
+   */
+  constexpr optional(optional &&)
+    requires std::is_move_constructible_v<T> &&
+                 std::is_trivially_move_constructible_v<T>
+  = default;
+
+  /**
+   *  @brief   Constructs the value in-place using the given arguments.
+   *
+   * @param args The arguments to use for in-place construction.
+   */
+  template <class... Args>
+  constexpr explicit optional(in_place_t, Args &&...args)
+    requires std::is_constructible_v<T, Args...>;
+
+  /**
+   *  @brief   Constructs the value in-place using the given arguments.
+   *
+   * @param il The initializer list to use for in-place construction.
+   * @param args The arguments to use for in-place construction.
+   */
+  template <class U, class... Args>
+  constexpr explicit optional(in_place_t, std::initializer_list<U> il,
+                              Args &&...args)
+    requires std::is_constructible_v<T, std::initializer_list<U> &, Args &&...>;
+
+  /**
+   * @brief   Constructs the value from \p u, forwarding it if necessary.
+   *
+   * If \p u is convertible to \p T, this is an explicit constructor.
+   */
+  template <class U = T>
+  constexpr explicit(!std::is_convertible_v<U, T>) optional(U &&u)
+    requires detail::enable_forward_value<T, U>;
+
+  /**
+   * @brief   Constructs the value from \p rhs if it has one.
+   *
+   * @tparam U
+   */
+  template <class U>
+  constexpr explicit(!std::is_convertible_v<U, T>)
+      optional(const optional<U> &rhs)
+    requires(detail::enable_from_other<T, U, const U &>);
+
+  /**
+   * @brief   Constructs the value from \p rhs if it has one.
+   */
+  template <class U>
+  constexpr explicit(!std::is_convertible_v<U, T>) optional(optional<U> &&rhs)
+    requires(detail::enable_from_other<T, U, U &&>);
+
+  // \ref{optional.dtor}, destructor
+  /**
+   * @brief   Destructs the optional.
+   *
+   */
+  constexpr ~optional()
+    requires std::is_trivially_destructible_v<T>
+  = default;
+
+  /**
+   *  @brief   Destroys the optional and its value if it has one.
+   */
+  constexpr ~optional()
+    requires(!std::is_trivially_destructible_v<T>);
+
+  // \ref{optional.assign}, assignment
+  /**
+   * @brief   Resets the optional to an empty state.
+   */
+  constexpr optional &operator=(nullopt_t) noexcept;
+
+  /**
+   * @brief   Copy assigns the value from \p rhs if it has one.
+   */
+  constexpr optional &operator=(const optional &rhs)
+    requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
+             (!std::is_trivially_copy_assignable_v<T>);
+
+  /**
+   * @brief Copy assigns the value from \p rhs if it has one.
+   *
+   * @return optional&
+   */
+  constexpr optional &operator=(const optional &)
+    requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
+                 std::is_trivially_copy_constructible_v<T> &&
+                 std::is_trivially_copy_assignable_v<T>
+  = default;
+
+  /**
+   *  @brief   Move assigns the value from \p rhs if it has one.
+   */
+  constexpr optional &
+  operator=(optional &&rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
+    requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
+             (!std::is_trivially_move_assignable_v<T>);
+
+  /**
+   * @brief   Move assigns the value from \p rhs if it has one.
+   */
+  constexpr optional &operator=(optional &&)
+    requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
+                 std::is_trivially_move_constructible_v<T> &&
+                 std::is_trivially_move_assignable_v<T>
+  = default;
+
+  /**
+   * @brief  Assigns the contained value from \p u, destroying the old value if
+   * there
+   *
+   * @tparam U The type of the value to assign.
+   * @param u The value to assign.
+   * @return optional&
+   */
+  template <class U = T>
+  constexpr optional &operator=(U &&u)
+    requires detail::enable_assign_forward<T, U>;
+
+  /**
+   * @brief   Assigns the contained value from \p rhs if it has one, destroying
+   * the old value if there
+   *
+   */
+  template <class U>
+  constexpr optional &operator=(const optional<U> &rhs)
+    requires(detail::enable_assign_from_other<T, U, const U &>);
+
+  /**
+   * @brief   Assigns the contained value from \p rhs if it has one, destroying
+   * the old value if there
+   */
+  template <class U>
+  constexpr optional &operator=(optional<U> &&rhs)
+    requires(detail::enable_assign_from_other<T, U, U>);
+  /**
+   * @brief Constructs the value in-place, destroying the current one if there
+   *
+   * @tparam Args
+   * @param args The argument list to use in emplacement construction.
+   * @return T&
+   */
+  template <class... Args> constexpr T &emplace(Args &&...args);
+  /**
+   * @brief Constructs the value in-place using the given arguments, destroying
+   * the current one if there
+   *
+   * @tparam U
+   * @tparam Args
+   * @param il The initializer list to use in emplacement construction.
+   * @param args The argument list to use in emplacement construction.
+   * @return T&
+   */
+  template <class U, class... Args>
+  constexpr T &emplace(std::initializer_list<U> il, Args &&...args);
+
+  // \ref{optional.swap}, swap
+  /**
+   * @brief Swaps this optional with the other.
+   *
+   * @param rhs The optional to swap with.
+   */
+  constexpr void
+  swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
+                               std::is_nothrow_swappable<T>::value);
+
+  // \ref{optional.iterators}, iterator support
+  /**
+   * @brief   Returns an iterator to the beginning of the optional.
+   * @return iterator
+   */
+  constexpr iterator begin() noexcept;
+
+  /**
+   * @brief   Returns a const iterator to the beginning of the optional.
+   * @return const_iterator
+   */
+  constexpr const_iterator begin() const noexcept;
+
+  /**
+   * @brief   Returns an iterator to the end of the optional.
+   * @return iterator
+   */
+  constexpr iterator end() noexcept;
+
+  /**
+   * @brief   Returns a const iterator to the end of the optional.
+   * @return const_iterator
+   */
+  constexpr const_iterator end() const noexcept;
+
+  // \ref{optional.observe}, observers
+  /**
+   * @brief   Returns a pointer to the contained value.
+   */
+  constexpr const T *operator->() const;
+
+  /**
+   * @brief   Returns a pointer to the contained value.
+   *
+   * @return T*
+   */
+  constexpr T *operator->();
+  /**
+   * @brief Returns a reference to the contained value.
+   *
+   * @return T&
+   */
+  constexpr T &operator*() &;
+
+  /**
+   * @brief  Returns a reference to the contained value.
+   *
+   * @return const T&
+   */
+  constexpr const T &operator*() const &;
+
+  /**
+   * @brief   Returns a reference to the contained value.
+   *
+   * @return T&&
+   */
+  constexpr T &&operator*() &&;
+
+  /**
+   * @brief Converts the optional to a boolean indicating whether it has a
+   * value.
+   *
+   * @return bool
+   */
+  constexpr explicit operator bool() const noexcept;
+
+  /**
+   * @brief   Returns whether or not the optional has a value.
+   *
+   * @return bool
+   */
+  constexpr bool has_value() const noexcept;
+
+  /**
+   * @brief Returns a reference to the contained value.
+   *
+   * @return T&
+   */
+  constexpr T &value() &;
+
+  /**
+   * @brief Returns a reference to the contained value.
+   *
+   * @return const T&
+   */
+  constexpr const T &value() const &;
+
+  /**
+   * @brief Returns a reference to the contained value.
+   *
+   * @return T&&
+   */
+  constexpr T &&value() &&;
+
+  /**
+   * @brief Returns the contained value if there is one, otherwise returns `u`.
+   *
+   * @tparam U The type of the alternate value
+   * @param u The value to return in the empty case
+   * @return T
+   */
+  template <class U = std::remove_cv_t<T>>
+  constexpr std::remove_cv_t<T> value_or(U &&u) const &;
+  /**
+   * @brief Returns the contained value if there is one, otherwise returns `u`.
+   *
+   * @tparam U The type of the alternate value
+   * @param u The value to return in the empty case
+   * @return T
+   */
+  template <class U = std::remove_cv_t<T>>
+  constexpr std::remove_cv_t<T> value_or(U &&u) &&;
+
+  // \ref{optional.monadic}, monadic operations
+
+  /**
+   * @brief Applies a function to the contained value if there is one.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return auto
+   *
+   * @details
+   * The return type is the same as `std::invoke_result_t<F, T&>`,
+   * but wrapped in an optional. The function \p f must return an optional type.
+   */
+  template <class F> constexpr auto and_then(F &&f) &;
+
+  /**
+   * @brief Applies a function to the contained value if there is one.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return auto
+   *
+   * @details
+   * The return type is the same as `std::invoke_result_t<F, T&>`,
+   * but wrapped in an optional. The function \p f must return an optional type.
+   */
+  template <class F> constexpr auto and_then(F &&f) &&;
+
+  /**
+   * @brief Applies a function to the contained value if there is one.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return auto
+   *
+   * @details
+   * The return type is the same as `std::invoke_result_t<F, T&>`,
+   * but wrapped in an optional. The function \p f must return an optional type.
+   */
+  template <class F> constexpr auto and_then(F &&f) const &;
+
+  /**
+   * @brief Applies a function to the contained value if there is one.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return auto
+   *
+   * @details
+   * The return type is the same as `std::invoke_result_t<F, T&>`,
+   * but wrapped in an optional. The function \p f must return an optional type.
+   */
+  template <class F> constexpr auto and_then(F &&f) const &&;
+
+  /**
+   * @brief Returns an optional containing the result of applying \p f to the
+   * contained value, or an empty optional if there is no contained value.
+   *
+   * @tparam F
+   * @param f An invocable to apply to the contained value.
+   * @return optional
+   */
+  template <class F> constexpr auto transform(F &&f) &;
+
+  /**
+   * @brief Returns an optional containing the result of applying \p f to the
+   * contained value, or an empty optional if there is no contained value.
+   *
+   * @tparam F
+   * @param f An invocable to apply to the contained value.
+   * @return auto
+   */
+  template <class F> constexpr auto transform(F &&f) &&;
+
+  /**
+   * @brief Returns an optional containing the result of applying \p f to the
+   * contained value, or an empty optional if there is no contained value.
+   *
+   * @tparam F
+   * @param f An invocable to apply to the contained value.
+   * @return auto
+   */
+  template <class F> constexpr auto transform(F &&f) const &;
+
+  /**
+   * @brief Returns an optional containing the result of applying \p f to the
+   * contained value, or an empty optional if there is no contained value.
+   *
+   * @tparam F
+   * @param f An invocable to apply to the contained value.
+   * @return auto
+   */
+  template <class F> constexpr auto transform(F &&f) const &&;
+
+  /**
+   * @brief Returns an optional containing the contained value if it has one, or
+   * the result of applying \p f to the optional if it does not.
+   *
+   * @tparam F An invocable type returning an optional.
+   * @param f The invocable to call if the optional is disengaged.
+   * @return optional
+   */
+  template <class F>
+  constexpr optional or_else(F &&f) const &
+    requires(std::invocable<F> && std::copy_constructible<T>);
+
+  /**
+   * @brief Returns an optional containing the contained value if it has one, or
+   * the result of calling \p f if it does not.
+   *
+   * @tparam F An invocable type returning an optional.
+   * @param f The invocable to call if the optional is disengaged.
+   * @return auto
+   */
+  template <class F>
+  constexpr optional or_else(F &&f) &&
+    requires(std::invocable<F> && std::move_constructible<T>);
+
+  // \ref{optional.mod}, modifiers
+  /**
+   * @brief Resets the optional to an empty state, destroying the contained
+   * value if there is one.
+   *
+   */
+  constexpr void reset() noexcept;
+
+private:
+  struct empty {};
+  union {
+    /**
+     * @brief The empty state of the optional.
+     *
+     */
+    empty _{};
+
+    /**
+     * @brief The contained value of the optional.
+     *
+     */
+    T value_;
+  };
+  bool engaged_ = false;
+
+  template <class... Args> constexpr void construct(Args &&...args) {
+    std::construct_at(std::addressof(value_), std::forward<Args>(args)...);
+    engaged_ = true;
+  }
+
+  constexpr void hard_reset() noexcept {
+    std::destroy_at(std::addressof(value_));
+    engaged_ = false;
+  }
+
+  template <class U> friend class optional;
+
+  template <class F, class Arg>
+  constexpr optional(detail::from_function_t, F &&f, Arg &&arg)
+      : value_(std::invoke(std::forward<F>(f), std::forward<Arg>(arg))),
+        engaged_(true) {}
+};
+
+/**
+ * @brief Exception thrown when trying to access the value of an empty optional
+ */
+class bad_optional_access : public std::exception {
+public:
+  /**
+   * @brief Construct a new bad optional access object
+   *
+   */
+  bad_optional_access() = default;
+
+  /**
+   * @brief Get the error message for bad optional access
+   *
+   * @return const char*
+   */
+  const char *what() const noexcept { return "Optional has no value"; }
+};
+
+// \rSec3[optional.ctor]{Constructors}
+template <class T>
+inline constexpr optional<T>::optional() noexcept : _(), engaged_(false) {}
+
+template <class T> inline constexpr optional<T>::optional(nullopt_t) noexcept {}
+
+template <class T>
+inline constexpr optional<T>::optional(const optional &rhs)
+  requires std::is_copy_constructible_v<T> &&
+           (!std::is_trivially_copy_constructible_v<T>)
+{
+  if (rhs.has_value()) {
+    construct(rhs.value_);
+  }
+}
+
+template <class T>
+inline constexpr optional<T>::optional(optional &&rhs) noexcept(
+    std::is_nothrow_move_constructible_v<T>)
+  requires std::is_move_constructible_v<T> &&
+           (!std::is_trivially_move_constructible_v<T>)
+{
+  if (rhs.has_value()) {
+    construct(std::move(rhs.value_));
+  }
+}
+
+/// Constructs the contained value in-place using the given arguments.
+template <class T>
+template <class... Args>
+inline constexpr optional<T>::optional(in_place_t, Args &&...args)
+  requires std::is_constructible_v<T, Args...>
+    : value_(std::forward<Args>(args)...), engaged_(true) {}
+
+template <class T>
+template <class U, class... Args>
+inline constexpr optional<T>::optional(in_place_t, std::initializer_list<U> il,
+                                       Args &&...args)
+  requires std::is_constructible_v<T, std::initializer_list<U> &, Args &&...>
+    : value_(il, std::forward<Args>(args)...), engaged_(true) {}
+
+/// Constructs the contained value with `u`.
+template <class T>
+template <class U>
+inline constexpr optional<T>::optional(U &&u)
+  requires detail::enable_forward_value<T, U>
+    : optional(in_place, std::forward<U>(u)) {}
+
+/// Converting copy constructor.
+template <class T>
+template <class U>
+inline constexpr optional<T>::optional(const optional<U> &rhs)
+  requires(detail::enable_from_other<T, U, const U &>)
+{
+  if (rhs.has_value()) {
+    construct(*rhs);
+  }
+}
+
+/// Converting move constructor.
+template <class T>
+template <class U>
+inline constexpr optional<T>::optional(optional<U> &&rhs)
+  requires(detail::enable_from_other<T, U, U &&>)
+{
+  if (rhs.has_value()) {
+    construct(*std::move(rhs));
+  }
+}
+
+// 22.5.3.3 Destructor[optional.dtor]
+
+template <class T>
+inline constexpr optional<T>::~optional()
+  requires(!std::is_trivially_destructible_v<T>)
+{
+  if (has_value())
+    std::destroy_at(std::addressof(value_));
+}
+
+// 22.5.3.4 Assignment[optional.assign]
+
+template <class T>
+inline constexpr optional<T> &optional<T>::operator=(nullopt_t) noexcept {
+  reset();
+  return *this;
+}
+
+template <class T>
+inline constexpr optional<T> &optional<T>::operator=(const optional<T> &rhs)
+  requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
+           (!std::is_trivially_copy_assignable_v<T>)
+{
+  if (!rhs.has_value())
+    reset();
+  else if (has_value())
+    value_ = rhs.value_;
+  else
+    construct(rhs.value_);
+  return *this;
+}
+
+template <class T>
+inline constexpr optional<T> &optional<T>::operator=(
+    optional<T> &&rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
+  requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
+           (!std::is_trivially_move_assignable_v<T>)
+{
+  if (!rhs.has_value())
+    reset();
+  else if (has_value())
+    value_ = std::move(rhs.value_);
+  else
+    construct(std::move(rhs.value_));
+  return *this;
+}
+
+/// Assigns the contained value from `u`, destroying the old value if there
+/// was one.
+template <class T>
+template <class U>
+inline constexpr optional<T> &optional<T>::operator=(U &&u)
+  requires detail::enable_assign_forward<T, U>
+{
+  if (has_value()) {
+    value_ = std::forward<U>(u);
+  } else {
+    construct(std::forward<U>(u));
+  }
+
+  return *this;
+}
+
+/// Converting copy assignment operator.
+///
+/// Copies the value from `rhs` if there is one. Otherwise resets the
+/// contained value in `*this`.
+template <class T>
+template <class U>
+inline constexpr optional<T> &optional<T>::operator=(const optional<U> &rhs)
+  requires(detail::enable_assign_from_other<T, U, const U &>)
+{
+  if (has_value()) {
+    if (rhs.has_value()) {
+      value_ = *rhs;
+    } else {
+      hard_reset();
+    }
+  }
+
+  else if (rhs.has_value()) {
+    construct(*rhs);
+  }
+
+  return *this;
+}
+
+/// Converting move assignment operator.
+///
+/// Moves the value from `rhs` if there is one. Otherwise resets the contained
+/// value in `*this`.
+template <class T>
+template <class U>
+inline constexpr optional<T> &optional<T>::operator=(optional<U> &&rhs)
+  requires(detail::enable_assign_from_other<T, U, U>)
+{
+  if (has_value()) {
+    if (rhs.has_value()) {
+      value_ = *std::move(rhs);
+    } else {
+      hard_reset();
+    }
+  }
+
+  else if (rhs.has_value()) {
+    construct(*std::move(rhs));
+  }
+
+  return *this;
+}
+
+/// Constructs the value in-place, destroying the current one if there is
+/// one.
+template <class T>
+template <class... Args>
+constexpr T &optional<T>::emplace(Args &&...args) {
+  static_assert(std::is_constructible_v<T, Args &&...>);
+  *this = nullopt;
+  construct(std::forward<Args>(args)...);
+  return value();
+}
+
+template <class T>
+template <class U, class... Args>
+constexpr T &optional<T>::emplace(std::initializer_list<U> il, Args &&...args) {
+  static_assert(
+      std::is_constructible_v<T, std::initializer_list<U> &, Args &&...>);
+  *this = nullopt;
+  construct(il, std::forward<Args>(args)...);
+  return value();
+}
+
+// 22.5.3.5 Swap[optional.swap]
+/// Swaps this optional with the other.
+///
+/// If neither optionals have a value, nothing happens.
+/// If both have a value, the values are swapped.
+/// If one has a value, it is moved to the other and the movee is left
+/// valueless.
+template <class T>
+inline constexpr void optional<T>::swap(optional<T> &rhs) noexcept(
+    std::is_nothrow_move_constructible<T>::value &&
+    std::is_nothrow_swappable<T>::value) {
+  static_assert(std::is_move_constructible_v<T>);
+  using std::swap;
+  if (has_value()) {
+    if (rhs.has_value()) {
+      swap(value(), *rhs);
+    } else {
+      std::construct_at(std::addressof(rhs.value_), std::move(value_));
+      value_.T::~T();
+    }
+  } else if (rhs.has_value()) {
+    std::construct_at(std::addressof(value_), std::move(rhs.value_));
+    rhs.value_.T::~T();
+  }
+  swap(engaged_, rhs.engaged_);
+}
+
+// 22.5.3.6 Iterator support[optional.iterators]
+// Since P3168R2: Give std::optional Range Support.
+template <class T>
+inline constexpr optional<T>::iterator optional<T>::begin() noexcept {
+  return iterator(has_value() ? std::addressof(value_) : nullptr);
+}
+
+template <class T>
+inline constexpr optional<T>::const_iterator
+optional<T>::begin() const noexcept {
+  return const_iterator(has_value() ? std::addressof(value_) : nullptr);
+}
+template <class T>
+inline constexpr optional<T>::iterator optional<T>::end() noexcept {
+  return begin() + has_value();
+}
+
+template <class T>
+inline constexpr optional<T>::const_iterator optional<T>::end() const noexcept {
+  return begin() + has_value();
+}
+
+// 22.5.3.7 Observers[optional.observe]
+
+/// Returns a pointer to the contained value
+template <class T> inline constexpr const T *optional<T>::operator->() const {
+  return std::addressof(value_);
+}
+
+template <class T> inline constexpr T *optional<T>::operator->() {
+  return std::addressof(value_);
+}
+
+/// Returns the contained value
+template <class T> inline constexpr T &optional<T>::operator*() & {
+  return value_;
+}
+
+template <class T> inline constexpr const T &optional<T>::operator*() const & {
+  return value_;
+}
+
+template <class T> inline constexpr T &&optional<T>::operator*() && {
+  return std::move(value_);
+}
+
+template <class T>
+inline constexpr optional<T>::operator bool() const noexcept {
+  return engaged_;
+}
+
+/// Returns whether or not the optional has a value
+template <class T>
+inline constexpr bool optional<T>::has_value() const noexcept {
+  return engaged_;
+}
+
+/// Returns the contained value if there is one, otherwise throws
+/// bad_optional_access
+template <class T> inline constexpr T &optional<T>::value() & {
+  return has_value() ? value_ : throw bad_optional_access();
+}
+template <class T> inline constexpr const T &optional<T>::value() const & {
+  return has_value() ? value_ : throw bad_optional_access();
+}
+template <class T> inline constexpr T &&optional<T>::value() && {
+#if defined(_MSC_VER) // MSVC BUG -- ternary creates temporary
+  if (has_value()) {
+    return std::move(value_);
+  }
+  throw bad_optional_access();
+#else
+  return has_value() ? std::move(value_) : throw bad_optional_access();
+#endif
+}
+
+/// Returns the contained value if there is one, otherwise returns `u`
+template <class T>
+template <class U>
+inline constexpr std::remove_cv_t<T> optional<T>::value_or(U &&u) const & {
+  using X = std::remove_cv_t<T>;
+  static_assert(std::is_convertible_v<const T &, X>,
+                "Must be able to convert const T& to remove_cv_t<T>");
+  static_assert(std::is_convertible_v<U, X>,
+                "Must be able to convert u to remove_cv_t<T>");
+  if (has_value())
+    return value_;
+  return std::forward<U>(u);
+}
+
+template <class T>
+template <class U>
+inline constexpr std::remove_cv_t<T> optional<T>::value_or(U &&u) && {
+  using X = std::remove_cv_t<T>;
+  static_assert(std::is_convertible_v<T, X>,
+                "Must be able to convert T to remove_cv_t<T>");
+  static_assert(std::is_convertible_v<U, X>,
+                "Must be able to convert u to remove_cv_t<T>");
+  if (has_value()) {
+    return std::move(value_);
+  }
+  return std::forward<U>(u);
+}
+
+// 22.5.3.8 Monadic operations[optional.monadic]
+template <class T>
+template <class F>
+constexpr auto optional<T>::and_then(F &&f) & {
+  using U = std::invoke_result_t<F, T &>;
+  static_assert(detail::is_optional<std::remove_cvref_t<U>>);
+  if (has_value()) {
+    return std::invoke(std::forward<F>(f), value_);
+  } else {
+    return std::remove_cvref_t<U>();
+  }
+}
+
+template <class T>
+template <class F>
+constexpr auto optional<T>::and_then(F &&f) && {
+  using U = std::invoke_result_t<F, T &&>;
+  static_assert(detail::is_optional<std::remove_cvref_t<U>>);
+  if (has_value()) {
+    return std::invoke(std::forward<F>(f), std::move(value_));
+  } else {
+    return std::remove_cvref_t<U>();
+  }
+}
+
+template <class T>
+template <class F>
+constexpr auto optional<T>::and_then(F &&f) const & {
+  using U = std::invoke_result_t<F, const T &>;
+  static_assert(detail::is_optional<std::remove_cvref_t<U>>);
+  if (has_value()) {
+    return std::invoke(std::forward<F>(f), value_);
+  } else {
+    return std::remove_cvref_t<U>();
+  }
+}
+
+template <class T>
+template <class F>
+constexpr auto optional<T>::and_then(F &&f) const && {
+  using U = std::invoke_result_t<F, const T &&>;
+  static_assert(detail::is_optional<std::remove_cvref_t<U>>);
+  if (has_value()) {
+    return std::invoke(std::forward<F>(f), std::move(value_));
+  } else {
+    return std::remove_cvref_t<U>();
+  }
+}
+
+/// Carries out some operation on the contained object if there is one.
+template <class T>
+template <class F>
+constexpr auto optional<T>::transform(F &&f) & {
+  using U = std::invoke_result_t<F, T &>;
+  static_assert(!std::is_array_v<U>);
+  static_assert(!std::is_same_v<U, in_place_t>);
+  static_assert(!std::is_same_v<U, nullopt_t>);
+  static_assert(std::is_object_v<U> ||
+                std::is_reference_v<U>); /// References now allowed
+  return (has_value())
+             ? optional<U>{detail::from_function, std::forward<F>(f), value_}
+             : optional<U>{};
+}
+
+template <class T>
+template <class F>
+constexpr auto optional<T>::transform(F &&f) && {
+  using U = std::invoke_result_t<F, T &&>;
+  static_assert(!std::is_array_v<U>);
+  static_assert(!std::is_same_v<U, in_place_t>);
+  static_assert(!std::is_same_v<U, nullopt_t>);
+  static_assert(std::is_object_v<U> ||
+                std::is_reference_v<U>); /// References now allowed
+  return (has_value()) ? optional<U>{detail::from_function, std::forward<F>(f),
+                                     std::move(value_)}
+                       : optional<U>{};
+}
+
+template <class T>
+template <class F>
+constexpr auto optional<T>::transform(F &&f) const & {
+  using U = std::invoke_result_t<F, const T &>;
+  static_assert(!std::is_array_v<U>);
+  static_assert(!std::is_same_v<U, in_place_t>);
+  static_assert(!std::is_same_v<U, nullopt_t>);
+  static_assert(std::is_object_v<U> ||
+                std::is_reference_v<U>); /// References now allowed
+  return (has_value())
+             ? optional<U>{detail::from_function, std::forward<F>(f), value_}
+             : optional<U>{};
+}
+
+template <class T>
+template <class F>
+constexpr auto optional<T>::transform(F &&f) const && {
+  using U = std::invoke_result_t<F, const T &>;
+  static_assert(!std::is_array_v<U>);
+  static_assert(!std::is_same_v<U, in_place_t>);
+  static_assert(!std::is_same_v<U, nullopt_t>);
+  static_assert(std::is_object_v<U> ||
+                std::is_reference_v<U>); /// References now allowed
+  return (has_value()) ? optional<U>{detail::from_function, std::forward<F>(f),
+                                     std::move(value_)}
+                       : optional<U>{};
+}
+
+/**
+ * @brief Returns an optional containing the contained value if it has one, or
+ * the result of calling
+ * \p `f` if it does not.
+ *
+ * @tparam T
+ * @tparam F
+ * @param f
+ * @return optional<T>
+ */
+template <class T>
+template <class F>
+constexpr optional<T> optional<T>::or_else(F &&f) const &
+  requires(std::invocable<F> && std::copy_constructible<T>)
+{
+  static_assert(
+      std::is_same_v<std::remove_cvref_t<std::invoke_result_t<F>>, optional>);
+  if (has_value())
+    return value_;
+
+  return std::forward<F>(f)();
+}
+
+/**
+ * @brief Returns an optional containing the contained value if it has one, or
+ * the result of calling
+ * \p `f` if it does not.
+ *
+ * @tparam T
+ * @tparam F
+ * @param f
+ * @return optional<T>
+ */
+template <class T>
+template <class F>
+constexpr optional<T> optional<T>::or_else(F &&f) &&
+  requires(std::invocable<F> && std::move_constructible<T>)
+{
+  static_assert(
+      std::is_same_v<std::remove_cvref_t<std::invoke_result_t<F>>, optional>);
+  if (has_value())
+    return std::move(value_);
+
+  return std::forward<F>(f)();
+}
+
+// 22.5.3.9 Modifiers[optional.mod]
+template <class T> constexpr void optional<T>::reset() noexcept {
+  if constexpr (!std::is_trivially_destructible_v<T>) {
+    if (has_value())
+      value_.~T();
+  }
+  engaged_ = false;
+}
+
+// 22.5.4 No-value state indicator[optional.nullopt]
+
+// 22.5.5 Class bad_optional_access[optional.bad.access]
+
+// 22.5.6 Relational operators[optional.relops]
+template <typename T, typename U>
+constexpr bool operator==(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_eq_rel<T, U>
+{
+  return static_cast<bool>(lhs) == static_cast<bool>(rhs) &&
+         (!lhs || *lhs == *rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator!=(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_ne_rel<T, U>
+{
+  return static_cast<bool>(lhs) != static_cast<bool>(rhs) ||
+         (static_cast<bool>(lhs) && *lhs != *rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator<(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_lt_rel<T, U>
+{
+  return static_cast<bool>(rhs) && (!lhs || *lhs < *rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator>(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_gt_rel<T, U>
+{
+  return static_cast<bool>(lhs) && (!rhs || *lhs > *rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator<=(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_le_rel<T, U>
+{
+  return !lhs || (static_cast<bool>(rhs) && *lhs <= *rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator>=(const optional<T> &lhs, const optional<U> &rhs)
+  requires detail::optional_ge_rel<T, U>
+{
+  return !rhs || (static_cast<bool>(lhs) && *lhs >= *rhs);
+}
+
+template <typename T, std::three_way_comparable_with<T> U>
+constexpr std::compare_three_way_result_t<T, U>
+operator<=>(const optional<T> &x, const optional<U> &y) {
+  return x && y ? *x <=> *y : bool(x) <=> bool(y);
+}
+
+// 22.5.7 Comparison with nullopt[optional.nullops]
+template <class T>
+constexpr bool operator==(const optional<T> &lhs, nullopt_t) noexcept {
+  return !lhs;
+}
+
+template <class T>
+constexpr std::strong_ordering operator<=>(const optional<T> &x,
+                                           nullopt_t) noexcept {
+  return bool(x) <=> false;
+}
+
+// 22.5.8 Comparison with T[optional.comp.with.t]
+template <typename T, typename U>
+constexpr bool operator==(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_eq_rel<T, U>
+{
+  return lhs && *lhs == rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator==(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_eq_rel<T, U>
+{
+  return rhs && lhs == *rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator!=(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_ne_rel<T, U>
+{
+  return !lhs || *lhs != rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator!=(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_ne_rel<T, U>
+{
+  return !rhs || lhs != *rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator<(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_lt_rel<T, U>
+{
+  return !lhs || *lhs < rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator<(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_lt_rel<T, U>
+{
+  return rhs && lhs < *rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator>(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_gt_rel<T, U>
+{
+  return lhs && *lhs > rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator>(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_gt_rel<T, U>
+{
+  return !rhs || lhs > *rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator<=(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_le_rel<T, U>
+{
+  return !lhs || *lhs <= rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator<=(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_le_rel<T, U>
+{
+  return rhs && lhs <= *rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator>=(const optional<T> &lhs, const U &rhs)
+  requires(!detail::is_optional<U>) && detail::optional_ge_rel<T, U>
+{
+  return lhs && *lhs >= rhs;
+}
+
+template <typename T, typename U>
+constexpr bool operator>=(const T &lhs, const optional<U> &rhs)
+  requires(!detail::is_optional<T>) && detail::optional_ge_rel<T, U>
+{
+  return !rhs || lhs >= *rhs;
+}
+
+template <typename T, typename U>
+  requires(!is_derived_from_optional<U>) && std::three_way_comparable_with<T, U>
+constexpr std::compare_three_way_result_t<T, U>
+operator<=>(const optional<T> &x, const U &v) {
+  return bool(x) ? *x <=> v : std::strong_ordering::less;
+}
+
+// 22.5.9 Specialized algorithms[optional.specalg]
+
+template <class T>
+constexpr void swap(optional<T> &x,
+                    optional<T> &y) noexcept(noexcept(x.swap(y)))
+  requires std::is_move_constructible_v<T> && std::is_swappable_v<T>
+{
+  return x.swap(y);
+}
+
+template <int, class T>
+constexpr optional<std::decay_t<T>> make_optional(T &&t) noexcept(
+    std::is_nothrow_constructible_v<optional<std::decay_t<T>>, T>)
+  requires std::is_constructible_v<std::decay_t<T>, T>
+{
+  return optional<std::decay_t<T>>{std::forward<T>(t)};
+}
+
+template <typename T, typename... Args>
+constexpr optional<T> make_optional(Args &&...args) noexcept(
+    std::is_nothrow_constructible_v<T, Args...>)
+  requires std::is_constructible_v<T, Args...>
+{
+  static_assert(!std::is_reference_v<T>,
+                "May not make an optional containing a reference");
+  return optional<T>{in_place, std::forward<Args>(args)...};
+}
+
+template <typename T, typename U, typename... Args>
+constexpr optional<T>
+make_optional(std::initializer_list<U> init_list, Args &&...args) noexcept(
+    std::is_nothrow_constructible_v<T, std::initializer_list<U> &, Args...>)
+  requires std::is_constructible_v<T, std::initializer_list<U> &, Args...>
+{
+  static_assert(!std::is_reference_v<U>,
+                "Can not make optional from initializer_list of references.");
+  return optional<T>{in_place, init_list, std::forward<Args>(args)...};
+}
+
+/****************/
+/* optional<T&> */
+/****************/
+
+namespace detail {
+
+#ifdef __cpp_lib_reference_from_temporary
+using std::reference_constructs_from_temporary_v;
+using std::reference_converts_from_temporary_v;
+#else
+template <class To, class From>
+concept reference_converts_from_temporary_v =
+    std::is_reference_v<To> &&
+    (
+        // A prvalue of a type similar to To, so that we're binding directly to
+        // the materialized prvalue of type From
+        (!std::is_reference_v<From> &&
+         std::is_convertible_v<std::remove_cvref_t<From> *,
+                               std::remove_cvref_t<To> *>) ||
+        // A value of an unrelated type, convertible to To, but only by
+        // materializing a To and binding a const reference; if we were trying
+        // to bind a non-const reference, we'd be unable to. (This is not quite
+        // exhaustive of the problem cases, but I think it's fairly close in
+        // practice.)
+        (std::is_lvalue_reference_v<To> &&
+         std::is_const_v<std::remove_reference_t<To>> &&
+         std::is_convertible_v<From, const std::remove_cvref_t<To> &&> &&
+         !std::is_convertible_v<From, std::remove_cvref_t<To> &>));
+
+template <class To, class From>
+concept reference_constructs_from_temporary_v =
+    // This is close in practice, because cases where conversion and
+    // construction differ in semantics are rare.
+    reference_converts_from_temporary_v<To, From>;
+#endif
+
+} // namespace detail
+
+/**
+ * @brief A specialization of `optional` for references.
+ */
+template <class T> class optional<T &> {
+public:
+  /**
+   * @brief The type of the value contained in the optional.
+   *
+   */
+  using value_type = T;
+  /**
+   * @brief The type of the iterator for the optional.
+   *
+   */
+  using iterator =
+      detail::contiguous_iterator<T,
+                                  optional>; // see [optionalref.iterators]
+public:
+  // \ref{optionalref.ctor}, constructors
+
+  /**
+   * @brief Default constructor.
+   */
+  constexpr optional() noexcept = default;
+
+  /**
+   * @brief Constructs an empty optional.
+   */
+  constexpr optional(nullopt_t) noexcept : optional() {}
+
+  /**
+   * @brief Copy constructor.
+   *
+   * Constructs an empty optional if the rhs is empty, otherwise constructs
+   * the contained value from the rhs.
+   */
+  constexpr optional(const optional &rhs) noexcept = default;
+
+  /**
+   * @brief In-place constructor.
+   *
+   * @tparam Arg
+   * @param arg The value to construct in-place from.
+   */
+  template <class Arg>
+    requires(std::is_constructible_v<T &, Arg> &&
+             !detail::reference_constructs_from_temporary_v<T &, Arg>)
+  constexpr explicit optional(in_place_t, Arg &&arg);
+
+  /**
+   * @brief Construct from a U
+   * @tparam U
+   * @param u The value to construct from.
+   * @details
+   * Constructs the contained value from `u` if it is convertible to `T&`.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U> &&
+             !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
+             !(std::is_same_v<std::remove_cvref_t<U>, optional>) &&
+             !detail::reference_constructs_from_temporary_v<T &, U>)
+  constexpr explicit(!std::is_convertible_v<U, T &>)
+      optional(U &&u) noexcept(std::is_nothrow_constructible_v<T &, U>) {
+    convert_ref_init_val(u);
+  }
+
+  /**
+   * @brief Constructs an optional from a U, but deletes the constructor if
+   *
+   * @tparam U
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U> &&
+             !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
+             !(std::is_same_v<std::remove_cvref_t<U>, optional>) &&
+             detail::reference_constructs_from_temporary_v<T &, U>)
+  constexpr optional(U &&u) = delete;
+
+  // The full set of 4 overloads on optional<U> by value category, doubled to
+  // 8 by deleting if reference_constructs_from_temporary_v is true. This
+  // allows correct constraints by propagating the value category from the
+  // optional to the value within the rhs.
+
+  /**
+   * @brief Constructs an optional from another optional of type U.
+   *
+   * @tparam U
+   * @param rhs The optional to construct from.
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U &> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             !detail::reference_constructs_from_temporary_v<T &, U &>)
+  constexpr explicit(!std::is_convertible_v<U &, T &>) optional(
+      optional<U> &rhs) noexcept(std::is_nothrow_constructible_v<T &, U &>);
+
+  /**
+   * @brief Constructs an optional from another optional of type U.
+   * @param rhs The optional to construct from.
+   * @tparam U
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, const U &> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             !detail::reference_constructs_from_temporary_v<T &, const U &>)
+  constexpr explicit(!std::is_convertible_v<const U &, T &>)
+      optional(const optional<U> &rhs) noexcept(
+          std::is_nothrow_constructible_v<T &, const U &>);
+
+  /**
+   * @brief Constructs an optional from another optional of type U.
+   * @param rhs The optional to construct from.
+   * @tparam U
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             !detail::reference_constructs_from_temporary_v<T &, U>)
+  constexpr explicit(!std::is_convertible_v<U, T &>)
+      optional(optional<U> &&rhs) noexcept(
+          noexcept(std::is_nothrow_constructible_v<T &, U>));
+
+  /**
+   * @brief Constructs an optional from another optional of type U.
+   *
+   * @tparam U The type contained the right hand side optional.
+   * @param rhs The optional to construct from.
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, const U> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             !detail::reference_constructs_from_temporary_v<T &, const U>)
+  constexpr explicit(!std::is_convertible_v<const U, T &>)
+      optional(const optional<U> &&rhs) noexcept(
+          noexcept(std::is_nothrow_constructible_v<T &, const U>));
+
+  /**
+   * @brief Constructs an optional from another optional of type U
+   *
+   * @tparam U
+   * @param rhs
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U &> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             detail::reference_constructs_from_temporary_v<T &, U &>)
+  constexpr optional(optional<U> &rhs) = delete;
+
+  /**
+   * @brief Constructs an optional from another optional of type U
+   *
+   * @tparam U
+   * @param rhs
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, const U &> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             detail::reference_constructs_from_temporary_v<T &, const U &>)
+  constexpr optional(const optional<U> &rhs) = delete;
+
+  /**
+   * @brief Constructs an optional from another optional of type U
+   *
+   * @tparam U
+   * @param rhs
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             detail::reference_constructs_from_temporary_v<T &, U>)
+  constexpr optional(optional<U> &&rhs) = delete;
+
+  /**
+   * @brief Constructs an optional from another optional of type U
+   *
+   * @tparam U
+   * @param rhs
+   * @details
+   * Constructs the contained value from the rhs if it has a value, otherwise
+   * constructs an empty optional.
+   * If `T&` can be constructed from a temporary, this constructor is
+   * deleted to prevent binding a temporary to a reference.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, const U> &&
+             !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+             !std::is_same_v<T &, U> &&
+             detail::reference_constructs_from_temporary_v<T &, const U>)
+  constexpr optional(const optional<U> &&rhs) = delete;
+
+  // \ref{optionalref.dtor}, destructor
+  /**
+   * @brief Destructor.
+   *
+   * @details
+   * Does not destroy the contained value, as it is a reference.
+   */
+  constexpr ~optional() = default;
+
+  // \ref{optionalref.assign}, assignment
+  /**
+   * @brief Nullopt assignment operator.
+   *
+   * @return optional&
+   *
+   * @details
+   * Destroys the current value if there is one, and leaves the optional
+   * in an empty state.
+   */
+  constexpr optional &operator=(nullopt_t) noexcept;
+
+  /**
+   * @brief Assignment operator.
+   *
+   * @param rhs The value to assign.
+   * @return optional&
+   * @details
+   * If `rhs` has a value, assigns it to the contained value. Otherwise resets
+   * the contained value in `*this`.
+   */
+  constexpr optional &operator=(const optional &rhs) noexcept = default;
+
+  /**
+   * @brief Emplaces a new value in the optional, destroying the current one
+   * if the optional is engaged.
+   *
+   * @tparam U The type of the value to emplace.
+   * @param u The value to emplace.
+   * @return T&
+   * @details
+   * Constructs the contained value from `u` if it is convertible to `T&`.
+   */
+  template <class U>
+    requires(std::is_constructible_v<T &, U> &&
+             !detail::reference_constructs_from_temporary_v<T &, U>)
+  constexpr T &emplace(U &&u) noexcept(std::is_nothrow_constructible_v<T &, U>);
+
+  // \ref{optionalref.swap}, swap
+  /**
+   * @brief Swaps the contents of this optional with another.
+   *
+   * @param rhs The value to swap with.
+   */
+  constexpr void swap(optional &rhs) noexcept;
+
+  // \ref{optional.iterators}, iterator support
+  /**
+   * @brief Returns an iterator to the beginning of the optional.
+   *
+   * @return iterator
+   */
+  constexpr iterator begin() const noexcept;
+
+  /**
+   * @brief Returns an iterator to the end of the optional.
+   *
+   * @return iterator
+   */
+  constexpr iterator end() const noexcept;
+
+  // \ref{optionalref.observe}, observers
+  /**
+   * @brief Returns a pointer to the contained value.
+   *
+   * @return T*
+   */
+  constexpr T *operator->() const noexcept;
+
+  /**
+   * @brief Returns a reference to the contained value.
+   *
+   * @return T&
+   */
+  constexpr T &operator*() const noexcept;
+
+  /**
+   * @brief Converts the optional to a boolean value.
+   *
+   * @return bool
+   */
+  constexpr explicit operator bool() const noexcept;
+
+  /**
+   * @brief Checks if the optional has a value.
+   *
+   * @return bool
+   */
+  constexpr bool has_value() const noexcept;
+
+  /**
+   * @brief Returns the contained value if there is one, otherwise throws
+   *
+   * @return T&
+   */
+  constexpr T &value() const;
+
+  // LWG4304. std::optional<NonReturnable&> is ill-formed due to value_o
+  // Resolution:
+  // -?- Constraints: T is a non-array object type.
+  // -?- Remarks: The return type is unspecified if T is an array type or a
+  //     non-object type. [Note ?: This is to avoid the declaration being
+  //     ill-formed. — end note]
+  //
+  // Implementer Note: Using decay_t as a detail as it is remove_cv_t for
+  // non-array objects, and produces a valid type for arrays and functions,
+  // which are otherwise `required` out.
+  /**
+   * @brief Returns the contained value if there is one, otherwise returns `u`.
+   *
+   * @tparam U The type of the alternate value
+   * @param u The value to return in the empty case
+   * @return std::remove_cv_t<T>
+   */
+  template <class U = std::remove_cv_t<T>>
+    requires(std::is_object_v<T> && !std::is_array_v<T>)
+  constexpr std::decay_t<T> value_or(U &&u) const;
+
+  // \ref{optionalref.monadic}, monadic operations
+  /**
+   * @brief Applies a function to the contained value if there is one.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return auto
+   *
+   * @details
+   * The return type is the same as `std::invoke_result_t<F, T&>`,
+   * but wrapped in an optional. The function \p f must return an optional type.
+   */
+  template <class F> constexpr auto and_then(F &&f) const;
+
+  /**
+   * @brief Applies a function to the contained value if there is one.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return optional<std::invoke_result_t<F, T&>>
+   *
+   * @details
+   * The return type is the same as `std::invoke_result_t<F, T&>`,
+   * but wrapped in an optional.
+   */
+  template <class F>
+  constexpr optional<std::invoke_result_t<F, T &>> transform(F &&f) const;
+
+  /**
+   * @brief Calls a function if the optional is empty.
+   *
+   * @tparam F The type of the invocable
+   * @param f The invocable to apply to the contained value
+   * @return optional
+   * @details
+   * The return type is the same as the return type of \p f, which must
+   * return an optional type.
+   */
+  template <class F>
+  constexpr optional or_else(F &&f) const
+    requires(std::invocable<F>);
+
+  // \ref{optional.mod}, modifiers
+  /**
+   * @brief Resets the optional to an empty state.
+   *
+   */
+  constexpr void reset() noexcept;
+
+private:
+  T *value_ = nullptr; // exposition only
+
+  // \ref{optionalref.expos}, exposition only helper functions
+  template <class U> constexpr void convert_ref_init_val(U &&u) {
+    // Creates a variable, \tcode{r},
+    // as if by \tcode{T\& r(std::forward<U>(u));}
+    // and then initializes \exposid{val} with \tcode{addressof(r)}
+    T &r(std::forward<U>(u));
+    value_ = std::addressof(r);
+  }
+
+  template <class U> friend class optional;
+
+  template <class F, class Arg>
+  constexpr optional(detail::from_function_t, F &&f, Arg &&arg) {
+    convert_ref_init_val(
+        std::invoke(std::forward<F>(f), std::forward<Arg>(arg)));
+  }
+};
+
+//  \rSec3[optionalref.ctor]{Constructors}
+template <class T>
+template <class Arg>
+  requires(std::is_constructible_v<T &, Arg> &&
+           !detail::reference_constructs_from_temporary_v<T &, Arg>)
+constexpr optional<T &>::optional(in_place_t, Arg &&arg) {
+  convert_ref_init_val(std::forward<Arg>(arg));
+}
+
+// Clang is unhappy with the out-of-line definition
+//
+// template <class T>
+// template <class U>
+//     requires(std::is_constructible_v<T&, U> && !(is_same_v<remove_cvref_t<U>,
+//     in_place_t>) &&
+//              !(is_same_v<remove_cvref_t<U>, optional<T&>>) &&
+//              !detail::reference_constructs_from_temporary_v<T&, U>)
+// constexpr optional<T&>::optional(U&& u)
+// noexcept(is_nothrow_constructible_v<T&, U>)
+//     : value_(std::addressof(static_cast<T&>(std::forward<U>(u)))) {}
+
+template <class T>
+template <class U>
+  requires(std::is_constructible_v<T &, U &> &&
+           !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+           !std::is_same_v<T &, U> &&
+           !detail::reference_constructs_from_temporary_v<T &, U &>)
+constexpr optional<T &>::optional(optional<U> &rhs) noexcept(
+    std::is_nothrow_constructible_v<T &, U &>) {
+  if (rhs.has_value()) {
+    convert_ref_init_val(*rhs);
+  }
+}
+
+template <class T>
+template <class U>
+  requires(std::is_constructible_v<T &, const U &> &&
+           !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+           !std::is_same_v<T &, U> &&
+           !detail::reference_constructs_from_temporary_v<T &, const U &>)
+constexpr optional<T &>::optional(const optional<U> &rhs) noexcept(
+    std::is_nothrow_constructible_v<T &, const U &>) {
+  if (rhs.has_value()) {
+    convert_ref_init_val(*rhs);
+  }
+}
+
+template <class T>
+template <class U>
+  requires(std::is_constructible_v<T &, U> &&
+           !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+           !std::is_same_v<T &, U> &&
+           !detail::reference_constructs_from_temporary_v<T &, U>)
+constexpr optional<T &>::optional(optional<U> &&rhs) noexcept(
+    noexcept(std::is_nothrow_constructible_v<T &, U>)) {
+  if (rhs.has_value()) {
+    convert_ref_init_val(*std::move(rhs));
+  }
+}
+
+template <class T>
+template <class U>
+  requires(std::is_constructible_v<T &, const U> &&
+           !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
+           !std::is_same_v<T &, U> &&
+           !detail::reference_constructs_from_temporary_v<T &, const U>)
+constexpr optional<T &>::optional(const optional<U> &&rhs) noexcept(
+    noexcept(std::is_nothrow_constructible_v<T &, const U>)) {
+  if (rhs.has_value()) {
+    convert_ref_init_val(*std::move(rhs));
+  }
+}
+
+// \rSec3[optionalref.assign]{Assignment}
+template <class T>
+constexpr optional<T &> &optional<T &>::operator=(nullopt_t) noexcept {
+  value_ = nullptr;
+  return *this;
+}
+
+template <class T>
+template <class U>
+  requires(std::is_constructible_v<T &, U> &&
+           !detail::reference_constructs_from_temporary_v<T &, U>)
+constexpr T &optional<T &>::emplace(U &&u) noexcept(
+    std::is_nothrow_constructible_v<T &, U>) {
+  convert_ref_init_val(std::forward<U>(u));
+  return *value_;
+}
+
+//   \rSec3[optionalref.swap]{Swap}
+
+template <class T>
+constexpr void optional<T &>::swap(optional<T &> &rhs) noexcept {
+  std::swap(value_, rhs.value_);
+}
+
+// \rSec3[optionalref.iterators]{Iterator Support}
+
+template <class T>
+constexpr optional<T &>::iterator optional<T &>::begin() const noexcept {
+  return iterator(has_value() ? value_ : nullptr);
+};
+
+template <class T>
+constexpr optional<T &>::iterator optional<T &>::end() const noexcept {
+  return begin() + has_value();
+}
+
+// \rSec3[optionalref.observe]{Observers}
+template <class T> constexpr T *optional<T &>::operator->() const noexcept {
+  return value_;
+}
+
+template <class T> constexpr T &optional<T &>::operator*() const noexcept {
+  return *value_;
+}
+
+template <class T> constexpr optional<T &>::operator bool() const noexcept {
+  return value_ != nullptr;
+}
+template <class T> constexpr bool optional<T &>::has_value() const noexcept {
+  return value_ != nullptr;
+}
+
+template <class T> constexpr T &optional<T &>::value() const {
+  if (has_value()) {
+    return *value_;
+  }
+  throw bad_optional_access();
+}
+
+template <class T>
+template <class U>
+  requires(std::is_object_v<T> && !std::is_array_v<T>)
+constexpr std::decay_t<T> optional<T &>::value_or(U &&u) const {
+  using X = std::remove_cv_t<T>;
+  static_assert(std::is_convertible_v<T &, X>,
+                "remove_cv_t<T> must be constructible from a T&");
+  static_assert(std::is_convertible_v<U, X>,
+                "Must be able to convert u to remove_cv_t<T>");
+  if (has_value()) {
+    return *value_;
+  }
+  return std::forward<U>(u);
+}
+
+//   \rSec3[optionalref.monadic]{Monadic operations}
+template <class T>
+template <class F>
+constexpr auto optional<T &>::and_then(F &&f) const {
+  using U = std::invoke_result_t<F, T &>;
+  static_assert(detail::is_optional<U>, "F must return an optional");
+  if (has_value()) {
+    return std::invoke(std::forward<F>(f), *value_);
+  } else {
+    return std::remove_cvref_t<U>();
+  }
+}
+
+/**
+ * @brief Transforms the value contained in the optional, if it exists.
+ *
+ * @return optional<std::invoke_result_t<F, T&>>
+ */
+template <class T>
+template <class F>
+constexpr optional<std::invoke_result_t<F, T &>>
+optional<T &>::transform(F &&f) const {
+  using U = std::invoke_result_t<F, T &>;
+  static_assert(!std::is_same_v<std::remove_cvref_t<U>, in_place_t>,
+                "Result must not be in_place_t");
+  static_assert(!std::is_same_v<std::remove_cvref_t<U>, nullopt_t>,
+                "Result must not be nullopt_t");
+  static_assert((std::is_object_v<U> && !std::is_array_v<U>) ||
+                    std::is_lvalue_reference_v<U>,
+                "Result must be an non-array object or an lvalue reference");
+  if (has_value()) {
+    return optional<U>{detail::from_function, std::forward<F>(f), *value_};
+  } else {
+    return optional<U>{};
+  }
+}
+
+/**
+ * @brief Returns an optional containing the contained value if it has one, or
+ * the result of calling
+ * \p `f` if it does not.
+ *
+ * @tparam T
+ * @tparam F
+ * @param f
+ * @return optional<T&>
+ */
+template <class T>
+template <class F>
+constexpr optional<T &> optional<T &>::or_else(F &&f) const
+
+  requires(std::invocable<F>)
+{
+  using U = std::invoke_result_t<F>;
+  static_assert(std::is_same_v<std::remove_cvref_t<U>, optional>,
+                "Result must be an optional");
+  if (has_value()) {
+    return *this;
+  } else {
+    return std::forward<F>(f)();
+  }
+}
+
+// \rSec3[optional.mod]{modifiers}
+template <class T> constexpr void optional<T &>::reset() noexcept {
+  value_ = nullptr;
+}
+} // namespace beman::optional
+
+namespace std {
+template <typename T>
+  requires requires(T a) {
+    { std::hash<remove_const_t<T>>{}(a) } -> std::convertible_to<std::size_t>;
+  }
+struct hash<beman::optional::optional<T>> {
+  static_assert(!is_reference_v<T>, "hash is not enabled for reference types");
+  /**
+   * @brief Hashes the optional value.
+   *
+   * @param o
+   * @return size_t
+   */
+  size_t operator()(const beman::optional::optional<T> &o) const
+      noexcept(noexcept(hash<remove_const_t<T>>{}(*o))) {
+    if (o) {
+      return std::hash<std::remove_const_t<T>>{}(*o);
+    } else {
+      return 0;
+    }
+  }
+};
+} // namespace std
+
+#endif // BEMAN_OPTIONAL_OPTIONAL_HPP
diff --git a/tests/beman/inplace_vector/constructors.test.cpp b/tests/beman/inplace_vector/constructors.test.cpp
index ce53716..e1c5c09 100644
--- a/tests/beman/inplace_vector/constructors.test.cpp
+++ b/tests/beman/inplace_vector/constructors.test.cpp
@@ -25,7 +25,7 @@ TYPED_TEST(Constructors, SizedDefault) {
 
   SAFE_EXPECT_THROW(IV(IV::capacity() + 1), std::bad_alloc);
 
-  constexpr auto mid_size = std::midpoint(0ul, IV::capacity());
+  constexpr auto mid_size = std::midpoint(std::size_t{0}, IV::capacity());
   IV mid(mid_size);
   EXPECT_EQ(mid.size(), mid_size);
   if constexpr (std::is_scalar_v<T> || std::is_aggregate_v<T> ||
@@ -131,7 +131,7 @@ TYPED_TEST(Constructors, CopyRanges) {
   }
 
   {
-    auto mid = std::midpoint(0ul, reference.size());
+    auto mid = std::midpoint(std::size_t{0}, reference.size());
     IV device(beman::inplace_vector::details::from_range,
               reference | std::ranges::views::take(mid));
     EXPECT_EQ(device, IV(reference.begin(), reference.begin() + mid));
diff --git a/tests/beman/inplace_vector/freestanding.test.cpp b/tests/beman/inplace_vector/freestanding.test.cpp
index a26429e..0472e09 100644
--- a/tests/beman/inplace_vector/freestanding.test.cpp
+++ b/tests/beman/inplace_vector/freestanding.test.cpp
@@ -271,14 +271,14 @@ TEST(Freestanding, usage) {
   for (auto i = 0; i < device.capacity(); ++i) {
     const auto value = T{i};
     auto res = device.try_emplace_back(value);
-    EXPECT_NE(res, nullptr);
+    EXPECT_NE(res, beman::optional::nullopt);
     EXPECT_EQ(*res, value);
     EXPECT_EQ(device.back(), value);
   }
 
   EXPECT_EQ(device.size(), device.capacity());
 
-  EXPECT_EQ(nullptr, device.try_emplace_back(T{}));
+  EXPECT_EQ(beman::optional::nullopt, device.try_emplace_back(T{}));
 
   EXPECT_EQ(device.size(), device.capacity());
 
diff --git a/tests/beman/inplace_vector/modifiers.test.cpp b/tests/beman/inplace_vector/modifiers.test.cpp
index 4f702e3..501ecba 100644
--- a/tests/beman/inplace_vector/modifiers.test.cpp
+++ b/tests/beman/inplace_vector/modifiers.test.cpp
@@ -373,7 +373,7 @@ TYPED_TEST(Modifiers, InsertAppendRange) {
   EXPECT_EQ(device, reference);
   device.clear();
 
-  auto half_size = std::midpoint(0ul, reference.size());
+  auto half_size = std::midpoint(std::size_t{0}, reference.size());
   device.append_range(reference | std::views::take(half_size));
   device.append_range(reference | std::views::drop(half_size));
   EXPECT_EQ(device, reference);
@@ -484,16 +484,17 @@ TYPED_TEST(Modifiers, TryEmplaceBack) {
   if (!reference.empty()) {
     for (auto i = 0ul; i < reference.size(); ++i) {
       auto res = device.try_emplace_back(reference[i].value);
-      EXPECT_EQ(res, std::addressof(device.back()));
+      ASSERT_TRUE(res.has_value());
+      EXPECT_EQ(std::addressof(*res), std::addressof(device.back()));
       EXPECT_EQ(device, IV(reference.begin(), reference.begin() + i + 1));
     }
 
     auto res = device.try_emplace_back(reference[0].value);
-    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(res, beman::optional::nullopt);
     EXPECT_EQ(device, reference);
   } else {
     auto res = device.try_emplace_back(0);
-    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(res, beman::optional::nullopt);
     EXPECT_EQ(device, IV());
   }
 }
@@ -526,18 +527,19 @@ TYPED_TEST(Modifiers, TryPushBackConstRef) {
   if (!reference.empty()) {
     for (auto i = 0ul; i < reference.size(); ++i) {
       auto res = device.try_push_back(reference[i]);
-      EXPECT_EQ(res, std::addressof(device.back()));
+      ASSERT_TRUE(res.has_value());
+      EXPECT_EQ(std::addressof(*res), std::addressof(device.back()));
       EXPECT_EQ(device, IV(reference.begin(), reference.begin() + i + 1));
     }
 
     auto res = device.try_push_back(reference[0]);
-    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(res, beman::optional::nullopt);
     EXPECT_EQ(device, reference);
   } else {
     T val{0};
 
     auto res = device.try_push_back(val);
-    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(res, beman::optional::nullopt);
     EXPECT_EQ(device, IV());
   }
 }
@@ -573,18 +575,19 @@ TYPED_TEST(Modifiers, TryPushBackRV) {
       T val{reference[i].value};
 
       auto res = device.try_push_back(std::move(val));
-      EXPECT_EQ(res, std::addressof(device.back()));
+      ASSERT_TRUE(res.has_value());
+      EXPECT_EQ(std::addressof(*res), std::addressof(device.back()));
       EXPECT_EQ(device, IV(reference.begin(), reference.begin() + i + 1));
     }
 
     auto res = device.try_push_back(reference[0]);
-    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(res, beman::optional::nullopt);
     EXPECT_EQ(device, reference);
   } else {
     T val{0};
 
     auto res = device.try_push_back(std::move(val));
-    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(res, beman::optional::nullopt);
     EXPECT_EQ(device, IV());
   }
 }
diff --git a/tests/beman/inplace_vector/noexceptions.test.cpp b/tests/beman/inplace_vector/noexceptions.test.cpp
index 74d103a..579c6f0 100644
--- a/tests/beman/inplace_vector/noexceptions.test.cpp
+++ b/tests/beman/inplace_vector/noexceptions.test.cpp
@@ -30,8 +30,8 @@ TYPED_TEST(NoExceptions, NonThrowing) {
   device.assign(reference.begin(), reference.end());
   EXPECT_EQ(device, reference);
 
-  EXPECT_EQ(device.try_emplace_back(T{}), nullptr);
-  EXPECT_EQ(device.try_push_back(T{}), nullptr);
+  EXPECT_EQ(device.try_emplace_back(T{}), beman::optional::nullopt);
+  EXPECT_EQ(device.try_push_back(T{}), beman::optional::nullopt);
   auto range = std::array<T, 1>{};
   EXPECT_EQ(device.try_append_range(range), range.begin());
 
diff --git a/tests/beman/inplace_vector/ref_impl.test.cpp b/tests/beman/inplace_vector/ref_impl.test.cpp
index e7f9d1a..fac3483 100644
--- a/tests/beman/inplace_vector/ref_impl.test.cpp
+++ b/tests/beman/inplace_vector/ref_impl.test.cpp
@@ -390,7 +390,7 @@ int main() {
     CHECK(a.size() == std::size_t(10));
     CHECK(!a.empty());
     CHECK_THROWS(a.push_back(0), std::bad_alloc);
-    CHECK((uintptr_t)nullptr == (uintptr_t)a.try_push_back(0));
+    CHECK(!a.try_push_back(0).has_value());
   }
 
   { // resize copyable
@@ -778,17 +778,19 @@ int main() {
   }
   { // try_emplace_back
     vector<non_copyable, 2> c;
-    CHECK((uintptr_t)c.begin() == (uintptr_t)c.try_emplace_back(2, 3.5));
+    CHECK((uintptr_t)c.begin() ==
+          (uintptr_t)std::addressof(*c.try_emplace_back(2, 3.5)));
     CHECK(c.size() == 1);
     CHECK(c.front().geti() == 2);
     CHECK(c.front().getd() == 3.5);
-    CHECK((uintptr_t)(c.begin() + 1) == (uintptr_t)c.try_emplace_back(3, 4.5));
+    CHECK((uintptr_t)(c.begin() + 1) ==
+          (uintptr_t)std::addressof(*c.try_emplace_back(3, 4.5)));
     CHECK(c.size() == 2);
     CHECK(c.front().geti() == 2);
     CHECK(c.front().getd() == 3.5);
     CHECK(c.back().geti() == 3);
     CHECK(c.back().getd() == 4.5);
-    CHECK((uintptr_t)nullptr == (uintptr_t)c.try_emplace_back(2, 3.5));
+    CHECK(!c.try_emplace_back(2, 3.5).has_value());
   }
   { // unchecked_emplace_back
     vector<non_copyable, 2> c;
@@ -1106,30 +1108,30 @@ int main() {
       vector<moint, 6> c;
       auto i = c.try_push_back(moint(0));
       CHECK(c.size() == 1);
-      CHECK((uintptr_t)(c.begin() + 0) == (uintptr_t)i);
+      CHECK((uintptr_t)(c.begin() + 0) == (uintptr_t)std::addressof(*i));
       for (std::size_t j = 0; j < c.size(); ++j) {
         CHECK(c[j] == moint(j));
       }
       i = c.try_push_back(moint(1));
       CHECK(c.size() == 2);
-      CHECK((uintptr_t)(c.begin() + 1) == (uintptr_t)i);
+      CHECK((uintptr_t)(c.begin() + 1) == (uintptr_t)std::addressof(*i));
       for (std::size_t j = 0; j < c.size(); ++j) {
         CHECK(c[j] == moint(j));
       }
       i = c.try_push_back(moint(2));
-      CHECK((uintptr_t)(c.begin() + 2) == (uintptr_t)i);
+      CHECK((uintptr_t)(c.begin() + 2) == (uintptr_t)std::addressof(*i));
       CHECK(c.size() == 3);
       for (std::size_t j = 0; j < c.size(); ++j) {
         CHECK(c[j] == moint(j));
       }
       i = c.try_push_back(moint(3));
-      CHECK((uintptr_t)(c.begin() + 3) == (uintptr_t)i);
+      CHECK((uintptr_t)(c.begin() + 3) == (uintptr_t)std::addressof(*i));
       CHECK(c.size() == 4);
       for (std::size_t j = 0; j < c.size(); ++j) {
         CHECK(c[j] == moint(j));
       }
       i = c.try_push_back(moint(4));
-      CHECK((uintptr_t)(c.begin() + 4) == (uintptr_t)i);
+      CHECK((uintptr_t)(c.begin() + 4) == (uintptr_t)std::addressof(*i));
       CHECK(c.size() == 5);
       for (std::size_t j = 0; j < c.size(); ++j) {
         CHECK(c[j] == moint(j));
diff --git a/tests/beman/inplace_vector/size_n_data.test.cpp b/tests/beman/inplace_vector/size_n_data.test.cpp
index f689728..4ec3347 100644
--- a/tests/beman/inplace_vector/size_n_data.test.cpp
+++ b/tests/beman/inplace_vector/size_n_data.test.cpp
@@ -53,7 +53,7 @@ TYPED_TEST(SizeNCapacity, ResizeDown) {
 
   auto device = this->unique();
 
-  auto mid_size = std::midpoint(0ul, device.size());
+  auto mid_size = std::midpoint(std::size_t{0}, device.size());
   device.resize(mid_size);
   EXPECT_EQ(device, IV(device.begin(), device.begin() + mid_size));
 
@@ -74,7 +74,7 @@ TYPED_TEST(SizeNCapacity, ResizeDownWValue) {
 
   auto device = this->unique();
 
-  auto mid_size = std::midpoint(0ul, device.size());
+  auto mid_size = std::midpoint(std::size_t{0}, device.size());
   device.resize(mid_size, T{});
   EXPECT_EQ(device, IV(device.begin(), device.begin() + mid_size));