diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0262a45..49d3aab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,10 +8,20 @@ include(CompilerFeatureTest)
 
 beman_iterator26_check_deducing_this(COMPILER_SUPPORTS_DEDUCING_THIS)
 
-if(NOT COMPILER_SUPPORTS_DEDUCING_THIS)
-  message(FATAL_ERROR "The selected compiler and flags lack C++23's deducing this support, which is required to build this project. Try adding -DCMAKE_CXX_STANDARD=23 to your command line parameters and, failing that, upgrade your compiler.")
+option(BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS
+  "Make use of deducing this. Turn this off for non-conforming compilers."
+  ${COMPILER_SUPPORTS_DEDUCING_THIS})
+
+if(BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS AND NOT COMPILER_SUPPORTS_DEDUCING_THIS)
+  message(WARNING "Building with deducing this support despite of the compiler's lack of support for it")
 endif()
 
+configure_file(
+  "${PROJECT_SOURCE_DIR}/include/beman/iterator_interface26/config.hpp.in"
+  "${PROJECT_BINARY_DIR}/include/beman/iterator_interface26/config.hpp"
+  @ONLY
+)
+
 enable_testing()
 
 set(TARGETS_EXPORT_NAME ${CMAKE_PROJECT_NAME}Targets)
diff --git a/include/beman/iterator_interface26/config.hpp.in b/include/beman/iterator_interface26/config.hpp.in
new file mode 100644
index 0000000..b83cd27
--- /dev/null
+++ b/include/beman/iterator_interface26/config.hpp.in
@@ -0,0 +1,6 @@
+#ifndef BEMAN_ITERATOR_INTERFACE26_CONFIG_HPP
+#define BEMAN_ITERATOR_INTERFACE26_CONFIG_HPP
+
+#cmakedefine01 BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS()
+
+#endif
diff --git a/include/beman/iterator_interface26/detail/stl_interfaces/config.hpp b/include/beman/iterator_interface26/detail/stl_interfaces/config.hpp
new file mode 100644
index 0000000..68ad40c
--- /dev/null
+++ b/include/beman/iterator_interface26/detail/stl_interfaces/config.hpp
@@ -0,0 +1,49 @@
+// include/beman/optional26/detail/stl_interfaces/config.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright (C) 2020 T. Zachary Laine
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONFIG_HPP
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONFIG_HPP
+
+// Included for definition of __cpp_lib_concepts.
+#include <iterator>
+
+#if defined(__cpp_lib_concepts) && defined(__cpp_lib_ranges) && \
+    !defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DISABLE_CONCEPTS)
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS 1
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS 0
+#endif
+
+#if defined(__cpp_explicit_this_parameter) && BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS && \
+    !defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DISABLE_DEDUCED_THIS)
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS 1
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS 0
+#endif
+
+// The inline namespaces v1, v2, and v3 represent C++14, C++20, and C++23 and
+// later, respectively.  v1 is inline for standards before C++20, and v2 is
+// inline for C++20 and later.  Note that this only applies to code for which
+// multiple vI namespace alternatives exist.  For example, some instances of
+// the v1 namespace may still be inline, if there is no v2 version of its
+// contents.
+#if !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS && !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 inline namespace v1
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 namespace v2
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 namespace v3
+#elif BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS && !BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 namespace v1
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 inline namespace v2
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 namespace v3
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 namespace v1
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 namespace v2
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 inline namespace v3
+#endif
+
+#endif
diff --git a/include/beman/iterator_interface26/detail/stl_interfaces/fwd.hpp b/include/beman/iterator_interface26/detail/stl_interfaces/fwd.hpp
new file mode 100644
index 0000000..2ea5a8f
--- /dev/null
+++ b/include/beman/iterator_interface26/detail/stl_interfaces/fwd.hpp
@@ -0,0 +1,88 @@
+// include/beman/optional26/detail/stl_interfaces/fwd.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright (C) 2019 T. Zachary Laine
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_FWD_HPP
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_FWD_HPP
+
+#include <beman/iterator_interface26/detail/stl_interfaces/config.hpp>
+
+#if BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+#include <ranges>
+#endif
+#if defined(__cpp_lib_three_way_comparison)
+#include <compare>
+#endif
+
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+
+#if defined(_MSC_VER) || defined(__GNUC__) && __GNUC__ < 8
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NO_HIDDEN_FRIEND_CONSTEXPR
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR constexpr
+#endif
+
+#if defined(__GNUC__) && __GNUC__ < 9
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONCEPT concept bool
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_CONCEPT concept
+#endif
+
+#endif
+
+namespace beman::iterator_interface26::detail {
+namespace stl_interfaces {
+
+/** An enumeration used to indicate whether the underlying data have a
+    contiguous or discontiguous layout when instantiating `view_interface`
+    and `sequence_container_interface`. */
+enum class element_layout : bool { discontiguous = false, contiguous = true };
+
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 {
+
+    namespace v1_dtl {
+    template <typename... T>
+    using void_t = void;
+
+    template <typename Iter>
+    using iter_difference_t = typename std::iterator_traits<Iter>::difference_type;
+
+    template <typename Range, typename = void>
+    struct iterator;
+    template <typename Range>
+    struct iterator<Range, void_t<decltype(std::declval<Range&>().begin())>> {
+        using type = decltype(std::declval<Range&>().begin());
+    };
+    template <typename Range>
+    using iterator_t = typename iterator<Range>::type;
+
+    template <typename Range, typename = void>
+    struct sentinel;
+    template <typename Range>
+    struct sentinel<Range, void_t<decltype(std::declval<Range&>().end())>> {
+        using type = decltype(std::declval<Range&>().end());
+    };
+    template <typename Range>
+    using sentinel_t = typename sentinel<Range>::type;
+
+    template <typename Range>
+    using range_difference_t = iter_difference_t<iterator_t<Range>>;
+
+    template <typename Range>
+    using common_range = std::is_same<iterator_t<Range>, sentinel_t<Range>>;
+
+    template <typename Range, typename = void>
+    struct decrementable_sentinel : std::false_type {};
+    template <typename Range>
+    struct decrementable_sentinel<Range, void_t<decltype(--std::declval<sentinel_t<Range>&>())>> : std::true_type {};
+    } // namespace v1_dtl
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#endif
diff --git a/include/beman/iterator_interface26/detail/stl_interfaces/iterator_interface.hpp b/include/beman/iterator_interface26/detail/stl_interfaces/iterator_interface.hpp
new file mode 100644
index 0000000..2ab8e09
--- /dev/null
+++ b/include/beman/iterator_interface26/detail/stl_interfaces/iterator_interface.hpp
@@ -0,0 +1,970 @@
+// include/beman/optional26/detail/stl_interfaces/iterator_interface.hpp -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright (C) 2019 T. Zachary Laine
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_ITERATOR_INTERFACE_HPP
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_ITERATOR_INTERFACE_HPP
+
+#include <beman/iterator_interface26/detail/stl_interfaces/fwd.hpp>
+#include <beman/iterator_interface26/iterator_interface_access.hpp>
+
+#include <utility>
+#include <type_traits>
+#if defined(__cpp_lib_three_way_comparison)
+#include <compare>
+#endif
+
+namespace beman::iterator_interface26::detail {
+namespace stl_interfaces {
+
+/** The return type of `operator->()` in a proxy iterator.
+
+    This template is used as the default `Pointer` template parameter in
+    the `proxy_iterator_interface` template alias.  Note that the use of
+    this template implies a copy or move of the underlying object of type
+    `T`. */
+template <typename T>
+#if defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+// clang-format off
+        requires std::is_object_v<T>
+#endif
+    struct proxy_arrow_result
+// clang-format on
+{
+    constexpr proxy_arrow_result(const T& value) noexcept(noexcept(T(value))) : value_(value) {}
+    constexpr proxy_arrow_result(T&& value) noexcept(noexcept(T(std::move(value)))) : value_(std::move(value)) {}
+
+    constexpr const T* operator->() const noexcept { return &value_; }
+    constexpr T*       operator->() noexcept { return &value_; }
+
+  private:
+    T value_;
+};
+
+namespace detail {
+template <typename Pointer, typename Reference, typename T>
+auto make_pointer(T&& value,
+                  std::enable_if_t<std::is_pointer<Pointer>::value && std::is_reference<Reference>::value, int> = 0)
+    -> decltype(std::addressof(value)) {
+    return std::addressof(value);
+}
+
+template <typename Pointer, typename Reference, typename T>
+auto make_pointer(T&& value,
+                  std::enable_if_t<!std::is_pointer<Pointer>::value && !std::is_same<Pointer, void>::value &&
+                                       std::is_reference<Reference>::value,
+                                   int> = 0) {
+    return Pointer(std::forward<T>(value));
+}
+
+template <typename Pointer, typename IteratorConcept>
+struct pointer {
+    using type = Pointer;
+};
+template <typename Pointer>
+struct pointer<Pointer, std::output_iterator_tag> {
+    using type = void;
+};
+template <typename Pointer, typename IteratorConcept>
+using pointer_t = typename pointer<Pointer, IteratorConcept>::type;
+
+template <typename T, typename U>
+using interoperable =
+    std::integral_constant<bool, (std::is_convertible<T, U>::value || std::is_convertible<U, T>::value)>;
+
+template <typename T, typename U>
+using common_t = std::conditional_t<std::is_convertible<T, U>::value, U, T>;
+
+template <typename T>
+using use_base = decltype(iterator_interface_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 iterator_interface_access::base(lhs) == iterator_interface_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::iterator_interface26::detail
+
+namespace beman::iterator_interface26::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V1 {
+
+    /** A CRTP template that one may derive from to make defining iterators
+        easier.
+
+        The template parameter `D` for `iterator_interface` may be an
+        incomplete type.  Before any member of the resulting specialization of
+        `iterator_interface` other than special member functions is
+        referenced, `D` shall be complete, and model
+        `std::derived_from<iterator_interface<D>>`. */
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType&,
+              typename Pointer        = ValueType*,
+              typename DifferenceType = std::ptrdiff_t
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+              ,
+              typename E = std::enable_if_t<std::is_class<Derived>::value &&
+                                            std::is_same<Derived, std::remove_cv_t<Derived>>::value>
+#endif
+              >
+    struct iterator_interface;
+
+    namespace v1_dtl {
+    template <typename Iterator, typename = void>
+    struct ra_iter : std::false_type {};
+    template <typename Iterator>
+    struct ra_iter<Iterator, void_t<typename Iterator::iterator_concept>>
+        : std::integral_constant<
+              bool,
+              std::is_base_of<std::random_access_iterator_tag, typename Iterator::iterator_concept>::value> {};
+
+    template <typename Iterator, typename DifferenceType, typename = void>
+    struct plus_eq : std::false_type {};
+    template <typename Iterator, typename DifferenceType>
+    struct plus_eq<Iterator,
+                   DifferenceType,
+                   void_t<decltype(std::declval<Iterator&>() += std::declval<DifferenceType>())>> : std::true_type {};
+
+    template <typename D,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference,
+              typename Pointer,
+              typename DifferenceType>
+    void
+    derived_iterator(const iterator_interface<D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType>&);
+    } // namespace v1_dtl
+
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference,
+              typename Pointer,
+              typename DifferenceType
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+              ,
+              typename E
+#endif
+              >
+    struct iterator_interface {
+#ifndef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+      private:
+        constexpr Derived&       derived() noexcept { return static_cast<Derived&>(*this); }
+        constexpr const Derived& derived() const noexcept { return static_cast<const Derived&>(*this); }
+
+        template <typename T, typename U, bool UseBase>
+        friend struct detail::common_eq;
+#endif
+
+      public:
+        using iterator_concept  = IteratorConcept;
+        using iterator_category = iterator_concept;
+        using value_type        = std::remove_const_t<ValueType>;
+        using reference         = Reference;
+        using pointer           = detail::pointer_t<Pointer, iterator_concept>;
+        using difference_type   = DifferenceType;
+
+        template <typename D = Derived>
+        constexpr auto operator*() noexcept(noexcept(*iterator_interface_access::base(std::declval<D&>())))
+            -> decltype(*iterator_interface_access::base(std::declval<D&>())) {
+            return *iterator_interface_access::base(derived());
+        }
+        template <typename D = Derived>
+        constexpr auto operator*() const noexcept(noexcept(*iterator_interface_access::base(std::declval<const D&>())))
+            -> decltype(*iterator_interface_access::base(std::declval<const D&>())) {
+            return *iterator_interface_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(++iterator_interface_access::base(std::declval<D&>())))
+            -> decltype(++iterator_interface_access::base(std::declval<D&>()), std::declval<D&>()) {
+            ++iterator_interface_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(iterator_interface_access::base(std::declval<D&>()) += n))
+            -> decltype(iterator_interface_access::base(std::declval<D&>()) += n, std::declval<D&>()) {
+            iterator_interface_access::base(derived()) += n;
+            return derived();
+        }
+
+        template <typename D = Derived>
+        constexpr auto operator+(difference_type i) const noexcept(noexcept(D(std::declval<D&>()),
+                                                                            std::declval<D&>() += i))
+            -> std::remove_reference_t<decltype(D(std::declval<D&>()), std::declval<D&>() += i, std::declval<D&>())> {
+            D retval = derived();
+            retval += i;
+            return retval;
+        }
+        friend BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR Derived operator+(difference_type i,
+                                                                                                Derived it) noexcept {
+            return it + i;
+        }
+
+        template <typename D      = Derived,
+                  typename Enable = std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>>
+        constexpr auto operator--() noexcept(noexcept(--iterator_interface_access::base(std::declval<D&>())))
+            -> decltype(--iterator_interface_access::base(std::declval<D&>()), std::declval<D&>()) {
+            --iterator_interface_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(iterator_interface_access::base(std::declval<const D&>()) - iterator_interface_access::base(other)))
+                -> decltype(iterator_interface_access::base(std::declval<const D&>()) - iterator_interface_access::base(other)) {
+            return iterator_interface_access::base(derived()) - iterator_interface_access::base(other);
+        }
+
+        friend BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR Derived
+        operator-(Derived it, difference_type i) noexcept {
+            Derived retval = it;
+            retval += -i;
+            return retval;
+        }
+    };
+
+    /** Implementation of `operator==()`, implemented in terms of the iterator
+        underlying IteratorInterface, for all iterators derived from
+        `iterator_interface`, except those with an iterator category derived
+        from `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1,
+              typename IteratorInterface2,
+              typename Enable = std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value>>
+    constexpr auto operator==(IteratorInterface1 lhs, IteratorInterface2 rhs) noexcept
+        -> decltype(iterator_interface_access::base(std::declval<IteratorInterface1&>()) ==
+                    iterator_interface_access::base(std::declval<IteratorInterface2&>())) {
+        return iterator_interface_access::base(lhs) == iterator_interface_access::base(rhs);
+    }
+
+    /** Implementation of `operator==()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1,
+              typename IteratorInterface2,
+              typename Enable = std::enable_if_t<v1_dtl::ra_iter<IteratorInterface1>::value>>
+    constexpr auto operator==(IteratorInterface1 lhs,
+                              IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) == 0) {
+        return detail::common_diff(lhs, rhs) == 0;
+    }
+
+    /** Implementation of `operator!=()` for all iterators derived from
+        `iterator_interface`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator!=(IteratorInterface1 lhs, IteratorInterface2 rhs) noexcept(noexcept(!(lhs == rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), !(lhs == rhs)) {
+        return !(lhs == rhs);
+    }
+
+    /** Implementation of `operator<()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator<(IteratorInterface1 lhs,
+                             IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) < 0) {
+        return detail::common_diff(lhs, rhs) < 0;
+    }
+
+    /** Implementation of `operator<=()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator<=(IteratorInterface1 lhs,
+                              IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) <= 0) {
+        return detail::common_diff(lhs, rhs) <= 0;
+    }
+
+    /** Implementation of `operator>()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator>(IteratorInterface1 lhs,
+                             IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) > 0) {
+        return detail::common_diff(lhs, rhs) > 0;
+    }
+
+    /** Implementation of `operator>=()` for all iterators derived from
+        `iterator_interface` that have an iterator category derived from
+        `std::random_access_iterator_tag`.  */
+    template <typename IteratorInterface1, typename IteratorInterface2>
+    constexpr auto operator>=(IteratorInterface1 lhs,
+                              IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
+        ->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) >= 0) {
+        return detail::common_diff(lhs, rhs) >= 0;
+    }
+
+    /** A template alias useful for defining proxy iterators.  \see
+        `iterator_interface`. */
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType,
+              typename DifferenceType = std::ptrdiff_t>
+    using proxy_iterator_interface = iterator_interface<Derived,
+                                                        IteratorConcept,
+                                                        ValueType,
+                                                        Reference,
+                                                        proxy_arrow_result<Reference>,
+                                                        DifferenceType>;
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#if defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+
+namespace beman::iterator_interface26::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V2 {
+
+    namespace v2_dtl {
+    template <typename Iterator>
+    struct iter_concept;
+
+    template <typename Iterator>
+        requires requires { typename std::iterator_traits<Iterator>::iterator_concept; }
+    struct iter_concept<Iterator> {
+        using type = typename std::iterator_traits<Iterator>::iterator_concept;
+    };
+
+    template <typename Iterator>
+        requires(
+            !requires { typename std::iterator_traits<Iterator>::iterator_concept; } &&
+            requires { typename std::iterator_traits<Iterator>::iterator_category; })
+    struct iter_concept<Iterator> {
+        using type = typename std::iterator_traits<Iterator>::iterator_category;
+    };
+
+    template <typename Iterator>
+        requires(
+            !requires { typename std::iterator_traits<Iterator>::iterator_concept; } &&
+            !requires { typename std::iterator_traits<Iterator>::iterator_category; })
+    struct iter_concept<Iterator> {
+        using type = std::random_access_iterator_tag;
+    };
+
+    template <typename Iterator>
+    struct iter_concept {};
+
+    template <typename Iterator>
+    using iter_concept_t = typename iter_concept<Iterator>::type;
+
+    template <typename D, typename DifferenceType>
+    // clang-format off
+        concept plus_eq = requires (D d) { d += DifferenceType(1); };
+    // clang-format on
+
+    template <typename D, typename D2 = D>
+    // clang-format off
+        concept base_3way =
+#if defined(__cpp_impl_three_way_comparison)
+            requires (D d, D2 d2) { iterator_interface_access::base(d) <=> iterator_interface_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) { iterator_interface_access::base(d1) == iterator_interface_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) { *iterator_interface_access::base(d); } {
+          return *iterator_interface_access::base(derived());
+        }
+      constexpr decltype(auto) operator*() const
+        requires requires (D const d) { *iterator_interface_access::base(d); } {
+          return *iterator_interface_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) { ++iterator_interface_access::base(d); } &&
+          (!v2_dtl::plus_eq<D, difference_type>) {
+            ++iterator_interface_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) { iterator_interface_access::base(d) += n; } {
+          iterator_interface_access::base(derived()) += n;
+          return derived();
+        }
+
+      constexpr decltype(auto) operator--()
+        requires requires (D d) { --iterator_interface_access::base(d); } &&
+          (!v2_dtl::plus_eq<D, difference_type>) {
+            --iterator_interface_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 { iterator_interface_access::base(lhs) - iterator_interface_access::base(rhs); }
+          { return iterator_interface_access::base(lhs) - iterator_interface_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 iterator_interface_access::base(lhs) <=> iterator_interface_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 (iterator_interface_access::base(lhs) == iterator_interface_access::base(rhs));
+        } else if constexpr (v2_dtl::iter_sub<D1, D2>) {
+          return (lhs - rhs) == typename D1::difference_type(0);
+        }
+      }
+
+    template<typename D1, typename D2>
+      constexpr auto operator!=(D1 lhs, D2 rhs) -> decltype(!(lhs == rhs))
+        requires v2_dtl::derived_iter<D1> && v2_dtl::derived_iter<D2>
+          { return !(lhs == rhs); }
+
+    // clang-format on
+
+    /** A template alias useful for defining proxy iterators.  \see
+        `iterator_interface`. */
+    template <typename Derived,
+              typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType,
+              typename DifferenceType = std::ptrdiff_t>
+    using proxy_iterator_interface = iterator_interface<Derived,
+                                                        IteratorConcept,
+                                                        ValueType,
+                                                        Reference,
+                                                        proxy_arrow_result<Reference>,
+                                                        DifferenceType>;
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#endif
+
+#if defined(BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS
+
+namespace beman::iterator_interface26::detail {
+namespace stl_interfaces {
+BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_NAMESPACE_V3 {
+
+    // clang-format off
+
+    /** A base template that one may derive from to make defining iterators
+        easier. */
+    template<
+      typename IteratorConcept,
+      typename ValueType,
+      typename Reference = ValueType &,
+      typename Pointer = ValueType *,
+      typename DifferenceType = std::ptrdiff_t>
+    struct iterator_interface
+        : v2::v2_dtl::iterator_category_base<IteratorConcept, Reference>
+    {
+      using iterator_concept = IteratorConcept;
+      using value_type = std::remove_const_t<ValueType>;
+      using reference = Reference;
+      using pointer = detail::pointer_t<Pointer, iterator_concept>;
+      using difference_type = DifferenceType;
+
+      constexpr decltype(auto) operator*(this auto&& self)
+          requires requires { *iterator_interface_access::base(self); } {
+          return *iterator_interface_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 { ++iterator_interface_access::base(self); } && (!requires { self += difference_type(1); }) {
+          ++iterator_interface_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 { iterator_interface_access::base(self) += n; } {
+          iterator_interface_access::base(self) += n;
+          return self;
+        }
+
+      constexpr decltype(auto) operator--(this auto& self)
+          requires requires { --iterator_interface_access::base(self); } && (!requires { self += difference_type(1); }) {
+            --iterator_interface_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 { iterator_interface_access::base(lhs) - iterator_interface_access::base(rhs); }
+          { return iterator_interface_access::base(lhs) - iterator_interface_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 iterator_interface_access::base(lhs) <=> iterator_interface_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 (iterator_interface_access::base(lhs) == iterator_interface_access::base(rhs));
+        } else if constexpr (v2::v2_dtl::iter_sub<D1, D2>) {
+          return (lhs - rhs) == typename D1::difference_type(0);
+        }
+      }
+
+    template<typename D1, typename D2>
+      constexpr auto operator!=(D1 lhs, D2 rhs) -> decltype(!(lhs == rhs))
+        requires v3_dtl::derived_iter<D1> && v3_dtl::derived_iter<D2>
+          { return !(lhs == rhs); }
+
+    // clang-format on
+
+    /** A template alias useful for defining proxy iterators.  \see
+        `iterator_interface`. */
+    template <typename IteratorConcept,
+              typename ValueType,
+              typename Reference      = ValueType,
+              typename DifferenceType = std::ptrdiff_t>
+    using proxy_iterator_interface =
+        iterator_interface<IteratorConcept, ValueType, Reference, proxy_arrow_result<Reference>, DifferenceType>;
+}
+} // namespace stl_interfaces
+} // namespace beman::optional26::detail
+
+#endif
+
+#ifdef BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_DOXYGEN
+
+/** `static_asserts` that type `type` models concept `concept_name`.  This is
+    useful for checking that an iterator, view, etc. that you write using one
+    of the *`_interface` templates models the right C++ concept.
+
+    For example: `BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(my_iter,
+    std::input_iterator)`.
+
+    \note This macro expands to nothing when `__cpp_lib_concepts` is not
+    defined. */
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(type, concept_name)
+
+/** `static_asserts` that the types of all typedefs in
+    `std::iterator_traits<iter>` match the remaining macro parameters.  This
+    is useful for checking that an iterator you write using
+    `iterator_interface` has the correct iterator traits.
+
+    For example: `BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(my_iter,
+    std::input_iterator_tag, std::input_iterator, int, int &, int *, std::ptrdiff_t)`.
+
+    \note This macro ignores the `concept` parameter when `__cpp_lib_concepts`
+    is not defined. */
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS( \
+    iter, category, concept, value_type, reference, pointer, difference_type)
+
+#else
+
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(type, concept_name) \
+    static_assert(concept_name<type>, "");
+
+#if BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_USE_CONCEPTS
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(iter, concept_name) \
+    BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(iter, concept_name)
+#else
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(iter, concept_name)
+#endif
+
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL(                    \
+    iter, category, value_t, ref, ptr, diff_t)                                                        \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::value_type, value_t>::value, ""); \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::reference, ref>::value, "");      \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::pointer, ptr>::value, "");        \
+    static_assert(std::is_same<typename std::iterator_traits<iter>::difference_type, diff_t>::value, "");
+
+#define BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(  \
+    iter, category, concept, value_type, reference, pointer, difference_type)  \
+    BEMAN_OPTIONAL26_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL( \
+        iter, category, value_type, reference, pointer, difference_type)
+#endif
+
+#endif
diff --git a/include/beman/iterator_interface26/iterator_interface.hpp b/include/beman/iterator_interface26/iterator_interface.hpp
index ce5e456..afa7a82 100644
--- a/include/beman/iterator_interface26/iterator_interface.hpp
+++ b/include/beman/iterator_interface26/iterator_interface.hpp
@@ -2,6 +2,12 @@
 #ifndef INCLUDED_ITERATOR_INTERFACE
 #define INCLUDED_ITERATOR_INTERFACE
 
+#include <beman/iterator_interface26/config.hpp>
+#include <beman/iterator_interface26/iterator_interface_access.hpp>
+#if !BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS()
+#include <beman/iterator_interface26/detail/stl_interfaces/iterator_interface.hpp>
+#endif
+
 #include <concepts>
 #include <type_traits>
 #include <iterator>
@@ -9,6 +15,8 @@
 namespace beman {
 namespace iterator_interface26 {
 
+#if BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS()
+
 using std::conditional_t;
 using std::convertible_to;
 using std::is_convertible_v;
@@ -24,22 +32,6 @@ using std::same_as;
 using std::input_iterator_tag;
 using std::strong_ordering;
 
-// [iterator.interface], iterator interface
-// [iterator.interface.helpers], iterator interface helpers
-struct iterator_interface_access; // freestanding
-
-struct iterator_interface_access {
-    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();
-    }
-};
-
 template <typename T>
     requires is_object_v<T>
 class proxy_arrow_result {
@@ -339,7 +331,14 @@ constexpr bool operator==(D1 lhs, D2 rhs)
         return (lhs - rhs) == typename D1::difference_type(0);
     }
 }
-} // namespace iterator
-} // namespace Beman
+
+#else
+
+using detail::stl_interfaces::iterator_interface;
+
+#endif
+
+} // namespace iterator_interface26
+} // namespace beman
 
 #endif
diff --git a/include/beman/iterator_interface26/iterator_interface_access.hpp b/include/beman/iterator_interface26/iterator_interface_access.hpp
new file mode 100644
index 0000000..f13537a
--- /dev/null
+++ b/include/beman/iterator_interface26/iterator_interface_access.hpp
@@ -0,0 +1,23 @@
+#ifndef ITERATOR_INTERFACE_ACCESSS_HPP
+#define ITERATOR_INTERFACE_ACCESSS_HPP
+
+namespace beman {
+namespace iterator_interface26 {
+// [iterator.interface], iterator interface
+// [iterator.interface.helpers], iterator interface helpers
+struct iterator_interface_access; // freestanding
+
+struct iterator_interface_access {
+    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
diff --git a/src/beman/iterator_interface26/CMakeLists.txt b/src/beman/iterator_interface26/CMakeLists.txt
index e6d32b0..5ff71d6 100644
--- a/src/beman/iterator_interface26/CMakeLists.txt
+++ b/src/beman/iterator_interface26/CMakeLists.txt
@@ -11,7 +11,8 @@ include(GNUInstallDirs)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 target_include_directories(beman.iterator_interface26 PUBLIC
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../../include>
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
   $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${CMAKE_LOWER_PROJECT_NAME}>  # <prefix>/include/scratch
 )
 
diff --git a/src/beman/iterator_interface26/iterator_interface.t.cpp b/src/beman/iterator_interface26/iterator_interface.t.cpp
index 20ec2d7..8c9aadf 100644
--- a/src/beman/iterator_interface26/iterator_interface.t.cpp
+++ b/src/beman/iterator_interface26/iterator_interface.t.cpp
@@ -4,6 +4,7 @@
 
 #include <gtest/gtest.h>
 
+#include <algorithm>
 #include <ranges>
 
 namespace beman {
@@ -13,7 +14,13 @@ namespace {} // namespace
 
 TEST(IteratorTest, TestGTest) { ASSERT_EQ(1, 1); }
 
-struct repeated_chars_iterator : iterator_interface<std::random_access_iterator_tag, char, char> {
+struct repeated_chars_iterator : iterator_interface<
+#if !BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS()
+                                     repeated_chars_iterator,
+#endif
+                                     std::random_access_iterator_tag,
+                                     char,
+                                     char> {
     constexpr repeated_chars_iterator() : first_(nullptr), size_(0), n_(0) {}
     constexpr repeated_chars_iterator(const char* first, difference_type size, difference_type n)
         : first_(first), size_(size), n_(n) {}
@@ -40,7 +47,12 @@ TEST(IteratorTest, TestRepeatedChars) {
 }
 
 template <typename Pred>
-struct filtered_int_iterator : iterator_interface<std::forward_iterator_tag, int> {
+struct filtered_int_iterator : iterator_interface<
+#if !BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS()
+                                   filtered_int_iterator<Pred>,
+#endif
+                                   std::forward_iterator_tag,
+                                   int> {
     filtered_int_iterator() : it_(nullptr) {}
     filtered_int_iterator(int* it, int* last, Pred pred) : it_(it), last_(last), pred_(std::move(pred)) {
         it_ = std::find_if(it_, last_, pred_);
@@ -66,7 +78,11 @@ struct filtered_int_iterator : iterator_interface<std::forward_iterator_tag, int
     // These functions are picked up by iterator_interface, and used to
     // implement any operations that you don't define above.  They're not
     // called base() so that they do not collide with the base() member above.
+#ifdef __cpp_explicit_this_parameter
     constexpr decltype(auto) base_reference(this auto& self) noexcept { return self.it_; }
+#else
+    constexpr decltype(auto) base_reference() noexcept { return it_; }
+#endif
 
     int* it_;
     int* last_;
@@ -85,7 +101,13 @@ struct ClassWithMemberFunction {
     int f() { return 3; }
 };
 
-struct AlwaysIterator : iterator_interface<std::random_access_iterator_tag, ClassWithMemberFunction> {
+struct AlwaysIterator : iterator_interface<
+#if !BEMAN_ITERATOR_INTERFACE26_USE_DEDUCING_THIS()
+                            AlwaysIterator,
+#endif
+
+                            std::random_access_iterator_tag,
+                            ClassWithMemberFunction> {
     AlwaysIterator() : size_(0), n_(0) {}
     AlwaysIterator(difference_type size, difference_type n) : size_(size), n_(n) {}