From 95346e375db70d42bf9fc2233afd9c0bbc5c6d87 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 13 May 2025 10:57:11 +0100
Subject: [PATCH 01/66] Rename distance_t -> int_t

---
 .../multidimensional_memset_benchmark.cpp     | 18 +++----
 ...tidimensional_memset_benchmark_kernels.cpp | 27 ++++++-----
 include/flux/adaptor/adjacent.hpp             | 34 ++++++-------
 include/flux/adaptor/cartesian_base.hpp       | 48 +++++++++----------
 include/flux/adaptor/cartesian_power.hpp      |  6 +--
 include/flux/adaptor/cartesian_power_map.hpp  |  6 +--
 include/flux/adaptor/chain.hpp                | 19 ++++----
 include/flux/adaptor/chunk.hpp                | 33 +++++++------
 include/flux/adaptor/cursors.hpp              |  6 +--
 include/flux/adaptor/cycle.hpp                | 26 +++++-----
 include/flux/adaptor/drop.hpp                 |  9 ++--
 include/flux/adaptor/reverse.hpp              |  6 +--
 include/flux/adaptor/scan.hpp                 |  4 +-
 include/flux/adaptor/scan_first.hpp           |  2 +-
 include/flux/adaptor/slide.hpp                | 21 ++++----
 include/flux/adaptor/stride.hpp               | 36 +++++++-------
 include/flux/adaptor/take.hpp                 | 18 +++----
 include/flux/adaptor/zip.hpp                  |  4 +-
 include/flux/algorithm/count.hpp              | 14 +++---
 include/flux/algorithm/detail/heap_ops.hpp    |  9 ++--
 include/flux/algorithm/detail/pdqsort.hpp     | 13 +++--
 include/flux/algorithm/ends_with.hpp          |  4 +-
 include/flux/core/concepts.hpp                | 10 ++--
 include/flux/core/default_impls.hpp           | 32 ++++++-------
 include/flux/core/inline_sequence_base.hpp    | 12 +++--
 include/flux/core/operation_requirements.hpp  |  4 +-
 include/flux/core/ref.hpp                     |  2 +-
 include/flux/core/sequence_access.hpp         | 18 ++++---
 include/flux/core/sequence_iterator.hpp       |  2 +-
 include/flux/sequence/array_ptr.hpp           | 22 +++------
 include/flux/sequence/empty.hpp               |  3 +-
 include/flux/sequence/iota.hpp                | 25 ++++------
 include/flux/sequence/range.hpp               | 16 +++----
 include/flux/sequence/repeat.hpp              | 14 +++---
 include/flux/sequence/single.hpp              |  3 +-
 test/test_apply.cpp                           |  5 +-
 test/test_cartesian_product.cpp               | 38 ++++++++-------
 test/test_cartesian_product_map.cpp           |  2 +-
 test/test_chunk.cpp                           |  4 +-
 test/test_cycle.cpp                           |  4 +-
 test/test_range_iface.cpp                     |  8 ++--
 test/test_repeat.cpp                          |  4 +-
 test/test_sort.cpp                            | 11 +++--
 test/test_stride.cpp                          |  4 +-
 44 files changed, 291 insertions(+), 315 deletions(-)

diff --git a/benchmark/multidimensional_memset_benchmark.cpp b/benchmark/multidimensional_memset_benchmark.cpp
index 5174bc22..bf1f88a4 100644
--- a/benchmark/multidimensional_memset_benchmark.cpp
+++ b/benchmark/multidimensional_memset_benchmark.cpp
@@ -18,19 +18,21 @@ namespace an = ankerl::nanobench;
 // Kernels are placed in a separate translation unit to prevent compilers from
 // optimizing them based on the input that we'll be giving them and to make it
 // easier to study their compiled assembly.
-extern void memset_2d_reference(double* A, flux::distance_t N, flux::distance_t M);
-extern void memset_2d_std_cartesian_product_iota(double* A, flux::distance_t N, flux::distance_t M);
-extern void memset_2d_flux_cartesian_product_iota(double* A, flux::distance_t N, flux::distance_t M);
-extern void memset_diagonal_2d_reference(double* A, flux::distance_t N, flux::distance_t M);
-extern void memset_diagonal_2d_std_cartesian_product_iota_filter(double* A, flux::distance_t N, flux::distance_t M);
-extern void memset_diagonal_2d_flux_cartesian_product_iota_filter(double* A, flux::distance_t N, flux::distance_t M);
+extern void memset_2d_reference(double* A, flux::int_t N, flux::int_t M);
+extern void memset_2d_std_cartesian_product_iota(double* A, flux::int_t N, flux::int_t M);
+extern void memset_2d_flux_cartesian_product_iota(double* A, flux::int_t N, flux::int_t M);
+extern void memset_diagonal_2d_reference(double* A, flux::int_t N, flux::int_t M);
+extern void memset_diagonal_2d_std_cartesian_product_iota_filter(double* A, flux::int_t N,
+                                                                 flux::int_t M);
+extern void memset_diagonal_2d_flux_cartesian_product_iota_filter(double* A, flux::int_t N,
+                                                                  flux::int_t M);
 
 int main(int argc, char** argv)
 {
     int const n_iters = argc > 1 ? std::atoi(argv[1]) : 40;
 
-    constexpr flux::distance_t N = 1024;
-    constexpr flux::distance_t M = 2048;
+    constexpr flux::int_t N = 1024;
+    constexpr flux::int_t M = 2048;
     std::vector<double> A(N * M);
 
     const auto run_benchmark =
diff --git a/benchmark/multidimensional_memset_benchmark_kernels.cpp b/benchmark/multidimensional_memset_benchmark_kernels.cpp
index 4b3706ce..69ce8ba6 100644
--- a/benchmark/multidimensional_memset_benchmark_kernels.cpp
+++ b/benchmark/multidimensional_memset_benchmark_kernels.cpp
@@ -18,14 +18,16 @@
 #include <ranges>
 #include <algorithm>
 
-void memset_2d_reference(double* A, flux::distance_t N, flux::distance_t M)
+void memset_2d_reference(double* A, flux::int_t N, flux::int_t M)
 {
-    for (flux::distance_t i = 0; i != N; ++i)
-        for (flux::distance_t j = 0; j != M; ++j)
+    for (flux::int_t i = 0; i != N; ++i) {
+        for (flux::int_t j = 0; j != M; ++j) {
             A[i * M + j] = 0.0;
+        }
+    }
 }
 
-void memset_2d_std_cartesian_product_iota(double* A, flux::distance_t N, flux::distance_t M)
+void memset_2d_std_cartesian_product_iota(double* A, flux::int_t N, flux::int_t M)
 {
     std::ranges::for_each(
         std::views::cartesian_product(std::views::iota(0, N), std::views::iota(0, M)),
@@ -34,7 +36,7 @@ void memset_2d_std_cartesian_product_iota(double* A, flux::distance_t N, flux::d
         }));
 }
 
-void memset_2d_flux_cartesian_product_iota(double* A, flux::distance_t N, flux::distance_t M)
+void memset_2d_flux_cartesian_product_iota(double* A, flux::int_t N, flux::int_t M)
 {
     flux::for_each(
         flux::cartesian_product(flux::ints(0, N), flux::ints(0, M)),
@@ -43,14 +45,17 @@ void memset_2d_flux_cartesian_product_iota(double* A, flux::distance_t N, flux::
         }));
 }
 
-void memset_diagonal_2d_reference(double* A, flux::distance_t N, flux::distance_t M)
+void memset_diagonal_2d_reference(double* A, flux::int_t N, flux::int_t M)
 {
-    for (flux::distance_t i = 0; i != N; ++i)
-        for (flux::distance_t j = 0; j != M; ++j)
-            if (i == j) A[i * M + j] = 0.0;
+    for (flux::int_t i = 0; i != N; ++i) {
+        for (flux::int_t j = 0; j != M; ++j) {
+            if (i == j)
+                A[i * M + j] = 0.0;
+        }
+    }
 }
 
-void memset_diagonal_2d_std_cartesian_product_iota_filter(double* A, flux::distance_t N, flux::distance_t M)
+void memset_diagonal_2d_std_cartesian_product_iota_filter(double* A, flux::int_t N, flux::int_t M)
 {
     std::ranges::for_each(
         std::views::cartesian_product(std::views::iota(0, N), std::views::iota(0, M))
@@ -60,7 +65,7 @@ void memset_diagonal_2d_std_cartesian_product_iota_filter(double* A, flux::dista
         }));
 }
 
-void memset_diagonal_2d_flux_cartesian_product_iota_filter(double* A, flux::distance_t N, flux::distance_t M)
+void memset_diagonal_2d_flux_cartesian_product_iota_filter(double* A, flux::int_t N, flux::int_t M)
 {
     flux::for_each(
         flux::cartesian_product(flux::ints(0, N), flux::ints(0, M))
diff --git a/include/flux/adaptor/adjacent.hpp b/include/flux/adaptor/adjacent.hpp
index 5c5223da..acabacb9 100644
--- a/include/flux/adaptor/adjacent.hpp
+++ b/include/flux/adaptor/adjacent.hpp
@@ -19,7 +19,7 @@ namespace flux {
 
 namespace detail {
 
-template <typename Base, distance_t N>
+template <typename Base, int_t N>
 struct adjacent_sequence_traits_base : default_sequence_traits {
 protected:
     struct cursor_type {
@@ -91,7 +91,7 @@ struct adjacent_sequence_traits_base : default_sequence_traits {
         }, cur.arr);
     }
 
-    static constexpr auto inc(auto& self, cursor_type& cur, distance_t offset) -> void
+    static constexpr auto inc(auto& self, cursor_type& cur, int_t offset) -> void
         requires random_access_sequence<Base>
     {
         std::apply([&self, offset](auto&... curs) {
@@ -100,21 +100,21 @@ struct adjacent_sequence_traits_base : default_sequence_traits {
     }
 
     static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-        -> distance_t
+        -> int_t
         requires random_access_sequence<Base>
     {
         return flux::distance(self.base_, from.arr.back(), to.arr.back());
     }
 
-    static constexpr auto size(auto& self) -> distance_t
+    static constexpr auto size(auto& self) -> int_t
         requires sized_sequence<Base>
     {
         auto s = (flux::size(self.base_) - N) + 1;
-        return (cmp::max)(s, distance_t{0});
+        return (cmp::max)(s, int_t {0});
     }
 };
 
-template <typename Base, distance_t N>
+template <typename Base, int_t N>
 struct adjacent_adaptor : inline_sequence_base<adjacent_adaptor<Base, N>> {
 private:
     Base base_;
@@ -175,7 +175,7 @@ struct adjacent_adaptor : inline_sequence_base<adjacent_adaptor<Base, N>> {
     };
 };
 
-template <typename Base, distance_t N, typename Func>
+template <typename Base, int_t N, typename Func>
 struct adjacent_map_adaptor : inline_sequence_base<adjacent_map_adaptor<Base, N, Func>> {
 private:
     Base base_;
@@ -202,7 +202,7 @@ struct adjacent_map_adaptor : inline_sequence_base<adjacent_map_adaptor<Base, N,
     };
 };
 
-template <distance_t N>
+template <int_t N>
 struct adjacent_fn {
     template <adaptable_sequence Seq>
         requires multipass_sequence<Seq>
@@ -213,7 +213,7 @@ struct adjacent_fn {
     }
 };
 
-template <distance_t N>
+template <int_t N>
 struct adjacent_map_fn {
     template <adaptable_sequence Seq, typename Func>
         requires multipass_sequence<Seq> &&
@@ -229,21 +229,21 @@ struct adjacent_map_fn {
 } // namespace detail
 
 FLUX_EXPORT
-template <distance_t N>
-    requires (N > 0)
-inline constexpr auto adjacent = detail::adjacent_fn<N>{};
+template <int_t N>
+    requires(N > 0)
+inline constexpr auto adjacent = detail::adjacent_fn<N> {};
 
 FLUX_EXPORT inline constexpr auto pairwise = adjacent<2>;
 
 FLUX_EXPORT
-template <distance_t N>
-    requires (N > 0)
-inline constexpr auto adjacent_map = detail::adjacent_map_fn<N>{};
+template <int_t N>
+    requires(N > 0)
+inline constexpr auto adjacent_map = detail::adjacent_map_fn<N> {};
 
 FLUX_EXPORT inline constexpr auto pairwise_map = adjacent_map<2>;
 
 template <typename D>
-template <distance_t N>
+template <int_t N>
 constexpr auto inline_sequence_base<D>::adjacent() &&
     requires multipass_sequence<D>
 {
@@ -258,7 +258,7 @@ constexpr auto inline_sequence_base<D>::pairwise() &&
 }
 
 template <typename D>
-template <distance_t N, typename Func>
+template <int_t N, typename Func>
     requires multipass_sequence<D>
 constexpr auto inline_sequence_base<D>::adjacent_map(Func func) &&
 {
diff --git a/include/flux/adaptor/cartesian_base.hpp b/include/flux/adaptor/cartesian_base.hpp
index c61e4a42..2ee0b469 100644
--- a/include/flux/adaptor/cartesian_base.hpp
+++ b/include/flux/adaptor/cartesian_base.hpp
@@ -36,7 +36,7 @@ struct tuple_repeated {
     using repeater = T;
 
     template <std::size_t... Is>
-    static auto make_tuple(std::index_sequence<Is...>) -> std::tuple<repeater<Is>...>;    
+    static auto make_tuple(std::index_sequence<Is...>) -> std::tuple<repeater<Is>...>;
 
     using type = decltype(make_tuple(std::make_index_sequence<RepeatCount>{}));
 };
@@ -109,8 +109,8 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     }
 
     template <std::size_t I, typename Self>
-    static constexpr auto ra_inc_impl(Self& self, cursor_t<Self>& cur, distance_t offset)
-    -> cursor_t<Self>&
+    static constexpr auto ra_inc_impl(Self& self, cursor_t<Self>& cur, int_t offset)
+        -> cursor_t<Self>&
     {
         if (offset == 0) {
             return cur;
@@ -129,7 +129,7 @@ struct cartesian_traits_base_impl : default_sequence_traits {
             // Correct for negative index which may happen when underflowing.
             if (new_index < 0) {
                 new_index = num::add(new_index, this_size);
-                offset = num::sub(offset, flux::distance_t(1));
+                offset = num::sub(offset, flux::int_t(1));
             }
 
             // Call the next level down if necessary.
@@ -146,9 +146,8 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     }
 
     template <std::size_t I, typename Self>
-    static constexpr auto distance_impl(Self& self,
-                                        cursor_t<Self> const& from,
-                                        cursor_t<Self> const& to) -> distance_t
+    static constexpr auto distance_impl(Self& self, cursor_t<Self> const& from,
+                                        cursor_t<Self> const& to) -> int_t
     {
         if constexpr (I == 0) {
             return flux::distance(get_base<0>(self), std::get<0>(from), std::get<0>(to));
@@ -231,21 +230,21 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     }
 
     template <typename Self>
-    static constexpr auto size(Self& self) -> distance_t
-        requires (CartesianKind == cartesian_kind::product
-                  && (sized_sequence<Bases> && ...))
+    static constexpr auto size(Self& self) -> int_t
+        requires(CartesianKind == cartesian_kind::product && (sized_sequence<Bases> && ...))
     {
-        return std::apply([](auto& base0, auto&... bases) {
-            distance_t sz = flux::size(base0);
-            ((sz = num::mul(sz, flux::size(bases))), ...);
-            return sz;
-        }, self.bases_);
+        return std::apply(
+            [](auto& base0, auto&... bases) {
+                int_t sz = flux::size(base0);
+                ((sz = num::mul(sz, flux::size(bases))), ...);
+                return sz;
+            },
+            self.bases_);
     }
 
     template <typename Self>
-    static constexpr auto size(Self& self) -> distance_t
-        requires (CartesianKind == cartesian_kind::power
-                  && (sized_sequence<Bases> && ...))
+    static constexpr auto size(Self& self) -> int_t
+        requires(CartesianKind == cartesian_kind::power && (sized_sequence<Bases> && ...))
     {
         return checked_pow(flux::size(self.base_), Arity);
     }
@@ -267,9 +266,8 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     }
 
     template <typename Self>
-    static constexpr auto inc(Self& self, cursor_t<Self>& cur, distance_t offset) -> cursor_t<Self>&
-        requires ((random_access_sequence<Bases> && ...) &&
-                  (sized_sequence<Bases> && ...))
+    static constexpr auto inc(Self& self, cursor_t<Self>& cur, int_t offset) -> cursor_t<Self>&
+        requires((random_access_sequence<Bases> && ...) && (sized_sequence<Bases> && ...))
     {
         return ra_inc_impl<Arity - 1>(self, cur, offset);
     }
@@ -301,11 +299,9 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     }
 
     template <typename Self>
-    static constexpr auto distance(Self& self,
-                                        cursor_t<Self> const& from,
-                                        cursor_t<Self> const& to) -> distance_t
-        requires ((random_access_sequence<Bases> && ...) &&
-                  (sized_sequence<Bases> && ...))
+    static constexpr auto distance(Self& self, cursor_t<Self> const& from, cursor_t<Self> const& to)
+        -> int_t
+        requires((random_access_sequence<Bases> && ...) && (sized_sequence<Bases> && ...))
     {
         return distance_impl<Arity - 1>(self, from, to);
     }
diff --git a/include/flux/adaptor/cartesian_power.hpp b/include/flux/adaptor/cartesian_power.hpp
index 5dd2f5c5..419c4f01 100644
--- a/include/flux/adaptor/cartesian_power.hpp
+++ b/include/flux/adaptor/cartesian_power.hpp
@@ -61,9 +61,9 @@ struct cartesian_power_fn {
 } // end namespace detail
 
 FLUX_EXPORT
-template<distance_t N>
-    requires (N >= 0)
-inline constexpr auto cartesian_power = detail::cartesian_power_fn<N>{};
+template <int_t N>
+    requires(N >= 0)
+inline constexpr auto cartesian_power = detail::cartesian_power_fn<N> {};
 
 } // end namespace flux
 
diff --git a/include/flux/adaptor/cartesian_power_map.hpp b/include/flux/adaptor/cartesian_power_map.hpp
index 41737c47..1eaffa59 100644
--- a/include/flux/adaptor/cartesian_power_map.hpp
+++ b/include/flux/adaptor/cartesian_power_map.hpp
@@ -55,9 +55,9 @@ struct cartesian_power_map_fn
 } // namespace detail
 
 FLUX_EXPORT
-template <distance_t N>
-    requires (N >= 0)
-inline constexpr auto cartesian_power_map = detail::cartesian_power_map_fn<N>{};
+template <int_t N>
+    requires(N >= 0)
+inline constexpr auto cartesian_power_map = detail::cartesian_power_map_fn<N> {};
 
 } // namespace flux
 
diff --git a/include/flux/adaptor/chain.hpp b/include/flux/adaptor/chain.hpp
index 9051dd76..754428d7 100644
--- a/include/flux/adaptor/chain.hpp
+++ b/include/flux/adaptor/chain.hpp
@@ -208,9 +208,7 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_trait
     }
 
     template <std::size_t N, typename Self>
-    static constexpr auto inc_ra_impl(Self& self, cursor_type& cur,
-                                      distance_t offset)
-        -> cursor_type&
+    static constexpr auto inc_ra_impl(Self& self, cursor_type& cur, int_t offset) -> cursor_type&
     {
         if constexpr (N < End) {
             if (N < cur.index()) {
@@ -300,11 +298,10 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_trait
     }
 
     template <typename Self>
-    static constexpr auto distance(Self& self, cursor_type const& from,
-                                   cursor_type const& to)
-        -> distance_t
-        requires (random_access_sequence<const_like_t<Self, Bases>> && ...) &&
-                 (bounded_sequence<const_like_t<Self, Bases>> && ...)
+    static constexpr auto distance(Self& self, cursor_type const& from, cursor_type const& to)
+        -> int_t
+        requires(random_access_sequence<const_like_t<Self, Bases>> && ...)
+        && (bounded_sequence<const_like_t<Self, Bases>> && ...)
     {
         if (from.index() <= to.index()) {
             return distance_impl<0>(self, from, to);
@@ -314,9 +311,9 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_trait
     }
 
     template <typename Self>
-    static constexpr auto inc(Self& self, cursor_type& cur, distance_t offset)
-        requires (random_access_sequence<const_like_t<Self, Bases>> && ...) &&
-                 (bounded_sequence<const_like_t<Self, Bases>> && ...)
+    static constexpr auto inc(Self& self, cursor_type& cur, int_t offset)
+        requires(random_access_sequence<const_like_t<Self, Bases>> && ...)
+        && (bounded_sequence<const_like_t<Self, Bases>> && ...)
     {
         inc_ra_impl<0>(self, cur, offset);
     }
diff --git a/include/flux/adaptor/chunk.hpp b/include/flux/adaptor/chunk.hpp
index e215e91b..473356cb 100644
--- a/include/flux/adaptor/chunk.hpp
+++ b/include/flux/adaptor/chunk.hpp
@@ -19,12 +19,12 @@ template <typename Base>
 struct chunk_adaptor : inline_sequence_base<chunk_adaptor<Base>> {
 private:
     Base base_;
-    distance_t chunk_sz_;
+    int_t chunk_sz_;
     optional<cursor_t<Base>> cur_ = nullopt;
-    distance_t rem_ = chunk_sz_;
+    int_t rem_ = chunk_sz_;
 
 public:
-    constexpr chunk_adaptor(decays_to<Base> auto&& base, distance_t chunk_sz)
+    constexpr chunk_adaptor(decays_to<Base> auto&& base, int_t chunk_sz)
         : base_(FLUX_FWD(base)),
           chunk_sz_(chunk_sz)
     {}
@@ -124,7 +124,7 @@ struct chunk_adaptor : inline_sequence_base<chunk_adaptor<Base>> {
             return value_type(self);
         }
 
-        static constexpr auto size(self_t& self) -> distance_t
+        static constexpr auto size(self_t& self) -> int_t
             requires sized_sequence<Base>
         {
             auto s = flux::size(self.base_);
@@ -137,10 +137,10 @@ template <multipass_sequence Base>
 struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
 private:
     Base base_;
-    distance_t chunk_sz_;
+    int_t chunk_sz_;
 
 public:
-    constexpr chunk_adaptor(decays_to<Base> auto&& base, distance_t chunk_sz)
+    constexpr chunk_adaptor(decays_to<Base> auto&& base, int_t chunk_sz)
         : base_(FLUX_FWD(base)),
           chunk_sz_(chunk_sz)
     {}
@@ -176,7 +176,7 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
             return flux::last(self.base_);
         }
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<Base>
         {
             auto s = flux::size(self.base_);
@@ -189,10 +189,10 @@ template <bidirectional_sequence Base>
 struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
 private:
     Base base_;
-    distance_t chunk_sz_;
+    int_t chunk_sz_;
 
 public:
-    constexpr chunk_adaptor(decays_to<Base> auto&& base, distance_t chunk_sz)
+    constexpr chunk_adaptor(decays_to<Base> auto&& base, int_t chunk_sz)
         : base_(FLUX_FWD(base)),
           chunk_sz_(chunk_sz)
     {}
@@ -201,7 +201,7 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
     private:
         struct cursor_type {
             cursor_t<Base> cur{};
-            distance_t missing = 0;
+            int_t missing = 0;
 
             friend constexpr auto operator==(cursor_type const& lhs, cursor_type const& rhs) -> bool
             {
@@ -259,15 +259,15 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
         static constexpr auto last(auto& self) -> cursor_type
             requires bounded_sequence<Base> && sized_sequence<Base>
         {
-            distance_t missing =
-                (self.chunk_sz_ - flux::size(self.base_) % self.chunk_sz_) % self.chunk_sz_;
+            int_t missing
+                = (self.chunk_sz_ - flux::size(self.base_) % self.chunk_sz_) % self.chunk_sz_;
             return cursor_type{
                 .cur = flux::last(self.base_),
                 .missing = missing
             };
         }
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<Base>
         {
             auto s = flux::size(self.base_);
@@ -275,13 +275,13 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
         }
 
         static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> distance_t
+            -> int_t
             requires random_access_sequence<Base>
         {
             return (flux::distance(self.base_, from.cur, to.cur) - from.missing + to.missing)/self.chunk_sz_;
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t offset) -> void
+        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset) -> void
             requires random_access_sequence<Base>
         {
             if (offset > 0) {
@@ -301,8 +301,7 @@ struct chunk_fn {
         -> sequence auto
     {
         FLUX_ASSERT(chunk_sz > 0);
-        return chunk_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq),
-                                                num::checked_cast<distance_t>(chunk_sz));
+        return chunk_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), num::checked_cast<int_t>(chunk_sz));
     }
 };
 
diff --git a/include/flux/adaptor/cursors.hpp b/include/flux/adaptor/cursors.hpp
index d77e1966..68f794fe 100644
--- a/include/flux/adaptor/cursors.hpp
+++ b/include/flux/adaptor/cursors.hpp
@@ -53,14 +53,14 @@ struct cursors_adaptor : inline_sequence_base<cursors_adaptor<Base>> {
             flux::dec(self.base_, cur);
         }
 
-        static constexpr auto inc(auto& self, cursor_t<Base>& cur, distance_t offset) -> void
+        static constexpr auto inc(auto& self, cursor_t<Base>& cur, int_t offset) -> void
             requires random_access_sequence<Base>
         {
             flux::inc(self.base_, cur, offset);
         }
 
         static constexpr auto distance(auto& self, cursor_t<Base> const& from,
-                                       cursor_t<Base> const& to) -> distance_t
+                                       cursor_t<Base> const& to) -> int_t
             requires random_access_sequence<Base>
         {
             return flux::distance(self.base_, from, to);
@@ -72,7 +72,7 @@ struct cursors_adaptor : inline_sequence_base<cursors_adaptor<Base>> {
             return flux::last(self.base_);
         }
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<Base>
         {
             return flux::size(self.base_);
diff --git a/include/flux/adaptor/cycle.hpp b/include/flux/adaptor/cycle.hpp
index a0e98d71..fd64b9e1 100644
--- a/include/flux/adaptor/cycle.hpp
+++ b/include/flux/adaptor/cycle.hpp
@@ -156,9 +156,9 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
             flux::dec(self.base_, cur.base_cur);
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t offset)
-            requires random_access_sequence<decltype(self.base_)> &&
-                     bounded_sequence<decltype(self.base_)>
+        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset)
+            requires random_access_sequence<decltype(self.base_)>
+            && bounded_sequence<decltype(self.base_)>
         {
             auto const first = flux::first(self.base_);
 
@@ -180,13 +180,12 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
             cur.base_cur = flux::next(self.base_, first, off);
         }
 
-        static constexpr auto distance(auto& self,
-                                       cursor_type const& from,
-                                       cursor_type const& to) -> distance_t
-            requires random_access_sequence<decltype(self.base_)> &&
-                     sized_sequence<decltype(self.base_)>
+        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
+            -> int_t
+            requires random_access_sequence<decltype(self.base_)>
+            && sized_sequence<decltype(self.base_)>
         {
-            auto dist = num::cast<distance_t>(to.n) - num::cast<distance_t>(from.n);
+            auto dist = num::cast<int_t>(to.n) - num::cast<int_t>(from.n);
             dist = num::mul(dist, flux::size(self.base_));
             return num::add(dist,
                     flux::distance(self.base_, from.base_cur, to.base_cur));
@@ -200,11 +199,10 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
                                .n = self.data_.count};
         }
 
-        static constexpr auto size(auto& self) -> distance_t
-            requires (!IsInfinite && sized_sequence<Base>)
+        static constexpr auto size(auto& self) -> int_t
+            requires(!IsInfinite && sized_sequence<Base>)
         {
-            return num::mul(flux::size(self.base_),
-                            num::cast<flux::distance_t>(self.data_.count));
+            return num::mul(flux::size(self.base_), num::cast<flux::int_t>(self.data_.count));
         }
     };
 };
@@ -228,7 +226,7 @@ struct cycle_fn {
     constexpr auto operator()(Seq&& seq, num::integral auto count) const
         -> multipass_sequence auto
     {
-        auto c = num::checked_cast<distance_t>(count);
+        auto c = num::checked_cast<int_t>(count);
         if (c < 0) {
             runtime_error("Negative count passed to cycle()");
         }
diff --git a/include/flux/adaptor/drop.hpp b/include/flux/adaptor/drop.hpp
index 52173b34..1e796cef 100644
--- a/include/flux/adaptor/drop.hpp
+++ b/include/flux/adaptor/drop.hpp
@@ -17,10 +17,10 @@ template <sequence Base>
 struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
-    distance_t count_;
+    int_t count_;
 
 public:
-    constexpr drop_adaptor(decays_to<Base> auto&& base, distance_t count)
+    constexpr drop_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
           count_(count)
     {}
@@ -43,8 +43,7 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
         static constexpr auto size(auto& self)
             requires sized_sequence<Base>
         {
-            return (cmp::max)(num::sub(flux::size(self.base()), self.count_),
-                              distance_t{0});
+            return (cmp::max)(num::sub(flux::size(self.base()), self.count_), int_t {0});
         }
 
         static constexpr auto data(auto& self)
@@ -65,7 +64,7 @@ struct drop_fn {
     [[nodiscard]]
     constexpr auto operator()(Seq&& seq, num::integral auto count) const
     {
-        auto count_ = num::checked_cast<distance_t>(count);
+        auto count_ = num::checked_cast<int_t>(count);
         if (count_ < 0) {
             runtime_error("Negative argument passed to drop()");
         }
diff --git a/include/flux/adaptor/reverse.hpp b/include/flux/adaptor/reverse.hpp
index 2296692f..acf312a4 100644
--- a/include/flux/adaptor/reverse.hpp
+++ b/include/flux/adaptor/reverse.hpp
@@ -100,18 +100,18 @@ struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>>
             flux::inc(self.base_, cur.base_cur);
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t dist) -> void
+        static constexpr auto inc(auto& self, cursor_type& cur, int_t dist) -> void
         {
             flux::inc(self.base_, cur.base_cur, num::neg(dist));
         }
 
         static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> distance_t
+            -> int_t
         {
             return flux::distance(self.base_, to.base_cur, from.base_cur);
         }
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<decltype((self.base_))>
         {
             return flux::size(self.base_);
diff --git a/include/flux/adaptor/scan.hpp b/include/flux/adaptor/scan.hpp
index d3ac9fb7..46b81040 100644
--- a/include/flux/adaptor/scan.hpp
+++ b/include/flux/adaptor/scan.hpp
@@ -128,11 +128,11 @@ struct scan_adaptor : inline_sequence_base<scan_adaptor<Base, Func, R, Mode>> {
             return cur;
         }
 
-        static constexpr auto size(self_t& self) -> distance_t
+        static constexpr auto size(self_t& self) -> int_t
             requires sized_sequence<Base>
         {
             if constexpr (Mode == scan_mode::exclusive) {
-                return num::add(flux::size(self.base_), distance_t{1});
+                return num::add(flux::size(self.base_), int_t {1});
             } else {
                 return flux::size(self.base_);
             }
diff --git a/include/flux/adaptor/scan_first.hpp b/include/flux/adaptor/scan_first.hpp
index 1c781e71..6ae8a74a 100644
--- a/include/flux/adaptor/scan_first.hpp
+++ b/include/flux/adaptor/scan_first.hpp
@@ -89,7 +89,7 @@ struct scan_first_adaptor : inline_sequence_base<scan_first_adaptor<Base, Func,
             return cursor_type(flux::last(self.base_));
         }
 
-        static constexpr auto size(self_t& self) -> distance_t
+        static constexpr auto size(self_t& self) -> int_t
             requires sized_sequence<Base>
         {
             return flux::size(self.base_);
diff --git a/include/flux/adaptor/slide.hpp b/include/flux/adaptor/slide.hpp
index 038358c3..25329642 100644
--- a/include/flux/adaptor/slide.hpp
+++ b/include/flux/adaptor/slide.hpp
@@ -17,10 +17,10 @@ template <multipass_sequence Base>
 struct slide_adaptor : inline_sequence_base<slide_adaptor<Base>> {
 private:
     Base base_;
-    distance_t win_sz_;
+    int_t win_sz_;
 
 public:
-    constexpr slide_adaptor(decays_to<Base> auto&& base, distance_t win_sz)
+    constexpr slide_adaptor(decays_to<Base> auto&& base, int_t win_sz)
         : base_(FLUX_FWD(base)),
           win_sz_(win_sz)
     {}
@@ -49,7 +49,7 @@ struct slide_adaptor : inline_sequence_base<slide_adaptor<Base>> {
         static constexpr auto first(auto& self) -> cursor_type {
             auto cur = flux::first(self.base_);
             auto end = cur;
-            advance(self.base_, end, num::sub(self.win_sz_, distance_t{1}));
+            advance(self.base_, end, num::sub(self.win_sz_, int_t {1}));
 
             return cursor_type{.from = std::move(cur), .to = std::move(end)};
         }
@@ -76,7 +76,7 @@ struct slide_adaptor : inline_sequence_base<slide_adaptor<Base>> {
         {
             auto end = flux::last(self.base_);
             auto cur = end;
-            advance(self.base_, cur, num::sub(distance_t{1}, self.win_sz_));
+            advance(self.base_, cur, num::sub(int_t {1}, self.win_sz_));
             return cursor_type{.from = std::move(cur), .to = std::move(end)};
         }
 
@@ -87,7 +87,7 @@ struct slide_adaptor : inline_sequence_base<slide_adaptor<Base>> {
             flux::dec(self.base_, cur.to);
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t offset) -> void
+        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset) -> void
             requires random_access_sequence<Base>
         {
             flux::inc(self.base_, cur.from, offset);
@@ -95,17 +95,17 @@ struct slide_adaptor : inline_sequence_base<slide_adaptor<Base>> {
         }
 
         static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> distance_t
+            -> int_t
             requires random_access_sequence<Base>
         {
             return flux::distance(self.base_, from.from, to.from);
         }
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<Base>
         {
-            auto s = num::add(num::sub(flux::size(self.base_), self.win_sz_), distance_t{1});
-            return (cmp::max)(s, distance_t{0});
+            auto s = num::add(num::sub(flux::size(self.base_), self.win_sz_), int_t {1});
+            return (cmp::max)(s, int_t {0});
         }
     };
 };
@@ -117,8 +117,7 @@ struct slide_fn {
     constexpr auto operator()(Seq&& seq, num::integral auto win_sz) const
         -> sequence auto
     {
-        return slide_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq),
-                                                num::checked_cast<distance_t>(win_sz));
+        return slide_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), num::checked_cast<int_t>(win_sz));
     }
 };
 
diff --git a/include/flux/adaptor/stride.hpp b/include/flux/adaptor/stride.hpp
index c5f623f8..611dad32 100644
--- a/include/flux/adaptor/stride.hpp
+++ b/include/flux/adaptor/stride.hpp
@@ -15,10 +15,10 @@ namespace detail {
 // This is a Flux-ified version of ranges::advance.
 inline constexpr struct advance_fn {
     template <sequence Seq>
-    constexpr auto operator()(Seq& seq, cursor_t<Seq>& cur, distance_t offset) const -> distance_t
+    constexpr auto operator()(Seq& seq, cursor_t<Seq>& cur, int_t offset) const -> int_t
     {
         if (offset > 0) {
-            distance_t counter = 0;
+            int_t counter = 0;
             while (offset-- > 0 && !flux::is_last(seq, cur))  {
                 flux::inc(seq, cur);
                 ++counter;
@@ -44,7 +44,7 @@ inline constexpr struct advance_fn {
 
     template <random_access_sequence Seq>
         requires bounded_sequence<Seq>
-    constexpr auto operator()(Seq& seq, cursor_t<Seq>& cur, distance_t offset) const -> distance_t
+    constexpr auto operator()(Seq& seq, cursor_t<Seq>& cur, int_t offset) const -> int_t
     {
         if (offset > 0) {
             auto dist = (cmp::min)(flux::distance(seq, cur, flux::last(seq)), offset);
@@ -65,10 +65,10 @@ template <typename Base>
 struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
 private:
     Base base_;
-    distance_t stride_;
+    int_t stride_;
 
 public:
-    constexpr stride_adaptor(decays_to<Base> auto&& base, distance_t stride)
+    constexpr stride_adaptor(decays_to<Base> auto&& base, int_t stride)
         : base_(FLUX_FWD(base)),
           stride_(stride)
     {}
@@ -89,7 +89,7 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
         // This version of stride is never bidir
         static void dec(...) = delete;
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<Base>
         {
             auto s = flux::size(self.base_);
@@ -99,7 +99,7 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
         static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_t<Base>
             requires sequence<decltype((self.base_))>
         {
-            distance_t n = self.stride_;
+            int_t n = self.stride_;
             return flux::for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
                 if (++n < s) {
                     return true;
@@ -117,10 +117,10 @@ template <bidirectional_sequence Base>
 struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
 private:
     Base base_;
-    distance_t stride_;
+    int_t stride_;
 
 public:
-    constexpr stride_adaptor(decays_to<Base> auto&& base, distance_t stride)
+    constexpr stride_adaptor(decays_to<Base> auto&& base, int_t stride)
         : base_(FLUX_FWD(base)),
           stride_(stride)
     {}
@@ -129,7 +129,7 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
     private:
         struct cursor_type {
             cursor_t<Base> cur{};
-            distance_t missing = 0;
+            int_t missing = 0;
 
             friend constexpr auto operator==(cursor_type const& lhs, cursor_type const& rhs) -> bool
             {
@@ -193,8 +193,7 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
         static constexpr auto last(auto& self) -> cursor_type
             requires bounded_sequence<Base> && sized_sequence<Base>
         {
-            distance_t missing =
-                (self.stride_ - flux::size(self.base_) % self.stride_) % self.stride_;
+            int_t missing = (self.stride_ - flux::size(self.base_) % self.stride_) % self.stride_;
             return cursor_type{
                 .cur = flux::last(self.base_),
                 .missing = missing
@@ -208,21 +207,21 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
             cur.missing = 0;
         }
 
-        static constexpr auto size(auto& self) -> distance_t
+        static constexpr auto size(auto& self) -> int_t
             requires sized_sequence<Base>
         {
             auto s = flux::size(self.base_);
             return s/self.stride_ + (s % self.stride_ == 0 ? 0 : 1);
         }
 
-        static constexpr auto distance(auto& self, cursor_type const& from,
-                                       cursor_type const& to) -> distance_t
+        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
+            -> int_t
             requires random_access_sequence<Base>
         {
             return (flux::distance(self.base_, from.cur, to.cur) - from.missing + to.missing)/self.stride_;
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t offset) -> void
+        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset) -> void
             requires random_access_sequence<Base>
         {
             if (offset > 0) {
@@ -237,7 +236,7 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
         static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
             requires sequence<decltype((self.base_))>
         {
-            distance_t n = self.stride_;
+            int_t n = self.stride_;
             auto c = flux::for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
                 if (++n < s) {
                     return true;
@@ -257,8 +256,7 @@ struct stride_fn {
     constexpr auto operator()(Seq&& seq, num::integral auto by) const
     {
         FLUX_ASSERT(by > 0);
-        return stride_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq),
-                                                 num::checked_cast<distance_t>(by));
+        return stride_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), num::checked_cast<int_t>(by));
     }
 };
 
diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index 025a1c73..d6c88f43 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -17,10 +17,10 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
 {
 private:
     Base base_;
-    distance_t count_;
+    int_t count_;
 
 public:
-    constexpr take_adaptor(decays_to<Base> auto&& base, distance_t count)
+    constexpr take_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
           count_(count)
     {}
@@ -32,7 +32,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
     private:
         struct cursor_type {
             cursor_t<Base> base_cur;
-            distance_t length;
+            int_t length;
 
             friend bool operator==(cursor_type const&, cursor_type const&) = default;
             friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs) = default;
@@ -55,7 +55,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
         static constexpr auto inc(auto& self, cursor_type& cur)
         {
             flux::inc(self.base_, cur.base_cur);
-            cur.length = num::sub(cur.length, distance_t{1});
+            cur.length = num::sub(cur.length, int_t {1});
         }
 
         static constexpr auto read_at(auto& self, cursor_type const& cur)
@@ -86,10 +86,10 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
             requires bidirectional_sequence<Base>
         {
             flux::dec(self.base_, cur.base_cur);
-            cur.length = num::add(cur.length, distance_t{1});
+            cur.length = num::add(cur.length, int_t {1});
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t offset)
+        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset)
             requires random_access_sequence<Base>
         {
             flux::inc(self.base_, cur.base_cur, offset);
@@ -97,7 +97,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
         }
 
         static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> distance_t
+            -> int_t
             requires random_access_sequence<Base>
         {
             return (cmp::min)(flux::distance(self.base_, from.base_cur, to.base_cur),
@@ -133,7 +133,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
 
         static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
         {
-            distance_t len = self.count_;
+            int_t len = self.count_;
             auto cur = flux::for_each_while(self.base_, [&](auto&& elem) {
                 return (len-- > 0) && std::invoke(pred, FLUX_FWD(elem));
             });
@@ -148,7 +148,7 @@ struct take_fn {
     [[nodiscard]]
     constexpr auto operator()(Seq&& seq, num::integral auto count) const
     {
-        auto count_ = num::checked_cast<distance_t>(count);
+        auto count_ = num::checked_cast<int_t>(count);
         if (count_ < 0) {
             runtime_error("Negative argument passed to take()");
         }
diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index 67c756b1..b45162b9 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -92,8 +92,8 @@ struct zip_traits_base : default_sequence_traits {
     }
 
     template <typename Self>
-        requires (random_access_sequence<const_like_t<Self, Bases>> && ...)
-    static constexpr auto& inc(Self& self, cursor_t<Self>& cur, distance_t offset)
+        requires(random_access_sequence<const_like_t<Self, Bases>> && ...)
+    static constexpr auto& inc(Self& self, cursor_t<Self>& cur, int_t offset)
     {
         [&]<std::size_t... I>(std::index_sequence<I...>) {
             (flux::inc(std::get<I>(self.bases_), std::get<I>(cur), offset), ...);
diff --git a/include/flux/algorithm/count.hpp b/include/flux/algorithm/count.hpp
index 756fd079..9be202bd 100644
--- a/include/flux/algorithm/count.hpp
+++ b/include/flux/algorithm/count.hpp
@@ -15,12 +15,12 @@ namespace detail {
 struct count_fn {
     template <sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> distance_t
+    constexpr auto operator()(Seq&& seq) const -> int_t
     {
         if constexpr (sized_sequence<Seq>) {
             return flux::size(seq);
         } else {
-            distance_t counter = 0;
+            int_t counter = 0;
             flux::for_each_while(seq, [&](auto&&) {
                 ++counter;
                 return true;
@@ -34,10 +34,9 @@ struct count_eq_fn {
     template <sequence Seq, typename Value>
         requires std::equality_comparable_with<element_t<Seq>, Value const&>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Value const& value) const
-        -> distance_t
+    constexpr auto operator()(Seq&& seq, Value const& value) const -> int_t
     {
-        distance_t counter = 0;
+        int_t counter = 0;
         flux::for_each_while(seq, [&](auto&& elem) {
             if (value == FLUX_FWD(elem)) {
                 ++counter;
@@ -52,10 +51,9 @@ struct count_if_fn {
     template <sequence Seq, typename Pred>
         requires std::predicate<Pred&, element_t<Seq>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Pred pred) const
-        -> distance_t
+    constexpr auto operator()(Seq&& seq, Pred pred) const -> int_t
     {
-        distance_t counter = 0;
+        int_t counter = 0;
         flux::for_each_while(seq, [&](auto&& elem) {
             if (std::invoke(pred, FLUX_FWD(elem))) {
                 ++counter;
diff --git a/include/flux/algorithm/detail/heap_ops.hpp b/include/flux/algorithm/detail/heap_ops.hpp
index 43fcd0d4..e97de05a 100644
--- a/include/flux/algorithm/detail/heap_ops.hpp
+++ b/include/flux/algorithm/detail/heap_ops.hpp
@@ -33,7 +33,7 @@
 namespace flux::detail {
 
 template <typename Seq, typename Comp>
-constexpr void sift_up_n(Seq& seq, distance_t n, Comp& comp)
+constexpr void sift_up_n(Seq& seq, int_t n, Comp& comp)
 {
     cursor_t<Seq> first = flux::first(seq);
 
@@ -58,8 +58,7 @@ constexpr void sift_up_n(Seq& seq, distance_t n, Comp& comp)
 }
 
 template <typename Seq, typename Comp>
-constexpr void sift_down_n(Seq& seq, distance_t n, cursor_t<Seq> start,
-                           Comp& comp)
+constexpr void sift_down_n(Seq& seq, int_t n, cursor_t<Seq> start, Comp& comp)
 {
     cursor_t<Seq> first = flux::first(seq);
 
@@ -120,7 +119,7 @@ constexpr void sift_down_n(Seq& seq, distance_t n, cursor_t<Seq> start,
 template <sequence Seq, typename Comp>
 constexpr void make_heap(Seq& seq, Comp& comp)
 {
-    distance_t n = flux::size(seq);
+    int_t n = flux::size(seq);
     auto first = flux::first(seq);
 
     if (n > 1) {
@@ -131,7 +130,7 @@ constexpr void make_heap(Seq& seq, Comp& comp)
 }
 
 template <sequence Seq, typename Comp>
-constexpr void pop_heap(Seq& seq, distance_t n, Comp& comp)
+constexpr void pop_heap(Seq& seq, int_t n, Comp& comp)
 {
     auto first = flux::first(seq);
     if (n > 1) {
diff --git a/include/flux/algorithm/detail/pdqsort.hpp b/include/flux/algorithm/detail/pdqsort.hpp
index 31753f21..b60c9390 100644
--- a/include/flux/algorithm/detail/pdqsort.hpp
+++ b/include/flux/algorithm/detail/pdqsort.hpp
@@ -128,7 +128,7 @@ constexpr bool partial_insertion_sort(Seq& seq, Cur const begin, Cur const end,
         return true;
     }
 
-    distance_t limit = 0;
+    int_t limit = 0;
 
     for (auto cur = next(seq, begin); cur != end; inc(seq, cur)) {
         if (limit > pqdsort_partial_insertion_sort_limit) {
@@ -322,9 +322,8 @@ partition_right_branchless(Seq& seq, Cur const begin, Cur const end, Comp& comp)
             inc(seq, last, -pdqsort_block_size);
     }
 
-    distance_t l_size = 0, r_size = 0;
-    distance_t unknown_left =
-        distance(seq, first, last) - ((num_r || num_l) ? pdqsort_block_size : 0);
+    int_t l_size = 0, r_size = 0;
+    int_t unknown_left = distance(seq, first, last) - ((num_r || num_l) ? pdqsort_block_size : 0);
     if (num_r) {
         // Handle leftover block by assigning the unknown elements to the other
         // block.
@@ -343,7 +342,7 @@ partition_right_branchless(Seq& seq, Cur const begin, Cur const end, Comp& comp)
     if (unknown_left && !num_l) {
         start_l = 0;
         Cur cur = first;
-        for (unsigned char i = 0; static_cast<distance_t>(i) < l_size;) {
+        for (unsigned char i = 0; static_cast<int_t>(i) < l_size;) {
             offsets_l[num_l] = i++;
             num_l += !comp(read_at(seq, cur), pivot);
             inc(seq, cur);
@@ -352,7 +351,7 @@ partition_right_branchless(Seq& seq, Cur const begin, Cur const end, Comp& comp)
     if (unknown_left && !num_r) {
         start_r = 0;
         Cur cur = last;
-        for (unsigned char i = 0; static_cast<distance_t>(i) < r_size;) {
+        for (unsigned char i = 0; static_cast<int_t>(i) < r_size;) {
             offsets_r[num_r] = ++i;
             num_r += comp(read_at(seq, dec(seq, cur)), pivot);
         }
@@ -496,7 +495,7 @@ template <bool Branchless, typename Seq, typename Comp,
 constexpr void pdqsort_loop(Seq& seq, Cur begin, Cur end, Comp& comp,
                             int bad_allowed, bool leftmost = true)
 {
-    using diff_t = distance_t;
+    using diff_t = int_t;
 
     // Use a while loop for tail recursion elimination.
     while (true) {
diff --git a/include/flux/algorithm/ends_with.hpp b/include/flux/algorithm/ends_with.hpp
index bc6aca4e..b3c87690 100644
--- a/include/flux/algorithm/ends_with.hpp
+++ b/include/flux/algorithm/ends_with.hpp
@@ -66,8 +66,8 @@ struct ends_with_fn {
                      bounded_sequence<Needle>) {
             return bidir_impl(haystack, needle, cmp);
         } else {
-            distance_t len1 = flux::count(haystack);
-            distance_t len2 = flux::count(needle);
+            int_t len1 = flux::count(haystack);
+            int_t len2 = flux::count(needle);
 
             if (len1 < len2) {
                 return false;
diff --git a/include/flux/core/concepts.hpp b/include/flux/core/concepts.hpp
index 21201932..b04f2124 100644
--- a/include/flux/core/concepts.hpp
+++ b/include/flux/core/concepts.hpp
@@ -91,7 +91,7 @@ template <typename Seq>
 using value_t = typename detail::value_type<Seq>::type;
 
 FLUX_EXPORT
-using distance_t = flux::config::int_type;
+using int_t = flux::config::int_type;
 
 FLUX_EXPORT
 using index_t = flux::config::int_type;
@@ -198,11 +198,11 @@ namespace detail {
 template <typename Seq, typename Traits = sequence_traits<std::remove_cvref_t<Seq>>>
 concept random_access_sequence_requirements =
     ordered_cursor<cursor_t<Seq>> &&
-    requires (Seq& seq, cursor_t<Seq>& cur, distance_t offset) {
+    requires (Seq& seq, cursor_t<Seq>& cur, int_t offset) {
         { Traits::inc(seq, cur, offset) };
     } &&
     requires (Seq& seq, cursor_t<Seq> const& cur) {
-        { Traits::distance(seq, cur, cur) } -> std::convertible_to<distance_t>;
+        { Traits::distance(seq, cur, cur) } -> std::convertible_to<int_t>;
     };
 
 } // namespace detail
@@ -251,7 +251,7 @@ namespace detail {
 template <typename Seq, typename Traits = sequence_traits<std::remove_cvref_t<Seq>>>
 concept sized_sequence_requirements =
     requires (Seq& seq) {
-        { Traits::size(seq) } -> std::convertible_to<distance_t>;
+        { Traits::size(seq) } -> std::convertible_to<int_t>;
     };
 
 } // namespace detail
@@ -403,7 +403,7 @@ struct default_sequence_traits {
     template <typename Self>
         requires detail::random_access_sequence_requirements<Self> &&
                  detail::bounded_sequence_requirements<Self>
-    static constexpr auto size(Self& self) -> distance_t
+    static constexpr auto size(Self& self) -> int_t
     {
         using Traits = detail::traits_t<Self>;
         return Traits::distance(self, Traits::first(self), Traits::last(self));
diff --git a/include/flux/core/default_impls.hpp b/include/flux/core/default_impls.hpp
index de2ef191..2c7bc1b4 100644
--- a/include/flux/core/default_impls.hpp
+++ b/include/flux/core/default_impls.hpp
@@ -38,7 +38,7 @@ struct sequence_traits<T[N]> : default_sequence_traits {
     static constexpr auto inc(auto const&, index_t& idx)
     {
         FLUX_DEBUG_ASSERT(idx < N);
-        idx = num::add(idx, distance_t{1});
+        idx = num::add(idx, int_t {1});
     }
 
     static constexpr auto last(auto const&) -> index_t { return N; }
@@ -46,24 +46,24 @@ struct sequence_traits<T[N]> : default_sequence_traits {
     static constexpr auto dec(auto const&, index_t& idx)
     {
         FLUX_DEBUG_ASSERT(idx > 0);
-        idx = num::sub(idx, distance_t{1});
+        idx = num::sub(idx, int_t {1});
     }
 
-    static constexpr auto inc(auto const&, index_t& idx, distance_t offset)
+    static constexpr auto inc(auto const&, index_t& idx, int_t offset)
     {
         FLUX_DEBUG_ASSERT(num::add(idx, offset) <= N);
         FLUX_DEBUG_ASSERT(num::add(idx, offset) >= 0);
         idx = num::add(idx, offset);
     }
 
-    static constexpr auto distance(auto const&, index_t from, index_t to) -> distance_t
+    static constexpr auto distance(auto const&, index_t from, index_t to) -> int_t
     {
         return num::sub(to, from);
     }
 
     static constexpr auto data(auto& self) -> auto* { return self; }
 
-    static constexpr auto size(auto const&) -> distance_t { return N; }
+    static constexpr auto size(auto const&) -> int_t { return N; }
 
     static constexpr auto for_each_while(auto& self, auto&& pred) -> index_t
     {
@@ -125,16 +125,14 @@ struct sequence_traits<std::reference_wrapper<Seq>> : default_sequence_traits {
         return flux::dec(self.get(), cur);
     }
 
-    static constexpr auto inc(self_t self, cursor_t<Seq>& cur, distance_t offset)
-        -> cursor_t<Seq>&
+    static constexpr auto inc(self_t self, cursor_t<Seq>& cur, int_t offset) -> cursor_t<Seq>&
         requires random_access_sequence<Seq>
     {
         return flux::inc(self.get(), cur,  offset);
     }
 
-    static constexpr auto distance(self_t self, cursor_t<Seq> const& from,
-                                   cursor_t<Seq> const& to)
-        -> distance_t
+    static constexpr auto distance(self_t self, cursor_t<Seq> const& from, cursor_t<Seq> const& to)
+        -> int_t
         requires random_access_sequence<Seq>
     {
         return flux::distance(self.get(), from, to);
@@ -152,7 +150,7 @@ struct sequence_traits<std::reference_wrapper<Seq>> : default_sequence_traits {
         return flux::last(self.get());
     }
 
-    static constexpr auto size(self_t self) -> distance_t
+    static constexpr auto size(self_t self) -> int_t
         requires sized_sequence<Seq>
     {
         return flux::size(self.get());
@@ -186,7 +184,7 @@ struct sequence_traits<R> : default_sequence_traits {
     static constexpr auto inc(auto& self, index_t& idx)
     {
         FLUX_DEBUG_ASSERT(idx < size(self));
-        idx = num::add(idx, distance_t{1});
+        idx = num::add(idx, int_t {1});
     }
 
     static constexpr auto read_at(auto& self, index_t idx) -> decltype(auto)
@@ -203,26 +201,26 @@ struct sequence_traits<R> : default_sequence_traits {
     static constexpr auto dec(auto&, index_t& idx)
     {
         FLUX_DEBUG_ASSERT(idx > 0);
-        idx = num::sub(idx, distance_t{1});
+        idx = num::sub(idx, int_t {1});
     }
 
     static constexpr auto last(auto& self) -> index_t { return size(self); }
 
-    static constexpr auto inc(auto& self, index_t& idx, distance_t offset)
+    static constexpr auto inc(auto& self, index_t& idx, int_t offset)
     {
         FLUX_DEBUG_ASSERT(num::add(idx, offset) <= size(self));
         FLUX_DEBUG_ASSERT(num::add(idx, offset) >= 0);
         idx = num::add(idx, offset);
     }
 
-    static constexpr auto distance(auto&, index_t from, index_t to) -> distance_t
+    static constexpr auto distance(auto&, index_t from, index_t to) -> int_t
     {
         return num::sub(to, from);
     }
 
-    static constexpr auto size(auto& self) -> distance_t
+    static constexpr auto size(auto& self) -> int_t
     {
-        return num::cast<distance_t>(std::ranges::ssize(self));
+        return num::cast<int_t>(std::ranges::ssize(self));
     }
 
     static constexpr auto data(auto& self) -> auto*
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index 735287d7..3cbbeb5a 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -82,7 +82,10 @@ struct inline_sequence_base {
     /// Increments the given cursor by `offset` places
     template <std::same_as<Derived> D = Derived>
         requires random_access_sequence<Derived>
-    constexpr auto& inc(cursor_t<D>& cur, distance_t offset) { return flux::inc(derived(), cur, offset); }
+    constexpr auto& inc(cursor_t<D>& cur, int_t offset)
+    {
+        return flux::inc(derived(), cur, offset);
+    }
 
     /// Returns the number of times `from` must be incremented to reach `to`
     ///
@@ -221,9 +224,10 @@ struct inline_sequence_base {
      * Adaptors
      */
 
-    template <distance_t N>
+    template <int_t N>
     [[nodiscard]]
-    constexpr auto adjacent() && requires multipass_sequence<Derived>;
+    constexpr auto adjacent() &&
+        requires multipass_sequence<Derived>;
 
     template <typename Pred>
         requires multipass_sequence<Derived> &&
@@ -231,7 +235,7 @@ struct inline_sequence_base {
     [[nodiscard]]
     constexpr auto adjacent_filter(Pred pred) &&;
 
-    template <distance_t N, typename Func>
+    template <int_t N, typename Func>
         requires multipass_sequence<Derived>
     [[nodiscard]]
     constexpr auto adjacent_map(Func func) &&;
diff --git a/include/flux/core/operation_requirements.hpp b/include/flux/core/operation_requirements.hpp
index a80d9b21..f5f4c9b3 100644
--- a/include/flux/core/operation_requirements.hpp
+++ b/include/flux/core/operation_requirements.hpp
@@ -23,7 +23,7 @@ concept foldable_ =
     std::convertible_to<Init, R> &&
     std::assignable_from<R&, std::invoke_result_t<Func&, R, element_t<Seq>>>;
 
-template <typename Func, typename E, distance_t N>
+template <typename Func, typename E, int_t N>
 struct repeated_invocable_helper {
     template <std::size_t I>
     using repeater = E;
@@ -33,7 +33,7 @@ struct repeated_invocable_helper {
     }(std::make_index_sequence<N>{});
 };
 
-template <typename Func, typename E, distance_t N>
+template <typename Func, typename E, int_t N>
 concept repeated_invocable = repeated_invocable_helper<Func, E, N>::value;
 
 template <typename InnerSeq, typename Pattern>
diff --git a/include/flux/core/ref.hpp b/include/flux/core/ref.hpp
index 81ed1449..39c5ff2d 100644
--- a/include/flux/core/ref.hpp
+++ b/include/flux/core/ref.hpp
@@ -51,7 +51,7 @@ struct passthrough_traits_base : default_sequence_traits {
     }
 
     template <typename Self>
-    static constexpr auto inc(Self& self, auto& cur, distance_t dist)
+    static constexpr auto inc(Self& self, auto& cur, int_t dist)
         -> decltype(flux::inc(self.base(), cur, dist))
     {
         return flux::inc(self.base(), cur, dist);
diff --git a/include/flux/core/sequence_access.hpp b/include/flux/core/sequence_access.hpp
index 86bbc3b8..0e3a0d66 100644
--- a/include/flux/core/sequence_access.hpp
+++ b/include/flux/core/sequence_access.hpp
@@ -54,7 +54,7 @@ struct inc_fn {
     }
 
     template <random_access_sequence Seq>
-    constexpr auto operator()(Seq& seq, cursor_t<Seq>& cur, distance_t offset) const
+    constexpr auto operator()(Seq& seq, cursor_t<Seq>& cur, int_t offset) const
         noexcept(noexcept(traits_t<Seq>::inc(seq, cur, offset))) -> cursor_t<Seq>&
     {
         (void) traits_t<Seq>::inc(seq, cur, offset);
@@ -75,14 +75,13 @@ struct dec_fn {
 struct distance_fn {
     template <multipass_sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq& seq, cursor_t<Seq> const& from,
-                                            cursor_t<Seq> const& to) const
-        -> distance_t
+    constexpr auto operator()(Seq& seq, cursor_t<Seq> const& from, cursor_t<Seq> const& to) const
+        -> int_t
     {
         if constexpr (random_access_sequence<Seq>) {
             return traits_t<Seq>::distance(seq, from, to);
         } else {
-            distance_t n = 0;
+            int_t n = 0;
             auto from_ = from;
             while (from_ != to) {
                 inc_fn{}(seq, from_);
@@ -116,7 +115,7 @@ struct last_fn {
 struct size_fn {
     template <sized_sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> distance_t
+    constexpr auto operator()(Seq&& seq) const -> int_t
     {
         return traits_t<Seq>::size(seq);
     }
@@ -202,13 +201,12 @@ struct next_fn {
 
     template <sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq& seq, cursor_t<Seq> cur, distance_t offset) const
-        -> cursor_t<Seq>
+    constexpr auto operator()(Seq& seq, cursor_t<Seq> cur, int_t offset) const -> cursor_t<Seq>
     {
         if constexpr (random_access_sequence<Seq>) {
             return inc(seq, cur, offset);
         } else if constexpr (bidirectional_sequence<Seq>) {
-            auto const zero = distance_t{0};
+            auto const zero = int_t {0};
             if (offset > zero) {
                 while (offset-- > zero) {
                     inc(seq, cur);
@@ -220,7 +218,7 @@ struct next_fn {
             }
             return cur;
         } else {
-            while (offset-- > distance_t{0}) {
+            while (offset-- > int_t {0}) {
                 inc(seq, cur);
             }
             return cur;
diff --git a/include/flux/core/sequence_iterator.hpp b/include/flux/core/sequence_iterator.hpp
index 845b6b13..6b5dec04 100644
--- a/include/flux/core/sequence_iterator.hpp
+++ b/include/flux/core/sequence_iterator.hpp
@@ -39,7 +39,7 @@ struct sequence_iterator {
 
 public:
     using value_type = value_t<S>;
-    using difference_type = distance_t;
+    using difference_type = int_t;
     using element_type = value_t<S>; // Yes, really
     using iterator_concept = decltype(get_iterator_tag<S>());
 
diff --git a/include/flux/sequence/array_ptr.hpp b/include/flux/sequence/array_ptr.hpp
index 6ccc75e5..dbcd3de4 100644
--- a/include/flux/sequence/array_ptr.hpp
+++ b/include/flux/sequence/array_ptr.hpp
@@ -25,14 +25,11 @@ template <typename T>
 struct array_ptr : inline_sequence_base<array_ptr<T>> {
 private:
     T* data_ = nullptr;
-    distance_t sz_ = 0;
+    int_t sz_ = 0;
 
     friend struct detail::make_array_ptr_unchecked_fn;
 
-    constexpr array_ptr(T* ptr, distance_t sz) noexcept
-        : data_(ptr),
-          sz_(sz)
-    {}
+    constexpr array_ptr(T* ptr, int_t sz) noexcept : data_(ptr), sz_(sz) { }
 
 public:
     array_ptr() = default;
@@ -88,7 +85,7 @@ struct array_ptr : inline_sequence_base<array_ptr<T>> {
         static constexpr auto inc(array_ptr const& self, index_t& idx) -> void
         {
             FLUX_DEBUG_ASSERT(idx < self.sz_);
-            idx = num::add(idx, distance_t{1});
+            idx = num::add(idx, int_t {1});
         }
 
         static constexpr auto read_at(array_ptr const& self, index_t idx) -> T&
@@ -110,8 +107,7 @@ struct array_ptr : inline_sequence_base<array_ptr<T>> {
 
         static constexpr auto last(array_ptr const& self) -> index_t { return self.sz_; }
 
-        static constexpr auto inc(array_ptr const& self, index_t& idx, distance_t offset)
-            -> void
+        static constexpr auto inc(array_ptr const& self, index_t& idx, int_t offset) -> void
         {
             index_t nxt = num::add(idx, offset);
             FLUX_DEBUG_ASSERT(nxt >= 0);
@@ -119,16 +115,12 @@ struct array_ptr : inline_sequence_base<array_ptr<T>> {
             idx = nxt;
         }
 
-        static constexpr auto distance(array_ptr const&, index_t from, index_t to)
-            -> distance_t
+        static constexpr auto distance(array_ptr const&, index_t from, index_t to) -> int_t
         {
             return num::sub(to, from);
         }
 
-        static constexpr auto size(array_ptr const& self) -> distance_t
-        {
-            return self.sz_;
-        }
+        static constexpr auto size(array_ptr const& self) -> int_t { return self.sz_; }
 
         static constexpr auto data(array_ptr const& self) -> T* { return self.data_; }
 
@@ -158,7 +150,7 @@ struct make_array_ptr_unchecked_fn {
         requires (std::is_object_v<T> && !std::is_abstract_v<T>)
     constexpr auto operator()(T* ptr, num::integral auto size) const -> array_ptr<T>
     {
-        return array_ptr<T>(ptr, num::checked_cast<distance_t>(size));
+        return array_ptr<T>(ptr, num::checked_cast<int_t>(size));
     }
 };
 
diff --git a/include/flux/sequence/empty.hpp b/include/flux/sequence/empty.hpp
index a32b5654..4ca1f527 100644
--- a/include/flux/sequence/empty.hpp
+++ b/include/flux/sequence/empty.hpp
@@ -26,8 +26,7 @@ struct empty_sequence : inline_sequence_base<empty_sequence<T>> {
         static constexpr auto last(empty_sequence) -> cursor_type { return {}; }
         static constexpr auto is_last(empty_sequence, cursor_type) -> bool { return true; }
 
-        static constexpr auto inc(empty_sequence, cursor_type& cur, distance_t = 0)
-            -> cursor_type&
+        static constexpr auto inc(empty_sequence, cursor_type& cur, int_t = 0) -> cursor_type&
         {
             return cur;
         }
diff --git a/include/flux/sequence/iota.hpp b/include/flux/sequence/iota.hpp
index 774e281b..97792c93 100644
--- a/include/flux/sequence/iota.hpp
+++ b/include/flux/sequence/iota.hpp
@@ -40,7 +40,7 @@ concept advancable =
         T(u + o);
         T(o + u);
         T(u - o);
-        { u - u } -> std::convertible_to<distance_t>;
+        { u - u } -> std::convertible_to<int_t>;
     };
 
 struct iota_traits {
@@ -94,8 +94,7 @@ struct iota_sequence_traits : default_sequence_traits {
         return --cur;
     }
 
-    static constexpr auto inc(auto&, cursor_type& cur, distance_t offset)
-        -> cursor_type&
+    static constexpr auto inc(auto&, cursor_type& cur, int_t offset) -> cursor_type&
         requires advancable<T>
     {
         return cur += num::cast<std::iter_difference_t<T>>(offset);
@@ -104,13 +103,13 @@ struct iota_sequence_traits : default_sequence_traits {
     static constexpr auto distance(auto&, cursor_type const& from, cursor_type const& to)
         requires advancable<T>
     {
-        return from <= to ? num::cast<distance_t>(to - from) : -num::cast<distance_t>(from - to);
+        return from <= to ? num::cast<int_t>(to - from) : -num::cast<int_t>(from - to);
     }
 
-    static constexpr auto size(auto& self) -> distance_t
+    static constexpr auto size(auto& self) -> int_t
         requires advancable<T> && (Traits.has_start && Traits.has_end)
     {
-        return num::cast<distance_t>(self.end_ - self.start_);
+        return num::cast<int_t>(self.end_ - self.start_);
     }
 };
 
@@ -168,19 +167,13 @@ struct iota_fn {
 };
 
 struct ints_fn {
-    inline constexpr auto operator()() const
-    {
-        return basic_iota_sequence<distance_t>();
-    }
+    inline constexpr auto operator()() const { return basic_iota_sequence<int_t>(); }
 
-    inline constexpr auto operator()(distance_t from) const
-    {
-        return iota_sequence<distance_t>(from);
-    }
+    inline constexpr auto operator()(int_t from) const { return iota_sequence<int_t>(from); }
 
-    inline constexpr auto operator()(distance_t from, distance_t to) const
+    inline constexpr auto operator()(int_t from, int_t to) const
     {
-        return bounded_iota_sequence<distance_t>(from, to);
+        return bounded_iota_sequence<int_t>(from, to);
     }
 };
 
diff --git a/include/flux/sequence/range.hpp b/include/flux/sequence/range.hpp
index 7623ba83..a3d4d699 100644
--- a/include/flux/sequence/range.hpp
+++ b/include/flux/sequence/range.hpp
@@ -112,8 +112,8 @@ struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
         }
 
         template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto inc(Self& self, cursor_type& cur, distance_t offset)
+            requires(!std::is_const_v<Self> || can_const_iterate<V>)
+        static constexpr auto inc(Self& self, cursor_type& cur, int_t offset)
             requires std::ranges::random_access_range<R>
         {
             if (offset < 0) {
@@ -126,12 +126,12 @@ struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
         }
 
         template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
+            requires(!std::is_const_v<Self> || can_const_iterate<V>)
         static constexpr auto distance(Self&, cursor_type const& from, cursor_type const& to)
-            -> distance_t
+            -> int_t
             requires std::ranges::random_access_range<R>
         {
-            return num::cast<distance_t>(std::ranges::distance(from.iter, to.iter));
+            return num::cast<int_t>(std::ranges::distance(from.iter, to.iter));
         }
 
         template <typename Self>
@@ -155,11 +155,11 @@ struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
         }
 
         template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto size(Self& self) -> distance_t
+            requires(!std::is_const_v<Self> || can_const_iterate<V>)
+        static constexpr auto size(Self& self) -> int_t
             requires std::ranges::sized_range<R>
         {
-            return num::cast<distance_t>(std::ranges::ssize(self.rng_));
+            return num::cast<int_t>(std::ranges::ssize(self.rng_));
         }
 
         template <typename Self>
diff --git a/include/flux/sequence/repeat.hpp b/include/flux/sequence/repeat.hpp
index ebe4b464..5d7e937b 100644
--- a/include/flux/sequence/repeat.hpp
+++ b/include/flux/sequence/repeat.hpp
@@ -70,14 +70,14 @@ struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
             --cur;
         }
 
-        static constexpr auto inc(self_t const&, std::size_t& cur, distance_t offset) -> void
+        static constexpr auto inc(self_t const&, std::size_t& cur, int_t offset) -> void
         {
             cur += static_cast<std::size_t>(offset);
         }
 
-        static constexpr auto distance(self_t const&, std::size_t from, std::size_t to) -> distance_t
+        static constexpr auto distance(self_t const&, std::size_t from, std::size_t to) -> int_t
         {
-            return num::cast<distance_t>(to) - num::cast<distance_t>(from);
+            return num::cast<int_t>(to) - num::cast<int_t>(from);
         }
 
         static constexpr auto for_each_while(self_t const& self, auto&& pred) -> std::size_t
@@ -107,10 +107,10 @@ struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
             return self.data_.count;
         }
 
-        static constexpr auto size(self_t const& self) -> distance_t
-            requires (!IsInfinite)
+        static constexpr auto size(self_t const& self) -> int_t
+            requires(!IsInfinite)
         {
-            return num::cast<distance_t>(self.data_.count);
+            return num::cast<int_t>(self.data_.count);
         }
     };
 };
@@ -127,7 +127,7 @@ struct repeat_fn {
         requires std::movable<std::decay_t<T>>
     constexpr auto operator()(T&& obj, num::integral auto count) const
     {
-        auto c = num::checked_cast<distance_t>(count);
+        auto c = num::checked_cast<int_t>(count);
         if (c < 0) {
             runtime_error("Negative count passed to repeat()");
         }
diff --git a/include/flux/sequence/single.hpp b/include/flux/sequence/single.hpp
index 273e8169..00009215 100644
--- a/include/flux/sequence/single.hpp
+++ b/include/flux/sequence/single.hpp
@@ -93,8 +93,7 @@ struct sequence_traits<detail::single_sequence<T>> : default_sequence_traits
         return cur;
     }
 
-    static constexpr auto inc(self_t const&, cursor_type& cur, distance_t off)
-        -> cursor_type&
+    static constexpr auto inc(self_t const&, cursor_type& cur, int_t off) -> cursor_type&
     {
         if (off > 0) {
             FLUX_DEBUG_ASSERT(cur == cursor_type::valid && off == 1);
diff --git a/test/test_apply.cpp b/test/test_apply.cpp
index f72bfe5c..f06ae9b3 100644
--- a/test/test_apply.cpp
+++ b/test/test_apply.cpp
@@ -5,9 +5,7 @@
 #include "test_utils.hpp"
 
 // We don't have an in-place rotate yet, so let's borrow the STL's
-auto rotate_by = []<flux::random_access_sequence Seq>(Seq&& seq, flux::distance_t places)
-    -> Seq&&
-{
+auto rotate_by = []<flux::random_access_sequence Seq>(Seq&& seq, flux::int_t places) -> Seq&& {
     auto const sz = flux::size(seq);
 
     while (places < 0) {
@@ -22,7 +20,6 @@ auto rotate_by = []<flux::random_access_sequence Seq>(Seq&& seq, flux::distance_
     return FLUX_FWD(seq);
 };
 
-
 constexpr bool test_apply()
 {
     // Checking lvalue sequence
diff --git a/test/test_cartesian_product.cpp b/test/test_cartesian_product.cpp
index 284c2beb..81751ace 100644
--- a/test/test_cartesian_product.cpp
+++ b/test/test_cartesian_product.cpp
@@ -356,13 +356,19 @@ constexpr bool test_cartesian_product()
         static_assert(flux::bounded_sequence<C const>);
         static_assert(flux::sized_sequence<C const>);
 
-        static_assert(std::same_as<flux::element_t<C>, std::tuple<flux::distance_t, flux::distance_t, flux::distance_t>>);
-        static_assert(std::same_as<flux::value_t<C>, std::tuple<flux::distance_t, flux::distance_t, flux::distance_t>>);
-        static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<flux::distance_t, flux::distance_t, flux::distance_t>>);
-
-        static_assert(std::same_as<flux::element_t<C const>, std::tuple<flux::distance_t, flux::distance_t, flux::distance_t>>);
-        static_assert(std::same_as<flux::value_t<C const>, std::tuple<flux::distance_t, flux::distance_t, flux::distance_t>>);
-        static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<flux::distance_t, flux::distance_t, flux::distance_t>>);
+        static_assert(
+            std::same_as<flux::element_t<C>, std::tuple<flux::int_t, flux::int_t, flux::int_t>>);
+        static_assert(
+            std::same_as<flux::value_t<C>, std::tuple<flux::int_t, flux::int_t, flux::int_t>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C>,
+                                   std::tuple<flux::int_t, flux::int_t, flux::int_t>>);
+
+        static_assert(std::same_as<flux::element_t<C const>,
+                                   std::tuple<flux::int_t, flux::int_t, flux::int_t>>);
+        static_assert(std::same_as<flux::value_t<C const>,
+                                   std::tuple<flux::int_t, flux::int_t, flux::int_t>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C const>,
+                                   std::tuple<flux::int_t, flux::int_t, flux::int_t>>);
 
         STATIC_CHECK(flux::size(cart) == 4 * 2 * 3);
 
@@ -421,14 +427,14 @@ constexpr bool test_cartesian_product()
             STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -5) == std::tuple{1, 0, 0});
         }
 
-        flux::distance_t sum_i = 0;
-        flux::distance_t sum_j = 0;
-        flux::distance_t sum_k = 0;
-        cart.for_each(flux::unpack([&] (flux::distance_t i, flux::distance_t j, flux::distance_t k) {
-                sum_i += i;
-                sum_j += j;
-                sum_k += k;
-            }));
+        flux::int_t sum_i = 0;
+        flux::int_t sum_j = 0;
+        flux::int_t sum_k = 0;
+        cart.for_each(flux::unpack([&](flux::int_t i, flux::int_t j, flux::int_t k) {
+            sum_i += i;
+            sum_j += j;
+            sum_k += k;
+        }));
         constexpr auto triangular_number = [] (auto n) { return (n * (n + 1)) / 2; };
         STATIC_CHECK(sum_i == triangular_number(4 - 1) * 2 * 3);
         STATIC_CHECK(sum_j == 4 * triangular_number(2 - 1) * 3);
@@ -501,7 +507,7 @@ static_assert(test_cartesian_product());
 void issue_167()
 {
     // Check that overflowing size() is correctly caught
-    auto ints = flux::ints(0, std::numeric_limits<flux::distance_t>::max());
+    auto ints = flux::ints(0, std::numeric_limits<flux::int_t>::max());
 
     auto prod = flux::cartesian_product(ints, ints, ints);
 
diff --git a/test/test_cartesian_product_map.cpp b/test/test_cartesian_product_map.cpp
index 07e3dc76..20cceb5c 100644
--- a/test/test_cartesian_product_map.cpp
+++ b/test/test_cartesian_product_map.cpp
@@ -133,7 +133,7 @@ static_assert(test_cartesian_product_map());
 void issue_167()
 {
     // Check that overflowing size() is correctly caught
-    auto ints = flux::ints(0, std::numeric_limits<flux::distance_t>::max());
+    auto ints = flux::ints(0, std::numeric_limits<flux::int_t>::max());
 
     auto prod = flux::cartesian_product_map([](auto...) { return 0; }, ints, ints, ints);
 
diff --git a/test/test_chunk.cpp b/test/test_chunk.cpp
index 005c5f6f..1c840677 100644
--- a/test/test_chunk.cpp
+++ b/test/test_chunk.cpp
@@ -243,7 +243,7 @@ constexpr bool test_chunk_multipass()
     {
         std::array arr{1, 2, 3, 4, 5};
 
-        constexpr auto max = std::numeric_limits<flux::distance_t>::max();
+        constexpr auto max = std::numeric_limits<flux::int_t>::max();
 
         auto seq = NotBidir(arr).chunk(max);
 
@@ -372,7 +372,7 @@ constexpr bool test_chunk_bidir()
     {
         std::array arr{1, 2, 3, 4, 5};
 
-        constexpr auto max = std::numeric_limits<flux::distance_t>::max();
+        constexpr auto max = std::numeric_limits<flux::int_t>::max();
 
         auto seq = flux::chunk(arr,max);
 
diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 6d41d245..41f16c2f 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -187,7 +187,7 @@ constexpr bool test_cycle() {
 
         // Go a long way back from the start
         cur = seq.first();
-        seq.inc(cur, std::numeric_limits<flux::distance_t>::lowest());
+        seq.inc(cur, std::numeric_limits<flux::int_t>::lowest());
         (void) seq[cur];
     }
 
@@ -331,7 +331,7 @@ TEST_CASE("cycle")
 
     SUBCASE("over-large sizes are caught")
     {
-        constexpr auto max_dist = std::numeric_limits<flux::distance_t>::max();
+        constexpr auto max_dist = std::numeric_limits<flux::int_t>::max();
 
         auto seq = flux::ints(0, max_dist).cycle(max_dist);
 
diff --git a/test/test_range_iface.cpp b/test/test_range_iface.cpp
index ed170e03..78e30f31 100644
--- a/test/test_range_iface.cpp
+++ b/test/test_range_iface.cpp
@@ -27,20 +27,20 @@ constexpr bool test_range_iface()
         static_assert(rng::common_range<R>);
 
         static_assert(std::same_as<rng::range_reference_t<R>, int&>);
-        static_assert(std::same_as<rng::range_difference_t<R>, flux::distance_t>);
+        static_assert(std::same_as<rng::range_difference_t<R>, flux::int_t>);
         static_assert(std::same_as<rng::range_value_t<R>, int>);
         static_assert(std::same_as<rng::range_rvalue_reference_t<R>, int&&>);
-        static_assert(std::same_as<rng::range_size_t<R>, flux::distance_t>);
+        static_assert(std::same_as<rng::range_size_t<R>, flux::int_t>);
 
         static_assert(rng::random_access_range<R const>);
         static_assert(rng::sized_range<R const>);
         static_assert(rng::common_range<R const>);
 
         static_assert(std::same_as<rng::range_reference_t<R const>, int const&>);
-        static_assert(std::same_as<rng::range_difference_t<R const>, flux::distance_t>);
+        static_assert(std::same_as<rng::range_difference_t<R const>, flux::int_t>);
         static_assert(std::same_as<rng::range_value_t<R const>, int>);
         static_assert(std::same_as<rng::range_rvalue_reference_t<R const>, int const&&>);
-        static_assert(std::same_as<rng::range_size_t<R const>, flux::distance_t>);
+        static_assert(std::same_as<rng::range_size_t<R const>, flux::int_t>);
 
         STATIC_CHECK(std::ranges::equal(seq, std::array{1, 2, 3, 4, 5}));
 
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index e2528fa5..a87070b8 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -114,8 +114,8 @@ constexpr bool test_repeat()
     {
         auto seq = flux::repeat(1.0);
 
-        constexpr auto max_idx = std::numeric_limits<flux::distance_t>::max();
-        constexpr auto min_idx = std::numeric_limits<flux::distance_t>::lowest();
+        constexpr auto max_idx = std::numeric_limits<flux::int_t>::max();
+        constexpr auto min_idx = std::numeric_limits<flux::int_t>::lowest();
 
         auto cur = flux::next(seq, seq.first(), max_idx);
 
diff --git a/test/test_sort.cpp b/test/test_sort.cpp
index b2ae5512..0e8d70d3 100644
--- a/test/test_sort.cpp
+++ b/test/test_sort.cpp
@@ -26,16 +26,17 @@ struct span_seq {
         static constexpr T& read_at(span_seq const& self, std::size_t i) { return self.ptr_[i]; }
         static constexpr std::size_t last(span_seq const& self) { return self.sz_; }
         static constexpr std::size_t& dec(span_seq const&, std::size_t& i) { return --i; }
-        static constexpr std::size_t& inc(span_seq const&, std::size_t& i, flux::distance_t o)
+        static constexpr std::size_t& inc(span_seq const&, std::size_t& i, flux::int_t o)
         {
             return i += static_cast<std::size_t>(o);
         }
-        static constexpr flux::distance_t distance(span_seq const&, std::size_t from, std::size_t to)
+        static constexpr flux::int_t distance(span_seq const&, std::size_t from, std::size_t to)
         {
-            return static_cast<flux::distance_t>(to) - static_cast<flux::distance_t>(from);
+            return static_cast<flux::int_t>(to) - static_cast<flux::int_t>(from);
         }
-        static constexpr flux::distance_t size(span_seq const& self) {
-            return static_cast<flux::distance_t>(self.sz_);
+        static constexpr flux::int_t size(span_seq const& self)
+        {
+            return static_cast<flux::int_t>(self.sz_);
         }
         static constexpr T* data(span_seq const& self) { return self.ptr_; }
     };
diff --git a/test/test_stride.cpp b/test/test_stride.cpp
index 851b90ac..1cdb3b46 100644
--- a/test/test_stride.cpp
+++ b/test/test_stride.cpp
@@ -116,7 +116,7 @@ constexpr bool test_stride_non_bidir()
     // Stride of distance_t::max doesn't break stuff
     {
         std::array arr{0, 1, 2, 3, 4, 5};
-        auto seq = NotBidir(arr).stride(std::numeric_limits<flux::distance_t>::max());
+        auto seq = NotBidir(arr).stride(std::numeric_limits<flux::int_t>::max());
 
         auto cur = seq.first();
         STATIC_CHECK(!seq.is_last(cur));
@@ -259,7 +259,7 @@ constexpr bool test_stride_bidir()
     // Stride of distance_t::max doesn't break stuff
     {
         std::array arr{0, 1, 2, 3, 4, 5};
-        auto seq = flux::ref(arr).stride(std::numeric_limits<flux::distance_t>::max());
+        auto seq = flux::ref(arr).stride(std::numeric_limits<flux::int_t>::max());
 
         auto cur = seq.first();
         STATIC_CHECK(!seq.is_last(cur));

From 8ee1431a405e436894e062f35b7ac2a039d4e11e Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 13 May 2025 16:08:45 +0100
Subject: [PATCH 02/66] Add iterable and reverse_iterable concepts

---
 include/flux/core.hpp                   |   1 +
 include/flux/core/iterable_concepts.hpp | 388 ++++++++++++++++++++++++
 include/flux/core/utils.hpp             |  53 ++++
 test/CMakeLists.txt                     |   1 +
 test/test_iterable_concepts.cpp         | 188 ++++++++++++
 5 files changed, 631 insertions(+)
 create mode 100644 include/flux/core/iterable_concepts.hpp
 create mode 100644 test/test_iterable_concepts.cpp

diff --git a/include/flux/core.hpp b/include/flux/core.hpp
index 67064f8f..a48b2767 100644
--- a/include/flux/core.hpp
+++ b/include/flux/core.hpp
@@ -10,6 +10,7 @@
 #include <flux/core/default_impls.hpp>
 #include <flux/core/functional.hpp>
 #include <flux/core/inline_sequence_base.hpp>
+#include <flux/core/iterable_concepts.hpp>
 #include <flux/core/numeric.hpp>
 #include <flux/core/operation_requirements.hpp>
 #include <flux/core/optional.hpp>
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
new file mode 100644
index 00000000..8e3d3380
--- /dev/null
+++ b/include/flux/core/iterable_concepts.hpp
@@ -0,0 +1,388 @@
+// Copyright (c) 2025 Tristan Brindle (tcbrindle at gmail dot com)
+// 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 FLUX_CORE_ITERABLE_CONCEPTS_HPP_INCLUDED
+#define FLUX_CORE_ITERABLE_CONCEPTS_HPP_INCLUDED
+
+#include <flux/core/concepts.hpp>
+#include <flux/core/optional.hpp>
+
+namespace flux {
+
+/*
+ * MARK: Iteration context
+ */
+
+FLUX_EXPORT
+enum class iteration_result : bool { incomplete = false, complete = true };
+
+FLUX_EXPORT inline constexpr bool loop_break = false;
+FLUX_EXPORT inline constexpr bool loop_continue = true;
+
+FLUX_EXPORT template <typename Ctx>
+using context_element_t = typename std::remove_cvref_t<Ctx>::element_type;
+
+FLUX_EXPORT template <typename Ctx>
+concept iteration_context
+    = requires { typename Ctx::element_type; } && detail::can_reference<typename Ctx::element_type>
+    && requires(Ctx& ctx, bool (*pred)(context_element_t<Ctx>)) {
+           { ctx.run_while(flux::copy(pred)) } -> std::same_as<iteration_result>;
+       };
+
+FLUX_EXPORT
+struct run_while_t {
+    template <iteration_context Ctx, typename Pred>
+        requires callable_mut<Pred, bool(context_element_t<Ctx>)>
+    constexpr auto operator()(Ctx& ctx, Pred&& pred) const -> iteration_result
+    {
+        return ctx.run_while(FLUX_FWD(pred));
+    }
+};
+
+FLUX_EXPORT inline constexpr run_while_t run_while {};
+
+FLUX_EXPORT
+struct step_t {
+    template <iteration_context Ctx, typename Fn>
+        requires callable_once<Fn, void(context_element_t<Ctx>)>
+    constexpr auto operator()(Ctx& ctx, Fn&& fn)
+    {
+        using E = context_element_t<Ctx>;
+        using R = callable_result_t<Fn, E>;
+
+        if constexpr (std::is_void_v<R>) {
+            bool called = false;
+            run_while(ctx, [&](auto&& elem) {
+                std::move(fn)(FLUX_FWD(elem));
+                called = true;
+                return loop_break;
+            });
+            return called;
+        } else {
+            // If element_type is an rvalue reference, call with a value instead
+            using T = std::conditional_t<std::is_rvalue_reference_v<E>, std::remove_cvref_t<E>, E>;
+
+            flux::optional<T> opt = nullopt;
+            run_while(ctx, [&](auto&& elem) {
+                opt.emplace(std::move(fn)(FLUX_FWD(elem)));
+                return loop_break;
+            });
+            return opt;
+        }
+    }
+};
+
+FLUX_EXPORT inline constexpr step_t step {};
+
+/*
+ * MARK: Iterable
+ */
+
+FLUX_EXPORT template <typename>
+struct iterable_traits {
+    using _flux_is_primary_template = std::true_type;
+};
+
+namespace detail {
+
+template <typename T>
+concept has_member_iterable_traits = requires { typename T::flux_iterable_traits; }
+    && std::is_class_v<typename T::flux_iterable_traits>;
+
+} // namespace detail
+
+template <typename T>
+    requires detail::has_member_iterable_traits<T>
+struct iterable_traits<T> : T::flux_iterable_traits { };
+
+namespace detail {
+
+template <typename It>
+using iter_traits_t = iterable_traits<std::remove_cvref_t<It>>;
+
+template <typename T>
+concept has_iter_traits = !requires { typename iter_traits_t<T>::_flux_is_primary_template; };
+
+template <typename T>
+concept has_valid_iter_traits = has_iter_traits<T> && requires(T& t) {
+    { iter_traits_t<T>::iterate(t) } -> iteration_context;
+};
+
+template <typename T>
+concept has_member_iterate = requires(T& t) {
+    { t.iterate() } -> iteration_context;
+};
+
+template <typename T>
+concept can_iterate = has_valid_iter_traits<T> || has_member_iterate<T>
+    || std::ranges::input_range<T> || sequence<T>;
+
+template <std::ranges::input_range R>
+struct range_iteration_context : immovable {
+private:
+    std::ranges::iterator_t<R> iter_;
+    std::ranges::sentinel_t<R> sent_;
+    bool increment_next_ = false;
+
+public:
+    using element_type = std::ranges::range_reference_t<R>;
+
+    constexpr explicit range_iteration_context(R& rng)
+        : iter_(std::ranges::begin(rng)),
+          sent_(std::ranges::end(rng))
+    {
+    }
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        if (increment_next_ && iter_ != sent_) {
+            ++iter_;
+            increment_next_ = false;
+        }
+
+        while (iter_ != sent_) {
+            if (!pred(*iter_)) {
+                increment_next_ = true;
+                return iteration_result::incomplete;
+            }
+            ++iter_;
+        }
+
+        return iteration_result::complete;
+    }
+};
+
+template <std::ranges::forward_range R>
+struct range_iteration_context<R> : immovable {
+private:
+    std::ranges::iterator_t<R> iter_;
+    std::ranges::sentinel_t<R> sent_;
+
+public:
+    using element_type = std::ranges::range_reference_t<R>;
+
+    constexpr explicit range_iteration_context(R& rng)
+        : iter_(std::ranges::begin(rng)),
+          sent_(std::ranges::end(rng))
+    {
+    }
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        while (iter_ != sent_) {
+            if (!pred(*iter_++)) {
+                return iteration_result::incomplete;
+            }
+        }
+
+        return iteration_result::complete;
+    }
+};
+
+template <sequence Seq>
+struct sequence_iteration_context : immovable {
+private:
+    Seq* ptr_;
+    cursor_t<Seq> cur_;
+    bool inc_next_ = false;
+
+public:
+    using element_type = element_t<Seq>;
+
+    constexpr explicit sequence_iteration_context(Seq& seq)
+        : ptr_(std::addressof(seq)),
+          cur_(first(seq))
+    {
+    }
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        if (inc_next_ && !is_last(*ptr_, cur_)) {
+            inc(*ptr_, cur_);
+            inc_next_ = false;
+        }
+
+        while (!is_last(*ptr_, cur_)) {
+            if (!pred(read_at_unchecked(*ptr_, cur_))) {
+                inc_next_ = true;
+                return iteration_result::incomplete;
+            }
+            inc(*ptr_, cur_);
+        }
+
+        return iteration_result::complete;
+    }
+};
+
+template <multipass_sequence Seq>
+struct sequence_iteration_context<Seq> {
+private:
+    Seq* ptr_;
+    cursor_t<Seq> cur_;
+
+public:
+    using element_type = element_t<Seq>;
+
+    constexpr explicit sequence_iteration_context(Seq& seq)
+        : ptr_(std::addressof(seq)),
+          cur_(first(seq))
+    {
+    }
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        while (!is_last(*ptr_, cur_)) {
+            auto _ = detail::defer_t([&] { inc(*ptr_, cur_); });
+
+            if (!pred(read_at_unchecked(*ptr_, cur_))) {
+                return iteration_result::incomplete;
+            }
+        }
+
+        return iteration_result::complete;
+    }
+};
+
+} // namespace detail
+
+FLUX_EXPORT
+struct iterate_t {
+    template <typename It>
+        requires detail::can_iterate<It>
+    constexpr auto operator()(It& it) const -> iteration_context auto
+    {
+        if constexpr (detail::has_valid_iter_traits<It>) {
+            return iterable_traits<It>::iterate(it);
+        } else if constexpr (detail::has_member_iterate<It>) {
+            return it.iterate();
+        } else if constexpr (sequence<It>) {
+            return detail::sequence_iteration_context<It>(it);
+        } else if constexpr (std::ranges::input_range<It>) {
+            return detail::range_iteration_context<It>(it);
+        }
+    }
+};
+
+FLUX_EXPORT inline constexpr iterate_t iterate {};
+
+FLUX_EXPORT template <typename It>
+concept iterable = requires(It& it) {
+    { iterate(it) } -> iteration_context;
+};
+
+FLUX_EXPORT template <iterable I>
+using iteration_context_t = decltype(iterate(std::declval<I&>()));
+
+/*
+ * MARK: Reverse iterable
+ */
+
+namespace detail {
+
+template <typename T>
+concept has_reverse_iter_traits = requires(T& t) {
+    { iter_traits_t<T>::reverse_iterate(t) } -> iteration_context;
+};
+
+template <typename T>
+concept has_member_reverse_iterate = has_member_iterate<T> && requires(T& t) {
+    { t.reverse_iterate() } -> iteration_context;
+};
+
+template <typename T>
+concept can_reverse_iterate = has_reverse_iter_traits<T> || has_member_reverse_iterate<T>
+    || (bidirectional_sequence<T> && bounded_sequence<T>)
+    || (std::ranges::bidirectional_range<T> && std::ranges::common_range<T>);
+
+template <std::ranges::bidirectional_range R>
+    requires std::ranges::common_range<R>
+struct range_reverse_iteration_context : immovable {
+private:
+    std::ranges::iterator_t<R> iter_;
+    std::ranges::iterator_t<R> start_;
+
+public:
+    using element_type = std::ranges::range_reference_t<R>;
+
+    constexpr explicit range_reverse_iteration_context(R& rng)
+        : iter_(std::ranges::end(rng)),
+          start_(std::ranges::begin(rng))
+    {
+    }
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        while (iter_ != start_) {
+            if (!pred(*--iter_)) {
+                return iteration_result::incomplete;
+            }
+        }
+
+        return iteration_result::complete;
+    }
+};
+
+template <bidirectional_sequence Seq>
+    requires bounded_sequence<Seq>
+struct sequence_reverse_iteration_context : immovable {
+private:
+    Seq* ptr_;
+    cursor_t<Seq> cur_;
+    cursor_t<Seq> start_;
+
+public:
+    using element_type = element_t<Seq>;
+
+    constexpr explicit sequence_reverse_iteration_context(Seq& seq)
+        : ptr_(std::addressof(seq)),
+          cur_(last(seq)),
+          start_(first(seq))
+    {
+    }
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        while (cur_ != start_) {
+            dec(*ptr_, cur_);
+            if (!pred(read_at_unchecked(*ptr_, cur_))) {
+                return iteration_result::incomplete;
+            }
+        }
+
+        return iteration_result::complete;
+    }
+};
+} // namespace detail
+
+FLUX_EXPORT struct reverse_iterate_t {
+    template <typename It>
+        requires detail::can_reverse_iterate<It>
+    constexpr auto operator()(It& it) const -> iteration_context auto
+    {
+        if constexpr (detail::has_reverse_iter_traits<It>) {
+            return iterable_traits<It>::reverse_iterate(it);
+        } else if constexpr (detail::has_member_reverse_iterate<It>) {
+            return it.reverse_iterate();
+        } else if constexpr (bidirectional_sequence<It> && bounded_sequence<It>) {
+            return detail::sequence_reverse_iteration_context<It>(it);
+        } else if constexpr (std::ranges::bidirectional_range<It>
+                             && std::ranges::common_range<It>) {
+            return detail::range_reverse_iteration_context<It>(it);
+        }
+    }
+};
+
+FLUX_EXPORT inline constexpr reverse_iterate_t reverse_iterate {};
+
+FLUX_EXPORT template <typename It>
+concept reverse_iterable = iterable<It> && requires(It& it) {
+    { reverse_iterate(it) } -> iteration_context;
+};
+
+FLUX_EXPORT template <reverse_iterable I>
+using reverse_iteration_context_t = decltype(reverse_iterate(std::declval<I&>()));
+
+} // namespace flux
+
+#endif // FLUX_CORE_ITERABLE_CONCEPTS_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 44a12811..43677afb 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -43,6 +43,15 @@ struct copy_fn {
 
 FLUX_EXPORT inline constexpr auto copy = detail::copy_fn{};
 
+struct immovable {
+    immovable() = default;
+    ~immovable() = default;
+    immovable(immovable const&) = delete;
+    immovable(immovable&&) = delete;
+    immovable& operator=(immovable const&) = delete;
+    immovable& operator=(immovable&&) = delete;
+};
+
 namespace detail {
 
 template <typename T, typename... U>
@@ -66,6 +75,50 @@ concept ordering_invocable =
     detail::ordering_invocable_<Fn, T, T, Cat> &&
     detail::ordering_invocable_<Fn, U, U, Cat>;
 
+FLUX_EXPORT template <typename Fn, typename... Args>
+using callable_result_t = decltype(std::declval<Fn>()(std::declval<Args>()...));
+
+namespace detail {
+
+template <typename Fn, typename... Args>
+concept can_call_ = requires { typename callable_result_t<Fn, Args...>; };
+
+template <typename Fn, typename R, typename... Args>
+concept can_call_r
+    = can_call_<Fn, Args...> && std::convertible_to<callable_result_t<Fn, Args...>, R>;
+
+template <typename, typename>
+inline constexpr bool callable_ = false;
+
+template <typename Fn, typename R, typename... Args>
+inline constexpr bool callable_<Fn, R(Args...)>
+    = std::is_void_v<R> ? can_call_<Fn, Args...> : can_call_r<Fn, R, Args...>;
+
+} // namespace detail
+
+FLUX_EXPORT template <typename Fn, typename Sig>
+concept callable_once = detail::callable_<Fn, Sig>;
+
+FLUX_EXPORT template <typename Fn, typename Sig>
+concept callable_mut = detail::callable_<Fn&, Sig> && callable_once<Fn, Sig>;
+
+FLUX_EXPORT template <typename Fn, typename Sig>
+concept callable = detail::callable_<Fn const&, Sig> && callable_mut<Fn, Sig>;
+
+namespace detail {
+
+template <callable_once<void()> Fn>
+struct [[nodiscard("Discarded defer_t will execute its associated function immediately")]] defer_t {
+    FLUX_NO_UNIQUE_ADDRESS Fn fn;
+
+    ~defer_t() { fn(); }
+};
+
+// template <typename F>
+// defer_t(F) -> defer_t<F>;
+
+} // namespace detail
+
 } // namespace flux
 
 #endif
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 13757184..8712d2da 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -19,6 +19,7 @@ add_executable(test-flux
     num/test_checked_ops.cpp
     num/test_default_ops.cpp
 
+    test_iterable_concepts.cpp
     test_concepts.cpp
     test_optional.cpp
     test_predicates.cpp
diff --git a/test/test_iterable_concepts.cpp b/test/test_iterable_concepts.cpp
new file mode 100644
index 00000000..c3a21d74
--- /dev/null
+++ b/test/test_iterable_concepts.cpp
@@ -0,0 +1,188 @@
+// Copyright (c) 2025 Tristan Brindle (tcbrindle at gmail dot com)
+// 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)
+
+#include <doctest/doctest.h>
+
+#ifdef USE_MODULES
+import flux;
+#else
+#    include <flux.hpp>
+#endif
+
+/*
+ * Iteration context concept tests
+ */
+
+namespace {
+
+static_assert(not flux::iteration_context<void>);
+static_assert(not flux::iteration_context<void*>);
+static_assert(not flux::iteration_context<int>);
+static_assert(not flux::iteration_context<int[]>);
+
+struct empty { };
+static_assert(not flux::iteration_context<empty>);
+
+struct incomplete;
+static_assert(not flux::iteration_context<incomplete>);
+
+struct no_element_type {
+    auto run_while(auto&&) -> flux::iteration_result;
+};
+static_assert(not flux::iteration_context<no_element_type>);
+
+struct void_element_type {
+    using element_type = void;
+    auto run_while(auto&&) -> flux::iteration_result;
+};
+static_assert(not flux::iteration_context<void_element_type>);
+
+struct no_run_while {
+    using element_type = int;
+};
+static_assert(not flux::iteration_context<no_run_while>);
+
+struct run_while_returns_void {
+    using element_type = int;
+    auto run_while(auto&&) -> void;
+};
+static_assert(not flux::iteration_context<run_while_returns_void>);
+
+struct run_while_returns_int {
+    using element_type = int;
+    auto run_while(auto&&) -> int;
+};
+static_assert(not flux::iteration_context<run_while_returns_int>);
+
+struct run_while_takes_void {
+    using element_type = int;
+    auto run_while() -> flux::iteration_result;
+};
+static_assert(not flux::iteration_context<run_while_takes_void>);
+
+struct minimal_iteration_context {
+    using element_type = int;
+    auto run_while(auto&&) -> flux::iteration_result;
+};
+static_assert(flux::iteration_context<minimal_iteration_context>);
+
+} // namespace
+
+/*
+ * Iterable concept tests
+ */
+
+namespace {
+
+struct has_empty_iter_traits_specialisation { };
+struct has_incorrect_iter_traits_specialisation { };
+struct has_valid_iter_traits_specialisation { };
+} // namespace
+
+template <>
+struct flux::iterable_traits<has_empty_iter_traits_specialisation> { };
+
+template <>
+struct flux::iterable_traits<has_incorrect_iter_traits_specialisation> {
+    auto iterate() -> void;
+};
+
+template <>
+struct flux::iterable_traits<has_valid_iter_traits_specialisation> {
+    static auto iterate(has_valid_iter_traits_specialisation&) -> minimal_iteration_context
+    {
+        return {};
+    }
+};
+
+namespace {
+
+// Things that are not iterable
+
+static_assert(not flux::iterable<int>);
+static_assert(not flux::iterable<int*>);
+static_assert(not flux::iterable<int[]>);
+static_assert(not flux::iterable<void>);
+static_assert(not flux::iterable<void*>);
+
+static_assert(not flux::iterable<incomplete>);
+static_assert(not flux::iterable<empty>);
+
+static_assert(not flux::iterable<has_empty_iter_traits_specialisation>);
+static_assert(not flux::iterable<has_incorrect_iter_traits_specialisation>);
+
+struct member_iterate_returns_int {
+    auto iterate() -> int;
+};
+static_assert(not flux::iterable<member_iterate_returns_int>);
+
+// Things that *are* iterable
+
+static_assert(flux::iterable<has_valid_iter_traits_specialisation>);
+
+struct minimal_iterable {
+    auto iterate() -> minimal_iteration_context { return {}; }
+};
+static_assert(flux::iterable<minimal_iterable>);
+
+static_assert(flux::iterable<int (&)[5]>);
+static_assert(flux::iterable<int const (&)[5]>);
+static_assert(flux::iterable<std::initializer_list<int>>);
+
+static_assert(flux::iterable<decltype(flux::iota(0, 10))>);
+
+} // namespace
+
+/*
+ * Reverse iterable concept tests
+ */
+
+namespace {
+
+struct has_reverse_iter_traits { };
+
+} // namespace
+
+template <>
+struct flux::iterable_traits<has_reverse_iter_traits> {
+    static auto iterate(has_reverse_iter_traits&) -> minimal_iteration_context { return {}; }
+
+    static auto reverse_iterate(has_reverse_iter_traits&) -> minimal_iteration_context
+    {
+        return {};
+    }
+};
+
+namespace {
+
+// Things that are not reverse iterable
+static_assert(not flux::reverse_iterable<int>);
+static_assert(not flux::reverse_iterable<int*>);
+static_assert(not flux::reverse_iterable<int[]>);
+static_assert(not flux::reverse_iterable<void>);
+static_assert(not flux::reverse_iterable<void*>);
+
+static_assert(not flux::reverse_iterable<incomplete>);
+static_assert(not flux::reverse_iterable<empty>);
+
+static_assert(not flux::reverse_iterable<has_empty_iter_traits_specialisation>);
+static_assert(not flux::reverse_iterable<has_incorrect_iter_traits_specialisation>);
+
+// Things that *are* reverse iterable
+static_assert(flux::reverse_iterable<has_reverse_iter_traits>);
+
+struct has_member_reverse_iterate {
+    auto iterate() -> minimal_iteration_context { return {}; }
+    auto reverse_iterate() -> minimal_iteration_context { return {}; }
+};
+
+static_assert(flux::reverse_iterable<has_member_reverse_iterate>);
+
+static_assert(flux::reverse_iterable<int (&)[5]>);
+static_assert(flux::reverse_iterable<int const (&)[5]>);
+static_assert(flux::reverse_iterable<std::initializer_list<int>>);
+
+static_assert(flux::reverse_iterable<decltype(flux::iota(0, 10))>);
+
+} // namespace
\ No newline at end of file

From 4c98b7759809e95b03316756e105eb037e22efdb Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 13 May 2025 16:57:13 +0100
Subject: [PATCH 03/66] Temporarily rename for_each_while on sequences

...to `seq_for_each_while()`
---
 example/top10/08_three_consecutive_odds.cpp |  2 +-
 include/flux/adaptor/cartesian_base.hpp     | 23 +++++++++------------
 include/flux/adaptor/chain.hpp              |  4 ++--
 include/flux/adaptor/cycle.hpp              |  4 ++--
 include/flux/adaptor/drop_while.hpp         |  2 +-
 include/flux/adaptor/filter.hpp             |  2 +-
 include/flux/adaptor/flatten.hpp            |  4 ++--
 include/flux/adaptor/map.hpp                |  2 +-
 include/flux/adaptor/scan.hpp               |  2 +-
 include/flux/adaptor/scan_first.hpp         |  2 +-
 include/flux/adaptor/stride.hpp             | 19 +++++++++--------
 include/flux/adaptor/take.hpp               |  2 +-
 include/flux/adaptor/take_while.hpp         |  2 +-
 include/flux/algorithm/all_any_none.hpp     | 18 ++++++++--------
 include/flux/algorithm/contains.hpp         |  6 +++---
 include/flux/algorithm/count.hpp            |  6 +++---
 include/flux/algorithm/find.hpp             | 22 ++++++++------------
 include/flux/algorithm/fold.hpp             |  2 +-
 include/flux/algorithm/for_each.hpp         |  2 +-
 include/flux/algorithm/zip_algorithms.hpp   |  2 +-
 include/flux/core/inline_sequence_base.hpp  |  2 +-
 include/flux/core/ref.hpp                   |  4 ++--
 include/flux/core/sequence_access.hpp       |  4 ++--
 test/test_cycle.cpp                         |  2 +-
 test/test_repeat.cpp                        |  8 +++----
 25 files changed, 70 insertions(+), 78 deletions(-)

diff --git a/example/top10/08_three_consecutive_odds.cpp b/example/top10/08_three_consecutive_odds.cpp
index 05d46d9e..dbaaf0f9 100644
--- a/example/top10/08_three_consecutive_odds.cpp
+++ b/example/top10/08_three_consecutive_odds.cpp
@@ -17,7 +17,7 @@ namespace version1 {
 auto const tco = [](std::initializer_list<int> nums)
 {
     int odd_count = 0;
-    auto idx = flux::for_each_while(nums, [&](int i) {
+    auto idx = flux::seq_for_each_while(nums, [&](int i) {
         if (i % 2 != 0) {
             ++odd_count;
         } else {
diff --git a/include/flux/adaptor/cartesian_base.hpp b/include/flux/adaptor/cartesian_base.hpp
index 2ee0b469..21dea805 100644
--- a/include/flux/adaptor/cartesian_base.hpp
+++ b/include/flux/adaptor/cartesian_base.hpp
@@ -186,20 +186,17 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     {
         // We need to iterate right to left.
         if constexpr (I == Arity - 1) {
-            std::get<I>(cur) = flux::for_each_while(get_base<I>(self),
-                [&](auto&& elem) {
-                    keep_going = std::invoke(func,
-                                             element_t<Self>(FLUX_FWD(partial_elements)..., FLUX_FWD(elem)));
-                    return keep_going;
-                });
+            std::get<I>(cur) = flux::seq_for_each_while(get_base<I>(self), [&](auto&& elem) {
+                keep_going = std::invoke(
+                    func, element_t<Self>(FLUX_FWD(partial_elements)..., FLUX_FWD(elem)));
+                return keep_going;
+            });
         } else {
-            std::get<I>(cur) = flux::for_each_while(get_base<I>(self),
-                [&](auto&& elem) {
-                    for_each_while_impl<I+1>(
-                            self, keep_going, cur,
-                            func, FLUX_FWD(partial_elements)..., FLUX_FWD(elem));
-                    return keep_going;
-                });
+            std::get<I>(cur) = flux::seq_for_each_while(get_base<I>(self), [&](auto&& elem) {
+                for_each_while_impl<I + 1>(self, keep_going, cur, func,
+                                           FLUX_FWD(partial_elements)..., FLUX_FWD(elem));
+                return keep_going;
+            });
         }
     }
 
diff --git a/include/flux/adaptor/chain.hpp b/include/flux/adaptor/chain.hpp
index 754428d7..bb9b545c 100644
--- a/include/flux/adaptor/chain.hpp
+++ b/include/flux/adaptor/chain.hpp
@@ -168,7 +168,7 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_trait
     {
         if constexpr (N < End) {
             auto& base = std::get<N>(self.bases_);
-            auto base_cur = flux::for_each_while(base, pred);
+            auto base_cur = flux::seq_for_each_while(base, pred);
             if (!flux::is_last(base, base_cur)) {
                 return cursor_type(std::in_place_index<N>, std::move(base_cur));
             } else {
@@ -176,7 +176,7 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_trait
             }
         } else {
             return cursor_type(std::in_place_index<N>,
-                               flux::for_each_while(std::get<N>(self.bases_), pred));
+                               flux::seq_for_each_while(std::get<N>(self.bases_), pred));
         }
     }
 
diff --git a/include/flux/adaptor/cycle.hpp b/include/flux/adaptor/cycle.hpp
index fd64b9e1..bd9482a3 100644
--- a/include/flux/adaptor/cycle.hpp
+++ b/include/flux/adaptor/cycle.hpp
@@ -128,7 +128,7 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
             if constexpr (IsInfinite) {
                 std::size_t n = 0;
                 while (true) {
-                    auto cur = flux::for_each_while(self.base_, constify_pred);
+                    auto cur = flux::seq_for_each_while(self.base_, constify_pred);
                     if (!flux::is_last(self.base_, cur)) {
                         return cursor_type{std::move(cur), n};
                     }
@@ -136,7 +136,7 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
                 }
             } else {
                 for (std::size_t n = 0; n < self.data_.count; ++n) {
-                    auto cur = flux::for_each_while(self.base_, constify_pred);
+                    auto cur = flux::seq_for_each_while(self.base_, constify_pred);
                     if (!flux::is_last(self.base_, cur)) {
                         return cursor_type{std::move(cur), n};
                     }
diff --git a/include/flux/adaptor/drop_while.hpp b/include/flux/adaptor/drop_while.hpp
index ecd9c49b..ba064deb 100644
--- a/include/flux/adaptor/drop_while.hpp
+++ b/include/flux/adaptor/drop_while.hpp
@@ -36,7 +36,7 @@ struct drop_while_adaptor : inline_sequence_base<drop_while_adaptor<Base, Pred>>
 
         static constexpr auto first(auto& self)
         {
-            return flux::for_each_while(self.base_, std::ref(self.pred_));
+            return flux::seq_for_each_while(self.base_, std::ref(self.pred_));
         }
 
         static constexpr auto data(auto& self)
diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index ba5ff208..a3e8e46b 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -103,7 +103,7 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>>
         static constexpr auto for_each_while(auto& self, auto&& func)
             -> cursor_type
         {
-            return cursor_type{flux::for_each_while(self.base_, [&](auto&& elem) {
+            return cursor_type {flux::seq_for_each_while(self.base_, [&](auto&& elem) {
                 if (std::invoke(self.pred_, elem)) {
                     return std::invoke(func, FLUX_FWD(elem));
                 } else {
diff --git a/include/flux/adaptor/flatten.hpp b/include/flux/adaptor/flatten.hpp
index bd30e5a6..71eb2586 100644
--- a/include/flux/adaptor/flatten.hpp
+++ b/include/flux/adaptor/flatten.hpp
@@ -187,8 +187,8 @@ struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
         static constexpr auto for_each_while(Self& self, auto&& pred) -> cursor_type
         {
             auto inner_cur = cursor_t<InnerSeq>{};
-            auto outer_cur = flux::for_each_while(self.base_, [&](auto&& inner_seq) {
-                inner_cur = flux::for_each_while(inner_seq, pred);
+            auto outer_cur = flux::seq_for_each_while(self.base_, [&](auto&& inner_seq) {
+                inner_cur = flux::seq_for_each_while(inner_seq, pred);
                 return flux::is_last(inner_seq, inner_cur);
             });
             return cursor_type{.outer_cur = std::move(outer_cur),
diff --git a/include/flux/adaptor/map.hpp b/include/flux/adaptor/map.hpp
index 010ba45f..22a2668c 100644
--- a/include/flux/adaptor/map.hpp
+++ b/include/flux/adaptor/map.hpp
@@ -57,7 +57,7 @@ struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>>
 
         static constexpr auto for_each_while(auto& self, auto&& pred)
         {
-            return flux::for_each_while(self.base_, [&](auto&& elem) {
+            return flux::seq_for_each_while(self.base_, [&](auto&& elem) {
                 return std::invoke(pred, std::invoke(self.func_, FLUX_FWD(elem)));
             });
         }
diff --git a/include/flux/adaptor/scan.hpp b/include/flux/adaptor/scan.hpp
index 46b81040..9aa32d5f 100644
--- a/include/flux/adaptor/scan.hpp
+++ b/include/flux/adaptor/scan.hpp
@@ -141,7 +141,7 @@ struct scan_adaptor : inline_sequence_base<scan_adaptor<Base, Func, R, Mode>> {
         static constexpr auto for_each_while(self_t& self, auto&& pred) -> cursor_type
             requires (Mode != scan_mode::exclusive)
         {
-            return cursor_type(flux::for_each_while(self.base_, [&](auto&& elem) {
+            return cursor_type(flux::seq_for_each_while(self.base_, [&](auto&& elem) {
                 self.accum_ = std::invoke(self.func_, std::move(self.accum_), FLUX_FWD(elem));
                 return std::invoke(pred, std::as_const(self.accum_));
             }));
diff --git a/include/flux/adaptor/scan_first.hpp b/include/flux/adaptor/scan_first.hpp
index 6ae8a74a..128178b3 100644
--- a/include/flux/adaptor/scan_first.hpp
+++ b/include/flux/adaptor/scan_first.hpp
@@ -97,7 +97,7 @@ struct scan_first_adaptor : inline_sequence_base<scan_first_adaptor<Base, Func,
 
         static constexpr auto for_each_while(self_t& self, auto&& pred) -> cursor_type
         {
-            return cursor_type(flux::for_each_while(self.base_, [&](auto&& elem) {
+            return cursor_type(flux::seq_for_each_while(self.base_, [&](auto&& elem) {
                 if (self.accum_.has_value()) {
                     self.accum_.emplace(
                         std::invoke(self.func_,
diff --git a/include/flux/adaptor/stride.hpp b/include/flux/adaptor/stride.hpp
index 611dad32..24d3df1a 100644
--- a/include/flux/adaptor/stride.hpp
+++ b/include/flux/adaptor/stride.hpp
@@ -100,7 +100,7 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
             requires sequence<decltype((self.base_))>
         {
             int_t n = self.stride_;
-            return flux::for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
+            return flux::seq_for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
                 if (++n < s) {
                     return true;
                 } else {
@@ -237,14 +237,15 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
             requires sequence<decltype((self.base_))>
         {
             int_t n = self.stride_;
-            auto c = flux::for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
-                if (++n < s) {
-                    return true;
-                } else {
-                    n = 0;
-                    return std::invoke(pred, FLUX_FWD(elem));
-                }
-            });
+            auto c
+                = flux::seq_for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
+                      if (++n < s) {
+                          return true;
+                      } else {
+                          n = 0;
+                          return std::invoke(pred, FLUX_FWD(elem));
+                      }
+                  });
             return cursor_type{std::move(c), (n + 1) % self.stride_};
         }
     };
diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index d6c88f43..5dec9da3 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -134,7 +134,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
         static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
         {
             int_t len = self.count_;
-            auto cur = flux::for_each_while(self.base_, [&](auto&& elem) {
+            auto cur = flux::seq_for_each_while(self.base_, [&](auto&& elem) {
                 return (len-- > 0) && std::invoke(pred, FLUX_FWD(elem));
             });
 
diff --git a/include/flux/adaptor/take_while.hpp b/include/flux/adaptor/take_while.hpp
index 464968d0..fb3df4a0 100644
--- a/include/flux/adaptor/take_while.hpp
+++ b/include/flux/adaptor/take_while.hpp
@@ -73,7 +73,7 @@ struct sequence_traits<detail::take_while_adaptor<Base, Pred>>
 
     static constexpr auto for_each_while(auto& self, auto&& func)
     {
-        return flux::for_each_while(self.base_, [&](auto&& elem) {
+        return flux::seq_for_each_while(self.base_, [&](auto&& elem) {
             if (!std::invoke(self.pred_, elem)) {
                 return false;
             } else {
diff --git a/include/flux/algorithm/all_any_none.hpp b/include/flux/algorithm/all_any_none.hpp
index 6f0c8b44..26ca4583 100644
--- a/include/flux/algorithm/all_any_none.hpp
+++ b/include/flux/algorithm/all_any_none.hpp
@@ -17,9 +17,9 @@ struct fn {
         requires std::predicate<Pred&, element_t<Seq>>
     constexpr bool operator()(Seq&& seq, Pred pred) const
     {
-        return is_last(seq, for_each_while(seq, [&](auto&& elem) {
-            return std::invoke(pred, FLUX_FWD(elem));
-        }));
+        return is_last(seq, seq_for_each_while(seq, [&](auto&& elem) {
+                           return std::invoke(pred, FLUX_FWD(elem));
+                       }));
     }
 };
 
@@ -34,9 +34,9 @@ struct fn {
         requires std::predicate<Pred&, element_t<Seq>>
     constexpr bool operator()(Seq&& seq, Pred pred) const
     {
-        return is_last(seq, for_each_while(seq, [&](auto&& elem) {
-            return !std::invoke(pred, FLUX_FWD(elem));
-        }));
+        return is_last(seq, seq_for_each_while(seq, [&](auto&& elem) {
+                           return !std::invoke(pred, FLUX_FWD(elem));
+                       }));
     }
 };
 
@@ -51,9 +51,9 @@ struct fn {
         requires std::predicate<Pred&, element_t<Seq>>
     constexpr bool operator()(Seq&& seq, Pred pred) const
     {
-        return !is_last(seq, for_each_while(seq, [&](auto&& elem) {
-            return !std::invoke(pred, FLUX_FWD(elem));
-        }));
+        return !is_last(seq, seq_for_each_while(seq, [&](auto&& elem) {
+                            return !std::invoke(pred, FLUX_FWD(elem));
+                        }));
     }
 };
 
diff --git a/include/flux/algorithm/contains.hpp b/include/flux/algorithm/contains.hpp
index 95ec9ff9..fccbd85c 100644
--- a/include/flux/algorithm/contains.hpp
+++ b/include/flux/algorithm/contains.hpp
@@ -18,9 +18,9 @@ struct contains_fn {
     constexpr auto operator()(Seq&& seq, Value const& value) const
         -> bool
     {
-        return !flux::is_last(seq, flux::for_each_while(seq, [&](auto&& elem) {
-            return FLUX_FWD(elem) != value;
-        }));
+        return !flux::is_last(seq, flux::seq_for_each_while(seq, [&](auto&& elem) {
+                                  return FLUX_FWD(elem) != value;
+                              }));
     }
 };
 
diff --git a/include/flux/algorithm/count.hpp b/include/flux/algorithm/count.hpp
index 9be202bd..7df6e1d8 100644
--- a/include/flux/algorithm/count.hpp
+++ b/include/flux/algorithm/count.hpp
@@ -21,7 +21,7 @@ struct count_fn {
             return flux::size(seq);
         } else {
             int_t counter = 0;
-            flux::for_each_while(seq, [&](auto&&) {
+            flux::seq_for_each_while(seq, [&](auto&&) {
                 ++counter;
                 return true;
             });
@@ -37,7 +37,7 @@ struct count_eq_fn {
     constexpr auto operator()(Seq&& seq, Value const& value) const -> int_t
     {
         int_t counter = 0;
-        flux::for_each_while(seq, [&](auto&& elem) {
+        flux::seq_for_each_while(seq, [&](auto&& elem) {
             if (value == FLUX_FWD(elem)) {
                 ++counter;
             }
@@ -54,7 +54,7 @@ struct count_if_fn {
     constexpr auto operator()(Seq&& seq, Pred pred) const -> int_t
     {
         int_t counter = 0;
-        flux::for_each_while(seq, [&](auto&& elem) {
+        flux::seq_for_each_while(seq, [&](auto&& elem) {
             if (std::invoke(pred, FLUX_FWD(elem))) {
                 ++counter;
             }
diff --git a/include/flux/algorithm/find.hpp b/include/flux/algorithm/find.hpp
index 06e0cfd9..6bf3f093 100644
--- a/include/flux/algorithm/find.hpp
+++ b/include/flux/algorithm/find.hpp
@@ -20,9 +20,7 @@ struct find_fn {
     template <typename Seq, typename Value>
     static constexpr auto impl(Seq&& seq, Value const& value) -> cursor_t<Seq>
     {
-        return for_each_while(seq, [&](auto&& elem) {
-            return FLUX_FWD(elem) != value;
-        });
+        return seq_for_each_while(seq, [&](auto&& elem) { return FLUX_FWD(elem) != value; });
     }
 
 public:
@@ -30,10 +28,10 @@ struct find_fn {
         requires std::equality_comparable_with<element_t<Seq>, Value const&>
     constexpr auto operator()(Seq&& seq, Value const& value) const -> cursor_t<Seq>
     {
-        constexpr auto can_memchr = 
-            contiguous_sequence<Seq> && sized_sequence<Seq> && 
-            std::same_as<Value, value_t<Seq>> &&
-            flux::detail::any_of<value_t<Seq>, char, signed char, unsigned char, char8_t, std::byte>;
+        constexpr auto can_memchr = contiguous_sequence<Seq> && sized_sequence<Seq>
+            && std::same_as<Value, value_t<Seq>>
+            && flux::detail::any_of<value_t<Seq>, char, signed char, unsigned char, char8_t,
+                                    std::byte>;
 
         if constexpr (can_memchr) {
             if (std::is_constant_evaluated()) {
@@ -65,9 +63,8 @@ struct find_if_fn {
     constexpr auto operator()(Seq&& seq, Pred pred) const
         -> cursor_t<Seq>
     {
-        return for_each_while(seq, [&](auto&& elem) {
-            return !std::invoke(pred, FLUX_FWD(elem));
-        });
+        return seq_for_each_while(seq,
+                                  [&](auto&& elem) { return !std::invoke(pred, FLUX_FWD(elem)); });
     }
 };
 
@@ -77,9 +74,8 @@ struct find_if_not_fn {
     constexpr auto operator()(Seq&& seq, Pred pred) const
         -> cursor_t<Seq>
     {
-        return for_each_while(seq, [&](auto&& elem) {
-            return std::invoke(pred, FLUX_FWD(elem));
-        });
+        return seq_for_each_while(seq,
+                                  [&](auto&& elem) { return std::invoke(pred, FLUX_FWD(elem)); });
     }
 };
 
diff --git a/include/flux/algorithm/fold.hpp b/include/flux/algorithm/fold.hpp
index 8e01e75b..e60f2b42 100644
--- a/include/flux/algorithm/fold.hpp
+++ b/include/flux/algorithm/fold.hpp
@@ -22,7 +22,7 @@ struct fold_op {
     constexpr auto operator()(Seq&& seq, Func func, Init init = Init{}) const -> R
     {
         R init_ = R(std::move(init));
-        flux::for_each_while(seq, [&func, &init_](auto&& elem) {
+        flux::seq_for_each_while(seq, [&func, &init_](auto&& elem) {
             init_ = std::invoke(func, std::move(init_), FLUX_FWD(elem));
             return true;
         });
diff --git a/include/flux/algorithm/for_each.hpp b/include/flux/algorithm/for_each.hpp
index 43a59917..0d4f853c 100644
--- a/include/flux/algorithm/for_each.hpp
+++ b/include/flux/algorithm/for_each.hpp
@@ -19,7 +19,7 @@ struct for_each_fn {
                   !infinite_sequence<Seq>)
     constexpr auto operator()(Seq&& seq, Func func) const -> Func
     {
-        (void) flux::for_each_while(FLUX_FWD(seq), [&](auto&& elem) {
+        (void)flux::seq_for_each_while(FLUX_FWD(seq), [&](auto&& elem) {
             std::invoke(func, FLUX_FWD(elem));
             return true;
         });
diff --git a/include/flux/algorithm/zip_algorithms.hpp b/include/flux/algorithm/zip_algorithms.hpp
index a53bacdc..32c92a5b 100644
--- a/include/flux/algorithm/zip_algorithms.hpp
+++ b/include/flux/algorithm/zip_algorithms.hpp
@@ -21,7 +21,7 @@ struct zip_for_each_while_fn {
         if constexpr (sizeof...(Seqs) == 0) {
             return std::tuple<>{};
         } else if constexpr (sizeof...(Seqs) == 1) {
-            return std::tuple<cursor_t<Seqs>...>(flux::for_each_while(seqs..., std::ref(pred)));
+            return std::tuple<cursor_t<Seqs>...>(flux::seq_for_each_while(seqs..., std::ref(pred)));
         } else {
             return [&pred, &...seqs = seqs, ...curs = flux::first(seqs)]() mutable {
                 while (!(flux::is_last(seqs, curs) || ...)) {
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index 3cbbeb5a..06863e2a 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -129,7 +129,7 @@ struct inline_sequence_base {
         detail::boolean_testable<std::invoke_result_t<Pred&, element_t<Derived>>>
     constexpr auto for_each_while(Pred pred)
     {
-        return flux::for_each_while(derived(), std::ref(pred));
+        return flux::seq_for_each_while(derived(), std::ref(pred));
     }
 
     /// Returns true if the sequence contains no elements
diff --git a/include/flux/core/ref.hpp b/include/flux/core/ref.hpp
index 39c5ff2d..74c92b24 100644
--- a/include/flux/core/ref.hpp
+++ b/include/flux/core/ref.hpp
@@ -105,9 +105,9 @@ struct passthrough_traits_base : default_sequence_traits {
 
     template <typename Self>
     static constexpr auto for_each_while(Self& self, auto&& pred)
-        -> decltype(flux::for_each_while(self.base(), FLUX_FWD(pred)))
+        -> decltype(flux::seq_for_each_while(self.base(), FLUX_FWD(pred)))
     {
-        return flux::for_each_while(self.base(), FLUX_FWD(pred));
+        return flux::seq_for_each_while(self.base(), FLUX_FWD(pred));
     }
 };
 
diff --git a/include/flux/core/sequence_access.hpp b/include/flux/core/sequence_access.hpp
index 0e3a0d66..422e4306 100644
--- a/include/flux/core/sequence_access.hpp
+++ b/include/flux/core/sequence_access.hpp
@@ -160,7 +160,7 @@ struct move_at_unchecked_fn {
     }
 };
 
-struct for_each_while_fn {
+struct seq_for_each_while_fn {
     template <sequence Seq, typename Pred>
         requires std::invocable<Pred&, element_t<Seq>> &&
         boolean_testable<std::invoke_result_t<Pred&, element_t<Seq>>>
@@ -185,7 +185,7 @@ FLUX_EXPORT inline constexpr auto data = detail::data_fn{};
 FLUX_EXPORT inline constexpr auto last = detail::last_fn{};
 FLUX_EXPORT inline constexpr auto size = detail::size_fn{};
 FLUX_EXPORT inline constexpr auto usize = detail::usize_fn{};
-FLUX_EXPORT inline constexpr auto for_each_while = detail::for_each_while_fn{};
+FLUX_EXPORT inline constexpr auto seq_for_each_while = detail::seq_for_each_while_fn {};
 
 namespace detail {
 
diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 41f16c2f..1689180a 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -52,7 +52,7 @@ constexpr bool test_cycle() {
 
         // Make sure internal iteration works as expected
         int counter = 101;
-        cur = flux::for_each_while(seq, [&counter](auto&&) { return counter-- > 0; });
+        cur = flux::seq_for_each_while(seq, [&counter](auto&&) { return counter-- > 0; });
         STATIC_CHECK(seq.distance(cur, seq.first()) == -101);
     }
 
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index a87070b8..bc56743f 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -49,8 +49,7 @@ constexpr bool test_repeat()
         // Check that internal iteration works as expected
         {
             auto counter = 0;
-            auto inner_cur =
-                flux::for_each_while(seq, [&](int) { return counter++ < 5; });
+            auto inner_cur = flux::seq_for_each_while(seq, [&](int) { return counter++ < 5; });
             STATIC_CHECK(inner_cur == 5);
         }
     }
@@ -164,15 +163,14 @@ constexpr bool test_repeat_bounded()
 
         // Check that internal iteration works as expected
         {
-            auto cur = flux::for_each_while(seq, flux::pred::true_);
+            auto cur = flux::seq_for_each_while(seq, flux::pred::true_);
             STATIC_CHECK(cur == seq.last());
         }
 
         // ...and again with early termination
         {
             auto counter = 0;
-            auto cur =
-                flux::for_each_while(seq, [&](int) { return counter++ < 3; });
+            auto cur = flux::seq_for_each_while(seq, [&](int) { return counter++ < 3; });
             STATIC_CHECK(cur == 3);
         }
     }

From e5102e023e724f6df34670b7006ab124976fb9c7 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 15 May 2025 16:49:23 +0100
Subject: [PATCH 04/66] Modify many algorithms to work on iterables

Not quite all of them yet though
---
 .clang-format                                |   1 +
 include/flux/algorithm/all_any_none.hpp      |  65 ++++-----
 include/flux/algorithm/compare.hpp           | 139 ++++++++++---------
 include/flux/algorithm/contains.hpp          |  24 ++--
 include/flux/algorithm/count.hpp             |  62 ++++-----
 include/flux/algorithm/ends_with.hpp         |  84 +++--------
 include/flux/algorithm/equal.hpp             | 114 ++++++++-------
 include/flux/algorithm/fill.hpp              |  64 +++++----
 include/flux/algorithm/find_element.hpp      |  40 ++++++
 include/flux/algorithm/fold.hpp              | 126 +++++++++--------
 include/flux/algorithm/for_each.hpp          |  25 ++--
 include/flux/algorithm/for_each_while.hpp    |  26 ++++
 include/flux/algorithm/minmax.hpp            |  78 ++++++-----
 include/flux/algorithm/output_to.hpp         |  58 ++++----
 include/flux/algorithm/starts_with.hpp       |  37 ++---
 include/flux/algorithm/swap_elements.hpp     |  35 ++---
 include/flux/algorithm/write_to.hpp          |  21 ++-
 include/flux/algorithm/zip_algorithms.hpp    |  48 +++++--
 include/flux/core/iterable_concepts.hpp      | 129 ++++++++++++++++-
 include/flux/core/operation_requirements.hpp |  17 ++-
 include/flux/core/utils.hpp                  |   2 +-
 test/test_iterable_concepts.cpp              |  58 +++++++-
 test/test_utils.hpp                          |  28 ++--
 23 files changed, 745 insertions(+), 536 deletions(-)
 create mode 100644 include/flux/algorithm/find_element.hpp
 create mode 100644 include/flux/algorithm/for_each_while.hpp

diff --git a/.clang-format b/.clang-format
index e0c2e3e7..7c884e39 100644
--- a/.clang-format
+++ b/.clang-format
@@ -18,5 +18,6 @@ IndentPPDirectives: AfterHash
 InsertBraces: true
 NamespaceIndentation: None
 PackConstructorInitializers: CurrentLine
+SpaceBeforeCpp11BracedList: false
 SortIncludes: Never
 TabWidth: 4
diff --git a/include/flux/algorithm/all_any_none.hpp b/include/flux/algorithm/all_any_none.hpp
index 26ca4583..edb17574 100644
--- a/include/flux/algorithm/all_any_none.hpp
+++ b/include/flux/algorithm/all_any_none.hpp
@@ -6,60 +6,51 @@
 #ifndef FLUX_ALGORITHM_ALL_ANY_NONE_HPP_INCLUDED
 #define FLUX_ALGORITHM_ALL_ANY_NONE_HPP_INCLUDED
 
-#include <flux/core.hpp>
+#include <flux/algorithm/for_each_while.hpp>
 
 namespace flux {
 
-namespace all_detail {
-
-struct fn {
-    template <sequence Seq, typename Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
-    constexpr bool operator()(Seq&& seq, Pred pred) const
+FLUX_EXPORT
+struct all_t {
+    template <iterable It, typename Pred>
+        requires std::predicate<Pred const&, iterable_element_t<It>>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it, Pred const pred) const -> bool
     {
-        return is_last(seq, seq_for_each_while(seq, [&](auto&& elem) {
-                           return std::invoke(pred, FLUX_FWD(elem));
-                       }));
+        return for_each_while(it, [&](auto&& elem) { return std::invoke(pred, FLUX_FWD(elem)); })
+            == iteration_result::complete;
     }
 };
 
-} // namespace all_detail
-
-FLUX_EXPORT inline constexpr auto all = all_detail::fn{};
-
-namespace none_detail {
+FLUX_EXPORT inline constexpr all_t all {};
 
-struct fn {
-    template <sequence Seq, typename Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
-    constexpr bool operator()(Seq&& seq, Pred pred) const
+FLUX_EXPORT
+struct none_t {
+    template <iterable It, typename Pred>
+        requires std::predicate<Pred&, iterable_element_t<It>>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it, Pred const pred) const -> bool
     {
-        return is_last(seq, seq_for_each_while(seq, [&](auto&& elem) {
-                           return !std::invoke(pred, FLUX_FWD(elem));
-                       }));
+        return for_each_while(it, [&](auto&& elem) { return !std::invoke(pred, FLUX_FWD(elem)); })
+            == iteration_result::complete;
     }
 };
 
-} // namespace none_detail
+FLUX_EXPORT inline constexpr none_t none {};
 
-FLUX_EXPORT inline constexpr auto none = none_detail::fn{};
-
-namespace any_detail {
-
-struct fn {
-    template <sequence Seq, typename Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
-    constexpr bool operator()(Seq&& seq, Pred pred) const
+FLUX_EXPORT
+struct any_t {
+    template <iterable It, typename Pred>
+        requires std::predicate<Pred&, iterable_element_t<It>>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it, Pred const pred) const -> bool
     {
-        return !is_last(seq, seq_for_each_while(seq, [&](auto&& elem) {
-                            return !std::invoke(pred, FLUX_FWD(elem));
-                        }));
+        return for_each_while(it, [&](auto&& elem) { return !std::invoke(pred, FLUX_FWD(elem)); })
+            == iteration_result::incomplete;
     }
 };
 
-} // namespace any_detail
-
-FLUX_EXPORT inline constexpr auto any = any_detail::fn{};
+FLUX_EXPORT inline constexpr any_t any {};
 
 template <typename D>
 template <typename Pred>
diff --git a/include/flux/algorithm/compare.hpp b/include/flux/algorithm/compare.hpp
index 82a1b17e..639da076 100644
--- a/include/flux/algorithm/compare.hpp
+++ b/include/flux/algorithm/compare.hpp
@@ -14,90 +14,97 @@
 
 namespace flux {
 
-namespace detail {
-
-struct compare_fn {
+FLUX_EXPORT
+struct compare_t {
 private:
-    template <typename Seq1, typename Seq2, typename Cmp>
-    static constexpr auto impl(Seq1& seq1, Seq2& seq2, Cmp& cmp)
-        -> std::decay_t<
-            std::invoke_result_t<Cmp &, element_t<Seq1>, element_t<Seq2>>>
+    template <iterable It1, iterable It2, typename Cmp>
+        requires ordering_invocable<Cmp&, iterable_element_t<It1>, iterable_element_t<It2>>
+    static constexpr auto impl(It1& it1, It2& it2, Cmp& cmp) -> std::decay_t<
+        std::invoke_result_t<Cmp&, iterable_element_t<It1>, iterable_element_t<It2>>>
     {
-        auto cur1 = flux::first(seq1);
-        auto cur2 = flux::first(seq2);
+        iteration_context auto ctx1 = iterate(it1);
+        iteration_context auto ctx2 = iterate(it2);
+
+        while (true) {
+            auto opt1 = next_element(ctx1);
+            auto opt2 = next_element(ctx2);
 
-        while (!flux::is_last(seq1, cur1) && !flux::is_last(seq2, cur2)) {
-            if (auto r = std::invoke(cmp, flux::read_at(seq1, cur1), flux::read_at(seq2, cur2));
-                r != 0) {
-                return r;
+            if (opt1.has_value() && opt2.has_value()) {
+                auto r = std::invoke(cmp, opt1.value(), opt2.value());
+                if (r != 0) {
+                    return r;
+                }
+            } else if (opt1.has_value()) {
+                return std::strong_ordering::greater;
+            } else if (opt2.has_value()) {
+                return std::strong_ordering::less;
+            } else {
+                return std::strong_ordering::equal;
             }
-            flux::inc(seq1, cur1);
-            flux::inc(seq2, cur2);
         }
+    }
 
-        return !flux::is_last(seq1, cur1) ? std::strong_ordering::greater :
-               !flux::is_last(seq2, cur2) ? std::strong_ordering::less :
-                                            std::strong_ordering::equal;
+    template <contiguous_sequence Seq1, contiguous_sequence Seq2>
+    static constexpr auto memcmp_impl(Seq1& seq1, Seq2& seq2) -> std::strong_ordering
+    {
+        auto const seq1_size = flux::usize(seq1);
+        auto const seq2_size = flux::usize(seq2);
+        auto min_size = (cmp::min)(seq1_size, seq2_size);
+
+        int cmp_result = 0;
+        if (min_size > 0) {
+            auto data1 = flux::data(seq1);
+            FLUX_ASSERT(data1 != nullptr);
+            auto data2 = flux::data(seq2);
+            FLUX_ASSERT(data2 != nullptr);
+
+            cmp_result = std::memcmp(data1, data2, min_size);
+        }
+
+        if (cmp_result == 0) {
+            if (seq1_size == seq2_size) {
+                return std::strong_ordering::equal;
+            } else if (seq1_size < seq2_size) {
+                return std::strong_ordering::less;
+            } else /* seq1_size > seq2_size */ {
+                return std::strong_ordering::greater;
+            }
+        } else if (cmp_result > 0) {
+            return std::strong_ordering::greater;
+        } else /* cmp_result < 0 */ {
+            return std::strong_ordering::less;
+        }
+    }
+
+    template <typename It1, typename It2, typename Cmp>
+    static consteval auto can_memcmp() -> bool
+    {
+        return std::same_as<Cmp, std::compare_three_way> && contiguous_sequence<It1>
+            && contiguous_sequence<It2> && sized_sequence<It1> && sized_sequence<It2>
+            && std::same_as<iterable_value_t<It1>, iterable_value_t<It2>>
+            && std::unsigned_integral<iterable_value_t<It1>>
+            && ((sizeof(iterable_value_t<It1>) == 1) || (std::endian::native == std::endian::big));
     }
 
 public:
-    template <sequence Seq1, sequence Seq2, typename Cmp = std::compare_three_way>
-        requires ordering_invocable<Cmp&, element_t<Seq1>, element_t<Seq2>>
-    constexpr auto operator()(Seq1 &&seq1, Seq2 &&seq2, Cmp cmp = {}) const
-        -> std::decay_t<
-            std::invoke_result_t<Cmp&, element_t<Seq1>, element_t<Seq2>>>
+    template <iterable It1, iterable It2, typename Cmp = std::compare_three_way>
+        requires ordering_invocable<Cmp&, iterable_element_t<It1>, iterable_element_t<It2>>
+    constexpr auto operator()(It1&& it1, It2&& it2, Cmp cmp = {}) const -> std::decay_t<
+        std::invoke_result_t<Cmp&, iterable_element_t<It1>, iterable_element_t<It2>>>
     {
-        constexpr bool can_memcmp = 
-            std::same_as<Cmp, std::compare_three_way> &&
-            contiguous_sequence<Seq1> && 
-            contiguous_sequence<Seq2> &&
-            sized_sequence<Seq1> && 
-            sized_sequence<Seq2> &&
-            std::same_as<value_t<Seq1>, value_t<Seq2>> &&
-            std::unsigned_integral<value_t<Seq1>> &&
-            ((sizeof(value_t<Seq1>) == 1) || (std::endian::native == std::endian::big));
-
-        if constexpr (can_memcmp) {
+        if constexpr (can_memcmp<It1, It2, Cmp>()) {
             if (std::is_constant_evaluated()) {
-                return impl(seq1, seq2, cmp); // LCOV_EXCL_LINE
+                return impl(it1, it2, cmp); // LCOV_EXCL_LINE
             } else {
-                auto const seq1_size = flux::usize(seq1);
-                auto const seq2_size = flux::usize(seq2);
-                auto min_size = (cmp::min)(seq1_size, seq2_size);
-
-                int cmp_result = 0;
-                if(min_size > 0) {
-                    auto data1 = flux::data(seq1);
-                    FLUX_ASSERT(data1 != nullptr);
-                    auto data2 = flux::data(seq2);
-                    FLUX_ASSERT(data2 != nullptr);
-
-                    cmp_result = std::memcmp(data1, data2, min_size);
-                }
-
-                if (cmp_result == 0) {
-                    if (seq1_size == seq2_size) {
-                        return std::strong_ordering::equal;
-                    } else if (seq1_size < seq2_size) {
-                        return std::strong_ordering::less;
-                    } else /* seq1_size > seq2_size */ {
-                        return std::strong_ordering::greater;
-                    }
-                } else if (cmp_result > 0) {
-                    return std::strong_ordering::greater;
-                } else /* cmp_result < 0 */ {
-                    return std::strong_ordering::less;
-                }
+                return memcmp_impl(it1, it2);
             }
         } else {
-            return impl(seq1, seq2, cmp);
+            return impl(it1, it2, cmp);
         }
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto compare = detail::compare_fn{};
+FLUX_EXPORT inline constexpr auto compare = compare_t{};
 
 } // namespace flux
 
diff --git a/include/flux/algorithm/contains.hpp b/include/flux/algorithm/contains.hpp
index fccbd85c..5096a3f5 100644
--- a/include/flux/algorithm/contains.hpp
+++ b/include/flux/algorithm/contains.hpp
@@ -6,28 +6,22 @@
 #ifndef FLUX_ALGORITHM_CONTAINS_HPP_INCLUDED
 #define FLUX_ALGORITHM_CONTAINS_HPP_INCLUDED
 
-#include <flux/core.hpp>
+#include <flux/algorithm/all_any_none.hpp>
 
 namespace flux {
 
-namespace detail {
-
-struct contains_fn {
-    template <sequence Seq, typename Value>
-        requires std::equality_comparable_with<element_t<Seq>, Value const&>
-    constexpr auto operator()(Seq&& seq, Value const& value) const
-        -> bool
+FLUX_EXPORT
+struct contains_t {
+    template <iterable It, typename Value>
+        requires std::equality_comparable_with<iterable_element_t<It>, Value const&>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it, Value const& value) const -> bool
     {
-        return !flux::is_last(seq, flux::seq_for_each_while(seq, [&](auto&& elem) {
-                                  return FLUX_FWD(elem) != value;
-                              }));
+        return any(it, [&](auto&& elem) { return FLUX_FWD(elem) == value; });
     }
 };
 
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto contains = detail::contains_fn{};
+FLUX_EXPORT inline constexpr contains_t contains {};
 
 template <typename D>
 template <typename Value>
diff --git a/include/flux/algorithm/count.hpp b/include/flux/algorithm/count.hpp
index 7df6e1d8..e4831028 100644
--- a/include/flux/algorithm/count.hpp
+++ b/include/flux/algorithm/count.hpp
@@ -6,69 +6,59 @@
 #ifndef FLUX_ALGORITHM_COUNT_HPP_INCLUDED
 #define FLUX_ALGORITHM_COUNT_HPP_INCLUDED
 
-#include <flux/core.hpp>
+#include <flux/algorithm/for_each.hpp>
 
 namespace flux {
 
-namespace detail {
-
-struct count_fn {
-    template <sequence Seq>
+FLUX_EXPORT
+struct count_t {
+    template <iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> int_t
+    constexpr auto operator()(It&& it) const -> int_t
     {
-        if constexpr (sized_sequence<Seq>) {
-            return flux::size(seq);
+        if constexpr (sized_iterable<It>) {
+            return flux::iterable_size(it);
         } else {
             int_t counter = 0;
-            flux::seq_for_each_while(seq, [&](auto&&) {
-                ++counter;
-                return true;
-            });
+            for_each(it, [&](auto&&) { counter = num::add(counter, int_t{1}); });
             return counter;
         }
     }
 };
 
-struct count_eq_fn {
-    template <sequence Seq, typename Value>
-        requires std::equality_comparable_with<element_t<Seq>, Value const&>
+FLUX_EXPORT inline constexpr count_t count{};
+
+FLUX_EXPORT
+struct count_if_t {
+    template <iterable It, typename Pred>
+        requires std::predicate<Pred&, iterable_element_t<It>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Value const& value) const -> int_t
+    constexpr auto operator()(It&& it, Pred pred) const -> int_t
     {
         int_t counter = 0;
-        flux::seq_for_each_while(seq, [&](auto&& elem) {
-            if (value == FLUX_FWD(elem)) {
+        for_each(it, [&](auto&& elem) {
+            if (std::invoke(pred, FLUX_FWD(elem))) {
                 ++counter;
             }
-            return true;
         });
         return counter;
     }
 };
 
-struct count_if_fn {
-    template <sequence Seq, typename Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
+FLUX_EXPORT inline constexpr count_if_t count_if{};
+
+FLUX_EXPORT
+struct count_eq_t {
+    template <iterable It, typename Value>
+        requires std::equality_comparable_with<iterable_element_t<It>, Value const&>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Pred pred) const -> int_t
+    constexpr auto operator()(It&& it, Value const& value) const -> int_t
     {
-        int_t counter = 0;
-        flux::seq_for_each_while(seq, [&](auto&& elem) {
-            if (std::invoke(pred, FLUX_FWD(elem))) {
-                ++counter;
-            }
-            return true;
-        });
-        return counter;
+        return count_if(it, [&](auto&& elem) { return value == FLUX_FWD(elem); });
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto count = detail::count_fn{};
-FLUX_EXPORT inline constexpr auto count_eq = detail::count_eq_fn{};
-FLUX_EXPORT inline constexpr auto count_if = detail::count_if_fn{};
+FLUX_EXPORT inline constexpr count_eq_t count_eq{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::count()
diff --git a/include/flux/algorithm/ends_with.hpp b/include/flux/algorithm/ends_with.hpp
index b3c87690..12c6d853 100644
--- a/include/flux/algorithm/ends_with.hpp
+++ b/include/flux/algorithm/ends_with.hpp
@@ -6,85 +6,41 @@
 #ifndef FLUX_ALGORITHM_ENDS_WITH_HPP_INCLUDED
 #define FLUX_ALGORITHM_ENDS_WITH_HPP_INCLUDED
 
+#include <flux/adaptor/drop.hpp>
+#include <flux/adaptor/reverse.hpp>
 #include <flux/algorithm/count.hpp>
 #include <flux/algorithm/equal.hpp>
+#include <flux/algorithm/starts_with.hpp>
 
 namespace flux {
 
-namespace detail {
-
-struct ends_with_fn {
-private:
-    template <typename H, typename N>
-    static constexpr auto bidir_impl(H& h, N& n, auto& cmp) -> bool
+FLUX_EXPORT
+struct ends_with_t {
+    template <iterable Haystack, iterable Needle, typename Cmp = std::ranges::equal_to>
+        requires std::predicate<Cmp&, iterable_element_t<Haystack>, iterable_element_t<Needle>>
+        && (multipass_sequence<Haystack> || sized_iterable<Haystack>)
+        && (multipass_sequence<Needle> || sized_iterable<Needle>)
+    [[nodiscard]]
+    constexpr auto operator()(Haystack&& haystack, Needle&& needle, Cmp cmp = Cmp{}) const -> bool
     {
-        if constexpr (sized_sequence<H> && sized_sequence<N>) {
-            if (flux::size(h) < flux::size(n)) {
-                return false;
-            }
-        }
-
-        auto cur1 = flux::last(h);
-        auto cur2 = flux::last(n);
-
-        auto const f1 = flux::first(h);
-        auto const f2 = flux::first(n);
-
-        if (cur2 == f2) {
-            return true;
-        } else if (cur1 == f1) {
-            return false;
-        }
-
-        while (true) {
-            flux::dec(h, cur1);
-            flux::dec(n, cur2);
-
-            if (!std::invoke(cmp, flux::read_at(h, cur1), flux::read_at(n, cur2))) {
-                return false;
-            }
-
-            if (cur2 == f2) {
-                return true;
-            } else if (cur1 == f1) {
-                return false;
-            }
-        }
-    }
-
-public:
-    template <sequence Haystack, sequence Needle, typename Cmp = std::ranges::equal_to>
-        requires std::predicate<Cmp&, element_t<Haystack>, element_t<Needle>> &&
-                 (multipass_sequence<Haystack> || sized_sequence<Haystack>) &&
-                 (multipass_sequence<Needle> || sized_sequence<Needle>)
-    constexpr auto operator()(Haystack&& haystack, Needle&& needle, Cmp cmp = Cmp{}) const
-        -> bool
-    {
-        if constexpr(bidirectional_sequence<Haystack> &&
-                     bounded_sequence<Haystack> &&
-                     bidirectional_sequence<Needle> &&
-                     bounded_sequence<Needle>) {
-            return bidir_impl(haystack, needle, cmp);
+        if constexpr (reverse_iterable<Haystack> && reverse_iterable<Needle>) {
+            return starts_with(reverse(from_fwd_ref(haystack)), reverse(from_fwd_ref(needle)),
+                               std::ref(cmp));
         } else {
-            int_t len1 = flux::count(haystack);
-            int_t len2 = flux::count(needle);
+            int_t haystack_size = flux::count(haystack);
+            int_t needle_size = flux::count(needle);
 
-            if (len1 < len2) {
+            if (haystack_size < needle_size) {
                 return false;
             }
 
-            auto cur1 = flux::first(haystack);
-            detail::advance(haystack, cur1, len1 - len2);
-
-            return flux::equal(flux::slice(haystack, std::move(cur1), flux::last),
-                               needle, std::move(cmp));
+            return equal(drop(from_fwd_ref(haystack), num::sub(haystack_size, needle_size)), needle,
+                         std::ref(cmp));
         }
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto ends_with = detail::ends_with_fn{};
+FLUX_EXPORT inline constexpr auto ends_with = ends_with_t{};
 
 template <typename Derived>
 template <sequence Needle, typename Cmp>
diff --git a/include/flux/algorithm/equal.hpp b/include/flux/algorithm/equal.hpp
index 2ba36888..89370ce5 100644
--- a/include/flux/algorithm/equal.hpp
+++ b/include/flux/algorithm/equal.hpp
@@ -12,89 +12,97 @@
 
 namespace flux {
 
-namespace detail {
-
-struct equal_fn {
+FLUX_EXPORT
+struct equal_t {
 private:
-    template <typename Seq1, typename Seq2, typename Cmp>
-    static constexpr auto impl(Seq1& seq1, Seq2& seq2, Cmp cmp)
+    template <typename It1, typename It2, typename Cmp>
+    static constexpr auto impl(It1& it1, It2& it2, Cmp& cmp) -> bool
     {
-        auto cur1 = flux::first(seq1);
-        auto cur2 = flux::first(seq2);
+        iteration_context auto ctx1 = iterate(it1);
+        iteration_context auto ctx2 = iterate(it2);
+
+        while (true) {
+            flux::optional opt1 = next_element(ctx1);
+            flux::optional opt2 = next_element(ctx2);
 
-        while (!flux::is_last(seq1, cur1) && !flux::is_last(seq2, cur2)) {
-            if (!std::invoke(cmp, flux::read_at(seq1, cur1), flux::read_at(seq2, cur2))) {
+            if (opt1.has_value() && opt2.has_value()) {
+                if (!std::invoke(cmp, opt1.value(), opt2.value())) {
+                    return false;
+                }
+            } else if (opt1.has_value() || opt2.has_value()) {
                 return false;
+            } else {
+                return true;
             }
-            flux::inc(seq1, cur1);
-            flux::inc(seq2, cur2);
         }
+    }
+
+    template <contiguous_sequence Seq1, contiguous_sequence Seq2>
+    static constexpr auto memcmp_impl(Seq1& seq1, Seq2& seq2) -> bool
+    {
+        auto size = flux::usize(seq1);
+        if (size == 0) {
+            return true;
+        }
+
+        auto data1 = flux::data(seq1);
+        auto data2 = flux::data(seq2);
+        FLUX_ASSERT(data1 != nullptr);
+        FLUX_ASSERT(data2 != nullptr);
 
-        return flux::is_last(seq1, cur1) == flux::is_last(seq2, cur2);
+        auto result = std::memcmp(data1, data2, size * sizeof(iterable_value_t<Seq1>));
+        return result == 0;
+    }
+
+    template <typename It1, typename It2, typename Cmp>
+    static consteval auto can_memcmp() -> bool
+    {
+        return std::same_as<Cmp, std::ranges::equal_to> && contiguous_sequence<It1>
+            && contiguous_sequence<It2> && sized_sequence<It1> && sized_sequence<It2>
+            && std::same_as<iterable_value_t<It1>, iterable_value_t<It2>>
+            && (std::integral<iterable_value_t<It1>> || std::is_pointer_v<iterable_value_t<It1>>)
+            && std::has_unique_object_representations_v<iterable_value_t<It1>>;
     }
 
 public:
-    template <sequence Seq1, sequence Seq2, typename Cmp = std::ranges::equal_to>
-        requires std::predicate<Cmp&, element_t<Seq1>, element_t<Seq2>>
-    constexpr auto operator()(Seq1&& seq1, Seq2&& seq2, Cmp cmp = {}) const
-        -> bool
+    template <iterable It1, iterable It2, typename Cmp = std::ranges::equal_to>
+        requires std::predicate<Cmp&, iterable_element_t<It1>, iterable_element_t<It2>>
+    constexpr auto operator()(It1&& it1, It2&& it2, Cmp cmp = {}) const -> bool
     {
-        if constexpr (sized_sequence<Seq1> && sized_sequence<Seq2>) {
-            if (flux::size(seq1) != flux::size(seq2)) {
+        if constexpr (sized_iterable<It1> && sized_iterable<It2>) {
+            if (flux::iterable_size(it1) != flux::iterable_size(it2)) {
                 return false;
             }
         }
 
-        constexpr bool can_memcmp = 
-            std::same_as<Cmp, std::ranges::equal_to> &&
-            contiguous_sequence<Seq1> && contiguous_sequence<Seq2> &&
-            sized_sequence<Seq1> && sized_sequence<Seq2> &&
-            std::same_as<value_t<Seq1>, value_t<Seq2>> &&
-            (std::integral<value_t<Seq1>> || std::is_pointer_v<value_t<Seq1>>) &&
-            std::has_unique_object_representations_v<value_t<Seq1>>;
-
-        if constexpr (can_memcmp) {
+        if constexpr (can_memcmp<It1, It2, Cmp>()) {
             if (std::is_constant_evaluated()) {
-                return impl(seq1, seq2, cmp); // LCOV_EXCL_LINE
+                return impl(it1, it2, cmp); // LCOV_EXCL_LINE
             } else {
-                auto size = flux::usize(seq1);
-                if(size == 0) {
-                    return true;
-                }
-
-                auto data1 = flux::data(seq1);
-                auto data2 = flux::data(seq2);
-                FLUX_ASSERT(data1 != nullptr);
-                FLUX_ASSERT(data2 != nullptr);
-
-                auto result = std::memcmp(data1, data2, size * sizeof(value_t<Seq1>));
-                return result == 0;
+                return memcmp_impl(it1, it2);
             }
         } else {
-            return impl(seq1, seq2, cmp);
+            return impl(it1, it2, cmp);
         }
     }
 
-    template <sequence Seq1, sequence Seq2>
-        requires (sequence<element_t<Seq1>> &&
-                 sequence<element_t<Seq2>> &&
-                 !std::equality_comparable_with<element_t<Seq1>, element_t<Seq2>> &&
-                 std::is_invocable_v<equal_fn&, Seq1&, Seq2&, equal_fn&>)
-    constexpr auto operator()(Seq1&& seq1, Seq2&& seq2) const -> bool
+    template <iterable It1, iterable It2>
+        requires iterable<iterable_element_t<It1>> && iterable<iterable_element_t<It2>>
+        && (!std::equality_comparable_with<iterable_element_t<It1>, iterable_element_t<It2>>
+            && std::is_invocable_v<equal_t&, It1&, It2&, equal_t&>)
+    constexpr auto operator()(It1&& it1, It2&& it2) const -> bool
     {
-        if constexpr (sized_sequence<Seq1> && sized_sequence<Seq2>) {
-            if (flux::size(seq1) != flux::size(seq2)) {
+        if constexpr (sized_iterable<It1> && sized_iterable<It2>) {
+            if (flux::iterable_size(it1) != flux::iterable_size(it2)) {
                 return false;
             }
         }
 
-        return (*this)(seq1, seq2, *this);
+        return (*this)(it1, it2, *this);
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto equal = detail::equal_fn{};
+FLUX_EXPORT inline constexpr equal_t equal{};
 
 } // namespace flux
 
diff --git a/include/flux/algorithm/fill.hpp b/include/flux/algorithm/fill.hpp
index 71c57066..94c3c6c5 100644
--- a/include/flux/algorithm/fill.hpp
+++ b/include/flux/algorithm/fill.hpp
@@ -11,51 +11,49 @@
 
 namespace flux {
 
-namespace detail {
-
-struct fill_fn {
+FLUX_EXPORT
+struct fill_t {
 private:
+    template <typename It, typename Value>
+    static constexpr auto impl(It&& it, Value const& value) -> void
+    {
+        flux::for_each(it, [&value](auto&& elem) { FLUX_FWD(elem) = value; });
+    }
+
     template <typename Seq, typename Value>
-    static constexpr auto impl(Seq& seq, Value const& value)
+    static constexpr auto memset_impl(Seq& seq, Value const& value) -> void
     {
-        flux::for_each(seq, [&value](auto&& elem) { FLUX_FWD(elem) = value; });
+        if (std::is_constant_evaluated()) {
+            impl(seq, value); // LCOV_EXCL_LINE
+        } else {
+            auto size = flux::usize(seq);
+            if (size == 0) {
+                return;
+            }
+
+            FLUX_ASSERT(flux::data(seq) != nullptr);
+
+            std::memset(flux::data(seq), value, size * sizeof(value_t<Seq>));
+        }
     }
 
 public:
-    template <typename Value, writable_sequence_of<Value> Seq>
-    constexpr void operator()(Seq&& seq, Value const& value) const
+    template <iterable It, typename Value>
+        requires std::assignable_from<element_t<It>, Value const&>
+    constexpr auto operator()(It&& it, Value const& value) const -> void
     {
-        constexpr bool can_memset = 
-            contiguous_sequence<Seq> &&
-            sized_sequence<Seq> &&
-            std::same_as<Value, value_t<Seq>> &&
-            // only allow memset on single byte types
-            sizeof(value_t<Seq>) == 1 &&
-            std::is_trivially_copyable_v<value_t<Seq>>;
-
-        if constexpr (can_memset) {
-            if (std::is_constant_evaluated()) {
-                impl(seq, value); // LCOV_EXCL_LINE
-            } else {
-                auto size = flux::usize(seq);
-                if(size == 0) {
-                    return;
-                }
-                
-                FLUX_ASSERT(flux::data(seq) != nullptr);
-                
-                std::memset(flux::data(seq), value,
-                    size * sizeof(value_t<Seq>));
-            }
+        if constexpr (contiguous_sequence<It> && sized_sequence<It>
+                      && std::same_as<Value, iterable_value_t<It>>
+                      // only allow memset on single byte types
+                      && sizeof(value_t<It>) == 1 && std::is_trivially_copyable_v<value_t<It>>) {
+            memset_impl(it, value);
         } else {
-            impl(seq, value);
+            impl(it, value);
         }
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto fill = detail::fill_fn{};
+FLUX_EXPORT inline constexpr fill_t fill {};
 
 template <typename D>
 template <typename Value>
diff --git a/include/flux/algorithm/find_element.hpp b/include/flux/algorithm/find_element.hpp
new file mode 100644
index 00000000..c9359d5f
--- /dev/null
+++ b/include/flux/algorithm/find_element.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2025 Tristan Brindle (tcbrindle at gmail dot com)
+// 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 FLUX_ALGORITHM_FIND_ELEMENT_HPP_INCLUDED
+#define FLUX_ALGORITHM_FIND_ELEMENT_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+namespace flux {
+
+FLUX_EXPORT
+struct find_element_if_t {
+    template <iterable It, typename Pred>
+        requires std::predicate<Pred&, iterable_element_t<It>>
+    constexpr auto operator()(It&& it, Pred pred) const
+    {
+        iterable auto filtered = filter(std::ref(it), std::ref(pred));
+        iteration_context auto ctx = iterate(filtered);
+        return next_element(ctx);
+    }
+};
+
+FLUX_EXPORT inline constexpr find_element_if_t find_element_if{};
+
+FLUX_EXPORT
+struct find_element_t {
+    template <iterable It, typename Value>
+        requires std::equality_comparable_with<iterable_element_t<It>, Value const&>
+    constexpr auto operator()(It&& it, Value const& value) const
+    {
+        return find_element_if(it, [&value](auto&& elem) { return FLUX_FWD(elem) == value; });
+    }
+};
+
+FLUX_EXPORT inline constexpr find_element_t find_element{};
+
+} // namespace flux
+
+#endif // FLUX_ALGORITHM_FIND_ELEMENT_HPP_INCLUDED
diff --git a/include/flux/algorithm/fold.hpp b/include/flux/algorithm/fold.hpp
index e60f2b42..88f9fb8b 100644
--- a/include/flux/algorithm/fold.hpp
+++ b/include/flux/algorithm/fold.hpp
@@ -6,23 +6,22 @@
 #ifndef FLUX_ALGORITHM_FOLD_HPP_INCLUDED
 #define FLUX_ALGORITHM_FOLD_HPP_INCLUDED
 
-#include <flux/core.hpp>
+#include <flux/algorithm/for_each_while.hpp>
 
 namespace flux {
 
-namespace detail {
-
-struct fold_op {
-    template <sequence Seq, typename Func, std::movable Init = value_t<Seq>,
-              typename R = fold_result_t<Seq, Func, Init>>
-        requires std::invocable<Func&,  Init, element_t<Seq>> &&
-                 std::invocable<Func&, R, element_t<Seq>> &&
-                 std::convertible_to<Init, R> &&
-                 std::assignable_from<Init&, std::invoke_result_t<Func&, R, element_t<Seq>>>
-    constexpr auto operator()(Seq&& seq, Func func, Init init = Init{}) const -> R
+FLUX_EXPORT
+struct fold_t {
+    template <iterable It, typename Func, std::movable Init = iterable_value_t<It>,
+              typename R = fold_result_t<It, Func, Init>>
+        requires std::invocable<Func&, Init, element_t<It>>
+        && std::invocable<Func&, R, element_t<It>> && std::convertible_to<Init, R>
+        && std::assignable_from<Init&, std::invoke_result_t<Func&, R, element_t<It>>>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it, Func func, Init init = Init{}) const -> R
     {
         R init_ = R(std::move(init));
-        flux::seq_for_each_while(seq, [&func, &init_](auto&& elem) {
+        for_each_while(it, [&func, &init_](auto&& elem) {
             init_ = std::invoke(func, std::move(init_), FLUX_FWD(elem));
             return true;
         });
@@ -30,31 +29,39 @@ struct fold_op {
     }
 };
 
-struct fold_first_op {
-    template <sequence Seq, typename Func, typename V = value_t<Seq>>
-        requires std::invocable<Func&, V, element_t<Seq>> &&
-                 std::assignable_from<value_t<Seq>&, std::invoke_result_t<Func&, V&&, element_t<Seq>>>
+FLUX_EXPORT inline constexpr auto fold = fold_t{};
+
+FLUX_EXPORT
+struct fold_first_t {
+    template <iterable It, typename Func, typename V = iterable_value_t<It>>
+        requires std::invocable<Func&, V, iterable_element_t<It>>
+        && std::assignable_from<iterable_value_t<It>&,
+                                std::invoke_result_t<Func&, V&&, iterable_element_t<It>>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Func func) const -> flux::optional<V>
+    constexpr auto operator()(It&& it, Func func) const -> flux::optional<V>
     {
-        auto cur = flux::first(seq);
+        iteration_context auto ctx = iterate(it);
 
-        if (flux::is_last(seq, cur)) {
-            return std::nullopt;
-        }
-
-        V init(flux::read_at(seq, cur));
-        flux::inc(seq, cur);
+        auto opt = next_element(ctx);
 
-        while (!flux::is_last(seq, cur)) {
-            init = std::invoke(func, std::move(init), flux::read_at(seq, cur));
-            flux::inc(seq, cur);
+        if (!opt.has_value()) {
+            return flux::nullopt;
         }
 
+        V init = std::move(opt).value();
+        run_while(ctx, [&](auto&& elem) {
+            init = std::invoke(func, std::move(init), FLUX_FWD(elem));
+            return loop_continue;
+        });
+
         return flux::optional<V>(std::in_place, std::move(init));
     }
 };
 
+FLUX_EXPORT inline constexpr fold_first_t fold_first{};
+
+namespace detail {
+
 // Workaround libc++18 invoke() bug: https://github.com/llvm/llvm-project/issues/106428
 consteval bool libcpp_fold_invoke_workaround_required()
 {
@@ -65,66 +72,67 @@ consteval bool libcpp_fold_invoke_workaround_required()
 #endif
 }
 
-struct sum_op {
-    template <sequence Seq>
-        requires std::default_initializable<value_t<Seq>> &&
-                 std::invocable<fold_op, Seq, std::plus<>>
+} // namespace detail
+
+FLUX_EXPORT
+struct sum_t {
+    template <iterable It>
+        requires std::invocable<fold_t, It, std::plus<>> && requires { iterable_value_t<It>(0); }
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> value_t<Seq>
+    constexpr auto operator()(It&& it) const -> iterable_value_t<It>
     {
-        if constexpr (num::integral<value_t<Seq>>) {
-            if constexpr (libcpp_fold_invoke_workaround_required()) {
+        if constexpr (num::integral<iterable_value_t<It>>) {
+            if constexpr (detail::libcpp_fold_invoke_workaround_required()) {
                 auto add = []<typename T>(T lhs, T rhs) -> T { return num::add(lhs, rhs); };
-                return fold_op{}(FLUX_FWD(seq), add, value_t<Seq>(0));
+                return fold(FLUX_FWD(it), add, iterable_value_t<It>(0));
             } else {
-                return fold_op{}(FLUX_FWD(seq), num::add, value_t<Seq>(0));
+                return fold(FLUX_FWD(it), num::add, iterable_value_t<It>(0));
             }
         } else {
-            return fold_op{}(FLUX_FWD(seq), std::plus<>{}, value_t<Seq>(0));
+            return fold(FLUX_FWD(it), std::plus<>{}, iterable_value_t<It>(0));
         }
     }
 };
 
-struct product_op {
-    template <sequence Seq>
-        requires std::invocable<fold_op, Seq, std::multiplies<>> &&
-                 requires { value_t<Seq>(1); }
+FLUX_EXPORT inline constexpr auto sum = sum_t{};
+
+FLUX_EXPORT
+struct product_t {
+    template <iterable It>
+        requires std::invocable<fold_t, It, std::multiplies<>>
+        && requires { iterable_value_t<It>(1); }
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> value_t<Seq>
+    constexpr auto operator()(It&& it) const -> iterable_value_t<It>
     {
-        if constexpr (num::integral<value_t<Seq>>) {
-            if constexpr (libcpp_fold_invoke_workaround_required()) {
+        if constexpr (num::integral<iterable_value_t<It>>) {
+            if constexpr (detail::libcpp_fold_invoke_workaround_required()) {
                 auto mul = []<typename T>(T lhs, T rhs) -> T { return num::mul(lhs, rhs); };
-                return fold_op{}(FLUX_FWD(seq), mul, value_t<Seq>(1));
+                return fold(FLUX_FWD(it), mul, iterable_value_t<It>(1));
             } else {
-                return fold_op{}(FLUX_FWD(seq), num::mul, value_t<Seq>(1));
+                return fold(FLUX_FWD(it), num::mul, iterable_value_t<It>(1));
             }
         } else {
-            return fold_op{}(FLUX_FWD(seq), std::multiplies<>{}, value_t<Seq>(1));
+            return fold(FLUX_FWD(it), std::multiplies<>{}, iterable_value_t<It>(1));
         }
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto fold = detail::fold_op{};
-FLUX_EXPORT inline constexpr auto fold_first = detail::fold_first_op{};
-FLUX_EXPORT inline constexpr auto sum = detail::sum_op{};
-FLUX_EXPORT inline constexpr auto product = detail::product_op{};
+FLUX_EXPORT inline constexpr auto product = product_t{};
 
 template <typename Derived>
 template <typename D, typename Func, typename Init>
     requires foldable<Derived, Func, Init>
 [[nodiscard]]
-constexpr auto inline_sequence_base<Derived>::fold(Func func, Init init) -> fold_result_t<D, Func, Init>
+constexpr auto inline_sequence_base<Derived>::fold(Func func, Init init)
+    -> fold_result_t<D, Func, Init>
 {
     return flux::fold(derived(), std::move(func), std::move(init));
 }
 
 template <typename Derived>
 template <typename D, typename Func>
-    requires std::invocable<Func&, value_t<D>, element_t<D>> &&
-             std::assignable_from<value_t<D>&, std::invoke_result_t<Func&, value_t<D>, element_t<D>>>
+    requires std::invocable<Func&, value_t<D>, element_t<D>>
+    && std::assignable_from<value_t<D>&, std::invoke_result_t<Func&, value_t<D>, element_t<D>>>
 constexpr auto inline_sequence_base<Derived>::fold_first(Func func)
 {
     return flux::fold_first(derived(), std::move(func));
@@ -132,16 +140,14 @@ constexpr auto inline_sequence_base<Derived>::fold_first(Func func)
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::sum()
-    requires foldable<D, std::plus<>, value_t<D>> &&
-             std::default_initializable<value_t<D>>
+    requires foldable<D, std::plus<>, value_t<D>> && std::default_initializable<value_t<D>>
 {
     return flux::sum(derived());
 }
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::product()
-    requires foldable<D, std::multiplies<>, value_t<D>> &&
-             requires { value_t<D>(1); }
+    requires foldable<D, std::multiplies<>, value_t<D>> && requires { value_t<D>(1); }
 {
     return flux::product(derived());
 }
diff --git a/include/flux/algorithm/for_each.hpp b/include/flux/algorithm/for_each.hpp
index 0d4f853c..5b3292d8 100644
--- a/include/flux/algorithm/for_each.hpp
+++ b/include/flux/algorithm/for_each.hpp
@@ -6,30 +6,25 @@
 #ifndef FLUX_ALGORITHM_FOR_EACH_HPP_INCLUDED
 #define FLUX_ALGORITHM_FOR_EACH_HPP_INCLUDED
 
-#include <flux/core.hpp>
+#include <flux/algorithm/for_each_while.hpp>
 
 namespace flux {
 
-namespace detail {
-
-struct for_each_fn {
-
-    template <sequence Seq, typename Func>
-        requires (std::invocable<Func&, element_t<Seq>> &&
-                  !infinite_sequence<Seq>)
-    constexpr auto operator()(Seq&& seq, Func func) const -> Func
+FLUX_EXPORT
+struct for_each_t {
+    template <iterable It, typename Func>
+        requires std::invocable<Func&, iterable_element_t<It>>
+    constexpr auto operator()(It&& it, Func func) const -> Func
     {
-        (void)flux::seq_for_each_while(FLUX_FWD(seq), [&](auto&& elem) {
-            std::invoke(func, FLUX_FWD(elem));
-            return true;
+        for_each_while(it, [&](auto&& elem) {
+            static_cast<void>(std::invoke(func, FLUX_FWD(elem)));
+            return loop_continue;
         });
         return func;
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto for_each = detail::for_each_fn{};
+FLUX_EXPORT inline constexpr for_each_t for_each {};
 
 template <typename D>
 template <typename Func>
diff --git a/include/flux/algorithm/for_each_while.hpp b/include/flux/algorithm/for_each_while.hpp
new file mode 100644
index 00000000..b8d5ba94
--- /dev/null
+++ b/include/flux/algorithm/for_each_while.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2025 Tristan Brindle (tcbrindle at gmail dot com)
+// 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 FLUX_ALGORITHM_FOR_EACH_WHILE_HPP_INCLUDED
+#define FLUX_ALGORITHM_FOR_EACH_WHILE_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+namespace flux {
+
+FLUX_EXPORT
+struct for_each_while_t {
+    template <iterable It, callable_mut<bool(iterable_element_t<It>)> Pred>
+    constexpr auto operator()(It&& it, Pred&& pred) const -> iteration_result
+    {
+        iteration_context auto ctx = iterate(it);
+        return ctx.run_while(FLUX_FWD(pred));
+    }
+};
+
+FLUX_EXPORT inline constexpr for_each_while_t for_each_while {};
+
+} // namespace flux
+
+#endif // FLUX_ALGORITHM_FOR_EACH_WHILE_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/algorithm/minmax.hpp b/include/flux/algorithm/minmax.hpp
index 52018419..0f0829f7 100644
--- a/include/flux/algorithm/minmax.hpp
+++ b/include/flux/algorithm/minmax.hpp
@@ -19,17 +19,16 @@ struct minmax_result {
     T max;
 };
 
-namespace detail {
-
-struct min_op {
-    template <sequence Seq, weak_ordering_for<Seq> Cmp = std::compare_three_way>
+FLUX_EXPORT
+struct min_t {
+    template <iterable It, weak_ordering_for<It> Cmp = std::compare_three_way>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Cmp cmp = Cmp{}) const
-        -> flux::optional<value_t<Seq>>
+    constexpr auto operator()(It&& it, Cmp cmp = Cmp{}) const
+        -> flux::optional<iterable_value_t<It>>
     {
-        return flux::fold_first(FLUX_FWD(seq), [&](auto min, auto&& elem) -> value_t<Seq> {
+        return fold_first(FLUX_FWD(it), [&](auto min, auto&& elem) -> iterable_value_t<It> {
             if (std::invoke(cmp, elem, min) < 0) {
-                return value_t<Seq>(FLUX_FWD(elem));
+                return iterable_value_t<It>(FLUX_FWD(elem));
             } else {
                 return min;
             }
@@ -37,15 +36,18 @@ struct min_op {
     }
 };
 
-struct max_op {
-    template <sequence Seq, weak_ordering_for<Seq> Cmp = std::compare_three_way>
+FLUX_EXPORT inline constexpr min_t min{};
+
+FLUX_EXPORT
+struct max_t {
+    template <iterable It, weak_ordering_for<It> Cmp = std::compare_three_way>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Cmp cmp = Cmp{}) const
-        -> flux::optional<value_t<Seq>>
+    constexpr auto operator()(It&& it, Cmp cmp = Cmp{}) const
+        -> flux::optional<iterable_value_t<It>>
     {
-        return flux::fold_first(FLUX_FWD(seq), [&](auto max, auto&& elem) -> value_t<Seq> {
+        return fold_first(FLUX_FWD(it), [&](auto max, auto&& elem) -> iterable_value_t<It> {
             if (!(std::invoke(cmp, elem, max) < 0)) {
-                return value_t<Seq>(FLUX_FWD(elem));
+                return iterable_value_t<It>(FLUX_FWD(elem));
             } else {
                 return max;
             }
@@ -53,42 +55,42 @@ struct max_op {
     }
 };
 
-struct minmax_op {
-    template <sequence Seq, weak_ordering_for<Seq> Cmp = std::compare_three_way>
+FLUX_EXPORT inline constexpr max_t max{};
+
+FLUX_EXPORT
+struct minmax_t {
+    template <iterable It, weak_ordering_for<It> Cmp = std::compare_three_way>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Cmp cmp = Cmp{}) const
-        -> flux::optional<minmax_result<value_t<Seq>>>
+    constexpr auto operator()(It&& it, Cmp cmp = Cmp{}) const
+        -> flux::optional<minmax_result<iterable_value_t<It>>>
     {
-        using R = minmax_result<value_t<Seq>>;
+        using R = minmax_result<iterable_value_t<It>>;
 
-        auto cur = flux::first(seq);
-        if (flux::is_last(seq, cur)) {
-            return std::nullopt;
+        iteration_context auto ctx = iterate(it);
+
+        auto opt = next_element(ctx);
+        if (!opt.has_value()) {
+            return flux::nullopt;
         }
 
-        R init = R{value_t<Seq>(flux::read_at(seq, cur)),
-                   value_t<Seq>(flux::read_at(seq, cur))};
+        auto min = iterable_value_t<It>(opt.value());
+        auto max = iterable_value_t<It>(std::move(opt).value());
 
-        auto fold_fn = [&](R mm, auto&& elem) -> R {
-            if (std::invoke(cmp, elem, mm.min) < 0) {
-                mm.min = value_t<Seq>(elem);
+        run_while(ctx, [&](auto&& elem) {
+            if (std::invoke(cmp, elem, min) < 0) {
+                min = iterable_value_t<It>(elem);
             }
-            if (!(std::invoke(cmp, elem, mm.max) < 0)) {
-                mm.max = value_t<Seq>(FLUX_FWD(elem));
+            if (!(std::invoke(cmp, elem, max) < 0)) {
+                max = iterable_value_t<It>(FLUX_FWD(elem));
             }
-            return mm;
-        };
+            return loop_continue;
+        });
 
-        return flux::optional<R>(std::in_place,
-                                flux::fold(flux::slice(seq, std::move(cur), flux::last), fold_fn, std::move(init)));
+        return flux::optional<R>(R(std::move(min), std::move(max)));
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto min = detail::min_op{};
-FLUX_EXPORT inline constexpr auto max = detail::max_op{};
-FLUX_EXPORT inline constexpr auto minmax = detail::minmax_op{};
+FLUX_EXPORT inline constexpr minmax_t minmax{};
 
 template <typename Derived>
 template <typename Cmp>
diff --git a/include/flux/algorithm/output_to.hpp b/include/flux/algorithm/output_to.hpp
index 3815df7f..9bd03586 100644
--- a/include/flux/algorithm/output_to.hpp
+++ b/include/flux/algorithm/output_to.hpp
@@ -13,43 +13,49 @@
 
 namespace flux {
 
-namespace detail {
-
-struct output_to_fn {
+FLUX_EXPORT
+struct output_to_t {
 private:
     template <typename Seq, typename Iter>
-    static constexpr auto impl(Seq& seq, Iter& iter) -> Iter
+    static constexpr auto impl(Seq& seq, Iter iter) -> Iter
     {
-        flux::for_each(seq, [&iter](auto&& elem) {
+        for_each(seq, [&iter](auto&& elem) {
             *iter = FLUX_FWD(elem);
             ++iter;
         });
         return iter;
     }
 
+    template <typename Seq, typename Iter>
+    static consteval auto can_memcpy() -> bool
+    {
+        return contiguous_sequence<Seq> && sized_sequence<Seq> && std::contiguous_iterator<Iter>
+            && std::is_trivially_copyable_v<value_t<Seq>>;
+    }
+
+    template <typename Seq, typename Iter>
+    static constexpr auto memcpy_impl(Seq& seq, Iter iter) -> Iter
+    {
+        auto size = flux::usize(seq);
+        if (size == 0) {
+            return iter;
+        }
+        FLUX_ASSERT(flux::data(seq) != nullptr);
+        std::memmove(std::to_address(iter), flux::data(seq), size * sizeof(value_t<Seq>));
+        return iter + num::cast<std::iter_difference_t<Iter>>(flux::size(seq));
+    }
+
 public:
-    template <sequence Seq, std::weakly_incrementable Iter>
-        requires std::indirectly_writable<Iter, element_t<Seq>>
+    template <iterable Seq, typename Iter>
+        requires std::weakly_incrementable<Iter>
+        && std::indirectly_writable<Iter, iterable_element_t<Seq>>
     constexpr auto operator()(Seq&& seq, Iter iter) const -> Iter
     {
-        constexpr bool can_memcpy =
-            contiguous_sequence<Seq> &&
-            sized_sequence<Seq> &&
-            std::contiguous_iterator<Iter> &&
-            std::is_trivially_copyable_v<value_t<Seq>>;
-
-        if constexpr (can_memcpy) {
+        if constexpr (can_memcpy<Seq, Iter>()) {
             if (std::is_constant_evaluated()) {
                 return impl(seq, iter); // LCOV_EXCL_LINE
             } else {
-                auto size = flux::usize(seq);
-                if (size == 0) {
-                    return iter;
-                }
-                FLUX_ASSERT(flux::data(seq) != nullptr);
-                std::memmove(std::to_address(iter), flux::data(seq),
-                             size * sizeof(value_t<Seq>));
-                return iter + num::checked_cast<std::iter_difference_t<Iter>>(flux::size(seq));
+                return memcpy_impl(seq, iter);
             }
         } else {
             return impl(seq, iter);
@@ -57,19 +63,15 @@ struct output_to_fn {
     }
 };
 
-}
-
-FLUX_EXPORT inline constexpr auto output_to = detail::output_to_fn{};
+FLUX_EXPORT inline constexpr output_to_t output_to{};
 
 template <typename D>
 template <typename Iter>
-    requires std::weakly_incrementable<Iter> &&
-             std::indirectly_writable<Iter, element_t<D>>
+    requires std::weakly_incrementable<Iter> && std::indirectly_writable<Iter, element_t<D>>
 constexpr auto inline_sequence_base<D>::output_to(Iter iter) -> Iter
 {
     return flux::output_to(derived(), std::move(iter));
 }
-
 }
 
 #endif // FLUX_ALGORITHM_OUTPUT_TO_HPP_INCLUDED
diff --git a/include/flux/algorithm/starts_with.hpp b/include/flux/algorithm/starts_with.hpp
index 5ebf88bd..36f44b14 100644
--- a/include/flux/algorithm/starts_with.hpp
+++ b/include/flux/algorithm/starts_with.hpp
@@ -10,37 +10,40 @@
 
 namespace flux {
 
-namespace detail {
-
-struct starts_with_fn {
-    template <sequence Haystack, sequence Needle, typename Cmp = std::ranges::equal_to>
+FLUX_EXPORT
+struct starts_with_t {
+    template <iterable Haystack, iterable Needle, typename Cmp = std::ranges::equal_to>
         requires std::predicate<Cmp&, element_t<Haystack>, element_t<Needle>>
+    [[nodiscard]]
     constexpr auto operator()(Haystack&& haystack, Needle&& needle, Cmp cmp = Cmp{}) const -> bool
     {
-        if constexpr (sized_sequence<Haystack> && sized_sequence<Needle>) {
-            if (flux::size(haystack) < flux::size(needle)) {
+        if constexpr (sized_iterable<Haystack> && sized_iterable<Needle>) {
+            if (flux::iterable_size(haystack) < flux::iterable_size(needle)) {
                 return false;
             }
         }
 
-        auto h = flux::first(haystack);
-        auto n = flux::first(needle);
+        iteration_context auto haystack_ctx = iterate(haystack);
+        iteration_context auto needle_ctx = iterate(needle);
+
+        while (true) {
+            auto haystack_elem = next_element(haystack_ctx);
+            auto needle_elem = next_element(needle_ctx);
 
-        while (!flux::is_last(haystack, h) && !flux::is_last(needle, n)) {
-            if (!std::invoke(cmp, flux::read_at(haystack, h), flux::read_at(needle, n))) {
+            if (haystack_elem.has_value() && needle_elem.has_value()) {
+                if (!std::invoke(cmp, haystack_elem.value(), needle_elem.value())) {
+                    return false;
+                }
+            } else if (needle_elem.has_value()) {
                 return false;
+            } else {
+                return true;
             }
-            flux::inc(haystack, h);
-            flux::inc(needle, n);
         }
-
-        return flux::is_last(needle, n);
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto starts_with = detail::starts_with_fn{};
+FLUX_EXPORT inline constexpr starts_with_t starts_with{};
 
 template <typename Derived>
 template <sequence Needle, typename Cmp>
diff --git a/include/flux/algorithm/swap_elements.hpp b/include/flux/algorithm/swap_elements.hpp
index a0ad44a3..7d1e1b70 100644
--- a/include/flux/algorithm/swap_elements.hpp
+++ b/include/flux/algorithm/swap_elements.hpp
@@ -10,28 +10,29 @@
 
 namespace flux {
 
-namespace detail {
-
-struct swap_elements_fn {
-    template <sequence Seq1, sequence Seq2>
-        requires element_swappable_with<Seq1&, Seq2&>
-    constexpr void operator()(Seq1&& seq1, Seq2&& seq2) const
+FLUX_EXPORT
+struct swap_elements_t {
+    template <iterable It1, iterable It2>
+        requires std::swappable_with<iterable_element_t<It1>, iterable_element_t<It2>>
+    constexpr auto operator()(It1&& it1, It2&& it2) const -> void
     {
-        auto cur1 = flux::first(seq1);
-        auto cur2 = flux::first(seq2);
-
-        while (!flux::is_last(seq1, cur1) && !flux::is_last(seq2, cur2)) {
-            flux::swap_with(seq1, cur1, seq2, cur2);
-            flux::inc(seq1, cur1);
-            flux::inc(seq2, cur2);
+        iteration_context auto ctx1 = iterate(it1);
+        iteration_context auto ctx2 = iterate(it2);
+
+        while (true) {
+            auto opt1 = next_element(ctx1);
+            auto opt2 = next_element(ctx2);
+
+            if (opt1.has_value() && opt2.has_value()) {
+                std::ranges::swap(*std::move(opt1), *std::move(opt2));
+            } else {
+                break;
+            }
         }
     }
 };
 
-}
-
-FLUX_EXPORT inline constexpr auto swap_elements = detail::swap_elements_fn{};
-
+FLUX_EXPORT inline constexpr swap_elements_t swap_elements{};
 }
 
 #endif // FLUX_ALGORITHM_SWAP_ELEMENTS_HPP_INCLUDED
diff --git a/include/flux/algorithm/write_to.hpp b/include/flux/algorithm/write_to.hpp
index 0886ffbe..2a532fdd 100644
--- a/include/flux/algorithm/write_to.hpp
+++ b/include/flux/algorithm/write_to.hpp
@@ -12,27 +12,24 @@
 
 namespace flux {
 
-namespace detail {
-
-struct write_to_fn {
-
-    template <sequence Seq, typename OStream>
+FLUX_EXPORT
+struct write_to_t {
+    template <iterable It, typename OStream>
         requires std::derived_from<OStream, std::ostream>
-    auto operator()(Seq&& seq, OStream& os) const
-        -> std::ostream&
+    auto operator()(It&& it, OStream& os) const -> OStream&
     {
         bool first = true;
         os << '[';
 
-        flux::for_each(FLUX_FWD(seq), [&os, &first](auto&& elem) {
+        for_each(it, [&os, &first](auto&& elem) {
             if (first) {
                 first = false;
             } else {
                 os << ", ";
             }
 
-            if constexpr (sequence<element_t<Seq>>) {
-                write_to_fn{}(FLUX_FWD(elem), os);
+            if constexpr (iterable<iterable_element_t<It>>) {
+                write_to_t{}(FLUX_FWD(elem), os);
             } else {
                 os << FLUX_FWD(elem);
             }
@@ -43,9 +40,7 @@ struct write_to_fn {
     }
 };
 
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto write_to = detail::write_to_fn{};
+FLUX_EXPORT inline constexpr write_to_t write_to{};
 
 template <typename Derived>
 auto inline_sequence_base<Derived>::write_to(std::ostream& os) -> std::ostream&
diff --git a/include/flux/algorithm/zip_algorithms.hpp b/include/flux/algorithm/zip_algorithms.hpp
index 32c92a5b..f1522b4e 100644
--- a/include/flux/algorithm/zip_algorithms.hpp
+++ b/include/flux/algorithm/zip_algorithms.hpp
@@ -5,7 +5,8 @@
 #ifndef FLUX_ALGORITHM_ZIP_ALGORITHMS_HPP_INCLUDED
 #define FLUX_ALGORITHM_ZIP_ALGORITHMS_HPP_INCLUDED
 
-#include <flux/core.hpp>
+#include <flux/algorithm/find.hpp>
+#include <flux/algorithm/for_each_while.hpp>
 
 namespace flux {
 
@@ -13,24 +14,27 @@ namespace detail {
 
 struct zip_for_each_while_fn {
     template <typename Pred, sequence... Seqs>
-        requires std::invocable<Pred&, element_t<Seqs>...> &&
-                 boolean_testable<std::invoke_result_t<Pred&, element_t<Seqs>...>>
-    constexpr auto operator()(Pred pred, Seqs&&... seqs) const
-        -> std::tuple<cursor_t<Seqs>...>
+        requires std::invocable<Pred&, element_t<Seqs>...>
+        && boolean_testable<std::invoke_result_t<Pred&, element_t<Seqs>...>>
+    constexpr auto operator()(Pred pred, Seqs&&... seqs) const -> iteration_result
     {
         if constexpr (sizeof...(Seqs) == 0) {
-            return std::tuple<>{};
+            return {};
         } else if constexpr (sizeof...(Seqs) == 1) {
-            return std::tuple<cursor_t<Seqs>...>(flux::seq_for_each_while(seqs..., std::ref(pred)));
+            return flux::for_each_while(seqs..., std::ref(pred));
         } else {
-            return [&pred, &...seqs = seqs, ...curs = flux::first(seqs)]() mutable {
-                while (!(flux::is_last(seqs, curs) || ...)) {
-                    if (!std::invoke(pred, flux::read_at_unchecked(seqs, curs)...)) {
-                        break;
+            return [&pred, ... ctxs = iterate(seqs)]() mutable {
+                return [&pred, &ctxs..., ... opts = step(ctxs, std::identity {})]() mutable {
+                    while (true) {
+                        if (!(opts.has_value() && ...)) {
+                            return iteration_result::complete;
+                        }
+                        if (!std::invoke(pred, opts.value_unchecked()...)) {
+                            return iteration_result::incomplete;
+                        }
+                        ((opts = step(ctxs, std::identity {})), ...);
                     }
-                    (flux::inc(seqs, curs), ...);
-                }
-                return std::tuple<cursor_t<Seqs>...>(std::move(curs)...);
+                }();
             }();
         }
     }
@@ -61,7 +65,21 @@ struct zip_find_if_fn {
     constexpr auto operator()(Pred pred, Seqs&&... seqs) const
         -> std::tuple<cursor_t<Seqs>...>
     {
-        return zip_for_each_while(std::not_fn(pred), seqs...);
+        if constexpr (sizeof...(Seqs) == 0) {
+            return {};
+        } else if constexpr (sizeof...(Seqs) == 1) {
+            return std::tuple<cursor_t<Seqs>...>(flux::find_if(seqs..., std::ref(pred)));
+        } else {
+            return [&pred, &... seqs = seqs, ... curs = first(seqs)]() mutable {
+                while ((!is_last(seqs, curs) && ...)) {
+                    if (std::invoke(pred, read_at_unchecked(seqs, curs)...)) {
+                        break;
+                    }
+                    ((inc(seqs, curs)), ...);
+                }
+                return std::tuple<cursor_t<Seqs>...>(std::move(curs)...);
+            }();
+        }
     }
 };
 
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 8e3d3380..3b4be154 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -6,6 +6,7 @@
 #define FLUX_CORE_ITERABLE_CONCEPTS_HPP_INCLUDED
 
 #include <flux/core/concepts.hpp>
+#include <flux/core/numeric.hpp>
 #include <flux/core/optional.hpp>
 
 namespace flux {
@@ -46,7 +47,7 @@ FLUX_EXPORT
 struct step_t {
     template <iteration_context Ctx, typename Fn>
         requires callable_once<Fn, void(context_element_t<Ctx>)>
-    constexpr auto operator()(Ctx& ctx, Fn&& fn)
+    constexpr auto operator()(Ctx& ctx, Fn fn) const
     {
         using E = context_element_t<Ctx>;
         using R = callable_result_t<Fn, E>;
@@ -73,7 +74,21 @@ struct step_t {
     }
 };
 
-FLUX_EXPORT inline constexpr step_t step {};
+FLUX_EXPORT inline constexpr step_t step{};
+
+FLUX_EXPORT
+struct next_element_t {
+    template <iteration_context Ctx>
+    constexpr auto operator()(Ctx& ctx) const
+        -> std::conditional_t<std::is_rvalue_reference_v<context_element_t<Ctx>>,
+                              flux::optional<std::remove_cvref_t<context_element_t<Ctx>>>,
+                              flux::optional<context_element_t<Ctx>>>
+    {
+        return step(ctx, std::identity{});
+    }
+};
+
+FLUX_EXPORT inline constexpr next_element_t next_element{};
 
 /*
  * MARK: Iterable
@@ -115,8 +130,8 @@ concept has_member_iterate = requires(T& t) {
 };
 
 template <typename T>
-concept can_iterate = has_valid_iter_traits<T> || has_member_iterate<T>
-    || std::ranges::input_range<T> || sequence<T>;
+concept can_iterate = has_valid_iter_traits<T> || has_member_iterate<T> || sequence<T>
+    || std::ranges::input_range<T>;
 
 template <std::ranges::input_range R>
 struct range_iteration_context : immovable {
@@ -253,7 +268,7 @@ struct iterate_t {
     constexpr auto operator()(It& it) const -> iteration_context auto
     {
         if constexpr (detail::has_valid_iter_traits<It>) {
-            return iterable_traits<It>::iterate(it);
+            return detail::iter_traits_t<It>::iterate(it);
         } else if constexpr (detail::has_member_iterate<It>) {
             return it.iterate();
         } else if constexpr (sequence<It>) {
@@ -266,13 +281,113 @@ struct iterate_t {
 
 FLUX_EXPORT inline constexpr iterate_t iterate {};
 
+FLUX_EXPORT template <typename I>
+using iteration_context_t = decltype(iterate(std::declval<I&>()));
+
+FLUX_EXPORT template <typename I>
+using iterable_element_t = context_element_t<iteration_context_t<I>>;
+
+namespace detail {
+
+// Try to work out the value type of the iterable
+// * If iterable_context_t<T>::value_type exists, use that
+// * otherwise, if iterable_traits<T>::value_type exists, use that
+// * otherwise, if T::value_type exists, use that,
+// * otherwise, fall back to std::remove_cvref_t<iterable_element_t<T>>
+
+template <typename T>
+concept has_context_value_type = requires { typename iteration_context_t<T>::value_type; };
+
+template <typename T>
+concept has_traits_value_type = requires { typename iter_traits_t<T>::value_type; };
+
+template <typename T>
+concept has_member_value_type = requires { typename T::value_type; };
+
+template <typename T>
+struct iterable_value_type {
+    using type = std::remove_cvref_t<iterable_element_t<T>>;
+};
+
+template <typename T>
+    requires has_context_value_type<T>
+struct iterable_value_type<T> {
+    using type = typename iteration_context_t<T>::value_type;
+};
+
+template <typename T>
+    requires has_traits_value_type<T> && (!has_context_value_type<T>)
+struct iterable_value_type<T> {
+    using type = typename iter_traits_t<T>::value_type;
+};
+
+template <typename T>
+    requires has_member_value_type<T> && (!has_context_value_type<T> && !has_traits_value_type<T>)
+struct iterable_value_type<T> {
+    using type = std::remove_cvref_t<iterable_element_t<T>>;
+};
+
+} // namespace detail
+
+FLUX_EXPORT template <typename I>
+using iterable_value_t = typename detail::iterable_value_type<I>::type;
+
+FLUX_EXPORT template <typename Seq>
+using iterable_common_element_t = std::common_reference_t<element_t<Seq>, value_t<Seq>&>;
+
 FLUX_EXPORT template <typename It>
 concept iterable = requires(It& it) {
     { iterate(it) } -> iteration_context;
+} && requires {
+    typename iterable_value_t<It>;
+} && std::is_object_v<iterable_value_t<It>> && std::common_reference_with<iterable_element_t<It>&&, iterable_value_t<It>&>;
+
+/*
+ * MARK: Sized iterable
+ */
+
+namespace detail {
+
+template <typename T>
+concept has_iterable_traits_size = requires(T& t) {
+    { iter_traits_t<T>::size(t) } -> num::integral;
 };
 
-FLUX_EXPORT template <iterable I>
-using iteration_context_t = decltype(iterate(std::declval<I&>()));
+template <typename T>
+concept has_member_size = has_member_iterate<T> && requires(T& t) {
+    { t.size() } -> num::integral;
+};
+
+template <typename T>
+concept is_sized_iterable = has_iterable_traits_size<T> || has_member_size<T> || sized_sequence<T>
+    || std::ranges::sized_range<T>;
+
+} // namespace detail
+
+struct iterable_size_fn_t {
+    template <typename It>
+        requires detail::is_sized_iterable<It>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it) const -> int_t
+    {
+        if constexpr (detail::has_iterable_traits_size<It>) {
+            return num::cast<int_t>(detail::iter_traits_t<It>::size(it));
+        } else if constexpr (detail::has_member_size<It>) {
+            return num::cast<int_t>(it.size());
+        } else if constexpr (sized_sequence<It>) {
+            return sequence_traits<std::remove_cvref_t<It>>::size(it);
+        } else if constexpr (std::ranges::sized_range<It>) {
+            return num::cast<int_t>(std::ranges::ssize(it));
+        }
+    }
+};
+
+FLUX_EXPORT inline constexpr iterable_size_fn_t iterable_size{};
+
+FLUX_EXPORT template <typename It>
+concept sized_iterable = iterable<It> && requires(It&& it) {
+    { iterable_size(it) } -> std::same_as<int_t>;
+};
 
 /*
  * MARK: Reverse iterable
diff --git a/include/flux/core/operation_requirements.hpp b/include/flux/core/operation_requirements.hpp
index f5f4c9b3..5d8f6274 100644
--- a/include/flux/core/operation_requirements.hpp
+++ b/include/flux/core/operation_requirements.hpp
@@ -7,6 +7,7 @@
 #define FLUX_CORE_OPERATION_REQUIREMENTS_HPP_INCLUDED
 
 #include <flux/core/concepts.hpp>
+#include <flux/core/iterable_concepts.hpp>
 
 namespace flux {
 
@@ -52,15 +53,13 @@ concept foldable =
     detail::foldable_<Seq, Func, Init>;
 
 FLUX_EXPORT
-template <typename Fn, typename Seq1, typename Seq2 = Seq1>
-concept weak_ordering_for =
-    sequence<Seq1> &&
-    sequence<Seq2> &&
-    ordering_invocable<Fn&, element_t<Seq1>, element_t<Seq2>, std::weak_ordering> &&
-    ordering_invocable<Fn&, value_t<Seq1>&, element_t<Seq2>, std::weak_ordering> &&
-    ordering_invocable<Fn&, element_t<Seq1>, value_t<Seq2>&, std::weak_ordering> &&
-    ordering_invocable<Fn&, value_t<Seq1>&, value_t<Seq2>&, std::weak_ordering> &&
-    ordering_invocable<Fn&, common_element_t<Seq1>, common_element_t<Seq2>, std::weak_ordering>;
+template <typename Fn, typename It1, typename It2 = It1>
+concept weak_ordering_for = iterable<It1> && iterable<It2>
+    && ordering_invocable<Fn&, iterable_element_t<It1>, iterable_element_t<It2>, std::weak_ordering>
+    && ordering_invocable<Fn&, iterable_value_t<It1>&, iterable_value_t<It2>&, std::weak_ordering>
+    && ordering_invocable<Fn&, iterable_value_t<It1>&, iterable_value_t<It2>&, std::weak_ordering>
+    && ordering_invocable<Fn&, iterable_common_element_t<It1>, iterable_common_element_t<It2>,
+                          std::weak_ordering>;
 
 } // namespace flux
 
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 43677afb..0889a38a 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -111,7 +111,7 @@ template <callable_once<void()> Fn>
 struct [[nodiscard("Discarded defer_t will execute its associated function immediately")]] defer_t {
     FLUX_NO_UNIQUE_ADDRESS Fn fn;
 
-    ~defer_t() { fn(); }
+    constexpr ~defer_t() { fn(); }
 };
 
 // template <typename F>
diff --git a/test/test_iterable_concepts.cpp b/test/test_iterable_concepts.cpp
index c3a21d74..04392b49 100644
--- a/test/test_iterable_concepts.cpp
+++ b/test/test_iterable_concepts.cpp
@@ -185,4 +185,60 @@ static_assert(flux::reverse_iterable<std::initializer_list<int>>);
 
 static_assert(flux::reverse_iterable<decltype(flux::iota(0, 10))>);
 
-} // namespace
\ No newline at end of file
+} // namespace
+
+/*
+ * sized_iterable concept tests
+ */
+
+namespace {
+
+// Things that are not sized iterable
+
+static_assert(not flux::sized_iterable<int>);
+static_assert(not flux::sized_iterable<int*>);
+static_assert(not flux::sized_iterable<int[]>);
+static_assert(not flux::sized_iterable<void>);
+static_assert(not flux::sized_iterable<void*>);
+static_assert(not flux::sized_iterable<incomplete>);
+static_assert(not flux::sized_iterable<empty>);
+static_assert(not flux::sized_iterable<has_empty_iter_traits_specialisation>);
+static_assert(not flux::sized_iterable<has_incorrect_iter_traits_specialisation>);
+static_assert(not flux::sized_iterable<has_valid_iter_traits_specialisation>);
+
+struct has_invalid_member_size {
+    auto iterate() -> minimal_iteration_context { return {}; }
+    auto size() -> bool { return false; }
+};
+
+static_assert(not flux::sized_iterable<has_invalid_member_size>);
+
+struct has_sized_iter_traits_specialisation { };
+
+} // namespace
+
+template <>
+struct flux::iterable_traits<has_sized_iter_traits_specialisation> {
+    static auto iterate(has_sized_iter_traits_specialisation&) -> minimal_iteration_context
+    {
+        return {};
+    }
+
+    static auto size(has_sized_iter_traits_specialisation&) -> int_t { return 0; }
+};
+
+namespace {
+
+// Things that *are* sized iterable
+static_assert(flux::sized_iterable<has_sized_iter_traits_specialisation>);
+static_assert(flux::sized_iterable<int (&)[5]>);
+static_assert(flux::sized_iterable<int const (&)[5]>);
+static_assert(flux::sized_iterable<std::initializer_list<int>>);
+
+struct has_member_size {
+    auto iterate() -> minimal_iteration_context { return {}; }
+    auto size() -> int { return 0; }
+};
+static_assert(flux::sized_iterable<has_member_size>);
+
+} // namespace
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index eb0e8958..0b29c96c 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -24,21 +24,27 @@ inline namespace test_utils {
 
 inline constexpr struct {
 private:
-    static constexpr bool impl(flux::sequence auto&& seq1, flux::sequence auto&& seq2)
+    static constexpr bool impl(flux::iterable auto&& it1, flux::iterable auto&& it2)
     {
         using namespace flux;
 
-        auto cur1 = first(seq1);
-        auto cur2 = first(seq2);
-
-        while (!is_last(seq1, cur1) && !is_last(seq2, cur2)) {
-            if (read_at(seq1, cur1) != read_at(seq2, cur2)) { return false; }
-
-            inc(seq1, cur1);
-            inc(seq2, cur2);
+        auto ctx1 = iterate(it1);
+        auto ctx2 = iterate(it2);
+
+        while (true) {
+            auto opt1 = next_element(ctx1);
+            auto opt2 = next_element(ctx2);
+
+            if (opt1.has_value() && opt2.has_value()) {
+                if (*opt1 != *opt2) {
+                    return false;
+                }
+            } else if (opt1.has_value() || opt2.has_value()) {
+                return false;
+            } else {
+                return true;
+            }
         }
-
-        return is_last(seq1, cur1) == is_last(seq2, cur2);
     }
 
 public:

From d42b5404fca3d29823e5c81a47c2105c122e3897 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 15 May 2025 17:46:08 +0100
Subject: [PATCH 05/66] Add find_element tests

---
 include/flux/algorithm.hpp              |  1 +
 include/flux/algorithm/find_element.hpp |  2 +
 test/CMakeLists.txt                     |  1 +
 test/test_find_element.cpp              | 99 +++++++++++++++++++++++++
 4 files changed, 103 insertions(+)
 create mode 100644 test/test_find_element.cpp

diff --git a/include/flux/algorithm.hpp b/include/flux/algorithm.hpp
index 676d3830..9a507eb2 100644
--- a/include/flux/algorithm.hpp
+++ b/include/flux/algorithm.hpp
@@ -14,6 +14,7 @@
 #include <flux/algorithm/equal.hpp>
 #include <flux/algorithm/fill.hpp>
 #include <flux/algorithm/find.hpp>
+#include <flux/algorithm/find_element.hpp>
 #include <flux/algorithm/find_min_max.hpp>
 #include <flux/algorithm/fold.hpp>
 #include <flux/algorithm/for_each.hpp>
diff --git a/include/flux/algorithm/find_element.hpp b/include/flux/algorithm/find_element.hpp
index c9359d5f..331e7d86 100644
--- a/include/flux/algorithm/find_element.hpp
+++ b/include/flux/algorithm/find_element.hpp
@@ -13,6 +13,7 @@ FLUX_EXPORT
 struct find_element_if_t {
     template <iterable It, typename Pred>
         requires std::predicate<Pred&, iterable_element_t<It>>
+    [[nodiscard]]
     constexpr auto operator()(It&& it, Pred pred) const
     {
         iterable auto filtered = filter(std::ref(it), std::ref(pred));
@@ -27,6 +28,7 @@ FLUX_EXPORT
 struct find_element_t {
     template <iterable It, typename Value>
         requires std::equality_comparable_with<iterable_element_t<It>, Value const&>
+    [[nodiscard]]
     constexpr auto operator()(It&& it, Value const& value) const
     {
         return find_element_if(it, [&value](auto&& elem) { return FLUX_FWD(elem) == value; });
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 8712d2da..3d1a6853 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -52,6 +52,7 @@ add_executable(test-flux
     test_filter.cpp
     test_filter_map.cpp
     test_find.cpp
+    test_find_element.cpp
     test_find_if.cpp
     test_find_if_not.cpp
     test_find_min_max.cpp
diff --git a/test/test_find_element.cpp b/test/test_find_element.cpp
new file mode 100644
index 00000000..0a4241e1
--- /dev/null
+++ b/test/test_find_element.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) 2025 Tristan Brindle (tcbrindle at gmail dot com)
+// 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)
+
+#include <doctest/doctest.h>
+
+#include "test_utils.hpp"
+
+namespace {
+
+constexpr bool test_find_element_if()
+{
+    {
+        std::array arr{1, 2, 3, 4, 5};
+
+        auto elem = flux::find_element_if(arr, flux::pred::eq(3));
+
+        static_assert(std::same_as<decltype(elem), flux::optional<int&>>);
+
+        STATIC_CHECK(elem.has_value());
+        STATIC_CHECK(*elem == 3);
+        STATIC_CHECK(&*elem == arr.data() + 2);
+
+        *elem = 99;
+        STATIC_CHECK(check_equal(arr, {1, 2, 99, 4, 5}));
+    }
+
+    {
+        std::array const arr{1, 2, 3, 4, 5};
+
+        auto elem = flux::find_element_if(arr, [](auto&&) { return false; });
+
+        static_assert(std::same_as<decltype(elem), flux::optional<int const&>>);
+
+        STATIC_CHECK(not elem.has_value());
+    }
+
+    return true;
+}
+static_assert(test_find_element_if());
+
+constexpr bool test_find_element()
+{
+    {
+        std::array arr{1, 2, 3, 4, 5};
+
+        auto elem = flux::find_element(arr, 3);
+
+        static_assert(std::same_as<decltype(elem), flux::optional<int&>>);
+
+        STATIC_CHECK(elem.has_value());
+        STATIC_CHECK(*elem == 3);
+        STATIC_CHECK(&*elem == arr.data() + 2);
+
+        *elem = 99;
+        STATIC_CHECK(check_equal(arr, {1, 2, 99, 4, 5}));
+    }
+
+    {
+        std::array const arr{1, 2, 3, 4, 5};
+
+        auto elem = flux::find_element(arr, 9999);
+
+        static_assert(std::same_as<decltype(elem), flux::optional<int const&>>);
+
+        STATIC_CHECK(not elem.has_value());
+    }
+
+    {
+        std::array arr{1, 2, 3, 4, 5};
+
+        auto copies = flux::map(arr, flux::copy);
+
+        auto elem = flux::find_element(copies, 3);
+
+        static_assert(std::same_as<decltype(elem), flux::optional<int>>);
+
+        STATIC_CHECK(elem.has_value());
+        STATIC_CHECK(*elem == 3);
+
+        *elem = 999;
+
+        STATIC_CHECK(check_equal(arr, {1, 2, 3, 4, 5}));
+    }
+
+    return true;
+}
+static_assert(test_find_element());
+
+} // namespace
+
+TEST_CASE("find_element")
+{
+    bool r = test_find_element_if();
+    REQUIRE(r);
+
+    r = test_find_element();
+    REQUIRE(r);
+}
\ No newline at end of file

From da005daafeff244d6c0cfc5f819b4550d74664bb Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 16 May 2025 17:49:20 +0100
Subject: [PATCH 06/66] Update ranges::to to use iterables

...and while we're at it, use the new std::from_range constructors in C++23 if we can, and the revised formulation for appending elements
---
 include/flux/adaptor/cartesian_base.hpp |   2 +-
 include/flux/algorithm/to.hpp           | 175 +++++++++++++++---------
 include/flux/core.hpp                   |   1 +
 include/flux/core/as_range.hpp          |  90 ++++++++++++
 include/flux/core/iterable_concepts.hpp |   1 +
 test/test_to.cpp                        |   8 +-
 6 files changed, 205 insertions(+), 72 deletions(-)
 create mode 100644 include/flux/core/as_range.hpp

diff --git a/include/flux/adaptor/cartesian_base.hpp b/include/flux/adaptor/cartesian_base.hpp
index 21dea805..3791fa14 100644
--- a/include/flux/adaptor/cartesian_base.hpp
+++ b/include/flux/adaptor/cartesian_base.hpp
@@ -19,7 +19,7 @@ inline constexpr auto checked_pow =
 {
     T res{1};
     for(U i{0}; i < exponent; i++) {
-        res = num::mul(res, base, loc);
+        res = num::checked_mul(res, base, loc);
     }
     return res;
 };
diff --git a/include/flux/algorithm/to.hpp b/include/flux/algorithm/to.hpp
index 6f3d06c9..874f9830 100644
--- a/include/flux/algorithm/to.hpp
+++ b/include/flux/algorithm/to.hpp
@@ -10,51 +10,61 @@
 #include <flux/adaptor/map.hpp>
 #include <flux/algorithm/output_to.hpp>
 
+#if defined(__cpp_lib_ranges_to_container) && (__cpp_lib_ranges_to_container >= 202202L)
+#    define FLUX_HAVE_FROM_RANGE_CONSTRUCTORS
+#endif
+
 namespace flux {
 
 FLUX_EXPORT
-struct from_sequence_t {
-    explicit from_sequence_t() = default;
+struct from_iterable_t {
+    explicit from_iterable_t() = default;
 };
 
-FLUX_EXPORT inline constexpr auto from_sequence = from_sequence_t{};
+FLUX_EXPORT inline constexpr auto from_iterable = from_iterable_t{};
 
 namespace detail {
 
-template <typename C, typename Seq, typename... Args>
-concept direct_sequence_constructible =
-    std::constructible_from<C, Seq, Args...>;
+template <typename C, typename It, typename... Args>
+concept direct_iterable_constructible = std::constructible_from<C, It, Args...>;
+
+template <typename C, typename It, typename... Args>
+concept from_iterable_constructible = std::constructible_from<C, from_iterable_t, It, Args...>;
 
-template <typename C, typename Seq, typename... Args>
-concept from_sequence_constructible =
-    std::constructible_from<C, from_sequence_t, Seq, Args...>;
+#ifdef FLUX_HAVE_FROM_RANGE_CONSTRUCTORS
+template <typename C, typename It, typename... Args>
+concept from_range_constructible
+    = std::constructible_from<C, std::from_range_t, decltype(as_range(std::declval<It>())),
+                              Args...>;
+#else
+template <typename...>
+concept from_range_constructible = false;
+#endif
 
 template <typename C>
 using container_value_t = typename C::value_type; // Let's just assume it exists
 
-template <sequence Seq>
-using common_iterator_t =
-    std::ranges::iterator_t<decltype(std::views::common(FLUX_DECLVAL(Seq)))>;
+template <iterable It>
+using common_iterator_t
+    = std::ranges::iterator_t<decltype(std::views::common(as_range(std::declval<It>())))>;
 
-
-template <typename C, typename Seq, typename... Args>
-concept cpp17_range_constructible =
-    std::constructible_from<C, common_iterator_t<Seq>, common_iterator_t<Seq>, Args...>;
+template <typename C, typename It, typename... Args>
+concept cpp17_range_constructible
+    = std::constructible_from<C, common_iterator_t<It>, common_iterator_t<It>, Args...>;
 
 template <typename C, typename Elem>
-concept container_insertable =
-    requires (C& c, Elem&& elem) {
-        requires (requires { c.push_back(FLUX_FWD(elem)); } ||
-                  requires { c.insert(c.end(), FLUX_FWD(elem)); });
-    };
+concept container_appendable = requires(C& c, Elem&& elem) {
+    requires(
+        requires { c.emplace_back(FLUX_FWD(elem)); } || requires { c.push_back(FLUX_FWD(elem)); }
+        || requires { c.emplace(c.end(), FLUX_FWD(elem)); }
+        || requires { c.insert(c.end(), FLUX_FWD(elem)); });
+};
 
-template <typename C, typename Seq, typename... Args>
-concept container_convertible =
-    direct_sequence_constructible<C, Seq, Args...> ||
-    from_sequence_constructible<C, Seq, Args...> ||
-    cpp17_range_constructible<C, Seq, Args...> ||
-    (  std::constructible_from<C, Args...> &&
-        container_insertable<C, element_t<Seq>>);
+template <typename C, typename It, typename... Args>
+concept container_convertible
+    = direct_iterable_constructible<C, It, Args...> || from_iterable_constructible<C, It, Args...>
+    || from_range_constructible<C, It, Args...> || cpp17_range_constructible<C, It, Args...>
+    || (std::constructible_from<C, Args...> && container_appendable<C, iterable_element_t<It>>);
 
 template <typename C>
 concept reservable_container =
@@ -65,43 +75,69 @@ concept reservable_container =
         { c.capacity() } -> std::same_as<std::ranges::range_size_t<C>>;
     };
 
-template <typename Elem, typename C>
-constexpr auto make_inserter(C& c)
+template <typename Container>
+constexpr auto container_appender(Container& c)
 {
-    if constexpr (requires { c.push_back(FLUX_DECLVAL(Elem)); }) {
-        return std::back_inserter(c);
-    } else {
-        return std::inserter(c, c.end());
-    }
+    return [&c](auto&& elem) {
+        if constexpr (requires { c.emplace_back(FLUX_FWD(elem)); }) {
+            c.emplace_back(FLUX_FWD(elem));
+        } else if constexpr (requires { c.push_back(FLUX_FWD(elem)); }) {
+            c.push_back(FLUX_FWD(elem));
+            // } else if constexpr (requires { c.emplace(c.end(), FLUX_FWD(elem)); }) {
+            //     c.emplace(c.end(), FLUX_FWD(elem));
+        } else {
+            c.insert(c.end(), FLUX_FWD(elem));
+        }
+    };
 }
 
 template <template <typename...> typename C, typename Seq, typename... Args>
-using ctad_direct_seq = decltype(C(FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...));
+using ctad_direct_iterable = decltype(C(FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...));
 
 template <template <typename...> typename C, typename Seq, typename... Args>
-using ctad_from_seq = decltype((C(from_sequence, FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...)));
+using ctad_from_iterable = decltype((C(from_iterable, FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...)));
+
+#ifdef FLUX_HAVE_FROM_RANGE_CONSTRUCTORS
+template <template <typename...> typename C, typename It, typename... Args>
+using ctad_from_range
+    = decltype((C(std::from_range, as_range(std::declval<It>()), std::declval<Args>()...)));
+#else
+template <typename...>
+struct nonesuch { };
+
+template <template <typename...> typename, typename... Args>
+using ctad_from_range = typename nonesuch<Args...>::type;
+#endif
 
 template <template <typename...> typename C, typename Seq, typename... Args>
-using ctad_from_iters = decltype(C(FLUX_DECLVAL(common_iterator_t<Seq>), FLUX_DECLVAL(common_iterator_t<Seq>), FLUX_DECLVAL(Args)...));
+using ctad_from_iters = decltype(C(FLUX_DECLVAL(common_iterator_t<Seq>),
+                                   FLUX_DECLVAL(common_iterator_t<Seq>), FLUX_DECLVAL(Args)...));
 
 template <template <typename...> typename C, typename Seq, typename... Args>
-concept can_deduce_container_type =
-    requires { typename ctad_direct_seq<C, Seq, Args...>; } ||
-    requires { typename ctad_from_seq<C, Seq, Args...>; } ||
-    requires { typename ctad_from_iters<C, Seq, Args...>; } ||
-    ( sizeof...(Args) == 0 && requires { typename C<value_t<Seq>>; });
+concept can_deduce_container_type = requires { typename ctad_direct_iterable<C, Seq, Args...>; }
+    || requires { typename ctad_from_iterable<C, Seq, Args...>; }
+    || requires { typename ctad_from_range<C, Seq, Args...>; }
+    || requires { typename ctad_from_iters<C, Seq, Args...>; }
+    || (sizeof...(Args) == 0 && requires { typename C<iterable_value_t<Seq>>; });
 
 template <typename T>
-struct type_t { using type = T; };
+struct type_t {
+    using type = T;
+};
 
 template <template <typename...> typename C, typename Seq, typename... Args>
     requires can_deduce_container_type<C, Seq, Args...>
 consteval auto deduce_container_type()
 {
-    if constexpr (requires { typename ctad_direct_seq<C, Seq, Args...>; }) {
+    if constexpr (requires { typename ctad_direct_iterable<C, Seq, Args...>; }) {
         return type_t<decltype(C(FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...))>{};
-    } else if constexpr (requires { typename ctad_from_seq<C, Seq, Args...>; }) {
-        return type_t<decltype((C(from_sequence, FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...)))>{};
+    } else if constexpr (requires { typename ctad_from_iterable<C, Seq, Args...>; }) {
+        return type_t<decltype((C(from_iterable, FLUX_DECLVAL(Seq), FLUX_DECLVAL(Args)...)))>{};
+#ifdef FLUX_HAVE_FROM_RANGE_CONSTRUCTORS
+    } else if constexpr (requires { typename ctad_from_range<C, Seq, Args...>; }) {
+        return type_t<decltype((
+            C(std::from_range, as_range(std::declval<Seq>()), std::declval<Args>()...)))>{};
+#endif
     } else if constexpr (requires { typename ctad_from_iters<C, Seq, Args...>; }) {
         using I = common_iterator_t<Seq>;
         return type_t<decltype(C(FLUX_DECLVAL(I), FLUX_DECLVAL(I), FLUX_DECLVAL(Args)...))>{};
@@ -119,33 +155,40 @@ using deduced_container_t = typename decltype(deduce_container_type<C, Seq, Args
 } // namespace detail
 
 FLUX_EXPORT
-template <typename Container, sequence Seq, typename... Args>
-    requires (std::convertible_to<element_t<Seq>, detail::container_value_t<Container>> &&
-                 detail::container_convertible<Container, Seq, Args...>) ||
-             sequence<element_t<Seq>>
-constexpr auto to(Seq&& seq, Args&&... args) -> Container
+template <typename Container, iterable It, typename... Args>
+    requires(std::convertible_to<iterable_element_t<It>, detail::container_value_t<Container>>
+             && detail::container_convertible<Container, It, Args...>)
+    || iterable<iterable_element_t<It>>
+constexpr auto to(It&& it, Args&&... args) -> Container
 {
-    if constexpr (std::convertible_to<element_t<Seq>, detail::container_value_t<Container>>) {
-        if constexpr (detail::direct_sequence_constructible<Container, Seq, Args...>) {
-            return Container(FLUX_FWD(seq), FLUX_FWD(args)...);
-        } else if constexpr (detail::from_sequence_constructible<Container, Seq, Args...>) {
-            return Container(from_sequence, FLUX_FWD(seq), FLUX_FWD(args)...);
-        } else if constexpr (detail::cpp17_range_constructible<Container, Seq, Args...>) {
-            auto view_ = std::views::common(FLUX_FWD(seq));
+    if constexpr (std::convertible_to<element_t<It>, detail::container_value_t<Container>>) {
+        if constexpr (detail::direct_iterable_constructible<Container, It, Args...>) {
+            return Container(FLUX_FWD(it), FLUX_FWD(args)...);
+        } else if constexpr (detail::from_iterable_constructible<Container, It, Args...>) {
+            return Container(from_iterable, FLUX_FWD(it), FLUX_FWD(args)...);
+#ifdef FLUX_HAVE_FROM_RANGE_CONSTRUCTORS
+        } else if constexpr (detail::from_range_constructible<Container, It, Args...>) {
+            return Container(std::from_range, as_range(FLUX_FWD(it)), FLUX_FWD(args)...);
+#endif
+        } else if constexpr (detail::cpp17_range_constructible<Container, It, Args...>) {
+            auto view_ = std::views::common(as_range(FLUX_FWD(it)));
             return Container(view_.begin(), view_.end(), FLUX_FWD(args)...);
         } else {
             auto c = Container(FLUX_FWD(args)...);
-            if constexpr (sized_sequence<Seq> && detail::reservable_container<Container>) {
-                c.reserve(flux::usize(seq));
+            if constexpr (sized_iterable<It> && detail::reservable_container<Container>) {
+                c.reserve(num::cast<std::size_t>(flux::iterable_size(it)));
             }
-            flux::output_to(seq, detail::make_inserter<element_t<Seq>>(c));
+            for_each(it, detail::container_appender(c));
             return c;
         }
     } else {
-        static_assert(sequence<element_t<Seq>>);
-        return flux::to<Container>(flux::map(flux::from_fwd_ref(FLUX_FWD(seq)), [](auto&& elem) {
-            return flux::to<detail::container_value_t<Container>>(FLUX_FWD(elem));
-        }), FLUX_FWD(args)...);
+        static_assert(iterable<iterable_element_t<It>>);
+        return flux::to<Container>(
+            flux::map(flux::from_fwd_ref(FLUX_FWD(it)),
+                      [](auto&& elem) {
+                          return flux::to<detail::container_value_t<Container>>(FLUX_FWD(elem));
+                      }),
+            FLUX_FWD(args)...);
     }
 }
 
diff --git a/include/flux/core.hpp b/include/flux/core.hpp
index a48b2767..617b1745 100644
--- a/include/flux/core.hpp
+++ b/include/flux/core.hpp
@@ -6,6 +6,7 @@
 #ifndef FLUX_CORE_HPP_INCLUDED
 #define FLUX_CORE_HPP_INCLUDED
 
+#include <flux/core/as_range.hpp>
 #include <flux/core/concepts.hpp>
 #include <flux/core/default_impls.hpp>
 #include <flux/core/functional.hpp>
diff --git a/include/flux/core/as_range.hpp b/include/flux/core/as_range.hpp
new file mode 100644
index 00000000..09fadd13
--- /dev/null
+++ b/include/flux/core/as_range.hpp
@@ -0,0 +1,90 @@
+// Copyright (c) 2025 Tristan Brindle (tcbrindle at gmail dot com)
+// 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 FLUX_CORE_AS_RANGE_HPP_INCLUDED
+#define FLUX_CORE_AS_RANGE_HPP_INCLUDED
+
+#include <flux/core/iterable_concepts.hpp>
+
+#include <ranges>
+
+namespace flux {
+
+namespace detail {
+
+template <typename It>
+struct iterable_range : std::ranges::view_interface<iterable_range<It>> {
+private:
+    It iterable_;
+    iteration_context_t<It> ctx_ = iterate(iterable_);
+    using opt_t = decltype(next_element(ctx_));
+    opt_t next_ = next_element(ctx_);
+
+    struct iterator {
+    private:
+        iterable_range* parent_ = nullptr;
+
+    public:
+        using reference = iterable_element_t<It>;
+        using value_type = iterable_value_t<It>;
+        using difference_type = int_t;
+
+        iterator() = default;
+
+        explicit iterator(iterable_range& parent) : parent_(std::addressof(parent)) { }
+
+        iterator(iterator&&) = default;
+        iterator& operator=(iterator&&) = default;
+
+        constexpr auto operator*() const -> reference
+        {
+            return static_cast<reference>(parent_->next_.value());
+        }
+
+        constexpr auto operator++() -> iterator&
+        {
+            parent_->next_ = next_element(parent_->ctx_);
+            return *this;
+        }
+
+        constexpr auto operator++(int) -> void { ++*this; }
+
+        constexpr auto operator==(std::default_sentinel_t) const -> bool
+        {
+            return !static_cast<bool>(parent_->next_);
+        }
+    };
+
+public:
+    explicit constexpr iterable_range(decays_to<It> auto&& it) : iterable_(FLUX_FWD(it)) { }
+
+    constexpr auto begin() -> iterator { return iterator(*this); }
+
+    static constexpr auto end() -> std::default_sentinel_t { return {}; }
+};
+
+} // namespace detail
+
+FLUX_EXPORT
+struct as_range_t {
+    template <iterable It>
+    constexpr auto operator()(It&& it) const -> std::ranges::input_range decltype(auto)
+    {
+        if constexpr (std::ranges::input_range<It>) {
+            return FLUX_FWD(it);
+        } else {
+            if constexpr (std::is_lvalue_reference_v<It>) {
+                return detail::iterable_range<std::reference_wrapper<It>>(std::ref(it));
+            } else {
+                return detail::iterable_range<It>(it);
+            }
+        }
+    }
+};
+
+FLUX_EXPORT inline constexpr as_range_t as_range{};
+
+} // namespace flux
+
+#endif // FLUX_CORE_AS_RANGE_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 3b4be154..7655de8b 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -8,6 +8,7 @@
 #include <flux/core/concepts.hpp>
 #include <flux/core/numeric.hpp>
 #include <flux/core/optional.hpp>
+#include <flux/core/sequence_access.hpp>
 
 namespace flux {
 
diff --git a/test/test_to.cpp b/test/test_to.cpp
index 43501bb6..10604220 100644
--- a/test/test_to.cpp
+++ b/test/test_to.cpp
@@ -41,14 +41,13 @@ struct test_vector {
     test_vector() = default;
 
     template <flux::sequence Seq>
-    test_vector(flux::from_sequence_t, Seq&& seq)
+    test_vector(flux::from_iterable_t, Seq&& seq)
     {
         flux::output_to(seq, std::back_inserter(vec_));
     }
 
     template <flux::sequence Seq>
-    test_vector(flux::from_sequence_t, Seq&& seq, A const& alloc)
-        : vec_(alloc)
+    test_vector(flux::from_iterable_t, Seq&& seq, A const& alloc) : vec_(alloc)
     {
         flux::output_to(seq, std::back_inserter(vec_));
     }
@@ -61,8 +60,7 @@ struct test_vector {
 };
 
 template <flux::sequence Seq, typename A>
-test_vector(flux::from_sequence_t, Seq&&, A const&) -> test_vector<flux::value_t<Seq>, A>;
-
+test_vector(flux::from_iterable_t, Seq&&, A const&) -> test_vector<flux::value_t<Seq>, A>;
 }
 
 TEST_CASE("to")

From 6b9070c3d46a2a617645574c8b6a3333227364b5 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 16 May 2025 18:00:39 +0100
Subject: [PATCH 07/66] Re-enable deduction guide for defer_t

Turns out it is needed sometimes
---
 include/flux/core/utils.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 0889a38a..bd9ea824 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -114,8 +114,8 @@ struct [[nodiscard("Discarded defer_t will execute its associated function immed
     constexpr ~defer_t() { fn(); }
 };
 
-// template <typename F>
-// defer_t(F) -> defer_t<F>;
+template <typename F>
+defer_t(F) -> defer_t<F>;
 
 } // namespace detail
 

From 34559d9f89adf519a159bcf44e1ff90927373352 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 16 May 2025 18:22:30 +0100
Subject: [PATCH 08/66] Add missing header

---
 test/test_iterable_concepts.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/test_iterable_concepts.cpp b/test/test_iterable_concepts.cpp
index 04392b49..cdac2f68 100644
--- a/test/test_iterable_concepts.cpp
+++ b/test/test_iterable_concepts.cpp
@@ -4,6 +4,8 @@
 
 #include <doctest/doctest.h>
 
+#include <initializer_list>
+
 #ifdef USE_MODULES
 import flux;
 #else

From 536bd7a9cf12e53d4f376668c0c5e6142ff9587c Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Sat, 17 May 2025 15:02:21 +0100
Subject: [PATCH 09/66] At iterable impl to filter

---
 include/flux/adaptor/filter.hpp         | 66 ++++++++++++++++++++++---
 include/flux/core/concepts.hpp          | 21 ++++----
 include/flux/core/iterable_concepts.hpp | 14 ++++--
 test/test_filter.cpp                    | 42 +++++++++++++++-
 test/test_utils.hpp                     | 43 ++++++++++++----
 5 files changed, 154 insertions(+), 32 deletions(-)

diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index a3e8e46b..9901177f 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -13,12 +13,40 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base, typename Pred>
-class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>>
+template <typename Fn>
+constexpr auto copy_or_ref(Fn& fn)
 {
+    if constexpr (std::is_trivially_copyable_v<Fn> && sizeof(Fn) <= sizeof(void*)) {
+        return fn;
+    } else {
+        return std::ref(fn);
+    }
+}
+
+template <typename Base, typename Pred>
+class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Pred pred_;
 
+    template <typename BaseCtx, typename FilterFn>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        FilterFn filter_fn;
+
+        using element_type = context_element_t<BaseCtx>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            return base_ctx.run_while([this, &pred](auto&& elem) {
+                if (std::invoke(filter_fn, std::as_const(elem))) {
+                    return std::invoke(pred, FLUX_FWD(elem));
+                } else {
+                    return loop_continue;
+                }
+            });
+        }
+    };
+
 public:
     constexpr filter_adaptor(decays_to<Base> auto&& base, decays_to<Pred> auto&& pred)
         : base_(FLUX_FWD(base)),
@@ -30,6 +58,32 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>>
     [[nodiscard]]
     constexpr auto base() && -> Base { return std::move(base_); }
 
+    constexpr auto iterate()
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .filter_fn = copy_or_ref(pred_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const> && std::invocable<Pred&, iterable_element_t<Base const>>
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .filter_fn = copy_or_ref(pred_)};
+    }
+
+    constexpr auto reverse_iterate()
+        requires reverse_iterable<Base>
+    {
+        return context_type{.base_ctx = flux::reverse_iterate(base_),
+                            .filter_fn = copy_or_ref(pred_)};
+    }
+
+    constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const>
+        && std::invocable<Pred&, iterable_element_t<Base const>>
+    {
+        return context_type{.base_ctx = flux::reverse_iterate(base_),
+                            .filter_fn = copy_or_ref(pred_)};
+    }
+
     struct flux_sequence_traits {
     private:
         struct cursor_type {
@@ -115,12 +169,12 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>>
 };
 
 struct filter_fn {
-    template <adaptable_sequence Seq, std::move_constructible Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
+    template <adaptable_iterable It, std::move_constructible Pred>
+        requires std::predicate<Pred&, iterable_element_t<It> const&>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Pred pred) const
+    constexpr auto operator()(It&& it, Pred pred) const
     {
-        return filter_adaptor<std::decay_t<Seq>, Pred>(FLUX_FWD(seq), std::move(pred));
+        return filter_adaptor<std::decay_t<It>, Pred>(FLUX_FWD(it), std::move(pred));
     }
 };
 
diff --git a/include/flux/core/concepts.hpp b/include/flux/core/concepts.hpp
index b04f2124..8dd6b223 100644
--- a/include/flux/core/concepts.hpp
+++ b/include/flux/core/concepts.hpp
@@ -324,26 +324,25 @@ template <typename T, typename E>
 constexpr bool is_ilist<T, std::initializer_list<E>> = true;
 
 template <typename Seq>
-concept rvalue_sequence =
+concept movable_rvalue =
     std::is_object_v<Seq> &&
-    std::move_constructible<Seq> &&
-    sequence<Seq>;
+    std::same_as<std::decay_t<Seq>, Seq> &&
+    std::move_constructible<Seq>;
 
 template <typename Seq>
-concept trivially_copyable_sequence =
-    std::copyable<Seq> &&
-    std::is_trivially_copyable_v<Seq> &&
-    sequence<Seq>;
+concept trivially_copyable_lvalue =
+    std::is_lvalue_reference_v<Seq> &&
+    std::copyable<std::decay_t<Seq>> &&
+    std::is_trivially_copyable_v<std::decay_t<Seq>>;
 
 }
 
 FLUX_EXPORT
 template <typename Seq>
 concept adaptable_sequence =
-    (detail::rvalue_sequence<Seq>
-         || (std::is_lvalue_reference_v<Seq> &&
-             detail::trivially_copyable_sequence<std::decay_t<Seq>>)) &&
-    !detail::is_ilist<Seq>;
+    sequence<std::decay_t<Seq>> &&
+    (detail::movable_rvalue<Seq> || detail::trivially_copyable_lvalue<Seq>) &&
+    !(detail::is_ilist<Seq>);
 
 FLUX_EXPORT
 template <typename D>
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 7655de8b..ece1ed9e 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -491,13 +491,21 @@ FLUX_EXPORT struct reverse_iterate_t {
 
 FLUX_EXPORT inline constexpr reverse_iterate_t reverse_iterate {};
 
+FLUX_EXPORT template <typename I>
+using reverse_iteration_context_t = decltype(reverse_iterate(std::declval<I&>()));
+
 FLUX_EXPORT template <typename It>
 concept reverse_iterable = iterable<It> && requires(It& it) {
     { reverse_iterate(it) } -> iteration_context;
-};
+} && std::same_as<iterable_element_t<It>, context_element_t<reverse_iteration_context_t<It>>>;
 
-FLUX_EXPORT template <reverse_iterable I>
-using reverse_iteration_context_t = decltype(reverse_iterate(std::declval<I&>()));
+/*
+ * MARK: Other concepts
+ */
+
+FLUX_EXPORT template <typename I>
+concept adaptable_iterable = iterable<std::decay_t<I>>
+    && (detail::movable_rvalue<I> || detail::trivially_copyable_lvalue<I>);
 
 } // namespace flux
 
diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index b9c4df90..d7f923f3 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -33,9 +33,47 @@ static_assert(not std::invocable<filter_fn, int(&)[10], decltype([](int) {})>);
 // Incompatible predicate
 static_assert(not std::invocable<filter_fn, int(&)[10], decltype([](int*) { return true; })>);
 
-
 constexpr bool test_filter()
 {
+    // Basic filtering with iterable
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+        auto filtered = flux::filter(iter, flux::pred::even);
+
+        using F = decltype(filtered);
+
+        static_assert(flux::iterable<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, int&>);
+        static_assert(std::same_as<flux::iterable_value_t<F>, int>);
+
+        static_assert(flux::iterable<F const>);
+        static_assert(std::same_as<flux::iterable_element_t<F const>, int const&>);
+        static_assert(std::same_as<flux::iterable_value_t<F const>, int>);
+
+        STATIC_CHECK(check_equal(filtered, {0, 2, 4, 6, 8}));
+
+        STATIC_CHECK(check_equal(std::as_const(filtered), {0, 2, 4, 6, 8}));
+    }
+
+    // Reverse iteration with filter
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto filtered = flux::filter(iter, flux::pred::odd);
+
+        using F = decltype(filtered);
+
+        static_assert(flux::reverse_iterable<F>);
+
+        flux::iteration_context auto ctx = flux::reverse_iterate(filtered);
+
+        STATIC_CHECK(flux::next_element(ctx).value() == 5);
+        STATIC_CHECK(flux::next_element(ctx).value() == 3);
+        STATIC_CHECK(flux::next_element(ctx).value() == 1);
+        STATIC_CHECK(not flux::next_element(ctx).has_value());
+    }
+
     // Basic filtering
     {
         int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -101,7 +139,7 @@ constexpr bool test_filter()
             {4, false}
         };
 
-        auto f = flux::filter(flux::ref(pairs), &Pair::ok);
+        auto f = flux::filter(iterable_only(pairs), &Pair::ok);
 
         if (!check_equal(f, {Pair{1, true}, Pair{3, true}})) {
             return false;
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index 0b29c96c..744ce4fd 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -49,14 +49,12 @@ inline constexpr struct {
 
 public:
     template <typename T>
-    constexpr bool operator()(flux::sequence auto&& seq,
-                              std::initializer_list<T> ilist) const
+    constexpr bool operator()(flux::iterable auto&& seq, std::initializer_list<T> ilist) const
     {
         return impl(FLUX_FWD(seq), ilist);
     }
 
-    constexpr bool operator()(flux::sequence auto&& seq1,
-                              flux::sequence auto&& seq2) const
+    constexpr bool operator()(flux::iterable auto&& seq1, flux::iterable auto&& seq2) const
     {
         return impl(FLUX_FWD(seq1), FLUX_FWD(seq2));
     }
@@ -91,6 +89,37 @@ struct single_pass_only : flux::inline_sequence_base<single_pass_only<Base>> {
     single_pass_only&  operator=(single_pass_only&&) = default;
 };
 
+template <flux::iterable Base>
+struct iterable_only {
+private:
+    Base base_;
+
+public:
+    constexpr explicit iterable_only(flux::decays_to<Base> auto&& base) : base_(FLUX_FWD(base)) { }
+
+    constexpr auto iterate() { return flux::iterate(base_); }
+
+    constexpr auto iterate() const
+        requires flux::iterable<Base const>
+    {
+        return flux::iterate(base_);
+    }
+
+    constexpr auto reverse_iterate()
+        requires flux::reverse_iterable<Base>
+    {
+        return flux::reverse_iterate(base_);
+    }
+
+    constexpr auto reverse_iterate() const
+        requires flux::reverse_iterable<Base const>
+    {
+        return flux::reverse_iterate(base_);
+    }
+};
+
+template <flux::iterable Base>
+iterable_only(Base) -> iterable_only<Base>;
 }
 
 template <typename Base>
@@ -133,9 +162,3 @@ struct flux::sequence_traits<single_pass_only<Base>> : flux::default_sequence_tr
         return flux::size(self.base_);
     }
 };
-
-template <typename Reqd, typename Expr>
-constexpr void assert_has_type(Expr&&)
-{
-    static_assert(std::same_as<Reqd, Expr>);
-}

From a986c283d8e348ae1d9fc2033e478fbb88a4f8a4 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Sun, 18 May 2025 17:41:47 +0100
Subject: [PATCH 10/66] Add iterable protocol to reverse_adaptor

---
 include/flux/adaptor/reverse.hpp | 40 ++++++++++++++++++++++----------
 test/test_reverse.cpp            | 10 ++++----
 2 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/include/flux/adaptor/reverse.hpp b/include/flux/adaptor/reverse.hpp
index acf312a4..996366d8 100644
--- a/include/flux/adaptor/reverse.hpp
+++ b/include/flux/adaptor/reverse.hpp
@@ -12,10 +12,8 @@ namespace flux {
 
 namespace detail {
 
-template <bidirectional_sequence Base>
-    requires bounded_sequence<Base>
-struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>>
-{
+template <reverse_iterable Base>
+struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
 
@@ -27,6 +25,26 @@ struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>>
     [[nodiscard]] constexpr auto base() const& -> Base const& { return base_; }
     [[nodiscard]] constexpr auto base() && -> Base&& { return std::move(base_); }
 
+    struct flux_iterable_traits {
+        static constexpr auto iterate(auto& self)
+            requires reverse_iterable<decltype(self.base_)>
+        {
+            return flux::reverse_iterate(self.base_);
+        }
+
+        static constexpr auto reverse_iterate(auto& self)
+            requires iterable<decltype(self.base_)>
+        {
+            return flux::iterate(self.base_);
+        }
+
+        static constexpr auto size(auto& self)
+            requires sized_iterable<decltype(self.base_)>
+        {
+            return flux::iterable_size(self.base_);
+        }
+    };
+
     struct flux_sequence_traits {
     private:
         struct cursor_type {
@@ -144,17 +162,15 @@ template <typename Base>
 inline constexpr bool is_reverse_adaptor<reverse_adaptor<Base>> = true;
 
 struct reverse_fn {
-    template <adaptable_sequence Seq>
-        requires bidirectional_sequence<Seq> &&
-                 bounded_sequence<Seq>
+    template <adaptable_iterable It>
+        requires reverse_iterable<It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const
-        -> sequence auto
+    constexpr auto operator()(It&& it) const -> reverse_iterable auto
     {
-        if constexpr (is_reverse_adaptor<std::decay_t<Seq>>) {
-            return FLUX_FWD(seq).base();
+        if constexpr (is_reverse_adaptor<std::decay_t<It>>) {
+            return FLUX_FWD(it).base();
         } else {
-            return reverse_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq));
+            return reverse_adaptor<std::decay_t<It>>(FLUX_FWD(it));
         }
     }
 };
diff --git a/test/test_reverse.cpp b/test/test_reverse.cpp
index 82a1abe2..5db47de7 100644
--- a/test/test_reverse.cpp
+++ b/test/test_reverse.cpp
@@ -156,15 +156,13 @@ TEST_CASE("reverse")
 
     {
         auto list = std::list{0, 1, 2, 3, 4};
-        auto rlist = flux::reverse(flux::from_range(list));
+        auto rlist = flux::reverse(std::move(list));
 
         using R = decltype(rlist);
 
-        static_assert(flux::regular_cursor<flux::cursor_t<R>>);
-        static_assert(flux::bidirectional_sequence<R>);
-        static_assert(not flux::random_access_sequence<R>);
-        static_assert(flux::sized_sequence<R>);
-        static_assert(flux::bounded_sequence<R>);
+        static_assert(flux::iterable<R>);
+        static_assert(flux::reverse_iterable<R>);
+        static_assert(flux::sized_iterable<R>);
 
         REQUIRE(check_equal(rlist, {4, 3, 2, 1, 0}));
     }

From 905a42bf91783dc4daeb9860fae08a85c438e4ba Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Mon, 19 May 2025 15:11:35 +0100
Subject: [PATCH 11/66] Add iterable conformance to map

---
 include/flux/adaptor/filter.hpp | 10 ------
 include/flux/adaptor/map.hpp    | 54 ++++++++++++++++++++++++++-------
 include/flux/core/utils.hpp     | 10 ++++++
 test/test_map.cpp               | 34 +++++++++++++++++++++
 test/test_utils.hpp             | 12 ++++++++
 5 files changed, 99 insertions(+), 21 deletions(-)

diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index 9901177f..838c2cf0 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -13,16 +13,6 @@ namespace flux {
 
 namespace detail {
 
-template <typename Fn>
-constexpr auto copy_or_ref(Fn& fn)
-{
-    if constexpr (std::is_trivially_copyable_v<Fn> && sizeof(Fn) <= sizeof(void*)) {
-        return fn;
-    } else {
-        return std::ref(fn);
-    }
-}
-
 template <typename Base, typename Pred>
 class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
     FLUX_NO_UNIQUE_ADDRESS Base base_;
diff --git a/include/flux/adaptor/map.hpp b/include/flux/adaptor/map.hpp
index 22a2668c..3b070042 100644
--- a/include/flux/adaptor/map.hpp
+++ b/include/flux/adaptor/map.hpp
@@ -12,17 +12,28 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base, typename Func>
-    requires std::is_object_v<Func> &&
-             std::regular_invocable<Func&, element_t<Base>>
-struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>>
-{
+template <typename Base, typename Func>
+struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Func func_;
 
     friend struct sequence_traits<map_adaptor>;
 
+    template <typename BaseCtx, typename MapFn>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        MapFn map_fn;
+
+        using element_type = std::invoke_result_t<MapFn&, context_element_t<BaseCtx>>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            return base_ctx.run_while(
+                [&pred, this](auto&& elem) { return pred(std::invoke(map_fn, FLUX_FWD(elem))); });
+        }
+    };
+
 public:
     constexpr map_adaptor(decays_to<Base> auto&& base, decays_to<Func> auto&& func)
         : base_(FLUX_FWD(base)),
@@ -34,10 +45,31 @@ struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>>
     constexpr auto base() && -> Base&& { return std::move(base_); }
     constexpr auto base() const&& -> Base const&& { return std::move(base_); }
 
-    struct flux_sequence_traits  : detail::passthrough_traits_base
+    constexpr auto iterate()
     {
-        using value_type = std::remove_cvref_t<std::invoke_result_t<Func&, element_t<Base>>>;
+        return context_type{.base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const>
+        && std::regular_invocable<Func&, iterable_element_t<Base const>>
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
+    }
+
+    constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        return flux::iterable_size(base_);
+    }
+
+    constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        return flux::iterable_size(base_);
+    }
 
+    struct flux_sequence_traits : detail::passthrough_traits_base {
         static constexpr bool disable_multipass = !multipass_sequence<Base>;
         static constexpr bool is_infinite = infinite_sequence<Base>;
 
@@ -70,12 +102,12 @@ struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>>
 };
 
 struct map_fn {
-    template <adaptable_sequence Seq, typename Func>
-        requires std::regular_invocable<Func&, element_t<Seq>>
+    template <adaptable_iterable It, std::move_constructible Func>
+        requires std::regular_invocable<Func&, iterable_element_t<It>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Func func) const
+    constexpr auto operator()(It&& it, Func func) const
     {
-        return map_adaptor<std::decay_t<Seq>, Func>(FLUX_FWD(seq), std::move(func));
+        return map_adaptor<std::decay_t<It>, Func>(FLUX_FWD(it), std::move(func));
     }
 };
 
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index bd9ea824..2738ee80 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -117,6 +117,16 @@ struct [[nodiscard("Discarded defer_t will execute its associated function immed
 template <typename F>
 defer_t(F) -> defer_t<F>;
 
+template <typename Fn>
+constexpr auto copy_or_ref(Fn& fn)
+{
+    if constexpr (std::is_trivially_copyable_v<Fn> && sizeof(Fn) <= sizeof(void*)) {
+        return fn;
+    } else {
+        return std::ref(fn);
+    }
+}
+
 } // namespace detail
 
 } // namespace flux
diff --git a/test/test_map.cpp b/test/test_map.cpp
index 52431ad6..2fe43a6f 100644
--- a/test/test_map.cpp
+++ b/test/test_map.cpp
@@ -13,6 +13,40 @@ namespace {
 
 constexpr bool test_map()
 {
+    // We can map basic iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto mapped = flux::map(std::move(iter), [](int& i) { return i * 2; });
+
+        using M = decltype(mapped);
+
+        static_assert(flux::iterable<M>);
+        static_assert(flux::sized_iterable<M>);
+        static_assert(std::same_as<flux::iterable_element_t<M>, int>);
+        static_assert(std::same_as<flux::iterable_value_t<M>, int>);
+
+        static_assert(not flux::iterable<M const>); // because func expects int&
+
+        STATIC_CHECK(check_equal(mapped, {2, 4, 6, 8, 10}));
+    }
+
+    // Const iteration works with iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto const mapped = flux::map(std::move(iter), [](int const& i) { return i * 2; });
+
+        using M = decltype(mapped);
+
+        static_assert(flux::iterable<M>);
+        static_assert(flux::sized_iterable<M>);
+        static_assert(std::same_as<flux::iterable_element_t<M>, int>);
+        static_assert(std::same_as<flux::iterable_value_t<M>, int>);
+
+        STATIC_CHECK(check_equal(mapped, {2, 4, 6, 8, 10}));
+    }
+
     {
         int arr[] = {0, 1, 2, 3, 4};
 
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index 744ce4fd..ab64f6f9 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -116,6 +116,18 @@ struct iterable_only {
     {
         return flux::reverse_iterate(base_);
     }
+
+    constexpr auto size() -> flux::int_t
+        requires flux::sized_iterable<Base>
+    {
+        return flux::iterable_size(base_);
+    }
+
+    constexpr auto size() const -> flux::int_t
+        requires flux::sized_iterable<Base const>
+    {
+        return flux::iterable_size(base_);
+    }
 };
 
 template <flux::iterable Base>

From 553bd3e3a02fadb66f21d32ef18115c2eccc2fa8 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Mon, 19 May 2025 15:54:53 +0100
Subject: [PATCH 12/66] Add iterable conformance to take()

---
 include/flux/adaptor/take.hpp | 54 +++++++++++++++++++++++++++++++----
 test/test_cycle.cpp           |  4 +--
 test/test_take.cpp            | 49 +++++++++++++++++++++++++++++++
 3 files changed, 99 insertions(+), 8 deletions(-)

diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index 5dec9da3..f025563b 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -12,13 +12,33 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base>
-struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
-{
+template <typename Base>
+struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
 private:
     Base base_;
     int_t count_;
 
+    template <typename BaseCtx>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        int_t remaining;
+
+        using element_type = context_element_t<BaseCtx>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            if (remaining > 0) {
+                auto res = base_ctx.run_while([&](auto&& elem) {
+                    --remaining;
+                    return pred(FLUX_FWD(elem)) && (remaining > 0);
+                });
+                return static_cast<iteration_result>(static_cast<bool>(res) || (remaining == 0));
+            } else {
+                return iteration_result::complete;
+            }
+        }
+    };
+
 public:
     constexpr take_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
@@ -28,6 +48,28 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
     [[nodiscard]] constexpr auto base() const& -> Base const& { return base_; }
     [[nodiscard]] constexpr auto base() && -> Base&& { return std::move(base_); }
 
+    constexpr auto iterate()
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+    }
+    constexpr auto iterate() const
+        requires iterable<Base const>
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+    }
+
+    constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        return (cmp::min)(flux::iterable_size(base_), count_);
+    }
+
+    constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        return (cmp::min)(flux::iterable_size(base_), count_);
+    }
+
     struct flux_sequence_traits {
     private:
         struct cursor_type {
@@ -144,16 +186,16 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
 };
 
 struct take_fn {
-    template <adaptable_sequence Seq>
+    template <adaptable_iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, num::integral auto count) const
+    constexpr auto operator()(It&& it, num::integral auto count) const
     {
         auto count_ = num::checked_cast<int_t>(count);
         if (count_ < 0) {
             runtime_error("Negative argument passed to take()");
         }
 
-        return take_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), count_);
+        return take_adaptor<std::decay_t<It>>(FLUX_FWD(it), count_);
     }
 };
 
diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 1689180a..8c133e37 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -77,7 +77,7 @@ constexpr bool test_cycle() {
         static_assert(std::same_as<flux::rvalue_element_t<C>, int const&&>);
         static_assert(std::same_as<flux::const_element_t<C>, int const&>);
 
-        STATIC_CHECK(seq.size() == 5);
+        STATIC_CHECK(flux::size(seq) == 5);
 
         STATIC_CHECK(check_equal(seq, {1, 2, 3, 1, 2}));
 
@@ -110,7 +110,7 @@ constexpr bool test_cycle() {
         static_assert(std::same_as<flux::const_element_t<C>, std::pair<int const&, double const&>>);
 #endif
 
-        STATIC_CHECK(seq.size() == 10);
+        STATIC_CHECK(flux::size(seq) == 10);
 
         auto firsts = flux::ref(seq).map([](auto p) { return p.first; });
 
diff --git a/test/test_take.cpp b/test/test_take.cpp
index e41fae68..6af64a33 100644
--- a/test/test_take.cpp
+++ b/test/test_take.cpp
@@ -13,6 +13,55 @@ namespace {
 
 constexpr bool test_take()
 {
+    // Test take with basic iterables
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take(arr, 3);
+
+        using T = decltype(taken);
+        static_assert(flux::iterable<T>);
+        static_assert(flux::sized_iterable<T>);
+
+        static_assert(flux::iterable<T const>);
+        static_assert(flux::sized_iterable<T const>);
+
+        STATIC_CHECK(flux::iterable_size(taken) == 3);
+        STATIC_CHECK(check_equal(taken, {0, 1, 2}));
+    }
+
+    // Taking all elements
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take(arr, 5);
+
+        STATIC_CHECK(flux::iterable_size(taken) == 5);
+        STATIC_CHECK(check_equal(taken, arr));
+    }
+
+    // Taking "too many" elements
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take(arr, 1'000'000);
+
+        STATIC_CHECK(flux::iterable_size(taken) == 5);
+        STATIC_CHECK(check_equal(taken, arr));
+    }
+
+    // Taking zero elements
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take(arr, 0);
+
+        STATIC_CHECK(flux::iterable_size(taken) == 0);
+
+        auto ctx = flux::iterate(taken);
+        STATIC_CHECK(flux::next_element(ctx) == std::nullopt);
+    }
+
     {
         int arr[] = {0, 1, 2, 3, 4};
         auto taken = flux::take(std::ref(arr), 3);

From 9199e78e980927358f428b93120951b9840af476 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Mon, 19 May 2025 18:21:36 +0100
Subject: [PATCH 13/66] Add iterable protocol to take_while

---
 include/flux/adaptor/take_while.hpp | 58 ++++++++++++++++++++++++-----
 test/test_take_while.cpp            | 49 ++++++++++++++++++++++++
 2 files changed, 97 insertions(+), 10 deletions(-)

diff --git a/include/flux/adaptor/take_while.hpp b/include/flux/adaptor/take_while.hpp
index fb3df4a0..3e94929c 100644
--- a/include/flux/adaptor/take_while.hpp
+++ b/include/flux/adaptor/take_while.hpp
@@ -12,7 +12,7 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base, typename Pred>
+template <typename Base, typename Pred>
 struct take_while_adaptor : inline_sequence_base<take_while_adaptor<Base, Pred>> {
 private:
     Base base_;
@@ -23,33 +23,71 @@ struct take_while_adaptor : inline_sequence_base<take_while_adaptor<Base, Pred>>
     friend struct sequence_traits<take_while_adaptor>;
     friend struct passthrough_traits_base;
 
+    template <typename BaseCtx, typename TakePred>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        TakePred take_pred;
+        bool done = false;
+
+        using element_type = context_element_t<BaseCtx>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            if (!done) {
+                auto res = base_ctx.run_while([&](auto&& elem) {
+                    if (!std::invoke(take_pred, std::as_const(elem))) {
+                        done = true;
+                        return loop_break;
+                    } else {
+                        return std::invoke(pred, FLUX_FWD(elem));
+                    }
+                });
+                return static_cast<iteration_result>(static_cast<bool>(res) || done);
+            } else {
+                return iteration_result::complete;
+            }
+        }
+    };
+
 public:
     constexpr take_while_adaptor(decays_to<Base> auto&& base, decays_to<Pred> auto&& pred)
         : base_(FLUX_FWD(base)),
           pred_(FLUX_FWD(pred))
-    {}
+    {
+    }
 
     [[nodiscard]] constexpr auto base() const& -> Base const& { return base_; }
     [[nodiscard]] constexpr auto base() && -> Base { return std::move(base_); }
+
+    [[nodiscard]]
+    constexpr auto iterate()
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .take_pred = copy_or_ref(pred_)};
+    }
+
+    [[nodiscard]]
+    constexpr auto iterate() const
+        requires iterable<Base const>
+        && std::predicate<Pred&, iterable_element_t<Base const> const&>
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .take_pred = copy_or_ref(pred_)};
+    }
 };
 
 struct take_while_fn {
-    template <adaptable_sequence Seq, std::move_constructible Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
+    template <adaptable_iterable It, std::move_constructible Pred>
+        requires std::predicate<Pred&, iterable_element_t<It> const&>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Pred pred) const
+    constexpr auto operator()(It&& it, Pred pred) const
     {
-        return take_while_adaptor<std::decay_t<Seq>, Pred>(
-                    FLUX_FWD(seq), std::move(pred));
+        return take_while_adaptor<std::decay_t<It>, Pred>(FLUX_FWD(it), std::move(pred));
     }
 };
 
 } // namespace detail
 
 template <typename Base, typename Pred>
-struct sequence_traits<detail::take_while_adaptor<Base, Pred>>
-    : detail::passthrough_traits_base
-{
+struct sequence_traits<detail::take_while_adaptor<Base, Pred>> : detail::passthrough_traits_base {
     using self_t = detail::take_while_adaptor<Base, Pred>;
 
     using value_type = value_t<Base>;
diff --git a/test/test_take_while.cpp b/test/test_take_while.cpp
index 8b391d80..ff718e43 100644
--- a/test/test_take_while.cpp
+++ b/test/test_take_while.cpp
@@ -24,6 +24,55 @@ struct ints {
 
 constexpr bool test_take_while()
 {
+    // Test take_while with basic iterables
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take_while(arr, [](int i) { return i < 3; });
+
+        using T = decltype(taken);
+        static_assert(flux::iterable<T>);
+
+        static_assert(flux::iterable<T const>);
+
+        STATIC_CHECK(check_equal(taken, {0, 1, 2}));
+    }
+
+    // Test take_while with a predicate that always returns true
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take_while(arr, [](int) { return true; });
+
+        STATIC_CHECK(check_equal(taken, arr));
+    }
+
+    // Test take_while with an always-false predicate returns no elements
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take_while(arr, [](int) { return false; });
+
+        auto ctx = flux::iterate(taken);
+        STATIC_CHECK(flux::next_element(ctx) == std::nullopt);
+    }
+
+    // Test (attempting to) restart iteration after completion
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::take_while(arr, flux::pred::lt(3));
+
+        auto ctx = flux::iterate(taken);
+        STATIC_CHECK(flux::next_element(ctx).value() == 0);
+        STATIC_CHECK(flux::next_element(ctx).value() == 1);
+        STATIC_CHECK(flux::next_element(ctx).value() == 2);
+        STATIC_CHECK(not flux::next_element(ctx).has_value());
+
+        // Restarting iteration
+        STATIC_CHECK(not flux::next_element(ctx).has_value());
+    }
+
     {
         auto seq = flux::take_while(ints{10}, [](int i) { return i != 25; });
 

From 9baef5b4d838ab0179275fab802a9aed4b42aceb Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Mon, 19 May 2025 19:15:23 +0100
Subject: [PATCH 14/66] Make stride() iterable

---
 include/flux/adaptor/stride.hpp | 344 ++++++++++++++++++--------------
 test/test_stride.cpp            |  81 ++++++++
 2 files changed, 280 insertions(+), 145 deletions(-)

diff --git a/include/flux/adaptor/stride.hpp b/include/flux/adaptor/stride.hpp
index 24d3df1a..575f932d 100644
--- a/include/flux/adaptor/stride.hpp
+++ b/include/flux/adaptor/stride.hpp
@@ -61,12 +61,36 @@ inline constexpr struct advance_fn {
     }
 } advance;
 
+template <typename BaseCtx>
+struct stride_iteration_context : immovable {
+    BaseCtx base_ctx;
+    int_t stride;
+    int_t skip = 0;
+
+    using element_type = context_element_t<BaseCtx>;
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        return base_ctx.run_while([&](auto&& elem) {
+            if (skip > 0) {
+                --skip;
+                return loop_continue;
+            } else {
+                skip = stride - 1;
+                return std::invoke(pred, FLUX_FWD(elem));
+            }
+        });
+    }
+};
+
 template <typename Base>
 struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
 private:
     Base base_;
     int_t stride_;
 
+    friend struct sequence_traits<stride_adaptor>;
+
 public:
     constexpr stride_adaptor(decays_to<Base> auto&& base, int_t stride)
         : base_(FLUX_FWD(base)),
@@ -76,188 +100,218 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
     constexpr auto base() & -> Base& { return base_; }
     constexpr auto base() const& -> Base const& { return base_; }
 
-    struct flux_sequence_traits : passthrough_traits_base {
-
-        using value_type = value_t<Base>;
-        static inline constexpr bool is_infinite = infinite_sequence<Base>;
+    [[nodiscard]] constexpr auto iterate()
+    {
+        return stride_iteration_context{.base_ctx = flux::iterate(base_), .stride = stride_};
+    }
 
-        static constexpr auto inc(auto& self, cursor_t<Base>& cur) -> void
-        {
-            advance(self.base(), cur, self.stride_);
-        }
+    [[nodiscard]] constexpr auto iterate() const
+        requires iterable<Base const>
+    {
+        return stride_iteration_context{.base_ctx = flux::iterate(base_), .stride = stride_};
+    }
 
-        // This version of stride is never bidir
-        static void dec(...) = delete;
+    [[nodiscard]] constexpr auto reverse_iterate()
+        requires reverse_iterable<Base> && sized_iterable<Base>
+    {
+        int_t initial_skip
+            = stride_ - 1 - (stride_ - flux::iterable_size(base_) % stride_) % stride_;
+        return stride_iteration_context{
+            .base_ctx = flux::reverse_iterate(base_), .stride = stride_, .skip = initial_skip};
+    }
 
-        static constexpr auto size(auto& self) -> int_t
-            requires sized_sequence<Base>
-        {
-            auto s = flux::size(self.base_);
-            return s/self.stride_ + (s % self.stride_ == 0 ? 0 : 1);
-        }
+    [[nodiscard]] constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const> && sized_iterable<Base const>
+    {
+        int_t initial_skip
+            = stride_ - 1 - (stride_ - flux::iterable_size(base_) % stride_) % stride_;
+        return stride_iteration_context{
+            .base_ctx = flux::reverse_iterate(base_), .stride = stride_, .skip = initial_skip};
+    }
 
-        static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_t<Base>
-            requires sequence<decltype((self.base_))>
-        {
-            int_t n = self.stride_;
-            return flux::seq_for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
-                if (++n < s) {
-                    return true;
-                } else {
-                    n = 0;
-                    return std::invoke(pred, FLUX_FWD(elem));
-                }
-            });
-        }
+    [[nodiscard]] constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        int_t sz = flux::iterable_size(base_);
+        return sz / stride_ + (sz % stride_ == 0 ? 0 : 1);
+    }
 
-    };
+    [[nodiscard]] constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        int_t sz = flux::iterable_size(base_);
+        return sz / stride_ + (sz % stride_ == 0 ? 0 : 1);
+    }
 };
 
-template <bidirectional_sequence Base>
-struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
-private:
-    Base base_;
-    int_t stride_;
+} // namespace detail
 
-public:
-    constexpr stride_adaptor(decays_to<Base> auto&& base, int_t stride)
-        : base_(FLUX_FWD(base)),
-          stride_(stride)
-    {}
+template <sequence Base>
+struct sequence_traits<detail::stride_adaptor<Base>> : detail::passthrough_traits_base {
 
-    struct flux_sequence_traits : default_sequence_traits {
-    private:
-        struct cursor_type {
-            cursor_t<Base> cur{};
-            int_t missing = 0;
+    using value_type = value_t<Base>;
+    static inline constexpr bool is_infinite = infinite_sequence<Base>;
 
-            friend constexpr auto operator==(cursor_type const& lhs, cursor_type const& rhs) -> bool
-            {
-                return lhs.cur == rhs.cur;
-            }
+    static constexpr auto inc(auto& self, cursor_t<Base>& cur) -> void
+    {
+        detail::advance(self.base(), cur, self.stride_);
+    }
+
+    // This version of stride is never bidir
+    static void dec(...) = delete;
 
-            friend constexpr auto operator<=>(cursor_type const& lhs, cursor_type const& rhs)
-                -> std::strong_ordering
-                requires ordered_cursor<cursor_t<Base>>
-            {
-                return lhs.cur <=> rhs.cur;
+    static constexpr auto size(auto& self) -> int_t
+        requires sized_sequence<Base>
+    {
+        auto s = flux::size(self.base_);
+        return s / self.stride_ + (s % self.stride_ == 0 ? 0 : 1);
+    }
+
+    static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_t<Base>
+        requires sequence<decltype((self.base_))>
+    {
+        int_t n = self.stride_;
+        return flux::seq_for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
+            if (++n < s) {
+                return true;
+            } else {
+                n = 0;
+                return std::invoke(pred, FLUX_FWD(elem));
             }
-        };
+        });
+    }
+};
 
-    public:
-        using value_type = value_t<Base>;
-        static constexpr bool is_infinite = infinite_sequence<Base>;
+template <bidirectional_sequence Base>
+struct sequence_traits<detail::stride_adaptor<Base>> : default_sequence_traits {
+private:
+    struct cursor_type {
+        cursor_t<Base> cur{};
+        int_t missing = 0;
 
-        static constexpr auto first(auto& self) -> cursor_type
+        friend constexpr auto operator==(cursor_type const& lhs, cursor_type const& rhs) -> bool
         {
-            return cursor_type {
-                .cur = flux::first(self.base_),
-                .missing = 0
-            };
+            return lhs.cur == rhs.cur;
         }
 
-        static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+        friend constexpr auto operator<=>(cursor_type const& lhs, cursor_type const& rhs)
+            -> std::strong_ordering
+            requires ordered_cursor<cursor_t<Base>>
         {
-            return flux::is_last(self.base_, cur.cur);
+            return lhs.cur <=> rhs.cur;
         }
+    };
 
-        static constexpr auto inc(auto& self, cursor_type& cur) -> void
-        {
-            cur.missing = advance(self.base_, cur.cur, self.stride_);
-        }
+public:
+    using value_type = value_t<Base>;
+    static constexpr bool is_infinite = infinite_sequence<Base>;
 
-        static constexpr auto read_at(auto& self, cursor_type const& cur)
-            -> decltype(flux::read_at(self.base_, cur.cur))
-        {
-            return flux::read_at(self.base_, cur.cur);
-        }
+    static constexpr auto first(auto& self) -> cursor_type
+    {
+        return cursor_type{.cur = flux::first(self.base_), .missing = 0};
+    }
 
-        static constexpr auto move_at(auto& self, cursor_type const& cur)
-            -> decltype(flux::move_at(self.base_, cur.cur))
-        {
-            return flux::move_at(self.base_, cur.cur);
-        }
+    static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+    {
+        return flux::is_last(self.base_, cur.cur);
+    }
 
-        static constexpr auto read_at_unchecked(auto& self, cursor_type const& cur)
-            -> decltype(flux::read_at_unchecked(self.base_, cur.cur))
-        {
-            return flux::read_at_unchecked(self.base_, cur.cur);
-        }
+    static constexpr auto inc(auto& self, cursor_type& cur) -> void
+    {
+        cur.missing = detail::advance(self.base_, cur.cur, self.stride_);
+    }
 
-        static constexpr auto move_at_unchecked(auto& self, cursor_type const& cur)
-            -> decltype(flux::move_at_unchecked(self.base_, cur.cur))
-        {
-            return flux::move_at_unchecked(self.base_, cur.cur);
-        }
+    static constexpr auto read_at(auto& self, cursor_type const& cur)
+        -> decltype(flux::read_at(self.base_, cur.cur))
+    {
+        return flux::read_at(self.base_, cur.cur);
+    }
 
-        static constexpr auto last(auto& self) -> cursor_type
-            requires bounded_sequence<Base> && sized_sequence<Base>
-        {
-            int_t missing = (self.stride_ - flux::size(self.base_) % self.stride_) % self.stride_;
-            return cursor_type{
-                .cur = flux::last(self.base_),
-                .missing = missing
-            };
-        }
+    static constexpr auto move_at(auto& self, cursor_type const& cur)
+        -> decltype(flux::move_at(self.base_, cur.cur))
+    {
+        return flux::move_at(self.base_, cur.cur);
+    }
 
-        static constexpr auto dec(auto& self, cursor_type& cur) -> void
-            requires bidirectional_sequence<Base>
-        {
-            advance(self.base_, cur.cur, cur.missing - self.stride_);
-            cur.missing = 0;
-        }
+    static constexpr auto read_at_unchecked(auto& self, cursor_type const& cur)
+        -> decltype(flux::read_at_unchecked(self.base_, cur.cur))
+    {
+        return flux::read_at_unchecked(self.base_, cur.cur);
+    }
 
-        static constexpr auto size(auto& self) -> int_t
-            requires sized_sequence<Base>
-        {
-            auto s = flux::size(self.base_);
-            return s/self.stride_ + (s % self.stride_ == 0 ? 0 : 1);
-        }
+    static constexpr auto move_at_unchecked(auto& self, cursor_type const& cur)
+        -> decltype(flux::move_at_unchecked(self.base_, cur.cur))
+    {
+        return flux::move_at_unchecked(self.base_, cur.cur);
+    }
 
-        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> int_t
-            requires random_access_sequence<Base>
-        {
-            return (flux::distance(self.base_, from.cur, to.cur) - from.missing + to.missing)/self.stride_;
-        }
+    static constexpr auto last(auto& self) -> cursor_type
+        requires bounded_sequence<Base> && sized_sequence<Base>
+    {
+        int_t missing = (self.stride_ - flux::size(self.base_) % self.stride_) % self.stride_;
+        return cursor_type{.cur = flux::last(self.base_), .missing = missing};
+    }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset) -> void
-            requires random_access_sequence<Base>
-        {
-            if (offset > 0) {
-                cur.missing = num::mod(advance(self.base_, cur.cur, num::mul(offset, self.stride_)),
-                                       self.stride_);
-            } else if (offset < 0) {
-                advance(self.base_, cur.cur, num::add(num::mul(offset, self.stride_), cur.missing));
-                cur.missing = 0;
-            }
-        }
+    static constexpr auto dec(auto& self, cursor_type& cur) -> void
+        requires bidirectional_sequence<Base>
+    {
+        detail::advance(self.base_, cur.cur, cur.missing - self.stride_);
+        cur.missing = 0;
+    }
 
-        static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
-            requires sequence<decltype((self.base_))>
-        {
-            int_t n = self.stride_;
-            auto c
-                = flux::seq_for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
-                      if (++n < s) {
-                          return true;
-                      } else {
-                          n = 0;
-                          return std::invoke(pred, FLUX_FWD(elem));
-                      }
-                  });
-            return cursor_type{std::move(c), (n + 1) % self.stride_};
+    static constexpr auto size(auto& self) -> int_t
+        requires sized_sequence<Base>
+    {
+        auto s = flux::size(self.base_);
+        return s / self.stride_ + (s % self.stride_ == 0 ? 0 : 1);
+    }
+
+    static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
+        -> int_t
+        requires random_access_sequence<Base>
+    {
+        return (flux::distance(self.base_, from.cur, to.cur) - from.missing + to.missing)
+            / self.stride_;
+    }
+
+    static constexpr auto inc(auto& self, cursor_type& cur, int_t offset) -> void
+        requires random_access_sequence<Base>
+    {
+        if (offset > 0) {
+            cur.missing = num::mod(
+                detail::advance(self.base_, cur.cur, num::mul(offset, self.stride_)), self.stride_);
+        } else if (offset < 0) {
+            detail::advance(self.base_, cur.cur,
+                            num::add(num::mul(offset, self.stride_), cur.missing));
+            cur.missing = 0;
         }
-    };
+    }
+
+    static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
+        requires sequence<decltype((self.base_))>
+    {
+        int_t n = self.stride_;
+        auto c = flux::seq_for_each_while(self.base_, [&n, &pred, s = self.stride_](auto&& elem) {
+            if (++n < s) {
+                return true;
+            } else {
+                n = 0;
+                return std::invoke(pred, FLUX_FWD(elem));
+            }
+        });
+        return cursor_type{std::move(c), (n + 1) % self.stride_};
+    }
 };
 
+namespace detail {
+
 struct stride_fn {
-    template <adaptable_sequence Seq>
+    template <adaptable_iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, num::integral auto by) const
+    constexpr auto operator()(It&& it, num::integral auto by) const
     {
         FLUX_ASSERT(by > 0);
-        return stride_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), num::checked_cast<int_t>(by));
+        return stride_adaptor<std::decay_t<It>>(FLUX_FWD(it), num::checked_cast<int_t>(by));
     }
 };
 
diff --git a/test/test_stride.cpp b/test/test_stride.cpp
index 1cdb3b46..0e637374 100644
--- a/test/test_stride.cpp
+++ b/test/test_stride.cpp
@@ -41,6 +41,87 @@ struct NotBidir : flux::inline_sequence_base<NotBidir<Base>> {
     };
 };
 
+constexpr bool test_stride_iterable()
+{
+    // Basic stride, n divides size
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5});
+
+        auto strided = flux::stride(iter, 2);
+
+        using S = decltype(strided);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(check_equal(strided, {0, 2, 4}));
+        STATIC_CHECK(flux::iterable_size(strided) == 3);
+    }
+
+    // Basic stride, n does not divide size
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5, 6, 7});
+
+        auto const strided = flux::stride(iter, 3);
+
+        using S = decltype(strided);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(check_equal(strided, {0, 3, 6}));
+        STATIC_CHECK(flux::iterable_size(strided) == 3);
+    }
+
+    // Stride of 1 returns the original sequence
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5, 6});
+
+        auto const strided = flux::stride(iter, 1);
+
+        STATIC_CHECK(check_equal(strided, iter));
+    }
+
+    // Stride >= than sequence size returns sequence of one element
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5});
+
+        auto strided = flux::stride(iter, flux::iterable_size(iter));
+
+        STATIC_CHECK(flux::iterable_size(strided) == 1);
+        STATIC_CHECK(check_equal(strided, {0}));
+    }
+
+    // Reverse iteration, n divides size
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5});
+
+        auto strided = flux::reverse(flux::stride(iter, 2));
+
+        using S = decltype(strided);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(check_equal(strided, {4, 2, 0}));
+        STATIC_CHECK(flux::iterable_size(strided) == 3);
+    }
+
+    // Reverse iteration, n does not divide size
+    {
+        auto iter = iterable_only(std::array{0, 1, 2, 3, 4, 5, 6, 7});
+
+        auto const strided = flux::reverse(flux::stride(iter, 3));
+
+        using S = decltype(strided);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(check_equal(strided, {6, 3, 0}));
+        STATIC_CHECK(flux::iterable_size(strided) == 3);
+    }
+
+    return true;
+}
+static_assert(test_stride_iterable());
+
 constexpr bool test_stride_non_bidir()
 {
     // Basic stride, n divides size

From 3033794612010e7437781c2146140750aab76a0e Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 20 May 2025 17:18:31 +0100
Subject: [PATCH 15/66] Make drop() implement iterable

---
 include/flux/adaptor/drop.hpp | 53 ++++++++++++++++++++++++++++++++---
 test/test_drop.cpp            | 51 ++++++++++++++++++++++++++++++++-
 2 files changed, 99 insertions(+), 5 deletions(-)

diff --git a/include/flux/adaptor/drop.hpp b/include/flux/adaptor/drop.hpp
index 1e796cef..4ac9cb36 100644
--- a/include/flux/adaptor/drop.hpp
+++ b/include/flux/adaptor/drop.hpp
@@ -13,12 +13,32 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base>
+template <typename Base>
 struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     int_t count_;
 
+    template <typename BaseCtx>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        int_t remaining;
+
+        using element_type = context_element_t<BaseCtx>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            return base_ctx.run_while([&](auto&& elem) {
+                if (remaining > 0) {
+                    --remaining;
+                    return loop_continue;
+                } else {
+                    return pred(FLUX_FWD(elem));
+                }
+            });
+        }
+    };
+
 public:
     constexpr drop_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
@@ -28,6 +48,31 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
     constexpr Base& base() & { return base_; }
     constexpr Base const& base() const& { return base_; }
 
+    [[nodiscard]] constexpr auto iterate()
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+    }
+
+    [[nodiscard]] constexpr auto iterate() const
+        requires iterable<Base const>
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+    }
+
+    [[nodiscard]] constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        auto sz = flux::iterable_size(base_);
+        return (cmp::max)(num::sub(sz, count_), int_t{0});
+    }
+
+    [[nodiscard]] constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        auto sz = flux::iterable_size(base_);
+        return (cmp::max)(num::sub(sz, count_), int_t{0});
+    }
+
     struct flux_sequence_traits : passthrough_traits_base {
         using value_type = value_t<Base>;
 
@@ -60,16 +105,16 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
 };
 
 struct drop_fn {
-    template <adaptable_sequence Seq>
+    template <adaptable_iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, num::integral auto count) const
+    constexpr auto operator()(It&& it, num::integral auto count) const
     {
         auto count_ = num::checked_cast<int_t>(count);
         if (count_ < 0) {
             runtime_error("Negative argument passed to drop()");
         }
 
-        return drop_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), count_);
+        return drop_adaptor<std::decay_t<It>>(FLUX_FWD(it), count_);
     }
 
 };
diff --git a/test/test_drop.cpp b/test/test_drop.cpp
index eb8814a9..25942078 100644
--- a/test/test_drop.cpp
+++ b/test/test_drop.cpp
@@ -14,7 +14,56 @@
 
 namespace {
 
-constexpr bool test_drop() {
+constexpr bool test_drop()
+{
+    // Test dropping elements from basic iterables
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop(arr, 2);
+
+        using D = decltype(dropped);
+        static_assert(flux::iterable<D>);
+        static_assert(flux::sized_iterable<D>);
+
+        static_assert(flux::iterable<D const>);
+        static_assert(flux::sized_iterable<D const>);
+
+        STATIC_CHECK(check_equal(dropped, {2, 3, 4}));
+        STATIC_CHECK(flux::iterable_size(dropped) == 3);
+    }
+
+    // Test dropping zero items
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop(arr, 0);
+
+        STATIC_CHECK(flux::iterable_size(dropped) == 5);
+        STATIC_CHECK(check_equal(dropped, arr));
+    }
+
+    // Test dropping all items
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop(arr, 5);
+
+        STATIC_CHECK(flux::iterable_size(dropped) == 0);
+        auto ctx = flux::iterate(dropped);
+        STATIC_CHECK(not flux::next_element(ctx).has_value());
+    }
+
+    // Test dropping too many items
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop(arr, 1000);
+
+        STATIC_CHECK(flux::iterable_size(dropped) == 0);
+        auto ctx = flux::iterate(dropped);
+        STATIC_CHECK(not flux::next_element(ctx).has_value());
+    }
 
     {
         int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

From c480169d47f9a445b70977ee6cc8b89e0491a580 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 20 May 2025 17:42:53 +0100
Subject: [PATCH 16/66] Make take() and drop() reverse_iterable

---
 include/flux/adaptor/drop.hpp | 88 ++++++++++++++++++++++++-----------
 include/flux/adaptor/take.hpp | 72 +++++++++++++---------------
 include/flux/core/utils.hpp   |  1 +
 test/test_drop.cpp            | 17 +++++++
 test/test_take.cpp            | 17 +++++++
 5 files changed, 130 insertions(+), 65 deletions(-)

diff --git a/include/flux/adaptor/drop.hpp b/include/flux/adaptor/drop.hpp
index 4ac9cb36..5e790249 100644
--- a/include/flux/adaptor/drop.hpp
+++ b/include/flux/adaptor/drop.hpp
@@ -13,64 +13,100 @@ namespace flux {
 
 namespace detail {
 
-template <typename Base>
-struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
-private:
-    FLUX_NO_UNIQUE_ADDRESS Base base_;
-    int_t count_;
+template <typename BaseCtx>
+struct drop_iteration_context : immovable {
+    BaseCtx base_ctx;
+    int_t remaining;
 
-    template <typename BaseCtx>
-    struct context_type : immovable {
-        BaseCtx base_ctx;
-        int_t remaining;
+    using element_type = context_element_t<BaseCtx>;
 
-        using element_type = context_element_t<BaseCtx>;
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        return base_ctx.run_while([&](auto&& elem) {
+            if (remaining > 0) {
+                --remaining;
+                return loop_continue;
+            } else {
+                return pred(FLUX_FWD(elem));
+            }
+        });
+    }
+};
 
-        constexpr auto run_while(auto&& pred) -> iteration_result
-        {
-            return base_ctx.run_while([&](auto&& elem) {
-                if (remaining > 0) {
-                    --remaining;
-                    return loop_continue;
-                } else {
-                    return pred(FLUX_FWD(elem));
-                }
+template <typename BaseCtx>
+struct take_iteration_context : immovable {
+    BaseCtx base_ctx;
+    int_t remaining;
+
+    using element_type = context_element_t<BaseCtx>;
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        if (remaining > 0) {
+            auto res = base_ctx.run_while([&](auto&& elem) {
+                --remaining;
+                return pred(FLUX_FWD(elem)) && (remaining > 0);
             });
+            return static_cast<iteration_result>(static_cast<bool>(res) || (remaining == 0));
+        } else {
+            return iteration_result::complete;
         }
-    };
+    }
+};
+
+template <typename Base>
+struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
+private:
+    FLUX_NO_UNIQUE_ADDRESS Base base_;
+    int_t count_;
 
 public:
     constexpr drop_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
           count_(count)
-    {}
+    {
+    }
 
     constexpr Base& base() & { return base_; }
     constexpr Base const& base() const& { return base_; }
 
     [[nodiscard]] constexpr auto iterate()
     {
-        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return drop_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
     }
 
     [[nodiscard]] constexpr auto iterate() const
         requires iterable<Base const>
     {
-        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return drop_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
+    }
+
+    [[nodiscard]] constexpr auto reverse_iterate()
+        requires reverse_iterable<Base> && sized_iterable<Base>
+    {
+        return take_iteration_context{.base_ctx = flux::reverse_iterate(base_),
+                                      .remaining = size()};
+    }
+
+    [[nodiscard]] constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const> && sized_iterable<Base const>
+    {
+        return take_iteration_context{.base_ctx = flux::reverse_iterate(base_),
+                                      .remaining = size()};
     }
 
     [[nodiscard]] constexpr auto size() -> int_t
         requires sized_iterable<Base>
     {
         auto sz = flux::iterable_size(base_);
-        return (cmp::max)(num::sub(sz, count_), int_t{0});
+        return sz > count_ ? sz - count_ : 0;
     }
 
     [[nodiscard]] constexpr auto size() const -> int_t
         requires sized_iterable<Base const>
     {
         auto sz = flux::iterable_size(base_);
-        return (cmp::max)(num::sub(sz, count_), int_t{0});
+        return sz > count_ ? sz - count_ : 0;
     }
 
     struct flux_sequence_traits : passthrough_traits_base {
@@ -88,7 +124,7 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
         static constexpr auto size(auto& self)
             requires sized_sequence<Base>
         {
-            return (cmp::max)(num::sub(flux::size(self.base()), self.count_), int_t {0});
+            return (cmp::max)(num::sub(flux::size(self.base()), self.count_), int_t{0});
         }
 
         static constexpr auto data(auto& self)
diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index f025563b..cc44f30b 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -7,6 +7,7 @@
 #define FLUX_ADAPTOR_TAKE_HPP_INCLUDED
 
 #include <flux/core.hpp>
+#include <flux/adaptor/drop.hpp>
 
 namespace flux {
 
@@ -18,27 +19,6 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
     Base base_;
     int_t count_;
 
-    template <typename BaseCtx>
-    struct context_type : immovable {
-        BaseCtx base_ctx;
-        int_t remaining;
-
-        using element_type = context_element_t<BaseCtx>;
-
-        constexpr auto run_while(auto&& pred) -> iteration_result
-        {
-            if (remaining > 0) {
-                auto res = base_ctx.run_while([&](auto&& elem) {
-                    --remaining;
-                    return pred(FLUX_FWD(elem)) && (remaining > 0);
-                });
-                return static_cast<iteration_result>(static_cast<bool>(res) || (remaining == 0));
-            } else {
-                return iteration_result::complete;
-            }
-        }
-    };
-
 public:
     constexpr take_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
@@ -48,23 +28,40 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
     [[nodiscard]] constexpr auto base() const& -> Base const& { return base_; }
     [[nodiscard]] constexpr auto base() && -> Base&& { return std::move(base_); }
 
-    constexpr auto iterate()
+    [[nodiscard]] constexpr auto iterate()
     {
-        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return take_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
     }
-    constexpr auto iterate() const
+
+    [[nodiscard]] constexpr auto iterate() const
         requires iterable<Base const>
     {
-        return context_type{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return take_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
+    }
+
+    [[nodiscard]] constexpr auto reverse_iterate()
+        requires reverse_iterable<Base> && sized_iterable<Base>
+    {
+        int_t sz = flux::iterable_size(base_);
+        return drop_iteration_context{.base_ctx = flux::reverse_iterate(base_),
+                                      .remaining = sz > count_ ? sz - count_ : 0};
+    }
+
+    [[nodiscard]] constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const> && sized_iterable<Base const>
+    {
+        int_t sz = flux::iterable_size(base_);
+        return drop_iteration_context{.base_ctx = flux::reverse_iterate(base_),
+                                      .remaining = sz > count_ ? sz - count_ : 0};
     }
 
-    constexpr auto size() -> int_t
+    [[nodiscard]] constexpr auto size() -> int_t
         requires sized_iterable<Base>
     {
         return (cmp::min)(flux::iterable_size(base_), count_);
     }
 
-    constexpr auto size() const -> int_t
+    [[nodiscard]] constexpr auto size() const -> int_t
         requires sized_iterable<Base const>
     {
         return (cmp::min)(flux::iterable_size(base_), count_);
@@ -85,8 +82,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
 
         static constexpr auto first(auto& self) -> cursor_type
         {
-            return cursor_type{.base_cur = flux::first(self.base_),
-                               .length = self.count_};
+            return cursor_type{.base_cur = flux::first(self.base_), .length = self.count_};
         }
 
         static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
@@ -97,7 +93,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
         static constexpr auto inc(auto& self, cursor_type& cur)
         {
             flux::inc(self.base_, cur.base_cur);
-            cur.length = num::sub(cur.length, int_t {1});
+            cur.length = num::sub(cur.length, int_t{1});
         }
 
         static constexpr auto read_at(auto& self, cursor_type const& cur)
@@ -128,7 +124,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
             requires bidirectional_sequence<Base>
         {
             flux::dec(self.base_, cur.base_cur);
-            cur.length = num::add(cur.length, int_t {1});
+            cur.length = num::add(cur.length, int_t{1});
         }
 
         static constexpr auto inc(auto& self, cursor_type& cur, int_t offset)
@@ -146,8 +142,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
                               num::sub(from.length, to.length));
         }
 
-        static constexpr auto data(auto& self)
-            -> decltype(flux::data(self.base_))
+        static constexpr auto data(auto& self) -> decltype(flux::data(self.base_))
             requires contiguous_sequence<Base>
         {
             return flux::data(self.base_);
@@ -164,13 +159,12 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
         }
 
         static constexpr auto last(auto& self) -> cursor_type
-            requires (random_access_sequence<Base> && sized_sequence<Base>) ||
-                      infinite_sequence<Base>
+            requires(random_access_sequence<Base> && sized_sequence<Base>)
+            || infinite_sequence<Base>
         {
-            return cursor_type{
-                .base_cur = flux::next(self.base_, flux::first(self.base_), size(self)),
-                .length = 0
-            };
+            return cursor_type{.base_cur
+                               = flux::next(self.base_, flux::first(self.base_), size(self)),
+                               .length = 0};
         }
 
         static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 2738ee80..9e4fe146 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -8,6 +8,7 @@
 
 #include <compare>
 #include <concepts>
+#include <functional>
 #include <type_traits>
 
 #include <flux/core/assert.hpp>
diff --git a/test/test_drop.cpp b/test/test_drop.cpp
index 25942078..c55b9a0b 100644
--- a/test/test_drop.cpp
+++ b/test/test_drop.cpp
@@ -65,6 +65,23 @@ constexpr bool test_drop()
         STATIC_CHECK(not flux::next_element(ctx).has_value());
     }
 
+    // Test reverse iteration
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+        auto dropped = flux::reverse(flux::drop(arr, 3));
+
+        using D = decltype(dropped);
+        static_assert(flux::iterable<D>);
+        static_assert(flux::sized_iterable<D>);
+
+        static_assert(flux::iterable<D const>);
+        static_assert(flux::sized_iterable<D const>);
+
+        STATIC_CHECK(check_equal(dropped, {9, 8, 7, 6, 5, 4, 3}));
+        STATIC_CHECK(flux::iterable_size(dropped) == 7);
+    }
+
     {
         int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
diff --git a/test/test_take.cpp b/test/test_take.cpp
index 6af64a33..702ec6ba 100644
--- a/test/test_take.cpp
+++ b/test/test_take.cpp
@@ -62,6 +62,23 @@ constexpr bool test_take()
         STATIC_CHECK(flux::next_element(ctx) == std::nullopt);
     }
 
+    // Reverse iteration
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto taken = flux::reverse(flux::take(arr, 3));
+
+        using T = decltype(taken);
+        static_assert(flux::iterable<T>);
+        static_assert(flux::sized_iterable<T>);
+
+        static_assert(flux::iterable<T const>);
+        static_assert(flux::sized_iterable<T const>);
+
+        STATIC_CHECK(flux::iterable_size(taken) == 3);
+        STATIC_CHECK(check_equal(taken, {2, 1, 0}));
+    }
+
     {
         int arr[] = {0, 1, 2, 3, 4};
         auto taken = flux::take(std::ref(arr), 3);

From b1d4e8d5f422d06a3801623cdc13c7eab2cc3656 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 20 May 2025 18:06:46 +0100
Subject: [PATCH 17/66] Make drop_while() implement iterable

---
 include/flux/adaptor/drop_while.hpp        | 53 ++++++++++++++++++----
 include/flux/core/inline_sequence_base.hpp |  6 ++-
 include/flux/core/sequence_iterator.hpp    |  2 +
 test/test_drop_while.cpp                   | 35 ++++++++++++++
 4 files changed, 86 insertions(+), 10 deletions(-)

diff --git a/include/flux/adaptor/drop_while.hpp b/include/flux/adaptor/drop_while.hpp
index ba064deb..dbee6e52 100644
--- a/include/flux/adaptor/drop_while.hpp
+++ b/include/flux/adaptor/drop_while.hpp
@@ -12,7 +12,7 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base, typename Pred>
+template <typename Base, typename Pred>
 struct drop_while_adaptor : inline_sequence_base<drop_while_adaptor<Base, Pred>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
@@ -23,18 +23,55 @@ struct drop_while_adaptor : inline_sequence_base<drop_while_adaptor<Base, Pred>>
     constexpr auto base() & -> Base& { return base_; }
     constexpr auto base() const& -> Base const& { return base_; }
 
+    template <typename BaseCtx, typename DropPred>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        DropPred drop_pred;
+        bool done = false;
+
+        using element_type = context_element_t<BaseCtx>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            return base_ctx.run_while([&](auto&& elem) {
+                if (done) {
+                    return std::invoke(pred, FLUX_FWD(elem));
+                } else {
+                    if (std::invoke(drop_pred, std::as_const(elem))) {
+                        return loop_continue;
+                    } else {
+                        done = true;
+                        return std::invoke(pred, FLUX_FWD(elem));
+                    }
+                }
+            });
+        }
+    };
+
 public:
     constexpr drop_while_adaptor(decays_to<Base> auto&& base, decays_to<Pred> auto&& pred)
         : base_(FLUX_FWD(base)),
           pred_(FLUX_FWD(pred))
-    {}
+    {
+    }
 
-    struct flux_sequence_traits : detail::passthrough_traits_base {
-        using value_type = value_t<Base>;
+    [[nodiscard]] constexpr auto iterate()
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .drop_pred = copy_or_ref(pred_)};
+    }
+
+    [[nodiscard]]
+    constexpr auto iterate() const
+        requires iterable<Base const> && std::predicate<Pred&, iterable_element_t<Base const>>
+    {
+        return context_type{.base_ctx = flux::iterate(base_), .drop_pred = copy_or_ref(pred_)};
+    }
 
+    struct flux_sequence_traits : detail::passthrough_traits_base {
         static constexpr bool disable_multipass = !multipass_sequence<Base>;
 
         static constexpr auto first(auto& self)
+            requires sequence<decltype((self.base_))>
         {
             return flux::seq_for_each_while(self.base_, std::ref(self.pred_));
         }
@@ -52,12 +89,12 @@ struct drop_while_adaptor : inline_sequence_base<drop_while_adaptor<Base, Pred>>
 };
 
 struct drop_while_fn {
-    template <adaptable_sequence Seq, std::move_constructible Pred>
-        requires std::predicate<Pred&, element_t<Seq>>
+    template <adaptable_iterable It, std::move_constructible Pred>
+        requires std::predicate<Pred&, iterable_element_t<It>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Pred pred) const
+    constexpr auto operator()(It&& it, Pred pred) const
     {
-        return drop_while_adaptor<std::decay_t<Seq>, Pred>(FLUX_FWD(seq), std::move(pred));
+        return drop_while_adaptor<std::decay_t<It>, Pred>(FLUX_FWD(it), std::move(pred));
     }
 };
 
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index 06863e2a..c920603d 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -212,11 +212,13 @@ struct inline_sequence_base {
     /*
      * Iterator support
      */
-    constexpr auto begin() &;
+    constexpr auto begin() &
+        requires sequence<Derived>;
 
     constexpr auto begin() const& requires sequence<Derived const>;
 
-    constexpr auto end() &;
+    constexpr auto end() &
+        requires sequence<Derived>;
 
     constexpr auto end() const& requires sequence<Derived const>;
 
diff --git a/include/flux/core/sequence_iterator.hpp b/include/flux/core/sequence_iterator.hpp
index 6b5dec04..cb8f6d5b 100644
--- a/include/flux/core/sequence_iterator.hpp
+++ b/include/flux/core/sequence_iterator.hpp
@@ -207,6 +207,7 @@ FLUX_EXPORT inline constexpr auto end = detail::end_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::begin() &
+    requires sequence<D>
 {
     return flux::begin(derived());
 }
@@ -220,6 +221,7 @@ constexpr auto inline_sequence_base<D>::begin() const&
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::end() &
+    requires sequence<D>
 {
     return flux::end(derived());
 }
diff --git a/test/test_drop_while.cpp b/test/test_drop_while.cpp
index f70f42f4..93147aed 100644
--- a/test/test_drop_while.cpp
+++ b/test/test_drop_while.cpp
@@ -11,6 +11,41 @@ namespace {
 
 constexpr bool test_drop_while()
 {
+    // Test drop while with basic iterables
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop_while(arr, [](int i) { return i < 3; });
+
+        using D = decltype(dropped);
+        static_assert(flux::iterable<D>);
+
+        static_assert(flux::iterable<D const>);
+        static_assert(not flux::reverse_iterable<D const>);
+        static_assert(not flux::sized_iterable<D const>);
+
+        STATIC_CHECK(check_equal(dropped, {3, 4}));
+    }
+
+    // Drop while with always-true predicate returns no elements
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop_while(arr, flux::pred::true_);
+
+        STATIC_CHECK(flux::count(dropped) == 0);
+    }
+
+    // Drop while with always-false predicate returns all elements
+    {
+        auto arr = iterable_only(std::array{0, 1, 2, 3, 4});
+
+        auto dropped = flux::drop_while(arr, flux::pred::false_);
+
+        STATIC_CHECK(flux::count(dropped) == 5);
+        STATIC_CHECK(check_equal(dropped, arr));
+    }
+
     {
         int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 

From 0c8971e7c0275343ea367afc8b847d591cc29211 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 20 May 2025 18:36:07 +0100
Subject: [PATCH 18/66] (Try to) fix some CI build errors

---
 include/flux/adaptor/filter.hpp | 2 +-
 include/flux/adaptor/map.hpp    | 6 ++++--
 include/flux/core/utils.hpp     | 3 +++
 test/test_bitset.cpp            | 3 +++
 4 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index 838c2cf0..920b2bcb 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -28,7 +28,7 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
         constexpr auto run_while(auto&& pred) -> iteration_result
         {
             return base_ctx.run_while([this, &pred](auto&& elem) {
-                if (std::invoke(filter_fn, std::as_const(elem))) {
+                if (std::invoke(filter_fn, elem)) {
                     return std::invoke(pred, FLUX_FWD(elem));
                 } else {
                     return loop_continue;
diff --git a/include/flux/adaptor/map.hpp b/include/flux/adaptor/map.hpp
index 3b070042..ecb9cb2c 100644
--- a/include/flux/adaptor/map.hpp
+++ b/include/flux/adaptor/map.hpp
@@ -47,14 +47,16 @@ struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>> {
 
     constexpr auto iterate()
     {
-        return context_type{.base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
+        return context_type<iteration_context_t<Base>, copy_or_ref_t<Func>>{
+            .base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
     }
 
     constexpr auto iterate() const
         requires iterable<Base const>
         && std::regular_invocable<Func&, iterable_element_t<Base const>>
     {
-        return context_type{.base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
+        return context_type<iteration_context_t<Base const>, copy_or_ref_t<Func const>>{
+            .base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
     }
 
     constexpr auto size() -> int_t
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 9e4fe146..50d2fb6e 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -128,6 +128,9 @@ constexpr auto copy_or_ref(Fn& fn)
     }
 }
 
+template <typename Fn>
+using copy_or_ref_t = decltype(copy_or_ref(std::declval<Fn&>()));
+
 } // namespace detail
 
 } // namespace flux
diff --git a/test/test_bitset.cpp b/test/test_bitset.cpp
index 89ec02b0..44023946 100644
--- a/test/test_bitset.cpp
+++ b/test/test_bitset.cpp
@@ -85,6 +85,8 @@ TEST_CASE("bitset")
         REQUIRE(check_equal(seq2, {false, true}));
     }
 
+    // FIXME: GCC 14
+#if 0
     // swap_elements between two bitsets
     {
         std::bitset<16> seq1{};
@@ -110,6 +112,7 @@ TEST_CASE("bitset")
         REQUIRE(seq1.all());
         REQUIRE(flux::none(seq2, std::identity{}));
     }
+#endif
 
     // reversing a bitset in-place
     {

From fd3a7c75277c35a1cd8600fd5761448a075f4745 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 21 May 2025 18:00:03 +0100
Subject: [PATCH 19/66] Fix Clang 17 compilation

I looks like the very neat CTAD-via-designated-initialisers unfortunately doesn't work with Clang 17
---
 include/flux/adaptor/drop_while.hpp |  6 ++++--
 include/flux/adaptor/filter.hpp     | 14 ++++++++------
 include/flux/adaptor/take_while.hpp |  6 ++++--
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/include/flux/adaptor/drop_while.hpp b/include/flux/adaptor/drop_while.hpp
index dbee6e52..752af436 100644
--- a/include/flux/adaptor/drop_while.hpp
+++ b/include/flux/adaptor/drop_while.hpp
@@ -57,14 +57,16 @@ struct drop_while_adaptor : inline_sequence_base<drop_while_adaptor<Base, Pred>>
 
     [[nodiscard]] constexpr auto iterate()
     {
-        return context_type{.base_ctx = flux::iterate(base_), .drop_pred = copy_or_ref(pred_)};
+        return context_type<iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .base_ctx = flux::iterate(base_), .drop_pred = copy_or_ref(pred_)};
     }
 
     [[nodiscard]]
     constexpr auto iterate() const
         requires iterable<Base const> && std::predicate<Pred&, iterable_element_t<Base const>>
     {
-        return context_type{.base_ctx = flux::iterate(base_), .drop_pred = copy_or_ref(pred_)};
+        return context_type<iteration_context_t<Base const>, copy_or_ref_t<Pred const>>{
+            .base_ctx = flux::iterate(base_), .drop_pred = copy_or_ref(pred_)};
     }
 
     struct flux_sequence_traits : detail::passthrough_traits_base {
diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index 920b2bcb..83befc31 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -50,28 +50,30 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
 
     constexpr auto iterate()
     {
-        return context_type{.base_ctx = flux::iterate(base_), .filter_fn = copy_or_ref(pred_)};
+        return context_type<iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .base_ctx = flux::iterate(base_), .filter_fn = copy_or_ref(pred_)};
     }
 
     constexpr auto iterate() const
         requires iterable<Base const> && std::invocable<Pred&, iterable_element_t<Base const>>
     {
-        return context_type{.base_ctx = flux::iterate(base_), .filter_fn = copy_or_ref(pred_)};
+        return context_type<iteration_context_t<Base const>, copy_or_ref_t<Pred const>>{
+            .base_ctx = flux::iterate(base_), .filter_fn = copy_or_ref(pred_)};
     }
 
     constexpr auto reverse_iterate()
         requires reverse_iterable<Base>
     {
-        return context_type{.base_ctx = flux::reverse_iterate(base_),
-                            .filter_fn = copy_or_ref(pred_)};
+        return context_type<reverse_iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .base_ctx = flux::reverse_iterate(base_), .filter_fn = copy_or_ref(pred_)};
     }
 
     constexpr auto reverse_iterate() const
         requires reverse_iterable<Base const>
         && std::invocable<Pred&, iterable_element_t<Base const>>
     {
-        return context_type{.base_ctx = flux::reverse_iterate(base_),
-                            .filter_fn = copy_or_ref(pred_)};
+        return context_type<reverse_iteration_context_t<Base const>, copy_or_ref_t<Pred const>>{
+            .base_ctx = flux::reverse_iterate(base_), .filter_fn = copy_or_ref(pred_)};
     }
 
     struct flux_sequence_traits {
diff --git a/include/flux/adaptor/take_while.hpp b/include/flux/adaptor/take_while.hpp
index 3e94929c..83218630 100644
--- a/include/flux/adaptor/take_while.hpp
+++ b/include/flux/adaptor/take_while.hpp
@@ -62,7 +62,8 @@ struct take_while_adaptor : inline_sequence_base<take_while_adaptor<Base, Pred>>
     [[nodiscard]]
     constexpr auto iterate()
     {
-        return context_type{.base_ctx = flux::iterate(base_), .take_pred = copy_or_ref(pred_)};
+        return context_type<iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .base_ctx = flux::iterate(base_), .take_pred = copy_or_ref(pred_)};
     }
 
     [[nodiscard]]
@@ -70,7 +71,8 @@ struct take_while_adaptor : inline_sequence_base<take_while_adaptor<Base, Pred>>
         requires iterable<Base const>
         && std::predicate<Pred&, iterable_element_t<Base const> const&>
     {
-        return context_type{.base_ctx = flux::iterate(base_), .take_pred = copy_or_ref(pred_)};
+        return context_type<iteration_context_t<Base const>, copy_or_ref_t<Pred const>>{
+            .base_ctx = flux::iterate(base_), .take_pred = copy_or_ref(pred_)};
     }
 };
 

From 90660ba8b6c7d81f8f874473f9de30717e275f1b Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 21 May 2025 18:21:36 +0100
Subject: [PATCH 20/66] More Clang CTAD fixes

---
 include/flux/adaptor/drop.hpp   | 14 ++++++++------
 include/flux/adaptor/stride.hpp | 10 ++++++----
 include/flux/adaptor/take.hpp   | 14 ++++++++------
 test/test_take_while.cpp        |  2 +-
 4 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/include/flux/adaptor/drop.hpp b/include/flux/adaptor/drop.hpp
index 5e790249..527ee790 100644
--- a/include/flux/adaptor/drop.hpp
+++ b/include/flux/adaptor/drop.hpp
@@ -72,27 +72,29 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
 
     [[nodiscard]] constexpr auto iterate()
     {
-        return drop_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return drop_iteration_context<iteration_context_t<Base>>{.base_ctx = flux::iterate(base_),
+                                                                 .remaining = count_};
     }
 
     [[nodiscard]] constexpr auto iterate() const
         requires iterable<Base const>
     {
-        return drop_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return drop_iteration_context<iteration_context_t<Base const>>{
+            .base_ctx = flux::iterate(base_), .remaining = count_};
     }
 
     [[nodiscard]] constexpr auto reverse_iterate()
         requires reverse_iterable<Base> && sized_iterable<Base>
     {
-        return take_iteration_context{.base_ctx = flux::reverse_iterate(base_),
-                                      .remaining = size()};
+        return take_iteration_context<reverse_iteration_context_t<Base>>{
+            .base_ctx = flux::reverse_iterate(base_), .remaining = size()};
     }
 
     [[nodiscard]] constexpr auto reverse_iterate() const
         requires reverse_iterable<Base const> && sized_iterable<Base const>
     {
-        return take_iteration_context{.base_ctx = flux::reverse_iterate(base_),
-                                      .remaining = size()};
+        return take_iteration_context<reverse_iteration_context_t<Base const>>{
+            .base_ctx = flux::reverse_iterate(base_), .remaining = size()};
     }
 
     [[nodiscard]] constexpr auto size() -> int_t
diff --git a/include/flux/adaptor/stride.hpp b/include/flux/adaptor/stride.hpp
index 575f932d..83e278e1 100644
--- a/include/flux/adaptor/stride.hpp
+++ b/include/flux/adaptor/stride.hpp
@@ -102,13 +102,15 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
 
     [[nodiscard]] constexpr auto iterate()
     {
-        return stride_iteration_context{.base_ctx = flux::iterate(base_), .stride = stride_};
+        return stride_iteration_context<iteration_context_t<Base>>{.base_ctx = flux::iterate(base_),
+                                                                   .stride = stride_};
     }
 
     [[nodiscard]] constexpr auto iterate() const
         requires iterable<Base const>
     {
-        return stride_iteration_context{.base_ctx = flux::iterate(base_), .stride = stride_};
+        return stride_iteration_context<iteration_context_t<Base const>>{
+            .base_ctx = flux::iterate(base_), .stride = stride_};
     }
 
     [[nodiscard]] constexpr auto reverse_iterate()
@@ -116,7 +118,7 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
     {
         int_t initial_skip
             = stride_ - 1 - (stride_ - flux::iterable_size(base_) % stride_) % stride_;
-        return stride_iteration_context{
+        return stride_iteration_context<reverse_iteration_context_t<Base>>{
             .base_ctx = flux::reverse_iterate(base_), .stride = stride_, .skip = initial_skip};
     }
 
@@ -125,7 +127,7 @@ struct stride_adaptor : inline_sequence_base<stride_adaptor<Base>> {
     {
         int_t initial_skip
             = stride_ - 1 - (stride_ - flux::iterable_size(base_) % stride_) % stride_;
-        return stride_iteration_context{
+        return stride_iteration_context<reverse_iteration_context_t<Base const>>{
             .base_ctx = flux::reverse_iterate(base_), .stride = stride_, .skip = initial_skip};
     }
 
diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index cc44f30b..2079b541 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -30,29 +30,31 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
 
     [[nodiscard]] constexpr auto iterate()
     {
-        return take_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return take_iteration_context<iteration_context_t<Base>>{.base_ctx = flux::iterate(base_),
+                                                                 .remaining = count_};
     }
 
     [[nodiscard]] constexpr auto iterate() const
         requires iterable<Base const>
     {
-        return take_iteration_context{.base_ctx = flux::iterate(base_), .remaining = count_};
+        return take_iteration_context<iteration_context_t<Base const>>{
+            .base_ctx = flux::iterate(base_), .remaining = count_};
     }
 
     [[nodiscard]] constexpr auto reverse_iterate()
         requires reverse_iterable<Base> && sized_iterable<Base>
     {
         int_t sz = flux::iterable_size(base_);
-        return drop_iteration_context{.base_ctx = flux::reverse_iterate(base_),
-                                      .remaining = sz > count_ ? sz - count_ : 0};
+        return drop_iteration_context<reverse_iteration_context_t<Base>>{
+            .base_ctx = flux::reverse_iterate(base_), .remaining = sz > count_ ? sz - count_ : 0};
     }
 
     [[nodiscard]] constexpr auto reverse_iterate() const
         requires reverse_iterable<Base const> && sized_iterable<Base const>
     {
         int_t sz = flux::iterable_size(base_);
-        return drop_iteration_context{.base_ctx = flux::reverse_iterate(base_),
-                                      .remaining = sz > count_ ? sz - count_ : 0};
+        return drop_iteration_context<reverse_iteration_context_t<Base const>>{
+            .base_ctx = flux::reverse_iterate(base_), .remaining = sz > count_ ? sz - count_ : 0};
     }
 
     [[nodiscard]] constexpr auto size() -> int_t
diff --git a/test/test_take_while.cpp b/test/test_take_while.cpp
index ff718e43..11311bfa 100644
--- a/test/test_take_while.cpp
+++ b/test/test_take_while.cpp
@@ -54,7 +54,7 @@ constexpr bool test_take_while()
         auto taken = flux::take_while(arr, [](int) { return false; });
 
         auto ctx = flux::iterate(taken);
-        STATIC_CHECK(flux::next_element(ctx) == std::nullopt);
+        STATIC_CHECK(flux::next_element(ctx) == flux::nullopt);
     }
 
     // Test (attempting to) restart iteration after completion

From ff329a6fef1a3be5ce97d6a0595d9bbb10071f58 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 22 May 2025 15:18:40 +0100
Subject: [PATCH 21/66] Implement iterable for flatten()

---
 include/flux/adaptor/drop.hpp    |   3 +-
 include/flux/adaptor/flatten.hpp | 142 ++++++++++++++++++++++++++++---
 include/flux/core/utils.hpp      |  13 +++
 test/test_flatten.cpp            |  33 +++++++
 4 files changed, 178 insertions(+), 13 deletions(-)

diff --git a/include/flux/adaptor/drop.hpp b/include/flux/adaptor/drop.hpp
index 527ee790..ca924f09 100644
--- a/include/flux/adaptor/drop.hpp
+++ b/include/flux/adaptor/drop.hpp
@@ -43,11 +43,10 @@ struct take_iteration_context : immovable {
     constexpr auto run_while(auto&& pred) -> iteration_result
     {
         if (remaining > 0) {
-            auto res = base_ctx.run_while([&](auto&& elem) {
+            return base_ctx.run_while([&](auto&& elem) {
                 --remaining;
                 return pred(FLUX_FWD(elem)) && (remaining > 0);
             });
-            return static_cast<iteration_result>(static_cast<bool>(res) || (remaining == 0));
         } else {
             return iteration_result::complete;
         }
diff --git a/include/flux/adaptor/flatten.hpp b/include/flux/adaptor/flatten.hpp
index 71eb2586..577a227c 100644
--- a/include/flux/adaptor/flatten.hpp
+++ b/include/flux/adaptor/flatten.hpp
@@ -12,8 +12,80 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base>
+template <typename BaseCtx, auto const& IterateFn = flux::iterate>
+struct flatten_iteration_context : immovable {
+    BaseCtx base_ctx;
+
+    using OptInnerElem = decltype(next_element(base_ctx));
+    OptInnerElem inner_elem = nullopt;
+
+    using InnerCtx = decltype(IterateFn(*inner_elem));
+    optional<InnerCtx> inner_ctx = nullopt;
+
+    using element_type = context_element_t<InnerCtx>;
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        while (true) {
+            if (!inner_ctx.has_value()) {
+                inner_elem = next_element(base_ctx);
+                if (!inner_elem) {
+                    return iteration_result::complete;
+                }
+                inner_ctx.emplace(detail::emplace_from([&] { return IterateFn(*inner_elem); }));
+            }
+
+            FLUX_DEBUG_ASSERT(inner_ctx.has_value());
+            auto res = flux::run_while(*inner_ctx, pred);
+            if (res == iteration_result::incomplete) {
+                return res;
+            } else {
+                inner_ctx.reset();
+            }
+        }
+    }
+};
+
+template <typename Base>
 struct flatten_adaptor : inline_sequence_base<flatten_adaptor<Base>> {
+private:
+    Base base_;
+
+public:
+    constexpr explicit flatten_adaptor(decays_to<Base> auto&& base) : base_(FLUX_FWD(base)) { }
+
+    constexpr auto iterate()
+    {
+        using Ctx = flatten_iteration_context<iteration_context_t<Base>>;
+        return Ctx{.base_ctx = flux::iterate(base_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const> && iterable<iterable_element_t<Base const>>
+    {
+        using Ctx = flatten_iteration_context<iteration_context_t<Base const>>;
+        return Ctx{.base_ctx = flux::iterate(base_)};
+    }
+
+    constexpr auto reverse_iterate()
+        requires reverse_iterable<Base> && reverse_iterable<iterable_element_t<Base>>
+    {
+        using Ctx
+            = flatten_iteration_context<reverse_iteration_context_t<Base>, flux::reverse_iterate>;
+        return Ctx{.base_ctx = flux::reverse_iterate(base_)};
+    }
+
+    constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const> && reverse_iterable<iterable_element_t<Base const>>
+    {
+        using Ctx = flatten_iteration_context<reverse_iteration_context_t<Base const>,
+                                              flux::reverse_iterate>;
+        return Ctx{.base_ctx = flux::reverse_iterate(base_)};
+    }
+};
+
+template <sequence Base>
+struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
 private:
     using InnerSeq = element_t<Base>;
 
@@ -21,9 +93,36 @@ struct flatten_adaptor : inline_sequence_base<flatten_adaptor<Base>> {
     optional<InnerSeq> inner_ = nullopt;
 
 public:
-    constexpr explicit flatten_adaptor(decays_to<Base> auto&& base)
-        : base_(FLUX_FWD(base))
-    {}
+    constexpr explicit flatten_adaptor(decays_to<Base> auto&& base) : base_(FLUX_FWD(base)) { }
+
+    constexpr auto iterate()
+    {
+        return flatten_iteration_context<iteration_context_t<Base>>{.base_ctx
+                                                                    = flux::iterate(base_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const> && iterable<iterable_element_t<Base const>>
+    {
+        return flatten_iteration_context<iteration_context_t<Base const>>{.base_ctx
+                                                                          = flux::iterate(base_)};
+    }
+
+    constexpr auto reverse_iterate()
+        requires reverse_iterable<Base> && reverse_iterable<iterable_element_t<Base>>
+    {
+        using Ctx
+            = flatten_iteration_context<reverse_iteration_context_t<Base>, flux::reverse_iterate>;
+        return Ctx{.base_ctx = flux::reverse_iterate(base_)};
+    }
+
+    constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const> && reverse_iterable<iterable_element_t<Base const>>
+    {
+        using Ctx = flatten_iteration_context<reverse_iteration_context_t<Base const>,
+                                              flux::reverse_iterate>;
+        return Ctx{.base_ctx = flux::reverse_iterate(base_)};
+    }
 
     struct flux_sequence_traits : default_sequence_traits {
     private:
@@ -101,9 +200,30 @@ struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
     Base base_;
 
 public:
-    constexpr explicit flatten_adaptor(decays_to<Base> auto&& base)
-        : base_(FLUX_FWD(base))
-    {}
+    constexpr explicit flatten_adaptor(decays_to<Base> auto&& base) : base_(FLUX_FWD(base)) { }
+
+    constexpr auto iterate() -> flatten_iteration_context<iteration_context_t<Base>>
+    {
+        return {.base_ctx = flux::iterate(base_)};
+    }
+
+    constexpr auto iterate() const -> flatten_iteration_context<iteration_context_t<Base const>>
+        requires iterable<Base const> && iterable<iterable_element_t<Base const>>
+    {
+        return {.base_ctx = flux::iterate(base_)};
+    }
+
+    constexpr auto size() -> int_t
+        requires sized_sequence<Base> && sized_sequence<element_t<Base>>
+    {
+        return num::mul(flux::size(base_), flux::size(flux::read_at(base_, flux::first(base_))));
+    }
+
+    constexpr auto size() const -> int_t
+        requires sized_sequence<Base const> && sized_sequence<element_t<Base const>>
+    {
+        return num::mul(flux::size(base_), flux::size(flux::read_at(base_, flux::first(base_))));
+    }
 
     struct flux_sequence_traits : default_sequence_traits {
     private:
@@ -231,12 +351,12 @@ struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
 };
 
 struct flatten_fn {
-    template <adaptable_sequence Seq>
-        requires sequence<element_t<Seq>>
+    template <adaptable_iterable It>
+        requires iterable<iterable_element_t<It>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> sequence auto
+    constexpr auto operator()(It&& it) const -> iterable auto
     {
-        return flatten_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq));
+        return flatten_adaptor<std::decay_t<It>>(FLUX_FWD(it));
     }
 };
 
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 50d2fb6e..77a312b1 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -131,6 +131,19 @@ constexpr auto copy_or_ref(Fn& fn)
 template <typename Fn>
 using copy_or_ref_t = decltype(copy_or_ref(std::declval<Fn&>()));
 
+template <typename Fn>
+struct emplace_from {
+    Fn fn;
+    using type = decltype(std::move(fn)());
+
+    constexpr operator type() && noexcept { return std::move(fn)(); }
+
+    constexpr type operator()() && { return std::move(fn)(); }
+};
+
+template <typename Fn>
+emplace_from(Fn) -> emplace_from<Fn>;
+
 } // namespace detail
 
 } // namespace flux
diff --git a/test/test_flatten.cpp b/test/test_flatten.cpp
index 9107c135..21c3ffe5 100644
--- a/test/test_flatten.cpp
+++ b/test/test_flatten.cpp
@@ -7,6 +7,7 @@
 #include <string>
 #include <string_view>
 #include <vector>
+#include <utility>
 
 #include "test_utils.hpp"
 
@@ -34,6 +35,38 @@ namespace {
 
 constexpr bool test_flatten_single_pass()
 {
+    // Test flatten with basic iterable
+    {
+        std::array<std::array<int, 3>, 3> nested_array
+            = {std::array{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+
+        auto flattened = flux::flatten(iterable_only(nested_array));
+
+        using F = decltype(flattened);
+        static_assert(flux::iterable<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, int&>);
+        STATIC_CHECK(check_equal(flattened, {1, 2, 3, 4, 5, 6, 7, 8, 9}));
+
+        static_assert(flux::iterable<F const>);
+        static_assert(std::same_as<flux::iterable_element_t<F const>, int const&>);
+        STATIC_CHECK(check_equal(std::as_const(flattened), {1, 2, 3, 4, 5, 6, 7, 8, 9}));
+    }
+
+    // If both the outer and the inner are reversible, we can reverse a flattened iterable
+    {
+        std::array<std::array<int, 3>, 3> nested_array{std::array{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+
+        auto flattened = flux::flatten(iterable_only(nested_array));
+
+        using F = decltype(flattened);
+        static_assert(flux::reverse_iterable<F>);
+        static_assert(flux::reverse_iterable<F const>);
+
+        auto reversed = flux::reverse(flattened);
+        STATIC_CHECK(check_equal(reversed, {9, 8, 7, 6, 5, 4, 3, 2, 1}));
+        STATIC_CHECK(check_equal(std::as_const(reversed), {9, 8, 7, 6, 5, 4, 3, 2, 1}));
+    }
+
     // Single-pass source sequence, inner sequence is multipass
     {
         std::array<std::array<int, 3>, 3> arr{

From e5e1c564c140b3d6f336da3376fa60d35b82c662 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 10:21:38 +0100
Subject: [PATCH 22/66] Update flatten_with() for iterables

---
 include/flux/adaptor/flatten_with.hpp        | 169 ++++++++++++++++---
 include/flux/core/operation_requirements.hpp |   7 +-
 test/test_flatten_with.cpp                   |  28 +++
 3 files changed, 181 insertions(+), 23 deletions(-)

diff --git a/include/flux/adaptor/flatten_with.hpp b/include/flux/adaptor/flatten_with.hpp
index 0b31a93e..a66bcfca 100644
--- a/include/flux/adaptor/flatten_with.hpp
+++ b/include/flux/adaptor/flatten_with.hpp
@@ -17,8 +17,8 @@ namespace detail {
 // Workaround for std::variant::emplace<N> not being constexpr in libc++
 // See P2231 (C++20 DR)
 template <std::size_t N>
-inline constexpr auto variant_emplace =
-[]<typename... Types>(std::variant<Types...>& variant, auto&&... args) {
+inline constexpr auto variant_emplace = []<typename... Types>(std::variant<Types...>& variant,
+                                                              auto&&... args) {
     if (std::is_constant_evaluated()) {
         variant = std::variant<Types...>(std::in_place_index<N>, FLUX_FWD(args)...); // LCOV_EXCL_LINE
     } else {
@@ -26,9 +26,111 @@ inline constexpr auto variant_emplace =
     }
 };
 
+template <typename BaseCtx, typename Pattern>
+struct flatten_with_iteration_context : immovable {
+    BaseCtx base_ctx;
+    Pattern pattern;
+
+    using OptInnerElem = decltype(next_element(base_ctx));
+    OptInnerElem inner_elem = nullopt;
+
+    using InnerCtx = decltype(flux::iterate(*inner_elem));
+    optional<InnerCtx> inner_ctx = nullopt;
+
+    using PatternCtx = decltype(flux::iterate(pattern));
+    optional<PatternCtx> pattern_ctx = nullopt;
+
+    enum class mode_t { pattern, inner };
+    mode_t mode = mode_t::inner;
+
+    constexpr bool try_advance_inner()
+    {
+        if (inner_ctx.has_value()) {
+            return true;
+        } else {
+            inner_elem = flux::next_element(base_ctx);
+            if (!inner_elem) {
+                return false;
+            } else {
+                inner_ctx.emplace(detail::emplace_from([&] { return flux::iterate(*inner_elem); }));
+                return true;
+            }
+        }
+    }
+
+    using element_type = std::common_reference_t<context_element_t<InnerCtx>, element_t<Pattern>>;
+
+    constexpr auto run_while(auto&& pred) -> iteration_result
+    {
+        if (!try_advance_inner()) {
+            return iteration_result::complete;
+        }
+
+        while (true) {
+            if (mode == mode_t::inner) {
+                FLUX_DEBUG_ASSERT(inner_ctx.has_value());
+                auto res = flux::run_while(*inner_ctx, pred);
+                if (res == iteration_result::incomplete) {
+                    return res;
+                } else {
+                    inner_ctx.reset();
+                    mode = mode_t::pattern;
+                }
+            } else {
+                if (!try_advance_inner()) {
+                    return iteration_result::complete;
+                }
+
+                if (!pattern_ctx.has_value()) {
+                    pattern_ctx.emplace(
+                        detail::emplace_from([&] { return flux::iterate(pattern); }));
+                }
+
+                FLUX_DEBUG_ASSERT(pattern_ctx.has_value());
+                auto res = flux::run_while(*pattern_ctx, pred);
+                if (res == iteration_result::incomplete) {
+                    return res;
+                } else {
+                    pattern_ctx.reset();
+                    mode = mode_t::inner;
+                }
+            }
+        }
+    }
+};
+
+template <typename Base, multipass_sequence Pattern>
+struct flatten_with_adaptor : inline_sequence_base<flatten_with_adaptor<Base, Pattern>> {
+private:
+    FLUX_NO_UNIQUE_ADDRESS Base base_;
+    FLUX_NO_UNIQUE_ADDRESS Pattern pattern_;
+
+public:
+    constexpr flatten_with_adaptor(decays_to<Base> auto&& base, decays_to<Pattern> auto&& pattern)
+        : base_(FLUX_FWD(base)),
+          pattern_(FLUX_FWD(pattern))
+    {
+    }
+
+    constexpr auto iterate()
+    {
+        return detail::flatten_with_iteration_context<iteration_context_t<Base>,
+                                                      decltype(flux::mut_ref(pattern_))>{
+            .base_ctx = flux::iterate(base_), .pattern = flux::mut_ref(pattern_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const> && iterable<iterable_element_t<Base const>>
+    {
+        return detail::flatten_with_iteration_context<iteration_context_t<Base const>,
+                                                      decltype(flux::ref(pattern_))>{
+            .base_ctx = flux::iterate(base_), .pattern = flux::ref(pattern_)};
+    }
+};
+
 template <sequence Base, multipass_sequence Pattern>
-struct flatten_with_adaptor : inline_sequence_base<flatten_with_adaptor<Base, Pattern>>
-{
+struct flatten_with_adaptor<Base, Pattern>
+    : inline_sequence_base<flatten_with_adaptor<Base, Pattern>> {
 private:
     using InnerSeq = element_t<Base>;
 
@@ -41,7 +143,23 @@ struct flatten_with_adaptor : inline_sequence_base<flatten_with_adaptor<Base, Pa
                                    decays_to<Pattern> auto&& pattern)
         : base_(FLUX_FWD(base)),
           pattern_(FLUX_FWD(pattern))
-    {}
+    {
+    }
+
+    constexpr auto iterate()
+    {
+        return detail::flatten_with_iteration_context<iteration_context_t<Base>,
+                                                      decltype(flux::mut_ref(pattern_))>{
+            .base_ctx = flux::iterate(base_), .pattern = flux::mut_ref(pattern_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const> && iterable<iterable_element_t<Base const>>
+    {
+        return detail::flatten_with_iteration_context<iteration_context_t<Base const>,
+                                                      decltype(flux::ref(pattern_))>{
+            .base_ctx = flux::iterate(base_), .pattern = flux::ref(pattern_)};
+    }
 
     struct flux_sequence_traits : default_sequence_traits {
     private:
@@ -169,6 +287,21 @@ struct flatten_with_adaptor<Base, Pattern>
           pattern_(FLUX_FWD(pattern))
     {}
 
+    constexpr auto iterate()
+    {
+        return detail::flatten_with_iteration_context<iteration_context_t<Base>,
+                                                      decltype(flux::mut_ref(pattern_))>{
+            .base_ctx = flux::iterate(base_), .pattern = flux::mut_ref(pattern_)};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const> && iterable<iterable_element_t<Base const>>
+    {
+        return detail::flatten_with_iteration_context<iteration_context_t<Base const>,
+                                                      decltype(flux::ref(pattern_))>{
+            .base_ctx = flux::iterate(base_), .pattern = flux::ref(pattern_)};
+    }
+
     struct flux_sequence_traits : default_sequence_traits {
     private:
         using InnerSeq = element_t<Base>;
@@ -341,24 +474,22 @@ struct flatten_with_adaptor<Base, Pattern>
 
 struct flatten_with_fn {
 
-    template <adaptable_sequence Seq, adaptable_sequence Pattern>
-        requires sequence<element_t<Seq>> &&
-                 multipass_sequence<Pattern> &&
-                 flatten_with_compatible<element_t<Seq>, Pattern>
-    constexpr auto operator()(Seq&& seq, Pattern&& pattern) const
-        -> sequence auto
+    template <adaptable_iterable It, adaptable_sequence Pattern>
+        requires iterable<iterable_element_t<It>> && multipass_sequence<Pattern>
+        && flatten_with_compatible<iterable_element_t<It>, Pattern>
+    constexpr auto operator()(It&& it, Pattern&& pattern) const -> iterable auto
     {
-        return flatten_with_adaptor<std::decay_t<Seq>, std::decay_t<Pattern>>(
-            FLUX_FWD(seq), FLUX_FWD(pattern));
+        return flatten_with_adaptor<std::decay_t<It>, std::decay_t<Pattern>>(FLUX_FWD(it),
+                                                                             FLUX_FWD(pattern));
     }
 
-    template <adaptable_sequence Seq>
-        requires sequence<element_t<Seq>> &&
-                 std::movable<value_t<element_t<Seq>>>
-    constexpr auto operator()(Seq&& seq, value_t<element_t<Seq>> value) const
-        -> sequence auto
+    template <adaptable_iterable It>
+        requires sequence<iterable_element_t<It>>
+        && std::movable<iterable_value_t<iterable_element_t<It>>>
+    constexpr auto operator()(It&& it, iterable_value_t<iterable_element_t<It>> value) const
+        -> iterable auto
     {
-        return (*this)(FLUX_FWD(seq), flux::single(std::move(value)));
+        return (*this)(FLUX_FWD(it), flux::single(std::move(value)));
     }
 };
 
diff --git a/include/flux/core/operation_requirements.hpp b/include/flux/core/operation_requirements.hpp
index 5d8f6274..1f3ea92f 100644
--- a/include/flux/core/operation_requirements.hpp
+++ b/include/flux/core/operation_requirements.hpp
@@ -38,10 +38,9 @@ template <typename Func, typename E, int_t N>
 concept repeated_invocable = repeated_invocable_helper<Func, E, N>::value;
 
 template <typename InnerSeq, typename Pattern>
-concept flatten_with_compatible =
-    std::common_reference_with<element_t<InnerSeq>, element_t<Pattern>> &&
-    std::common_reference_with<rvalue_element_t<InnerSeq>, rvalue_element_t<Pattern>> &&
-    std::common_with<value_t<InnerSeq>, value_t<Pattern>>;
+concept flatten_with_compatible
+    = std::common_reference_with<iterable_element_t<InnerSeq>, iterable_element_t<Pattern>>
+    && std::common_with<iterable_value_t<InnerSeq>, iterable_value_t<Pattern>>;
 
 } // namespace detail
 
diff --git a/test/test_flatten_with.cpp b/test/test_flatten_with.cpp
index 2c4785a1..0651ccc3 100644
--- a/test/test_flatten_with.cpp
+++ b/test/test_flatten_with.cpp
@@ -19,6 +19,34 @@ using namespace std::string_view_literals;
 
 constexpr bool test_flatten_with_single_pass()
 {
+    // Iterable outer, sequence pattern
+    {
+        std::array<std::string_view, 3> arr{"111", "222", "333"};
+
+        auto flattened = flux::flatten_with(iterable_only(arr), "-_-"sv);
+
+        using F = decltype(flattened);
+        static_assert(flux::iterable<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, char const&>);
+        static_assert(std::same_as<flux::iterable_value_t<F>, char>);
+        static_assert(not flux::sized_iterable<F>);
+
+        static_assert(flux::iterable<F const>);
+        static_assert(std::same_as<flux::iterable_element_t<F const>, char const&>);
+        static_assert(std::same_as<flux::iterable_value_t<F const>, char>);
+
+        STATIC_CHECK(check_equal(flattened, "111-_-222-_-333"sv));
+    }
+
+    // Iterable outer, value pattern
+    {
+        std::array<std::string_view, 3> arr{"111", "222", "333"};
+
+        auto flattened = flux::flatten_with(iterable_only(arr), '-');
+
+        STATIC_CHECK(check_equal(flattened, "111-222-333"sv));
+    }
+
     // Single-pass outer, multipass inner, sequence pattern
     {
         std::array<std::string_view, 3> arr{"111", "222", "333"};

From 9c32a08d1e66445537a4707edb10a856b12b69d1 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 11:28:19 +0100
Subject: [PATCH 23/66] Add iterable conformance to chain()

---
 include/flux/adaptor/chain.hpp | 103 ++++++++++++++++++++++++++++-----
 include/flux/core/utils.hpp    |  17 ++++++
 test/test_chain.cpp            |  31 ++++++++++
 3 files changed, 136 insertions(+), 15 deletions(-)

diff --git a/include/flux/adaptor/chain.hpp b/include/flux/adaptor/chain.hpp
index bb9b545c..11f0b1ad 100644
--- a/include/flux/adaptor/chain.hpp
+++ b/include/flux/adaptor/chain.hpp
@@ -15,17 +15,94 @@ namespace flux {
 
 namespace detail {
 
-template <sequence... Bases>
+template <typename... Bases>
 struct chain_adaptor : inline_sequence_base<chain_adaptor<Bases...>> {
 private:
     std::tuple<Bases...> bases_;
 
     friend struct sequence_traits<chain_adaptor>;
 
+    template <typename Parent, typename... BaseContexts>
+    struct iteration_context {
+        Parent* parent;
+        std::variant<BaseContexts...> base_context;
+
+        using element_type = std::common_reference_t<typename BaseContexts::element_type...>;
+
+        template <std::size_t I>
+        constexpr auto run_while_impl(auto&& pred) -> iteration_result
+        {
+            if constexpr (I < sizeof...(Bases) - 1) {
+                if (base_context.index() == I) {
+                    auto& ctx = std::get<I>(base_context);
+                    auto result = flux::run_while(ctx, pred);
+                    if (result == iteration_result::incomplete) {
+                        return result;
+                    } else {
+                        base_context.template emplace<I + 1>(emplace_from{
+                            [&] { return flux::iterate(std::get<I + 1>(parent->bases_)); }});
+                        return run_while_impl<I + 1>(pred);
+                    }
+                } else {
+                    return run_while_impl<I + 1>(pred);
+                }
+            } else {
+                if (base_context.index() == I) {
+                    return std::get<I>(base_context).run_while(pred);
+                } else {
+                    unreachable();
+                }
+            }
+        }
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            auto call_with_common_ref
+                = [&pred](auto&& elem) { return pred(static_cast<element_type>(FLUX_FWD(elem))); };
+            return run_while_impl<0>(call_with_common_ref);
+        }
+    };
+
 public:
     explicit constexpr chain_adaptor(decays_to<Bases> auto&&... bases)
         : bases_(FLUX_FWD(bases)...)
-    {}
+    {
+    }
+
+    [[nodiscard]]
+    constexpr auto iterate()
+    {
+        return iteration_context<chain_adaptor, iteration_context_t<Bases>...>{
+            .parent = this,
+            .base_context = std::variant<iteration_context_t<Bases>...>(
+                std::in_place_index<0>,
+                emplace_from([&] { return flux::iterate(std::get<0>(bases_)); }))};
+    }
+
+    [[nodiscard]]
+    constexpr auto iterate() const
+        requires(iterable<Bases const> && ...)
+    {
+        return iteration_context<chain_adaptor const, iteration_context_t<Bases const>...>{
+            .parent = this,
+            .base_context = std::variant<iteration_context_t<Bases const>...>(
+                std::in_place_index<0>,
+                emplace_from([&] { return flux::iterate(std::get<0>(bases_)); }))};
+    }
+
+    [[nodiscard]] constexpr auto size() -> int_t
+        requires(sized_iterable<Bases> && ...)
+    {
+        return std::apply([](auto&... bases) { return (flux::iterable_size(bases) + ...); },
+                          bases_);
+    }
+
+    [[nodiscard]] constexpr auto size() const -> int_t
+        requires(sized_iterable<Bases const> && ...)
+    {
+        return std::apply([](auto&... bases) { return (flux::iterable_size(bases) + ...); },
+                          bases_);
+    }
 };
 
 template <typename... Ts>
@@ -34,29 +111,26 @@ concept all_have_common_ref =
     (std::convertible_to<Ts, std::common_reference_t<Ts...>> && ...);
 
 template <typename... Seqs>
-concept chainable =
-    all_have_common_ref<element_t<Seqs>...> &&
-    all_have_common_ref<rvalue_element_t<Seqs>...> &&
-    requires { typename std::common_type_t<value_t<Seqs>...>; };
+concept chainable = all_have_common_ref<iterable_element_t<Seqs>...>
+    && requires { typename std::common_type_t<iterable_value_t<Seqs>...>; };
 
 struct chain_fn {
-    template <adaptable_sequence... Seqs>
-        requires (sizeof...(Seqs) >= 1) &&
-                 chainable<Seqs...>
+    template <adaptable_iterable... Its>
+        requires(sizeof...(Its) >= 1) && chainable<Its...>
     [[nodiscard]]
-    constexpr auto operator()(Seqs&&... seqs) const
+    constexpr auto operator()(Its&&... its) const
     {
-        if constexpr (sizeof...(Seqs) == 1) {
-            return std::forward<Seqs...>(seqs...);
+        if constexpr (sizeof...(Its) == 1) {
+            return std::forward<Its...>(its...);
         } else {
-            return chain_adaptor<std::decay_t<Seqs>...>(FLUX_FWD(seqs)...);
+            return chain_adaptor<std::decay_t<Its>...>(FLUX_FWD(its)...);
         }
     }
 };
 
 } // namespace detail
 
-template <typename... Bases>
+template <sequence... Bases>
 struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_traits {
 
     using value_type = std::common_type_t<value_t<Bases>...>;
@@ -317,7 +391,6 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> : default_sequence_trait
     {
         inc_ra_impl<0>(self, cur, offset);
     }
-
 };
 
 FLUX_EXPORT inline constexpr auto chain = detail::chain_fn{};
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 77a312b1..eb66f688 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -144,6 +144,23 @@ struct emplace_from {
 template <typename Fn>
 emplace_from(Fn) -> emplace_from<Fn>;
 
+[[noreturn]] inline void unreachable()
+{
+    if constexpr (config::enable_debug_asserts) {
+        runtime_error(
+            "Unreachable code reached! This should never happen. Please file a bug report.");
+    }
+#if defined(__cpp_lib_unreachable) && (__cpp_lib_unreachable >= 202202L)
+    std::unreachable();
+#elif defined(__has_builtin) && __has_builtin(__builtin_unreachable)
+    __builtin_unreachable();
+#elif defined(_MSC_VER)
+    __assume(false);
+#else
+    std::abort();
+#endif
+}
+
 } // namespace detail
 
 } // namespace flux
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index e4326038..d86e6d33 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -15,6 +15,37 @@ namespace {
 
 constexpr bool test_chain()
 {
+    // Basic chaining with iterables
+    {
+        auto iter1 = iterable_only(std::array{1, 2, 3});
+        auto iter2 = iterable_only(std::array{4, 5});
+        auto iter3 = iterable_only(std::array{6});
+
+        auto chained = flux::chain(iter1, iter2, iter3);
+
+        using C = decltype(chained);
+        static_assert(flux::iterable<C>);
+        static_assert(flux::sized_iterable<C>);
+
+        STATIC_CHECK(flux::iterable_size(chained) == 6);
+        STATIC_CHECK(check_equal(chained, {1, 2, 3, 4, 5, 6}));
+    }
+
+    // Const iteration with iterables
+    {
+        auto iter1 = iterable_only(std::array{1, 2, 3});
+        auto iter2 = iterable_only(std::array{4, 5, 6});
+
+        auto const chained = flux::chain(iter1, iter2);
+
+        using C = decltype(chained);
+        static_assert(flux::iterable<C>);
+        static_assert(flux::sized_iterable<C>);
+
+        STATIC_CHECK(flux::iterable_size(chained) == 6);
+        STATIC_CHECK(check_equal(chained, {1, 2, 3, 4, 5, 6}));
+    }
+
     // Basic chaining
     {
         int arr1[] = {0, 1, 2};

From c1ad734a33db9297d13a83befb2f6a1294fe7ad6 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 11:59:46 +0100
Subject: [PATCH 24/66] Add a 4th(!) chunk implementation

...this one dealing with plain iterables
---
 include/flux/adaptor/chunk.hpp | 130 +++++++++++++++++++++++++++++++--
 test/test_chunk.cpp            |  44 +++++++++++
 2 files changed, 169 insertions(+), 5 deletions(-)

diff --git a/include/flux/adaptor/chunk.hpp b/include/flux/adaptor/chunk.hpp
index 473356cb..0ba848e9 100644
--- a/include/flux/adaptor/chunk.hpp
+++ b/include/flux/adaptor/chunk.hpp
@@ -15,8 +15,128 @@ namespace flux {
 
 namespace detail {
 
+template <typename BaseCtx>
+struct chunk_iteration_context : immovable {
+    BaseCtx base_ctx;
+
+    using OptElem = decltype(next_element(base_ctx));
+
+    int_t chunk_sz;
+    OptElem elem = nullopt;
+    int_t remaining = 0;
+    bool base_done = false;
+
+    struct inner_iterable {
+        chunk_iteration_context* outer_ctx;
+
+        struct inner_context_type : immovable {
+            chunk_iteration_context* outer_ctx;
+
+            using element_type = context_element_t<BaseCtx>;
+
+            constexpr auto run_while(auto&& pred) -> iteration_result
+            {
+                while (true) {
+                    if (outer_ctx->remaining == 0) {
+                        return iteration_result::complete;
+                    }
+
+                    if (!outer_ctx->elem) {
+                        if (!outer_ctx->read_next()) {
+                            return iteration_result::complete;
+                        }
+                    }
+
+                    --outer_ctx->remaining;
+
+                    auto r = pred(*std::move(outer_ctx->elem));
+                    outer_ctx->elem.reset();
+                    if (!r) {
+                        return iteration_result::incomplete;
+                    }
+                }
+            }
+        };
+
+        constexpr auto iterate() const -> inner_context_type
+        {
+            return inner_context_type{.outer_ctx = this->outer_ctx};
+        }
+    };
+
+    constexpr bool read_next()
+    {
+        elem = flux::next_element(base_ctx);
+        return elem.has_value();
+    }
+
+    using element_type = inner_iterable;
+
+    constexpr auto run_while(auto&& outer_pred) -> iteration_result
+    {
+        while (true) {
+            while (remaining-- > 0) {
+                if (!read_next()) {
+                    return iteration_result::complete;
+                }
+            }
+
+            if (!read_next()) {
+                return iteration_result::complete;
+            }
+
+            remaining = chunk_sz;
+
+            if (!outer_pred(inner_iterable{.outer_ctx = this})) {
+                return iteration_result::incomplete;
+            }
+        }
+    }
+};
+
 template <typename Base>
 struct chunk_adaptor : inline_sequence_base<chunk_adaptor<Base>> {
+private:
+    Base base_;
+    int_t chunk_sz_;
+
+public:
+    constexpr chunk_adaptor(decays_to<Base> auto&& base, int_t chunk_sz)
+        : base_(FLUX_FWD(base)),
+          chunk_sz_(chunk_sz)
+    {
+    }
+
+    constexpr auto iterate()
+    {
+        return detail::chunk_iteration_context<iteration_context_t<Base>>{
+            .base_ctx = flux::iterate(base_), .chunk_sz = chunk_sz_};
+    }
+
+    constexpr auto iterate() const
+        requires iterable<Base const>
+    {
+        return detail::chunk_iteration_context<iteration_context_t<Base const>>{
+            .base_ctx = flux::iterate(base_), .chunk_sz = chunk_sz_};
+    }
+
+    constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        auto sz = flux::iterable_size(base_);
+        return sz / chunk_sz_ + (sz % chunk_sz_ == 0 ? 0 : 1);
+    }
+
+    constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        auto sz = flux::iterable_size(base_);
+        return sz / chunk_sz_ + (sz % chunk_sz_ == 0 ? 0 : 1);
+    }
+};
+
+template <sequence Base>
+struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
 private:
     Base base_;
     int_t chunk_sz_;
@@ -295,13 +415,13 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
 };
 
 struct chunk_fn {
-    template <adaptable_sequence Seq>
+    template <adaptable_iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, num::integral auto chunk_sz) const
-        -> sequence auto
+    constexpr auto operator()(It&& it, num::integral auto chunk_sz) const //-> iterable auto
     {
-        FLUX_ASSERT(chunk_sz > 0);
-        return chunk_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), num::checked_cast<int_t>(chunk_sz));
+        int_t chunk_sz_ = num::checked_cast<int_t>(chunk_sz);
+        FLUX_ASSERT(chunk_sz_ > 0);
+        return chunk_adaptor<std::decay_t<It>>(FLUX_FWD(it), chunk_sz_);
     }
 };
 
diff --git a/test/test_chunk.cpp b/test/test_chunk.cpp
index 1c840677..d36f2977 100644
--- a/test/test_chunk.cpp
+++ b/test/test_chunk.cpp
@@ -52,6 +52,50 @@ struct NotBidir : flux::inline_sequence_base<NotBidir<Base>> {
 
 constexpr bool test_chunk_single_pass()
 {
+    // Iterable chunk
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto chunked = flux::chunk(iter, 2);
+
+        using C = decltype(chunked);
+        static_assert(flux::iterable<C>);
+        static_assert(flux::sized_iterable<C>);
+
+        using Inner = flux::iterable_element_t<C>;
+        static_assert(flux::iterable<Inner>);
+
+        STATIC_CHECK(flux::iterable_size(chunked) == 3);
+
+        auto ctx = flux::iterate(chunked);
+        STATIC_CHECK(check_equal(flux::next_element(ctx).value(), {1, 2}));
+        STATIC_CHECK(check_equal(flux::next_element(ctx).value(), {3, 4}));
+        STATIC_CHECK(check_equal(flux::next_element(ctx).value(), {5}));
+        STATIC_CHECK(flux::next_element(ctx).has_value() == false);
+    }
+
+    // Const iterable chunk
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto const chunked = flux::chunk(iter, 2);
+
+        using C = decltype(chunked);
+        static_assert(flux::iterable<C>);
+        static_assert(flux::sized_iterable<C>);
+
+        using Inner = flux::iterable_element_t<C>;
+        static_assert(flux::iterable<Inner>);
+
+        STATIC_CHECK(flux::iterable_size(chunked) == 3);
+
+        auto ctx = flux::iterate(chunked);
+        STATIC_CHECK(check_equal(flux::next_element(ctx).value(), {1, 2}));
+        STATIC_CHECK(check_equal(flux::next_element(ctx).value(), {3, 4}));
+        STATIC_CHECK(check_equal(flux::next_element(ctx).value(), {5}));
+        STATIC_CHECK(flux::next_element(ctx).has_value() == false);
+    }
+
     // Basic single-pass chunk
     {
         std::array arr{1, 2, 3, 4, 5};

From 692018e68345c13f4c669c992670e8191a2fd2b5 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 12:07:18 +0100
Subject: [PATCH 25/66] Disable constexpr chain() test for older libc++

Older libc++ versions don't have constexpr emplace() member for variant, and our usual workaround of using assignment instead (during constant evaluation) doesn't work because iteration contexts are non-movable
---
 test/test_chain.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index d86e6d33..31ade93e 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -11,6 +11,11 @@
 
 #include "test_utils.hpp"
 
+// Older libc++ versions don't support constexpr emplace for variant
+#if defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION < 190000)
+#    define NO_CONSTEXPR_VARIANT_EMPLACE
+#endif
+
 namespace {
 
 constexpr bool test_chain()
@@ -185,8 +190,9 @@ constexpr bool test_chain()
 
     return true;
 }
+#ifndef NO_CONSTEXPR_VARIANT_EMPLACE
 static_assert(test_chain());
-
+#endif
 }
 
 TEST_CASE("chain")

From 284bda327516d9147fd6ba517fcf37df679a7ad3 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 16:26:51 +0100
Subject: [PATCH 26/66] Iterables for scan(), prescan() and scan_first()

These feel slightly messy for such an important adaptor. I wonder if there is a better way of doing this?
---
 include/flux/adaptor/scan.hpp                | 66 +++++++++++++++-----
 include/flux/adaptor/scan_first.hpp          | 58 ++++++++++++++---
 include/flux/core/operation_requirements.hpp | 20 +++---
 test/test_scan.cpp                           | 42 +++++++++++++
 4 files changed, 153 insertions(+), 33 deletions(-)

diff --git a/include/flux/adaptor/scan.hpp b/include/flux/adaptor/scan.hpp
index 9aa32d5f..c021e099 100644
--- a/include/flux/adaptor/scan.hpp
+++ b/include/flux/adaptor/scan.hpp
@@ -35,6 +35,31 @@ struct scan_adaptor : inline_sequence_base<scan_adaptor<Base, Func, R, Mode>> {
     FLUX_NO_UNIQUE_ADDRESS Func func_;
     FLUX_NO_UNIQUE_ADDRESS R accum_;
 
+    struct context_type : immovable {
+        scan_adaptor* parent;
+        iteration_context_t<Base> base_ctx;
+        bool first = true;
+
+        using element_type = R const&;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            if constexpr (Mode == scan_mode::exclusive) {
+                if (first) {
+                    first = false;
+                    if (!pred(std::as_const(parent->accum_))) {
+                        return iteration_result::incomplete;
+                    }
+                }
+            }
+            return base_ctx.run_while([&](auto&& elem) {
+                parent->accum_
+                    = std::invoke(parent->func_, std::move(parent->accum_), FLUX_FWD(elem));
+                return pred(std::as_const(parent->accum_));
+            });
+        }
+    };
+
 public:
     constexpr scan_adaptor(decays_to<Base> auto&& base, Func&& func, auto&& init)
         : base_(FLUX_FWD(base)),
@@ -45,6 +70,21 @@ struct scan_adaptor : inline_sequence_base<scan_adaptor<Base, Func, R, Mode>> {
     scan_adaptor(scan_adaptor&&) = default;
     scan_adaptor& operator=(scan_adaptor&&) = default;
 
+    constexpr auto iterate() -> context_type
+    {
+        return context_type{.parent = this, .base_ctx = flux::iterate(base_)};
+    }
+
+    constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        if constexpr (Mode == scan_mode::exclusive) {
+            return num::add(flux::iterable_size(base_), int_t{1});
+        } else {
+            return flux::iterable_size(base_);
+        }
+    }
+
     struct flux_sequence_traits : default_sequence_traits {
     private:
 
@@ -152,28 +192,26 @@ struct scan_adaptor : inline_sequence_base<scan_adaptor<Base, Func, R, Mode>> {
 };
 
 struct scan_fn {
-    template <adaptable_sequence Seq, typename Func, std::movable Init = value_t<Seq>,
-              typename R = fold_result_t<Seq, Func, Init>>
-        requires foldable<Seq, Func, Init>
+    template <adaptable_iterable It, typename Func, std::movable Init = iterable_value_t<It>,
+              typename R = fold_result_t<It, Func, Init>>
+        requires foldable<It, Func, Init>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Func func, Init init = Init{}) const
-        -> sequence auto
+    constexpr auto operator()(It&& it, Func func, Init init = Init{}) const -> iterable auto
     {
-        return scan_adaptor<std::decay_t<Seq>, Func, R, scan_mode::inclusive>(
-            FLUX_FWD(seq), std::move(func), std::move(init));
+        return scan_adaptor<std::decay_t<It>, Func, R, scan_mode::inclusive>(
+            FLUX_FWD(it), std::move(func), std::move(init));
     }
 };
 
 struct prescan_fn {
-    template <adaptable_sequence Seq, typename Func, std::movable Init,
-              typename R = fold_result_t<Seq, Func, Init>>
-        requires foldable<Seq, Func, Init>
+    template <adaptable_iterable It, typename Func, std::movable Init,
+              typename R = fold_result_t<It, Func, Init>>
+        requires foldable<It, Func, Init>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Func func, Init init) const
-        -> sequence auto
+    constexpr auto operator()(It&& it, Func func, Init init) const -> iterable auto
     {
-        return scan_adaptor<std::decay_t<Seq>, Func, R, scan_mode::exclusive>(
-            FLUX_FWD(seq), std::move(func), std::move(init));
+        return scan_adaptor<std::decay_t<It>, Func, R, scan_mode::exclusive>(
+            FLUX_FWD(it), std::move(func), std::move(init));
     }
 };
 
diff --git a/include/flux/adaptor/scan_first.hpp b/include/flux/adaptor/scan_first.hpp
index 128178b3..fc9ef7a7 100644
--- a/include/flux/adaptor/scan_first.hpp
+++ b/include/flux/adaptor/scan_first.hpp
@@ -22,11 +22,56 @@ struct scan_first_adaptor : inline_sequence_base<scan_first_adaptor<Base, Func,
     FLUX_NO_UNIQUE_ADDRESS Func func_;
     flux::optional<R> accum_;
 
+    struct context_type : immovable {
+        scan_first_adaptor* parent;
+        iteration_context_t<Base> base_ctx;
+
+        using element_type = R const&;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            if (!parent->accum_.has_value()) {
+                base_ctx.run_while([&](auto&& elem) {
+                    parent->accum_.emplace(FLUX_FWD(elem));
+                    return false;
+                });
+                if (!parent->accum_.has_value()) {
+                    return iteration_result::complete;
+                }
+                if (!std::invoke(pred, std::as_const(*parent->accum_))) {
+                    return iteration_result::incomplete;
+                }
+            }
+
+            FLUX_DEBUG_ASSERT(parent->accum_.has_value());
+            return base_ctx.run_while([&](auto&& elem) {
+                parent->accum_.emplace(
+                    std::invoke(parent->func_, *std::move(parent->accum_), FLUX_FWD(elem)));
+                return std::invoke(pred, std::as_const(*parent->accum_));
+            });
+        }
+    };
+
 public:
     constexpr scan_first_adaptor(decays_to<Base> auto&& base, Func&& func)
         : base_(FLUX_FWD(base)),
           func_(std::move(func))
-    {}
+    {
+    }
+
+    scan_first_adaptor(scan_first_adaptor&&) = default;
+    scan_first_adaptor& operator=(scan_first_adaptor&&) = default;
+
+    [[nodiscard]] constexpr auto iterate() -> context_type
+    {
+        return context_type{.parent = this, .base_ctx = flux::iterate(base_)};
+    }
+
+    [[nodiscard]] constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        return flux::iterable_size(base_);
+    }
 
     struct flux_sequence_traits : default_sequence_traits {
     private:
@@ -113,14 +158,13 @@ struct scan_first_adaptor : inline_sequence_base<scan_first_adaptor<Base, Func,
 };
 
 struct scan_first_fn {
-    template <adaptable_sequence Seq, typename Func>
-        requires foldable<Seq, Func, element_t<Seq>>
+    template <adaptable_iterable It, typename Func>
+        requires foldable<It, Func, iterable_element_t<It>>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, Func func) const -> sequence auto
+    constexpr auto operator()(It&& it, Func func) const -> iterable auto
     {
-        using R = fold_result_t<Seq, Func, element_t<Seq>>;
-        return scan_first_adaptor<std::decay_t<Seq>, Func, R>(
-            FLUX_FWD(seq), std::move(func));
+        using R = fold_result_t<It, Func, iterable_element_t<It>>;
+        return scan_first_adaptor<std::decay_t<It>, Func, R>(FLUX_FWD(it), std::move(func));
     }
 };
 
diff --git a/include/flux/core/operation_requirements.hpp b/include/flux/core/operation_requirements.hpp
index 1f3ea92f..b178b4bb 100644
--- a/include/flux/core/operation_requirements.hpp
+++ b/include/flux/core/operation_requirements.hpp
@@ -13,16 +13,14 @@ namespace flux {
 
 FLUX_EXPORT
 template <typename Seq, typename Func, typename Init>
-using fold_result_t = std::decay_t<std::invoke_result_t<Func&, Init, element_t<Seq>>>;
+using fold_result_t = std::decay_t<std::invoke_result_t<Func&, Init, iterable_element_t<Seq>>>;
 
 namespace detail {
 
-template <typename Seq, typename Func, typename Init,
-          typename R = fold_result_t<Seq, Func, Init>>
-concept foldable_ =
-    std::invocable<Func&, R, element_t<Seq>> &&
-    std::convertible_to<Init, R> &&
-    std::assignable_from<R&, std::invoke_result_t<Func&, R, element_t<Seq>>>;
+template <typename Seq, typename Func, typename Init, typename R = fold_result_t<Seq, Func, Init>>
+concept foldable_
+    = std::invocable<Func&, R, iterable_element_t<Seq>> && std::convertible_to<Init, R>
+    && std::assignable_from<R&, std::invoke_result_t<Func&, R, iterable_element_t<Seq>>>;
 
 template <typename Func, typename E, int_t N>
 struct repeated_invocable_helper {
@@ -45,11 +43,9 @@ concept flatten_with_compatible
 } // namespace detail
 
 FLUX_EXPORT
-template <typename Seq, typename Func, typename Init>
-concept foldable =
-    sequence<Seq> &&
-    std::invocable<Func&, Init, element_t<Seq>> &&
-    detail::foldable_<Seq, Func, Init>;
+template <typename It, typename Func, typename Init>
+concept foldable = iterable<It> && std::invocable<Func&, Init, iterable_element_t<It>>
+    && detail::foldable_<It, Func, Init>;
 
 FLUX_EXPORT
 template <typename Fn, typename It1, typename It2 = It1>
diff --git a/test/test_scan.cpp b/test/test_scan.cpp
index 5e5b2892..a2fd3fcc 100644
--- a/test/test_scan.cpp
+++ b/test/test_scan.cpp
@@ -13,6 +13,20 @@ namespace {
 
 constexpr bool test_inclusive_scan()
 {
+    // inclusive scan with iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto scan = flux::scan(iter, std::plus{});
+
+        using S = decltype(scan);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(flux::iterable_size(scan) == 5);
+        STATIC_CHECK(check_equal(scan, {1, 3, 6, 10, 15}));
+    }
+
     // scan returns the same as std::inclusive_scan
     {
         std::array arr{1, 2, 3, 4, 5};
@@ -75,6 +89,20 @@ static_assert(test_inclusive_scan());
 
 constexpr bool test_prescan()
 {
+    // exclusive scan with iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto scan = flux::prescan(iter, std::plus{}, 0);
+
+        using S = decltype(scan);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(flux::iterable_size(scan) == 6);
+        STATIC_CHECK(check_equal(scan, {0, 1, 3, 6, 10, 15}));
+    }
+
     // prescan returns the same as std::exclusive_scan with one extra value
     {
         std::array arr{1, 2, 3, 4, 5};
@@ -145,6 +173,20 @@ static_assert(test_prescan());
 
 constexpr bool test_scan_first()
 {
+    // scan_first with iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto scan = flux::scan_first(iter, std::plus{});
+
+        using S = decltype(scan);
+        static_assert(flux::iterable<S>);
+        static_assert(flux::sized_iterable<S>);
+
+        STATIC_CHECK(flux::iterable_size(scan) == 5);
+        STATIC_CHECK(check_equal(scan, {1, 3, 6, 10, 15}));
+    }
+
     // scan_first returns the same as std::inclusive_scan
     {
         std::array arr{1, 2, 3, 4, 5};

From 8041677e0456d8b56728cfba6032727d7ee7b7b7 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 16:57:17 +0100
Subject: [PATCH 27/66] Make map() reverse_iterable

Why didn't I do this already?
---
 include/flux/adaptor/map.hpp | 19 +++++++++++++++++--
 test/test_map.cpp            | 15 +++++++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/include/flux/adaptor/map.hpp b/include/flux/adaptor/map.hpp
index ecb9cb2c..909fb608 100644
--- a/include/flux/adaptor/map.hpp
+++ b/include/flux/adaptor/map.hpp
@@ -45,13 +45,13 @@ struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>> {
     constexpr auto base() && -> Base&& { return std::move(base_); }
     constexpr auto base() const&& -> Base const&& { return std::move(base_); }
 
-    constexpr auto iterate()
+    [[nodiscard]] constexpr auto iterate()
     {
         return context_type<iteration_context_t<Base>, copy_or_ref_t<Func>>{
             .base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
     }
 
-    constexpr auto iterate() const
+    [[nodiscard]] constexpr auto iterate() const
         requires iterable<Base const>
         && std::regular_invocable<Func&, iterable_element_t<Base const>>
     {
@@ -59,6 +59,21 @@ struct map_adaptor : inline_sequence_base<map_adaptor<Base, Func>> {
             .base_ctx = flux::iterate(base_), .map_fn = copy_or_ref(func_)};
     }
 
+    [[nodiscard]] constexpr auto reverse_iterate()
+        requires reverse_iterable<Base>
+    {
+        return context_type<reverse_iteration_context_t<Base>, copy_or_ref_t<Func>>{
+            .base_ctx = flux::reverse_iterate(base_), .map_fn = copy_or_ref(func_)};
+    }
+
+    [[nodiscard]] constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base const>
+        && std::regular_invocable<Func&, iterable_element_t<Base const>>
+    {
+        return context_type<reverse_iteration_context_t<Base const>, copy_or_ref_t<Func const>>{
+            .base_ctx = flux::reverse_iterate(base_), .map_fn = copy_or_ref(func_)};
+    }
+
     constexpr auto size() -> int_t
         requires sized_iterable<Base>
     {
diff --git a/test/test_map.cpp b/test/test_map.cpp
index 2fe43a6f..98d2c058 100644
--- a/test/test_map.cpp
+++ b/test/test_map.cpp
@@ -47,6 +47,21 @@ constexpr bool test_map()
         STATIC_CHECK(check_equal(mapped, {2, 4, 6, 8, 10}));
     }
 
+    // Reverse iteration works with iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto mapped = flux::map(std::move(iter), [](int i) { return i * 2; });
+
+        using M = decltype(mapped);
+
+        static_assert(flux::reverse_iterable<M>);
+        static_assert(flux::reverse_iterable<M const>);
+
+        STATIC_CHECK(check_equal(flux::reverse(mapped), {10, 8, 6, 4, 2}));
+        STATIC_CHECK(check_equal(flux::reverse(std::as_const(mapped)), {10, 8, 6, 4, 2}));
+    }
+
     {
         int arr[] = {0, 1, 2, 3, 4};
 

From 382755c3c3144728317895e03d0d68d69e32eb4b Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 16:57:38 +0100
Subject: [PATCH 28/66] Make filter_map() and filter_deref() iterable

---
 include/flux/adaptor/filter_map.hpp | 31 +++++++++++++++++------------
 test/test_filter_map.cpp            | 21 ++++++++-----------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/include/flux/adaptor/filter_map.hpp b/include/flux/adaptor/filter_map.hpp
index f5d26e56..c6fc3dda 100644
--- a/include/flux/adaptor/filter_map.hpp
+++ b/include/flux/adaptor/filter_map.hpp
@@ -7,6 +7,7 @@
 #define FLUX_ADAPTOR_FILTER_MAP_HPP_INCLUDED
 
 #include <flux/core.hpp>
+#include <flux/adaptor/filter.hpp>
 #include <flux/adaptor/map.hpp>
 
 namespace flux {
@@ -20,16 +21,20 @@ struct filter_map_fn {
     using strip_rvalue_ref_t = std::conditional_t<
         std::is_rvalue_reference_v<T>, std::remove_reference_t<T>, T>;
 
-    template <adaptable_sequence Seq, typename Func>
-        requires (std::invocable<Func&, element_t<Seq>> &&
-                  optional_like<std::remove_cvref_t<std::invoke_result_t<Func&, element_t<Seq>>>>)
-    constexpr auto operator()(Seq&& seq, Func func) const
+    template <adaptable_iterable It, typename Func>
+        requires(std::invocable<Func&, iterable_element_t<It>>
+                 && optional_like<
+                     std::remove_cvref_t<std::invoke_result_t<Func&, iterable_element_t<It>>>>)
+    constexpr auto operator()(It&& it, Func func) const
     {
-        return flux::map(FLUX_FWD(seq), std::move(func))
-            .filter([](auto&& opt) { return static_cast<bool>(opt); })
-            .map([](auto&& opt) -> strip_rvalue_ref_t<decltype(*FLUX_FWD(opt))> {
-                return *FLUX_FWD(opt);
-            });
+        // FIXME: Change this back to a pipeline later
+        auto mapped = flux::map(FLUX_FWD(it), std::move(func));
+        auto filtered
+            = flux::filter(std::move(mapped), [](auto&& opt) { return static_cast<bool>(opt); });
+        return flux::map(std::move(filtered),
+                         [](auto&& opt) -> strip_rvalue_ref_t<decltype(*FLUX_FWD(opt))> {
+                             return *FLUX_FWD(opt);
+                         });
     }
 };
 
@@ -50,11 +55,11 @@ namespace detail
 {
 
 struct filter_deref_fn {
-    template <adaptable_sequence Seq>
-        requires optional_like<value_t<Seq>>
-    constexpr auto operator()(Seq&& seq) const
+    template <adaptable_iterable It>
+        requires optional_like<iterable_value_t<It>>
+    constexpr auto operator()(It&& it) const
     {
-        return filter_map(FLUX_FWD(seq), [](auto&& opt) -> decltype(auto) { return FLUX_FWD(opt); });
+        return filter_map(FLUX_FWD(it), [](auto&& opt) -> decltype(auto) { return FLUX_FWD(opt); });
     }
 };
 
diff --git a/test/test_filter_map.cpp b/test/test_filter_map.cpp
index fbc57da4..8e65cb6b 100644
--- a/test/test_filter_map.cpp
+++ b/test/test_filter_map.cpp
@@ -37,20 +37,15 @@ constexpr bool test_filter()
 {
     // Basic filtering
     {
-        int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-        auto filtered = flux::filter_map(flux::ref(arr), is_even_opt);
+        std::array arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        auto filtered = flux::filter_map(iterable_only(arr), is_even_opt);
+
         using F = decltype(filtered);
-        static_assert(flux::sequence<F>);
-        static_assert(flux::bidirectional_sequence<F>);
-        static_assert(flux::bounded_sequence<F>);
-        static_assert(not flux::ordered_cursor<F>);
-        static_assert(not flux::sized_sequence<F>);
-
-        static_assert(flux::sequence<F const>);
-        static_assert(flux::bidirectional_sequence<F const>);
-        static_assert(flux::bounded_sequence<F const>);
-        static_assert(not flux::ordered_cursor<F const>);
-        static_assert(not flux::sized_sequence<F const>);
+        static_assert(flux::iterable<F>);
+        static_assert(flux::reverse_iterable<F>);
+
+        static_assert(flux::iterable<F const>);
+        static_assert(flux::reverse_iterable<F const>);
 
         STATIC_CHECK(check_equal(filtered, {0, 2, 4, 6, 8}));
         STATIC_CHECK(check_equal(std::as_const(filtered), {0, 2, 4, 6, 8}));

From 23886aac17f5e3eed020480b3c852cc01a2c42bf Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 17:30:17 +0100
Subject: [PATCH 29/66] Add iterable support to mask()

---
 include/flux/adaptor/mask.hpp | 51 ++++++++++++++++++++++++++++++-----
 test/test_mask.cpp            | 18 +++++++++++++
 2 files changed, 63 insertions(+), 6 deletions(-)

diff --git a/include/flux/adaptor/mask.hpp b/include/flux/adaptor/mask.hpp
index df7ad3b9..407b4fad 100644
--- a/include/flux/adaptor/mask.hpp
+++ b/include/flux/adaptor/mask.hpp
@@ -12,18 +12,57 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base, sequence Mask>
-struct mask_adaptor : inline_sequence_base<mask_adaptor<Base, Mask>>
-{
+template <iterable Base, iterable Mask>
+struct mask_adaptor : inline_sequence_base<mask_adaptor<Base, Mask>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Mask mask_;
 
+    template <typename BaseCtx, typename MaskCtx>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        MaskCtx mask_ctx;
+
+        using element_type = typename BaseCtx::element_type;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            while (true) {
+                auto base_elem = next_element(base_ctx);
+                auto mask_elem = next_element(mask_ctx);
+
+                if (!base_elem || !mask_elem) {
+                    return iteration_result::complete;
+                }
+
+                if (*mask_elem) {
+                    if (!pred(*std::move(base_elem))) {
+                        return iteration_result::incomplete;
+                    }
+                }
+            }
+        }
+    };
+
 public:
     constexpr mask_adaptor(decays_to<Base> auto&& base, decays_to<Mask> auto&& mask)
         : base_(FLUX_FWD(base)),
           mask_(FLUX_FWD(mask))
-    {}
+    {
+    }
+
+    [[nodiscard]] constexpr auto iterate()
+    {
+        return context_type<iteration_context_t<Base>, iteration_context_t<Mask>>{
+            .base_ctx = flux::iterate(base_), .mask_ctx = flux::iterate(mask_)};
+    }
+
+    [[nodiscard]] constexpr auto iterate() const
+        requires iterable<Base const> && iterable<Mask const>
+    {
+        return context_type<iteration_context_t<Base const>, iteration_context_t<Mask const>>{
+            .base_ctx = flux::iterate(base_), .mask_ctx = flux::iterate(mask_)};
+    }
 
     struct flux_sequence_traits : default_sequence_traits {
     private:
@@ -141,8 +180,8 @@ struct mask_adaptor : inline_sequence_base<mask_adaptor<Base, Mask>>
 };
 
 struct mask_fn {
-    template <adaptable_sequence Base, adaptable_sequence Mask>
-        requires boolean_testable<element_t<Mask>>
+    template <adaptable_iterable Base, adaptable_iterable Mask>
+        requires boolean_testable<iterable_element_t<Mask>>
     [[nodiscard]]
     constexpr auto operator()(Base&& base, Mask&& mask) const
     {
diff --git a/test/test_mask.cpp b/test/test_mask.cpp
index 5cabbcac..d4e529c8 100644
--- a/test/test_mask.cpp
+++ b/test/test_mask.cpp
@@ -12,6 +12,24 @@ namespace {
 
 constexpr bool test_mask()
 {
+    // Mask with non-sequence iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+        auto mask = iterable_only(std::array{true, false, true, false, true});
+
+        auto masked = flux::mask(iter, mask);
+
+        using S = decltype(masked);
+        static_assert(flux::iterable<S>);
+        static_assert(std::same_as<flux::iterable_element_t<S>, int&>);
+
+        static_assert(flux::iterable<S const>);
+        static_assert(std::same_as<flux::iterable_element_t<S const>, int const&>);
+
+        STATIC_CHECK(check_equal(masked, {1, 3, 5}));
+        STATIC_CHECK(check_equal(std::as_const(masked), {1, 3, 5}));
+    }
+
     // Basic mask
     {
         std::array values{1, 2, 3, 4, 5};

From e85e0fb6052f3b2aa0d26225a4fee19a06c5ed8d Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 17:37:47 +0100
Subject: [PATCH 30/66] Add missing headers in tests

---
 test/test_map.cpp  | 1 +
 test/test_mask.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/test/test_map.cpp b/test/test_map.cpp
index 98d2c058..3892d03e 100644
--- a/test/test_map.cpp
+++ b/test/test_map.cpp
@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <array>
 #include <ranges>
+#include <utility>
 
 #include "test_utils.hpp"
 
diff --git a/test/test_mask.cpp b/test/test_mask.cpp
index d4e529c8..049f9403 100644
--- a/test/test_mask.cpp
+++ b/test/test_mask.cpp
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <iostream>
+#include <utility>
 
 #include "test_utils.hpp"
 

From 66f32336441053b2239187334470343cba90ff70 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 23 May 2025 17:52:10 +0100
Subject: [PATCH 31/66] Make read_only() iterable

---
 include/flux/adaptor/read_only.hpp      | 19 +++++++++----------
 include/flux/core/iterable_concepts.hpp |  9 +++++++--
 test/test_read_only.cpp                 | 21 +++++++++++++++++++--
 3 files changed, 35 insertions(+), 14 deletions(-)

diff --git a/include/flux/adaptor/read_only.hpp b/include/flux/adaptor/read_only.hpp
index f68758cf..2e38ea1c 100644
--- a/include/flux/adaptor/read_only.hpp
+++ b/include/flux/adaptor/read_only.hpp
@@ -18,15 +18,14 @@ struct cast_to_const {
     constexpr auto operator()(auto&& elem) const -> T { return FLUX_FWD(elem); }
 };
 
-template <sequence Base>
-    requires (not read_only_sequence<Base>)
-struct read_only_adaptor : map_adaptor<Base, cast_to_const<const_element_t<Base>>> {
+template <iterable Base>
+struct read_only_adaptor : map_adaptor<Base, cast_to_const<iterable_const_element_t<Base>>> {
 private:
-    using map = map_adaptor<Base, cast_to_const<const_element_t<Base>>>;
+    using map = map_adaptor<Base, cast_to_const<iterable_const_element_t<Base>>>;
 
 public:
     constexpr explicit read_only_adaptor(decays_to<Base> auto&& base)
-        : map(FLUX_FWD(base), cast_to_const<const_element_t<Base>>{})
+        : map(FLUX_FWD(base), cast_to_const<iterable_const_element_t<Base>>{})
     {}
 
     struct flux_sequence_traits : map::flux_sequence_traits {
@@ -59,14 +58,14 @@ struct read_only_adaptor : map_adaptor<Base, cast_to_const<const_element_t<Base>
 };
 
 struct read_only_fn {
-    template <adaptable_sequence Seq>
+    template <adaptable_iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const -> read_only_sequence auto
+    constexpr auto operator()(It&& it) const -> iterable auto
     {
-        if constexpr (read_only_sequence<Seq>) {
-            return FLUX_FWD(seq);
+        if constexpr (std::same_as<iterable_element_t<It>, iterable_const_element_t<It>>) {
+            return FLUX_FWD(it);
         } else {
-            return read_only_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq));
+            return read_only_adaptor<std::decay_t<It>>(FLUX_FWD(it));
         }
     }
 };
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index ece1ed9e..7eddd180 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -333,8 +333,13 @@ struct iterable_value_type<T> {
 FLUX_EXPORT template <typename I>
 using iterable_value_t = typename detail::iterable_value_type<I>::type;
 
-FLUX_EXPORT template <typename Seq>
-using iterable_common_element_t = std::common_reference_t<element_t<Seq>, value_t<Seq>&>;
+FLUX_EXPORT template <typename It>
+using iterable_common_element_t
+    = std::common_reference_t<iterable_element_t<It>, iterable_value_t<It>&>;
+
+FLUX_EXPORT template <typename It>
+using iterable_const_element_t
+    = std::common_reference_t<iterable_value_t<It> const&&, iterable_element_t<It>>;
 
 FLUX_EXPORT template <typename It>
 concept iterable = requires(It& it) {
diff --git a/test/test_read_only.cpp b/test/test_read_only.cpp
index 9376c336..c79af377 100644
--- a/test/test_read_only.cpp
+++ b/test/test_read_only.cpp
@@ -9,7 +9,24 @@
 
 namespace {
 
-constexpr bool test_read_only() {
+constexpr bool test_read_only()
+{
+    // read_only with iterables
+    {
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
+
+        auto read_only = flux::read_only(iter);
+
+        using R = decltype(read_only);
+
+        static_assert(flux::iterable<R>);
+        static_assert(flux::sized_iterable<R>);
+
+        static_assert(std::same_as<flux::iterable_element_t<R>, int const&>);
+        static_assert(std::same_as<flux::iterable_value_t<R>, int>);
+
+        STATIC_CHECK(check_equal(read_only, {1, 2, 3, 4, 5}));
+    }
 
     // Mutable lvalue ref -> const lvalue ref
     {
@@ -120,7 +137,7 @@ constexpr bool test_read_only() {
         using S = decltype(seq);
 
         static_assert(flux::random_access_sequence<S>);
-        static_assert(flux::read_only_sequence<S>);
+        // static_assert(flux::read_only_sequence<S>);
         // This needs the C++23 tuple/pair converting constructors and
         // basic_common_reference specialisations to work properly
 #ifdef FLUX_HAVE_CPP23_TUPLE_COMMON_REF

From 982e3f8bf0786e897e0cd0cae32a411185775858 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 15:35:05 +0100
Subject: [PATCH 32/66] Make zip() iterable

---
 include/flux/adaptor/zip.hpp            | 74 ++++++++++++++++++++++---
 include/flux/core/iterable_concepts.hpp |  8 ++-
 test/test_zip.cpp                       | 32 +++++++++++
 3 files changed, 105 insertions(+), 9 deletions(-)

diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index b45162b9..751ee051 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -134,7 +134,7 @@ struct zip_traits_base : default_sequence_traits {
 
 namespace detail {
 
-template <sequence... Bases>
+template <iterable... Bases>
 struct zip_adaptor : inline_sequence_base<zip_adaptor<Bases...>> {
 private:
     pair_or_tuple_t<Bases...> bases_;
@@ -142,21 +142,81 @@ struct zip_adaptor : inline_sequence_base<zip_adaptor<Bases...>> {
     friend struct sequence_traits<zip_adaptor>;
     friend struct zip_traits_base<Bases...>;
 
+    template <typename... BaseCtx>
+    struct context_type : immovable {
+        std::tuple<BaseCtx...> base_ctxs;
+
+        using element_type = pair_or_tuple_t<context_element_t<BaseCtx>...>;
+
+        static constexpr auto run_while_impl(auto& pred, auto&... ctxs) -> iteration_result
+        {
+            return [&pred, &ctxs..., ... opts = flux::next_element(ctxs)]() mutable {
+                while (true) {
+                    if (!(opts.has_value() && ...)) {
+                        return iteration_result::complete;
+                    }
+                    if (!pred(element_type(std::move(opts).value_unchecked()...))) {
+                        return iteration_result::incomplete;
+                    }
+                    ((opts = flux::next_element(ctxs)), ...);
+                }
+            }();
+        }
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            return std::apply([&pred](auto&... ctxs) { return run_while_impl(pred, ctxs...); },
+                              base_ctxs);
+        }
+    };
+
 public:
+    using value_type = pair_or_tuple_t<iterable_value_t<Bases>...>;
+
     constexpr explicit zip_adaptor(decays_to<Bases> auto&&... bases)
-        : bases_(FLUX_FWD(bases)...)
-    {}
+        : bases_(FLUX_FWD(bases)...) { }
+
+    constexpr auto iterate() -> context_type<iteration_context_t<Bases>...>
+    {
+        return [&]<std::size_t... I>(std::index_sequence<I...>) {
+            return context_type<iteration_context_t<Bases>...>{
+                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
+        }(std::index_sequence_for<Bases...>{});
+    }
+
+    constexpr auto iterate() const -> context_type<iteration_context_t<Bases const>...>
+        requires(iterable<Bases const> && ...)
+    {
+        return [&]<std::size_t... I>(std::index_sequence<I...>) {
+            return context_type<iteration_context_t<Bases const>...>{
+                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
+        }(std::index_sequence_for<Bases...>{});
+    }
+
+    constexpr auto size() -> int_t
+        requires(sized_iterable<Bases> && ...)
+    {
+        return std::apply([](auto&... bases) { return std::min({flux::iterable_size(bases)...}); },
+                          bases_);
+    }
+
+    constexpr auto size() const -> int_t
+        requires(sized_iterable<Bases const> && ...)
+    {
+        return std::apply([](auto&... bases) { return std::min({flux::iterable_size(bases)...}); },
+                          bases_);
+    }
 };
 
 struct zip_fn {
-    template <adaptable_sequence... Seqs>
+    template <adaptable_iterable... Its>
     [[nodiscard]]
-    constexpr auto operator()(Seqs&&... seqs) const
+    constexpr auto operator()(Its&&... its) const
     {
-        if constexpr (sizeof...(Seqs) == 0) {
+        if constexpr (sizeof...(Its) == 0) {
             return empty<std::tuple<>>;
         } else {
-            return zip_adaptor<std::decay_t<Seqs>...>(FLUX_FWD(seqs)...);
+            return zip_adaptor<std::decay_t<Its>...>(FLUX_FWD(its)...);
         }
     }
 };
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 7eddd180..3706df9e 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -325,7 +325,7 @@ struct iterable_value_type<T> {
 template <typename T>
     requires has_member_value_type<T> && (!has_context_value_type<T> && !has_traits_value_type<T>)
 struct iterable_value_type<T> {
-    using type = std::remove_cvref_t<iterable_element_t<T>>;
+    using type = typename T::value_type;
 };
 
 } // namespace detail
@@ -346,7 +346,11 @@ concept iterable = requires(It& it) {
     { iterate(it) } -> iteration_context;
 } && requires {
     typename iterable_value_t<It>;
-} && std::is_object_v<iterable_value_t<It>> && std::common_reference_with<iterable_element_t<It>&&, iterable_value_t<It>&>;
+} && std::is_object_v<iterable_value_t<It>>
+#ifdef FLUX_HAVE_CPP23_TUPLE_COMMON_REF
+&& std::common_reference_with<iterable_element_t<It>&&, iterable_value_t<It>&>
+#endif
+;
 
 /*
  * MARK: Sized iterable
diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index e36523de..7eae4b75 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -13,6 +13,38 @@ namespace {
 
 constexpr bool test_zip()
 {
+    {
+        auto iter1 = iterable_only(std::array{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+        auto iter2 = iterable_only(std::array{100.0, 200.0, 300.0, 400.0, 500.0});
+
+        auto zipped = flux::zip(iter1, iter2);
+
+        using Z = decltype(zipped);
+        static_assert(flux::iterable<Z>);
+        static_assert(flux::iterable<Z const>);
+
+        static_assert(flux::sized_iterable<Z>);
+        static_assert(flux::sized_iterable<Z const>);
+
+        static_assert(std::same_as<flux::iterable_element_t<Z>, std::pair<int&, double&>>);
+        static_assert(
+            std::same_as<flux::iterable_element_t<Z const>, std::pair<int const&, double const&>>);
+        static_assert(std::same_as<flux::iterable_value_t<Z>, std::pair<int, double>>);
+
+        STATIC_CHECK(flux::iterable_size(zipped) == 5);
+
+        {
+            int n = 1;
+            auto ctx = flux::iterate(zipped);
+            while (auto opt = flux::next_element(ctx)) {
+                auto [i, d] = *opt;
+                STATIC_CHECK(i == n);
+                STATIC_CHECK(d == 100.0 * n);
+                ++n;
+            }
+        }
+    }
+
     {
         int arr1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         double arr2[] = {0, 100, 200, 300, 400};

From 850ba93e5f426ead2199672ee8274292768c564b Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 15:53:17 +0100
Subject: [PATCH 33/66] Make zip_map() iterable

---
 include/flux/adaptor/zip.hpp | 78 +++++++++++++++++++++++++++++++++---
 test/test_zip_map.cpp        | 23 +++++++++++
 2 files changed, 95 insertions(+), 6 deletions(-)

diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index 751ee051..762a2173 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -221,7 +221,7 @@ struct zip_fn {
     }
 };
 
-template <typename Func, sequence... Bases>
+template <typename Func, iterable... Bases>
 struct zip_map_adaptor : inline_sequence_base<zip_map_adaptor<Func, Bases...>> {
 private:
     pair_or_tuple_t<Bases...> bases_;
@@ -230,22 +230,88 @@ struct zip_map_adaptor : inline_sequence_base<zip_map_adaptor<Func, Bases...>> {
     friend struct sequence_traits<zip_map_adaptor>;
     friend struct zip_traits_base<Bases...>;
 
+    template <typename Fn, typename... BaseCtx>
+    struct context_type : immovable {
+        Fn fn;
+        std::tuple<BaseCtx...> base_ctxs;
+
+        using element_type = std::invoke_result_t<Fn&, context_element_t<BaseCtx>...>;
+
+        static constexpr auto run_while_impl(auto& fn, auto& pred, auto&... ctxs)
+            -> iteration_result
+        {
+            return [&fn, &pred, &ctxs..., ... opts = flux::next_element(ctxs)]() mutable {
+                while (true) {
+                    if (!(opts.has_value() && ...)) {
+                        return iteration_result::complete;
+                    }
+                    if (!pred(std::invoke(fn, std::move(opts).value_unchecked()...))) {
+                        return iteration_result::incomplete;
+                    }
+                    ((opts = flux::next_element(ctxs)), ...);
+                }
+            }();
+        }
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            return std::apply(
+                [&fn = fn, &pred](auto&... ctxs) { return run_while_impl(fn, pred, ctxs...); },
+                base_ctxs);
+        }
+    };
+
 public:
     constexpr explicit zip_map_adaptor(Func&& func, decays_to<Bases> auto&&... bases)
         : bases_(FLUX_FWD(bases)...), func_(std::move(func))
     {}
+
+    constexpr auto iterate() -> context_type<copy_or_ref_t<Func>, iteration_context_t<Bases>...>
+    {
+        return [&]<std::size_t... I>(std::index_sequence<I...>) {
+            return context_type<copy_or_ref_t<Func>, iteration_context_t<Bases>...>{
+                .fn = copy_or_ref(func_),
+                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
+        }(std::index_sequence_for<Bases...>{});
+    }
+
+    constexpr auto iterate() const
+        -> context_type<copy_or_ref_t<Func const>, iteration_context_t<Bases const>...>
+        requires(iterable<Bases const> && ...)
+        && std::regular_invocable<Func const&, iterable_element_t<Bases const>...>
+    {
+        return [&]<std::size_t... I>(std::index_sequence<I...>) {
+            return context_type<copy_or_ref_t<Func const>, iteration_context_t<Bases const>...>{
+                .fn = copy_or_ref(func_),
+                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
+        }(std::index_sequence_for<Bases...>{});
+    }
+
+    constexpr auto size() -> int_t
+        requires(sized_iterable<Bases> && ...)
+    {
+        return std::apply([](auto&... bases) { return std::min({flux::iterable_size(bases)...}); },
+                          bases_);
+    }
+
+    constexpr auto size() const -> int_t
+        requires(sized_iterable<Bases const> && ...)
+    {
+        return std::apply([](auto&... bases) { return std::min({flux::iterable_size(bases)...}); },
+                          bases_);
+    }
 };
 
 struct zip_map_fn {
-    template <typename Func, adaptable_sequence... Seqs>
-        requires std::regular_invocable<Func&, element_t<Seqs>...>
+    template <typename Func, adaptable_iterable... Its>
+        requires std::regular_invocable<Func&, iterable_element_t<Its>...>
     [[nodiscard]]
-    constexpr auto operator()(Func func, Seqs&&... seqs) const
+    constexpr auto operator()(Func func, Its&&... its) const
     {
-        if constexpr (sizeof...(Seqs) == 0) {
+        if constexpr (sizeof...(Its) == 0) {
             return empty<std::invoke_result_t<Func>>;
         } else {
-            return zip_map_adaptor<Func, std::decay_t<Seqs>...>(std::move(func), FLUX_FWD(seqs)...);
+            return zip_map_adaptor<Func, std::decay_t<Its>...>(std::move(func), FLUX_FWD(its)...);
         }
     }
 };
diff --git a/test/test_zip_map.cpp b/test/test_zip_map.cpp
index 35dc18dc..cb6861e8 100644
--- a/test/test_zip_map.cpp
+++ b/test/test_zip_map.cpp
@@ -13,6 +13,29 @@ namespace {
 
 constexpr bool test_zip_map()
 {
+    {
+        auto iter1 = iterable_only(std::array{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+        auto iter2 = iterable_only(std::array{100.0, 200.0, 300.0, 400.0, 500.0});
+
+        auto zipped = flux::zip_map(std::plus{}, iter1, iter2);
+
+        using Z = decltype(zipped);
+
+        static_assert(flux::iterable<Z>);
+        static_assert(flux::iterable<Z const>);
+        static_assert(std::same_as<flux::iterable_element_t<Z>, double>);
+
+        {
+            int n = 1;
+            auto ctx = flux::iterate(zipped);
+
+            while (auto opt = flux::next_element(ctx)) {
+                STATIC_CHECK(*opt == n + (100.0 * n));
+                ++n;
+            }
+        }
+    }
+
     {
         int arr1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         double arr2[] = {0, 100, 200, 300, 400};

From 3e828d71cbc6a8e7b1c943080891648d4218494e Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 16:07:19 +0100
Subject: [PATCH 34/66] CMake: disable bogus GCC warning

When using designated initializers, GCC will complain that a base class has a missing initializer -- even though there is no way to actually write it. It seems like this warning is fixed in GCC15, we'll use CMake to quiet it for now for older compilers, but perhaps we should use a pragma instead?
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b3073f86..fc1457ce 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,7 +34,7 @@ target_compile_options(flux-internal INTERFACE
         -ftemplate-backtrace-limit=0
     >
 
-    $<$<CXX_COMPILER_ID:GNU>: -fconcepts-diagnostics-depth=2>
+    $<$<CXX_COMPILER_ID:GNU>: -fconcepts-diagnostics-depth=2 -Wno-missing-field-initializers>
 
     $<$<CXX_COMPILER_ID:Clang,AppleClang>: -fconstexpr-backtrace-limit=0>
 

From 9201a3ef5538262d1b5f3b6d9f3f2d90e8961630 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 16:15:31 +0100
Subject: [PATCH 35/66] Zip: don't use return type which can hard error

something something immediate context
---
 include/flux/adaptor/zip.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index 762a2173..e9b587ac 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -184,7 +184,7 @@ struct zip_adaptor : inline_sequence_base<zip_adaptor<Bases...>> {
         }(std::index_sequence_for<Bases...>{});
     }
 
-    constexpr auto iterate() const -> context_type<iteration_context_t<Bases const>...>
+    constexpr auto iterate() const
         requires(iterable<Bases const> && ...)
     {
         return [&]<std::size_t... I>(std::index_sequence<I...>) {
@@ -276,7 +276,6 @@ struct zip_map_adaptor : inline_sequence_base<zip_map_adaptor<Func, Bases...>> {
     }
 
     constexpr auto iterate() const
-        -> context_type<copy_or_ref_t<Func const>, iteration_context_t<Bases const>...>
         requires(iterable<Bases const> && ...)
         && std::regular_invocable<Func const&, iterable_element_t<Bases const>...>
     {

From 7f188953c913c713b7282cedea8286c8170a1def Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 16:16:28 +0100
Subject: [PATCH 36/66] Reverse: Fix incorrect decltype constraint

This language, man *sigh*
---
 include/flux/adaptor/reverse.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/flux/adaptor/reverse.hpp b/include/flux/adaptor/reverse.hpp
index 996366d8..528db747 100644
--- a/include/flux/adaptor/reverse.hpp
+++ b/include/flux/adaptor/reverse.hpp
@@ -27,19 +27,19 @@ struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>> {
 
     struct flux_iterable_traits {
         static constexpr auto iterate(auto& self)
-            requires reverse_iterable<decltype(self.base_)>
+            requires reverse_iterable<decltype((self.base_))>
         {
             return flux::reverse_iterate(self.base_);
         }
 
         static constexpr auto reverse_iterate(auto& self)
-            requires iterable<decltype(self.base_)>
+            requires iterable<decltype((self.base_))>
         {
             return flux::iterate(self.base_);
         }
 
         static constexpr auto size(auto& self)
-            requires sized_iterable<decltype(self.base_)>
+            requires sized_iterable<decltype((self.base_))>
         {
             return flux::iterable_size(self.base_);
         }

From 6759d20fd6c8638056be36ef98e1e9737aefe67f Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 16:45:28 +0100
Subject: [PATCH 37/66] Use array rather than init_list in top10 examples

For some reason GCC was complaining about a non-constant call in flux::optional<int&>::has_value() inside of zip()... I don't *think* we're doing anything wrong as Clang doesn't complain, and it seems to work if we switch to std::array (which should have the same lifetime as the init list's backing array in these examples).
---
 example/top10/01_trapping_rain_water.cpp | 7 +++----
 example/top10/09_skyline.cpp             | 5 ++---
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/example/top10/01_trapping_rain_water.cpp b/example/top10/01_trapping_rain_water.cpp
index 270a1399..b375b819 100644
--- a/example/top10/01_trapping_rain_water.cpp
+++ b/example/top10/01_trapping_rain_water.cpp
@@ -15,8 +15,7 @@
 
 #include <flux.hpp>
 
-auto const rain_water = [](std::initializer_list<int> heights)
-{
+auto const rain_water = []<std::size_t N>(std::array<int, N> heights) {
     // Find the index of the maximum height
     flux::cursor auto max_idx = flux::find_max(heights);
 
@@ -37,7 +36,7 @@ auto const rain_water = [](std::initializer_list<int> heights)
     return trapped(left) + trapped(flux::reverse(right));
 };
 
-static_assert(rain_water({0,1,0,2,1,0,1,3,2,1,2,1}) == 6);
-static_assert(rain_water({4,2,0,3,2,5}) == 9);
+static_assert(rain_water(std::array{0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1}) == 6);
+static_assert(rain_water(std::array{4, 2, 0, 3, 2, 5}) == 9);
 
 int main() {}
\ No newline at end of file
diff --git a/example/top10/09_skyline.cpp b/example/top10/09_skyline.cpp
index 20a1059f..a32fe881 100644
--- a/example/top10/09_skyline.cpp
+++ b/example/top10/09_skyline.cpp
@@ -14,14 +14,13 @@
 
 #include <flux.hpp>
 
-auto const skyline = [](std::initializer_list<int> heights)
-{
+auto const skyline = [](auto heights) {
     auto h = flux::ref(heights);
 
     return 1 + flux::zip(flux::drop(h, 1), flux::scan(h, flux::cmp::max))
                    .count_if([](auto p) { return p.first > p.second; });
 };
 
-static_assert(skyline({5, 5, 2, 10, 3, 15, 10}) == 3);
+static_assert(skyline(std::array{5, 5, 2, 10, 3, 15, 10}) == 3);
 
 int main() {}
\ No newline at end of file

From 16311ff27ea889a8e751c7bfd78d5de9b5d04d97 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 17:16:02 +0100
Subject: [PATCH 38/66] Zip: try to placate MSVC

It didn't like the nifty way we constructed the contexts, so let's try using std::apply instead. I'm not sure this is 100% right, though...
---
 include/flux/adaptor/zip.hpp | 48 ++++++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 18 deletions(-)

diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index e9b587ac..a1407038 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -178,19 +178,25 @@ struct zip_adaptor : inline_sequence_base<zip_adaptor<Bases...>> {
 
     constexpr auto iterate() -> context_type<iteration_context_t<Bases>...>
     {
-        return [&]<std::size_t... I>(std::index_sequence<I...>) {
-            return context_type<iteration_context_t<Bases>...>{
-                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
-        }(std::index_sequence_for<Bases...>{});
+        return context_type<iteration_context_t<Bases>...>{
+            .base_ctxs = std::apply(
+                [&](auto&... bases) {
+                    return std::tuple<iteration_context_t<Bases>...>(
+                        emplace_from([&] { return flux::iterate(bases); })...);
+                },
+                bases_)};
     }
 
     constexpr auto iterate() const
         requires(iterable<Bases const> && ...)
     {
-        return [&]<std::size_t... I>(std::index_sequence<I...>) {
-            return context_type<iteration_context_t<Bases const>...>{
-                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
-        }(std::index_sequence_for<Bases...>{});
+        return context_type<iteration_context_t<Bases const>...>{
+            .base_ctxs = std::apply(
+                [&](auto&... bases) {
+                    return std::tuple<iteration_context_t<Bases const>...>(
+                        emplace_from([&] { return flux::iterate(bases); })...);
+                },
+                bases_)};
     }
 
     constexpr auto size() -> int_t
@@ -268,22 +274,28 @@ struct zip_map_adaptor : inline_sequence_base<zip_map_adaptor<Func, Bases...>> {
 
     constexpr auto iterate() -> context_type<copy_or_ref_t<Func>, iteration_context_t<Bases>...>
     {
-        return [&]<std::size_t... I>(std::index_sequence<I...>) {
-            return context_type<copy_or_ref_t<Func>, iteration_context_t<Bases>...>{
-                .fn = copy_or_ref(func_),
-                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
-        }(std::index_sequence_for<Bases...>{});
+        return context_type<copy_or_ref_t<Func>, iteration_context_t<Bases>...>{
+            .fn = copy_or_ref(func_),
+            .base_ctxs = std::apply(
+                [&](auto&... bases) {
+                    return std::tuple<iteration_context_t<Bases>...>(
+                        emplace_from([&] { return flux::iterate(bases); })...);
+                },
+                bases_)};
     }
 
     constexpr auto iterate() const
         requires(iterable<Bases const> && ...)
         && std::regular_invocable<Func const&, iterable_element_t<Bases const>...>
     {
-        return [&]<std::size_t... I>(std::index_sequence<I...>) {
-            return context_type<copy_or_ref_t<Func const>, iteration_context_t<Bases const>...>{
-                .fn = copy_or_ref(func_),
-                .base_ctxs{emplace_from([&] { return flux::iterate(std::get<I>(bases_)); })...}};
-        }(std::index_sequence_for<Bases...>{});
+        return context_type<copy_or_ref_t<Func const>, iteration_context_t<Bases const>...>{
+            .fn = copy_or_ref(func_),
+            .base_ctxs = std::apply(
+                [&](auto&... bases) {
+                    return std::tuple<iteration_context_t<Bases const>...>(
+                        emplace_from([&] { return flux::iterate(bases); })...);
+                },
+                bases_)};
     }
 
     constexpr auto size() -> int_t

From 75149b6821e2a214de66874b672405547e825074 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 18:32:01 +0100
Subject: [PATCH 39/66] Try again to make MSVC happy

---
 include/flux/core/iterable_concepts.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 3706df9e..7af6a86a 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -249,11 +249,11 @@ struct sequence_iteration_context<Seq> {
     constexpr auto run_while(auto&& pred) -> iteration_result
     {
         while (!is_last(*ptr_, cur_)) {
-            auto _ = detail::defer_t([&] { inc(*ptr_, cur_); });
-
             if (!pred(read_at_unchecked(*ptr_, cur_))) {
+                inc(*ptr_, cur_);
                 return iteration_result::incomplete;
             }
+            inc(*ptr_, cur_);
         }
 
         return iteration_result::complete;

From cfb925df45aa22e7703ffef395a12957899968d9 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 19:03:26 +0100
Subject: [PATCH 40/66] Rename chunk<single_pass_seq>::value_type

Injected class name causes chaos!

This was a weird on to track down.
---
 include/flux/adaptor/chunk.hpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/include/flux/adaptor/chunk.hpp b/include/flux/adaptor/chunk.hpp
index 0ba848e9..4e135832 100644
--- a/include/flux/adaptor/chunk.hpp
+++ b/include/flux/adaptor/chunk.hpp
@@ -167,18 +167,18 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
         using self_t = chunk_adaptor;
 
     public:
-        struct value_type : inline_sequence_base<value_type> {
+        struct inner_sequence : inline_sequence_base<inner_sequence> {
         private:
             chunk_adaptor* parent_;
-            constexpr explicit value_type(chunk_adaptor& parent)
+            constexpr explicit inner_sequence(chunk_adaptor& parent)
                 : parent_(std::addressof(parent))
             {}
 
             friend struct self_t::flux_sequence_traits;
 
         public:
-            value_type(value_type&&) = default;
-            value_type& operator=(value_type&&) = default;
+            inner_sequence(inner_sequence&&) = default;
+            inner_sequence& operator=(inner_sequence&&) = default;
 
             struct flux_sequence_traits : default_sequence_traits {
             private:
@@ -186,24 +186,24 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
                     inner_cursor(inner_cursor&&) = default;
                     inner_cursor& operator=(inner_cursor&&) = default;
 
-                    friend struct value_type::flux_sequence_traits;
+                    friend struct inner_sequence::flux_sequence_traits;
 
                 private:
                     explicit inner_cursor() = default;
                 };
 
             public:
-                static constexpr auto first(value_type&) -> inner_cursor
+                static constexpr auto first(inner_sequence&) -> inner_cursor
                 {
                     return inner_cursor{};
                 }
 
-                static constexpr auto is_last(value_type& self, inner_cursor const&) -> bool
+                static constexpr auto is_last(inner_sequence& self, inner_cursor const&) -> bool
                 {
                     return self.parent_->rem_ == 0;
                 }
 
-                static constexpr auto inc(value_type& self, inner_cursor&) -> void
+                static constexpr auto inc(inner_sequence& self, inner_cursor&) -> void
                 {
                     flux::inc(self.parent_->base_, *self.parent_->cur_);
                     if (flux::is_last(self.parent_->base_, *self.parent_->cur_)) {
@@ -213,7 +213,7 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
                     }
                 }
 
-                static constexpr auto read_at(value_type& self, inner_cursor const&)
+                static constexpr auto read_at(inner_sequence& self, inner_cursor const&)
                     -> element_t<Base>
                 {
                     return flux::read_at(self.parent_->base_, *self.parent_->cur_);
@@ -239,9 +239,9 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
             self.rem_ = self.chunk_sz_;
         }
 
-        static constexpr auto read_at(self_t& self, outer_cursor const&) -> value_type
+        static constexpr auto read_at(self_t& self, outer_cursor const&) -> inner_sequence
         {
-            return value_type(self);
+            return inner_sequence(self);
         }
 
         static constexpr auto size(self_t& self) -> int_t

From 56bf6ae44f012f90f5a8142018db14d6e14ea91d Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 19:03:45 +0100
Subject: [PATCH 41/66] Add missing #include for std::unreachable

---
 include/flux/core/utils.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index eb66f688..7d1bd5f1 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -10,6 +10,7 @@
 #include <concepts>
 #include <functional>
 #include <type_traits>
+#include <utility>
 
 #include <flux/core/assert.hpp>
 

From f5dc6fee527ae1c67d50e4639f7abd3eee035011 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 19:04:09 +0100
Subject: [PATCH 42/66] Fix clang complaints about make_single_header

---
 tools/make_single_header.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/make_single_header.cpp b/tools/make_single_header.cpp
index 6ebf06f6..b544ae2e 100644
--- a/tools/make_single_header.cpp
+++ b/tools/make_single_header.cpp
@@ -4,6 +4,7 @@
 // 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)
 
+#include <algorithm>
 #include <deque>
 #include <iostream>
 #include <filesystem>
@@ -37,7 +38,7 @@ struct include_processor {
     struct replacement {
         std::ptrdiff_t pos;
         std::ptrdiff_t len;
-        std::string text;
+        std::string text{};
     };
 
     include_processor(fs::path&& start_path)

From 4454e019ff9a7961fffcccd26ec64e75bcce2dda Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 10 Jun 2025 19:28:01 +0100
Subject: [PATCH 43/66] More MSVC whack-a-mole

---
 include/flux/algorithm/zip_algorithms.hpp | 26 +++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/include/flux/algorithm/zip_algorithms.hpp b/include/flux/algorithm/zip_algorithms.hpp
index f1522b4e..c084acbc 100644
--- a/include/flux/algorithm/zip_algorithms.hpp
+++ b/include/flux/algorithm/zip_algorithms.hpp
@@ -23,6 +23,31 @@ struct zip_for_each_while_fn {
         } else if constexpr (sizeof...(Seqs) == 1) {
             return flux::for_each_while(seqs..., std::ref(pred));
         } else {
+#ifdef _MSC_VER
+            // Do things the sad ugly way :(
+            auto ctxs = std::tuple<iteration_context_t<Seqs>...>(
+                emplace_from([&] { return iterate(seqs); })...);
+
+            auto opts
+                = std::apply([](auto&... ctx) { return std::tuple(next_element(ctx)...); }, ctxs);
+
+            while (true) {
+                bool all_have_value
+                    = std::apply([](auto&... opt) { return (opt.has_value() && ...); }, opts);
+                if (!all_have_value) {
+                    return iteration_result::complete;
+                }
+
+                auto res = std::apply([&](auto&... opt) { return pred(opt.value_unchecked()...); },
+                                      opts);
+                if (!res) {
+                    return iteration_result::incomplete;
+                }
+
+                opts = std::apply([&](auto&... ctx) { return std::tuple(next_element(ctx)...); },
+                                  ctxs);
+            }
+#else
             return [&pred, ... ctxs = iterate(seqs)]() mutable {
                 return [&pred, &ctxs..., ... opts = step(ctxs, std::identity {})]() mutable {
                     while (true) {
@@ -36,6 +61,7 @@ struct zip_for_each_while_fn {
                     }
                 }();
             }();
+#endif
         }
     }
 };

From 1fff11af5475273edcc87075b82e656c9584a8b0 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Tue, 17 Jun 2025 17:31:39 +0100
Subject: [PATCH 44/66] Add internal iteration for adjacent_filter

---
 include/flux/adaptor/adjacent_filter.hpp | 46 ++++++++++++++++++++++++
 include/flux/core/ref.hpp                |  7 ++++
 test/test_adjacent_filter.cpp            | 15 ++++++++
 3 files changed, 68 insertions(+)

diff --git a/include/flux/adaptor/adjacent_filter.hpp b/include/flux/adaptor/adjacent_filter.hpp
index bed86d14..9562e55b 100644
--- a/include/flux/adaptor/adjacent_filter.hpp
+++ b/include/flux/adaptor/adjacent_filter.hpp
@@ -19,12 +19,58 @@ struct adjacent_filter_adaptor
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Pred pred_;
 
+    template <typename BaseCtx, typename FilterPred>
+    struct context_type : immovable {
+        BaseCtx base_ctx;
+        FilterPred filter_pred;
+        using opt_t = decltype(next_element(std::declval<BaseCtx&>()));
+        opt_t opt = nullopt;
+
+        using element_type = context_element_t<BaseCtx>;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            if (!opt) {
+                opt = next_element(base_ctx);
+                if (!opt) {
+                    return iteration_result::complete;
+                }
+                if (!pred(opt.value_unchecked())) {
+                    return iteration_result::incomplete;
+                }
+            }
+
+            return base_ctx.run_while([&](auto&& elem) {
+                if (!filter_pred(opt.value_unchecked(), elem)) {
+                    return loop_continue;
+                } else {
+                    opt.emplace(elem);
+                    return pred(elem);
+                }
+            });
+        }
+    };
+
 public:
     constexpr adjacent_filter_adaptor(decays_to<Base> auto&& base, Pred pred)
         : base_(FLUX_FWD(base)),
           pred_(std::move(pred))
     {}
 
+    constexpr auto iterate()
+    {
+        return context_type<iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .base_ctx = flux::iterate(base_), .filter_pred = copy_or_ref(pred_)};
+    }
+
+    constexpr auto iterate() const
+        requires multipass_sequence<Base const>
+        && std::predicate<Pred const&, iterable_element_t<Base const>>
+    {
+        return context_type<iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .base_ctx = flux::iterate(base_), .filter_pred = copy_or_ref(pred_)};
+    }
+
     struct flux_sequence_traits : default_sequence_traits {
     private:
         struct cursor_type {
diff --git a/include/flux/core/ref.hpp b/include/flux/core/ref.hpp
index 74c92b24..2197442c 100644
--- a/include/flux/core/ref.hpp
+++ b/include/flux/core/ref.hpp
@@ -143,6 +143,13 @@ struct ref_adaptor : inline_sequence_base<ref_adaptor<Base>> {
 
     constexpr Base& base() const noexcept { return *base_; }
 
+    constexpr auto iterate() const { return flux::iterate(*base_); }
+    constexpr auto reverse_iterate() const
+        requires reverse_iterable<Base>
+    {
+        return flux::reverse_iterate(*base_);
+    }
+
     struct flux_sequence_traits : passthrough_traits_base {
         using value_type = value_t<Base>;
     };
diff --git a/test/test_adjacent_filter.cpp b/test/test_adjacent_filter.cpp
index a89efbad..a844faf2 100644
--- a/test/test_adjacent_filter.cpp
+++ b/test/test_adjacent_filter.cpp
@@ -11,6 +11,21 @@ namespace {
 
 constexpr bool test_adjacent_filter()
 {
+    {
+        std::array arr{1, 1, 1, 2, 2, 3, 4, 4, 4, 5};
+
+        auto filtered = flux::adjacent_filter(arr, std::not_equal_to{});
+
+        auto ctx = filtered.iterate();
+
+        STATIC_CHECK(flux::next_element(ctx).value() == 1);
+        STATIC_CHECK(flux::next_element(ctx).value() == 2);
+        STATIC_CHECK(flux::next_element(ctx).value() == 3);
+        STATIC_CHECK(flux::next_element(ctx).value() == 4);
+        STATIC_CHECK(flux::next_element(ctx).value() == 5);
+        STATIC_CHECK(not flux::next_element(ctx).has_value());
+    }
+
     // Basic adjacent_filter
     {
         std::array arr{1, 1, 1, 2, 2, 3, 4, 4, 4, 5};

From 87c23f67197ecade677fc3e2233a13023a241a8b Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 14:12:33 +0100
Subject: [PATCH 45/66] Make flux::generator an iterable (only)

This adds `iterable` conformance to `generator` and removes `sequence`
---
 include/flux/core/as_range.hpp      |  2 +-
 include/flux/sequence/generator.hpp | 57 +++++++++++------------------
 test/test_generator.cpp             | 49 ++++++++++++-------------
 3 files changed, 45 insertions(+), 63 deletions(-)

diff --git a/include/flux/core/as_range.hpp b/include/flux/core/as_range.hpp
index 09fadd13..158c1699 100644
--- a/include/flux/core/as_range.hpp
+++ b/include/flux/core/as_range.hpp
@@ -77,7 +77,7 @@ struct as_range_t {
             if constexpr (std::is_lvalue_reference_v<It>) {
                 return detail::iterable_range<std::reference_wrapper<It>>(std::ref(it));
             } else {
-                return detail::iterable_range<It>(it);
+                return detail::iterable_range<It>(FLUX_FWD(it));
             }
         }
     }
diff --git a/include/flux/sequence/generator.hpp b/include/flux/sequence/generator.hpp
index 17dd045b..c5ceac85 100644
--- a/include/flux/sequence/generator.hpp
+++ b/include/flux/sequence/generator.hpp
@@ -48,6 +48,26 @@ struct generator : inline_sequence_base<generator<ElemT>> {
         std::add_pointer_t<yielded_type> ptr_;
     };
 
+    struct iteration_context_type : immovable {
+        handle_type* coro_;
+
+        explicit iteration_context_type(handle_type& coro) : coro_(std::addressof(coro)) { }
+
+        using element_type = yielded_type;
+
+        auto run_while(auto&& pred) -> iteration_result
+        {
+            coro_->resume();
+            while (!coro_->done()) {
+                if (!std::invoke(pred, static_cast<element_type>(*coro_->promise().ptr_))) {
+                    return iteration_result::incomplete;
+                }
+                coro_->resume();
+            }
+            return iteration_result::complete;
+        }
+    };
+
 private:
     handle_type coro_;
 
@@ -70,43 +90,8 @@ struct generator : inline_sequence_base<generator<ElemT>> {
     {
         if (coro_) { coro_.destroy(); }
     }
-};
-
-template <typename T>
-struct sequence_traits<generator<T>> : default_sequence_traits
-{
-private:
-    struct cursor_type {
-        cursor_type(cursor_type&&) = default;
-        cursor_type& operator=(cursor_type&&) = default;
-    private:
-        cursor_type() = default;
-        friend struct sequence_traits;
-    };
-
-    using self_t = generator<T>;
 
-public:
-    static auto first(self_t& self) {
-        self.coro_.resume();
-        return cursor_type{};
-    }
-
-    static auto is_last(self_t& self, cursor_type const&) -> bool
-    {
-        return self.coro_.done();
-    }
-
-    static auto inc(self_t& self, cursor_type& cur) -> cursor_type&
-    {
-        self.coro_.resume();
-        return cur;
-    }
-
-    static auto read_at(self_t& self, cursor_type const&) -> decltype(auto)
-    {
-        return static_cast<typename self_t::yielded_type>(*self.coro_.promise().ptr_);
-    }
+    auto iterate() -> iteration_context_type { return iteration_context_type(coro_); }
 };
 
 } // namespace flux
diff --git a/test/test_generator.cpp b/test/test_generator.cpp
index fcb86136..cdf60da5 100644
--- a/test/test_generator.cpp
+++ b/test/test_generator.cpp
@@ -36,10 +36,12 @@ auto fib(int a, int b) -> generator<int const&>
     }
 }
 
-auto pythagorean_triples() -> generator<std::tuple<int, int, int>> {
-    for (int z : ints(1)) {
-        for (int y : ints(1, z)) {
-            for (int x : ints(1, y)) {
+auto pythagorean_triples() -> generator<std::tuple<int, int, int>>
+{
+    // TODO: Remove as_range from here when iterables can use range-for directly
+    for (int z : flux::as_range(ints(1))) {
+        for (int y : flux::as_range(ints(1, z))) {
+            for (int x : flux::as_range(ints(1, y))) {
                 if (x*x + y*y == z*z) {
                     co_yield {x, y, z};
                 }
@@ -65,14 +67,10 @@ TEST_CASE("generator")
 
         using I = decltype(ints);
 
-        static_assert(flux::sequence<I>);
-        static_assert(not flux::multipass_sequence<I>);
-        static_assert(not flux::sized_sequence<I>);
-        static_assert(not flux::bounded_sequence<I>);
+        static_assert(flux::iterable<I>);
 
-        static_assert(std::same_as<flux::element_t<I>, int const&>);
-        static_assert(std::same_as<flux::value_t<I>, int>);
-        static_assert(std::same_as<flux::rvalue_element_t<I>, int const&&>);
+        static_assert(std::same_as<flux::iterable_element_t<I>, int const&>);
+        static_assert(std::same_as<flux::iterable_value_t<I>, int>);
 
         CHECK(check_equal(std::move(ints).take(5), {0, 1, 2, 3, 4}));
     }
@@ -83,32 +81,30 @@ TEST_CASE("generator")
 
         using G = decltype(gen);
 
-        static_assert(std::same_as<flux::element_t<G>, std::unique_ptr<int>&&>);
-        static_assert(std::same_as<flux::value_t<G>, std::unique_ptr<int>>);
-        static_assert(std::same_as<flux::rvalue_element_t<G>, std::unique_ptr<int>&&>);
+        static_assert(std::same_as<flux::iterable_element_t<G>, std::unique_ptr<int>&&>);
+        static_assert(std::same_as<flux::iterable_value_t<G>, std::unique_ptr<int>>);
 
         int i = 0;
-        for (auto cur = gen.first(); !gen.is_last(cur); gen.inc(cur)) {
-            CHECK(*gen[cur] == i++);
+        auto ctx = gen.iterate();
+        while (auto opt = flux::next_element(ctx)) {
+            CHECK(**opt == i++);
         }
         CHECK(i == 5);
     }
 
     SUBCASE("ranges integration")
     {
-        auto view = ints();
+        auto view = flux::as_range(ints());
 
         using V = decltype(view);
 
         static_assert(std::ranges::input_range<V>);
-        static_assert(std::ranges::view<V>);
         static_assert(not std::ranges::forward_range<V>);
         static_assert(std::same_as<std::ranges::range_reference_t<V>, int const&>);
         static_assert(std::same_as<std::ranges::range_value_t<V>, int>);
         static_assert(std::same_as<std::ranges::range_rvalue_reference_t<V>, int const&&>);
 
-        CHECK(std::ranges::equal(std::views::take(std::move(view), 5),
-                                 std::views::iota(0, 5)));
+        CHECK(std::ranges::equal(std::views::take(view, 5), std::views::iota(0, 5)));
     }
 
     SUBCASE("fibonacci sequence")
@@ -122,12 +118,13 @@ TEST_CASE("generator")
     {
         auto triples = pythagorean_triples().take(5);
 
-        auto cur = triples.first();
+        auto ctx = flux::iterate(triples);
 
-        CHECK((triples[cur] == std::tuple{3, 4, 5}));
-        CHECK((triples[triples.inc(cur)] == std::tuple{6, 8, 10}));
-        CHECK((triples[triples.inc(cur)] == std::tuple{5, 12, 13}));
-        CHECK((triples[triples.inc(cur)] == std::tuple{9, 12, 15}));
-        CHECK((triples[triples.inc(cur)] == std::tuple{8, 15, 17}));
+        CHECK((flux::next_element(ctx).value() == std::tuple{3, 4, 5}));
+        CHECK((flux::next_element(ctx).value() == std::tuple{6, 8, 10}));
+        CHECK((flux::next_element(ctx).value() == std::tuple{5, 12, 13}));
+        CHECK((flux::next_element(ctx).value() == std::tuple{9, 12, 15}));
+        CHECK((flux::next_element(ctx).value() == std::tuple{8, 15, 17}));
+        CHECK(!flux::next_element(ctx).has_value());
     }
 }

From 8ae756d4218c7f02232df19186a5a964f6cfea65 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 14:24:18 +0100
Subject: [PATCH 46/66] element_type for generator<T> is T&&

Previously, if the user specified a non-reference `T` in `generator<T>`, we changed the actual element type to `const T&`, the reason being that it was possible to call `read_at()` multiple times so we couldn't safely yield an rvalue (reference).

Under the new model, we can only read each value once, so it's safe to actually give the user what they ask for -- well, almost. Instead of yielding a prvalue we actually use an xvalue to save a move.
---
 include/flux/sequence/generator.hpp | 4 +---
 test/test_generator.cpp             | 8 ++++----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/include/flux/sequence/generator.hpp b/include/flux/sequence/generator.hpp
index c5ceac85..34f8078f 100644
--- a/include/flux/sequence/generator.hpp
+++ b/include/flux/sequence/generator.hpp
@@ -17,9 +17,7 @@ FLUX_EXPORT
 template <typename ElemT>
 struct generator : inline_sequence_base<generator<ElemT>> {
 
-    using yielded_type = std::conditional_t<std::is_reference_v<ElemT>,
-                                            ElemT,
-                                            ElemT const&>;
+    using yielded_type = ElemT&&;
 
     struct promise_type;
 
diff --git a/test/test_generator.cpp b/test/test_generator.cpp
index cdf60da5..60760d98 100644
--- a/test/test_generator.cpp
+++ b/test/test_generator.cpp
@@ -50,7 +50,7 @@ auto pythagorean_triples() -> generator<std::tuple<int, int, int>>
     }
 }
 
-auto move_only() ->  generator<std::unique_ptr<int>&&>
+auto move_only() -> generator<std::unique_ptr<int>>
 {
     for (int i = 0; i < 5; i++) {
         co_yield std::make_unique<int>(i);
@@ -69,7 +69,7 @@ TEST_CASE("generator")
 
         static_assert(flux::iterable<I>);
 
-        static_assert(std::same_as<flux::iterable_element_t<I>, int const&>);
+        static_assert(std::same_as<flux::iterable_element_t<I>, int&&>);
         static_assert(std::same_as<flux::iterable_value_t<I>, int>);
 
         CHECK(check_equal(std::move(ints).take(5), {0, 1, 2, 3, 4}));
@@ -100,9 +100,9 @@ TEST_CASE("generator")
 
         static_assert(std::ranges::input_range<V>);
         static_assert(not std::ranges::forward_range<V>);
-        static_assert(std::same_as<std::ranges::range_reference_t<V>, int const&>);
+        static_assert(std::same_as<std::ranges::range_reference_t<V>, int&&>);
         static_assert(std::same_as<std::ranges::range_value_t<V>, int>);
-        static_assert(std::same_as<std::ranges::range_rvalue_reference_t<V>, int const&&>);
+        static_assert(std::same_as<std::ranges::range_rvalue_reference_t<V>, int&&>);
 
         CHECK(std::ranges::equal(std::views::take(view, 5), std::views::iota(0, 5)));
     }

From e4d119933bddc30dfd6cb17da86216d04225664b Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 16:43:47 +0100
Subject: [PATCH 47/66] Make ref() and mut_ref() accept iterables

---
 include/flux/core/ref.hpp | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/include/flux/core/ref.hpp b/include/flux/core/ref.hpp
index 2197442c..9bbdd124 100644
--- a/include/flux/core/ref.hpp
+++ b/include/flux/core/ref.hpp
@@ -111,7 +111,7 @@ struct passthrough_traits_base : default_sequence_traits {
     }
 };
 
-template <sequence Base>
+template <iterable Base>
 struct ref_adaptor : inline_sequence_base<ref_adaptor<Base>> {
 private:
     Base* base_;
@@ -144,6 +144,7 @@ struct ref_adaptor : inline_sequence_base<ref_adaptor<Base>> {
     constexpr Base& base() const noexcept { return *base_; }
 
     constexpr auto iterate() const { return flux::iterate(*base_); }
+
     constexpr auto reverse_iterate() const
         requires reverse_iterable<Base>
     {
@@ -162,33 +163,34 @@ template <typename T>
 inline constexpr bool is_ref_adaptor<ref_adaptor<T>> = true;
 
 struct mut_ref_fn {
-    template <sequence Seq>
-        requires (!std::is_const_v<Seq>)
+    template <iterable It>
+        requires(!std::is_const_v<It>)
     [[nodiscard]]
-    constexpr auto operator()(Seq& seq) const
+    constexpr auto operator()(It& it) const
     {
-        if constexpr (is_ref_adaptor<Seq>) {
-            return seq;
+        if constexpr (is_ref_adaptor<It>) {
+            return it;
         } else {
-            return ref_adaptor<Seq>(seq);
+            return ref_adaptor<It>(it);
         }
     }
 };
 
 struct ref_fn {
-    template <const_iterable_sequence Seq>
-        requires (!is_ref_adaptor<Seq>)
+    template <iterable It>
+        requires(iterable<It const> && !is_ref_adaptor<It>)
     [[nodiscard]]
-    constexpr auto operator()(Seq const& seq) const
+    constexpr auto operator()(It const& it) const
     {
-        return ref_adaptor<Seq const>(seq);
+        return ref_adaptor<It const>(it);
     }
 
-    template <const_iterable_sequence Seq>
+    template <iterable It>
+        requires iterable<It const>
     [[nodiscard]]
-    constexpr auto operator()(ref_adaptor<Seq> ref) const
+    constexpr auto operator()(ref_adaptor<It> ref) const
     {
-        return ref_adaptor<Seq const>(ref.base());
+        return ref_adaptor<It const>(ref.base());
     }
 
     template <typename T>

From a0d34df8ee1af2c400f5dc74d52878546e3983af Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 17:05:10 +0100
Subject: [PATCH 48/66] Make std::istreambufs iterable

...but no longer sequences.

Also, remove the `from_istreambuf()` function -- pass an lvalue istreambuf to `iterate()` instead.
---
 include/flux/algorithm/output_to.hpp |  2 +-
 include/flux/sequence/istreambuf.hpp | 78 +++++++++++-----------------
 test/test_istreambuf.cpp             | 46 ++++++++--------
 test/test_output_to.cpp              |  4 +-
 4 files changed, 58 insertions(+), 72 deletions(-)

diff --git a/include/flux/algorithm/output_to.hpp b/include/flux/algorithm/output_to.hpp
index 9bd03586..9b8f2fbd 100644
--- a/include/flux/algorithm/output_to.hpp
+++ b/include/flux/algorithm/output_to.hpp
@@ -30,7 +30,7 @@ struct output_to_t {
     static consteval auto can_memcpy() -> bool
     {
         return contiguous_sequence<Seq> && sized_sequence<Seq> && std::contiguous_iterator<Iter>
-            && std::is_trivially_copyable_v<value_t<Seq>>;
+            && std::is_trivially_copyable_v<iterable_value_t<Seq>>;
     }
 
     template <typename Seq, typename Iter>
diff --git a/include/flux/sequence/istreambuf.hpp b/include/flux/sequence/istreambuf.hpp
index 582dd4e3..b0369385 100644
--- a/include/flux/sequence/istreambuf.hpp
+++ b/include/flux/sequence/istreambuf.hpp
@@ -20,63 +20,47 @@ void derives_from_streambuf_test(std::basic_streambuf<CharT, Traits>&);
 template <typename T>
 concept derives_from_streambuf = requires (T& t) { derives_from_streambuf_test(t); };
 
-struct from_istreambuf_fn {
-    template <typename CharT, typename Traits>
-    [[nodiscard]]
-    auto operator()(std::basic_streambuf<CharT, Traits>* streambuf) const -> sequence auto
-    {
-        FLUX_ASSERT(streambuf != nullptr);
-        return flux::mut_ref(*streambuf);
-    }
-
-    template <typename CharT, typename Traits>
-    [[nodiscard]]
-    auto operator()(std::basic_istream<CharT, Traits>& istream) const -> sequence auto
-    {
-        return flux::mut_ref(*istream.rdbuf());
-    }
-};
-
 } // namespace detail
 
 template <detail::derives_from_streambuf Streambuf>
-struct sequence_traits<Streambuf> : default_sequence_traits
-{
-private:
-    struct cursor_type {
-        cursor_type(cursor_type&&) = default;
-        cursor_type& operator=(cursor_type&&) = default;
+struct iterable_traits<Streambuf> {
+
+    template <typename CharT, typename Traits>
+    struct context_type : immovable {
     private:
-        friend struct sequence_traits;
-        cursor_type() = default;
+        using streambuf_type = std::basic_streambuf<CharT, Traits>;
+        using char_type = CharT;
+        using traits_type = Traits;
+
+        streambuf_type* streambuf_;
+
+    public:
+        using element_type = char_type;
+
+        explicit context_type(streambuf_type& streambuf) : streambuf_(std::addressof(streambuf)) { }
+
+        auto run_while(auto&& pred) -> iteration_result
+        {
+            while (true) {
+                auto c = streambuf_->sbumpc();
+                if (c == traits_type::eof()) {
+                    return iteration_result::complete;
+                }
+                if (!std::invoke(pred, traits_type::to_char_type(c))) {
+                    return iteration_result::incomplete;
+                }
+            }
+        }
     };
 
-    using traits_type = typename Streambuf::traits_type;
-    using char_type = typename Streambuf::char_type;
-
-public:
-    static auto first(Streambuf&) -> cursor_type { return {}; }
-
-    static auto is_last(Streambuf& self, cursor_type const&) -> bool
-    {
-        return self.sgetc() == traits_type::eof();
-    }
-
-    static auto inc(Streambuf& self, cursor_type& cur) -> cursor_type&
-    {
-        self.sbumpc();
-        return cur;
-    }
-
-    static auto read_at(Streambuf& self, cursor_type const&) -> char_type
+    template <typename CharT, typename Traits>
+    static auto iterate(std::basic_streambuf<CharT, Traits>& streambuf)
+        -> context_type<CharT, Traits>
     {
-        return traits_type::to_char_type(self.sgetc());
+        return context_type<CharT, Traits>(streambuf);
     }
 };
 
-FLUX_EXPORT
-inline constexpr auto from_istreambuf = detail::from_istreambuf_fn{};
-
 } // namespace flux
 
 #endif // FLUX_SEQUENCE_ISTREAMBUF_HPP_INCLUDED
diff --git a/test/test_istreambuf.cpp b/test/test_istreambuf.cpp
index 7d82dfd2..2b5915f3 100644
--- a/test/test_istreambuf.cpp
+++ b/test/test_istreambuf.cpp
@@ -17,19 +17,16 @@ TEST_CASE("istreambuf")
 
         using S = decltype(seq);
 
-        static_assert(flux::sequence<S>);
+        static_assert(flux::iterable<S>);
         static_assert(not flux::multipass_sequence<S>);
         static_assert(not flux::sized_sequence<S>);
         static_assert(not flux::bounded_sequence<S>);
 
-        static_assert(std::same_as<flux::element_t<S>, char>);
-        static_assert(std::same_as<flux::rvalue_element_t<S>, char>);
-        static_assert(std::same_as<flux::value_t<S>, char>);
+        static_assert(std::same_as<flux::iterable_element_t<S>, char>);
+        static_assert(std::same_as<flux::iterable_value_t<S>, char>);
 
         std::string str;
-        FLUX_FOR(char c, seq) {
-            str.push_back(c);
-        }
+        flux::for_each(seq, [&](char c) { str.push_back(c); });
 
         REQUIRE(str == "hello world");
     }
@@ -37,15 +34,13 @@ TEST_CASE("istreambuf")
     {
         std::wistringstream iss(L"hello world");
 
-        auto seq = flux::from_istreambuf(iss.rdbuf());
+        auto& seq = *iss.rdbuf();
 
-        static_assert(flux::sequence<decltype(seq)>);
-        static_assert(std::same_as<flux::element_t<decltype(seq)>, wchar_t>);
+        static_assert(flux::iterable<decltype(seq)>);
+        static_assert(std::same_as<flux::iterable_element_t<decltype(seq)>, wchar_t>);
 
         std::wstring str;
-        FLUX_FOR(auto c, seq) {
-            str.push_back(c);
-        }
+        flux::for_each(seq, [&](wchar_t c) { str.push_back(c); });
 
         REQUIRE(str == L"hello world");
     }
@@ -53,22 +48,29 @@ TEST_CASE("istreambuf")
     {
         std::basic_istringstream<char32_t> iss(U"hello world");
 
-        auto seq = flux::from_istreambuf(iss);
+        auto& seq = *iss.rdbuf();
 
-        static_assert(flux::sequence<decltype(seq)>);
-        static_assert(std::same_as<flux::element_t<decltype(seq)>, char32_t>);
+        static_assert(flux::iterable<decltype(seq)>);
+        static_assert(std::same_as<flux::iterable_element_t<decltype(seq)>, char32_t>);
 
         std::u32string str;
-        FLUX_FOR(auto c, seq) {
-            str.push_back(c);
-        }
+        flux::for_each(seq, [&](char32_t c) { str.push_back(c); });
 
         REQUIRE(str == U"hello world");
     }
 
-    // Make sure assertion fires
+    SUBCASE("take(5) with streambuf")
     {
-        std::basic_streambuf<char, std::char_traits<char>>* ptr = nullptr;
-        REQUIRE_THROWS_AS(flux::from_istreambuf(ptr), flux::unrecoverable_error);
+        std::istringstream iss("123456789");
+
+        auto& buf = *iss.rdbuf();
+
+        auto taken = flux::mut_ref(buf).take(5);
+
+        std::string str;
+        flux::for_each(taken, [&](char c) { str.push_back(c); });
+
+        REQUIRE(str == "12345");
+        REQUIRE(buf.sgetc() == '6');
     }
 }
\ No newline at end of file
diff --git a/test/test_output_to.cpp b/test/test_output_to.cpp
index 4820fd6b..a290e642 100644
--- a/test/test_output_to.cpp
+++ b/test/test_output_to.cpp
@@ -73,11 +73,11 @@ TEST_CASE("output to")
         std::istringstream iss(" hello world!! ");
         std::ostringstream oss;
 
-        flux::from_istreambuf(iss).output_to(std::ostreambuf_iterator(oss));
+        flux::output_to(*iss.rdbuf(), std::ostreambuf_iterator(oss));
 
         REQUIRE(oss.str() == " hello world!! ");
     }
-    
+
     SUBCASE("...with empty input sequences")
     {
         std::vector<int> const in;

From 0f46623441e10ace0332163e6115ac0ed72a003a Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 17:30:05 +0100
Subject: [PATCH 49/66] Use iterable_element_t and iterable_value_t...

...rather than plain old `element_t` and `value_t` in inline_sequence_base.

Asking for one of the sequence typedefs with a non-sequence (i.e. just an iterable) can result in hard errors, which is really really annoying.
---
 example/shortest_path.cpp                  |  24 ++---
 include/flux/adaptor/adjacent_filter.hpp   |   7 +-
 include/flux/adaptor/chunk_by.hpp          |   4 +-
 include/flux/adaptor/drop_while.hpp        |   2 +-
 include/flux/adaptor/filter.hpp            |   2 +-
 include/flux/adaptor/filter_map.hpp        |   7 +-
 include/flux/adaptor/flatten.hpp           |   2 +-
 include/flux/adaptor/flatten_with.hpp      |   9 +-
 include/flux/adaptor/map.hpp               |   2 +-
 include/flux/adaptor/mask.hpp              |   2 +-
 include/flux/adaptor/scan_first.hpp        |   2 +-
 include/flux/adaptor/split.hpp             |  12 +--
 include/flux/adaptor/take_while.hpp        |   2 +-
 include/flux/algorithm/all_any_none.hpp    |   6 +-
 include/flux/algorithm/contains.hpp        |   2 +-
 include/flux/algorithm/count.hpp           |   4 +-
 include/flux/algorithm/ends_with.hpp       |   6 +-
 include/flux/algorithm/find.hpp            |   6 +-
 include/flux/algorithm/fold.hpp            |  17 ++--
 include/flux/algorithm/for_each.hpp        |   2 +-
 include/flux/algorithm/output_to.hpp       |   3 +-
 include/flux/algorithm/starts_with.hpp     |   2 +-
 include/flux/core/inline_sequence_base.hpp | 109 +++++++++++----------
 23 files changed, 116 insertions(+), 118 deletions(-)

diff --git a/example/shortest_path.cpp b/example/shortest_path.cpp
index 50e4681f..a612d60d 100644
--- a/example/shortest_path.cpp
+++ b/example/shortest_path.cpp
@@ -20,8 +20,8 @@
 
 using namespace std::string_literals;
 
-auto intersperse = [](flux::sequence auto seq, std::string sep) -> flux::generator<std::string>
-{
+auto intersperse
+    = [](flux::sequence auto seq, std::string sep) -> flux::generator<std::string const&> {
     bool first = true;
     for (auto c: seq) {
         if (first) {
@@ -35,9 +35,7 @@ auto intersperse = [](flux::sequence auto seq, std::string sep) -> flux::generat
 };
 
 namespace color {
-    std::string yellow(const std::string& s) { 
-        return "\u001b[33m"s + s + "\u001b[37m"; 
-    }
+std::string yellow(const std::string& s) { return "\u001b[33m"s + s + "\u001b[37m"; }
 }
 
 class maze {
@@ -66,7 +64,7 @@ class maze {
         width_(width),
         height_(height),
         fields_(width * height, 0)
-    { 
+    {
         assert(width > 1 && height > 1);
     }
 
@@ -75,7 +73,7 @@ class maze {
         std::mt19937 rng(seed);
         std::uniform_int_distribution dist(1, 9);
         maze m(width, height);
-        
+
         for (auto i: flux::ints(1, flux::size(m.fields_) - 1)) {
              m.fields_[size_t(i)] = (rng() % 4) == 0 ? wall : dist(rng);
         }
@@ -87,13 +85,13 @@ class maze {
         auto to_char = [print_costs] (int num) {
             if (num == wall) { return "#"s; }
             if (num == path) { return color::yellow("*"); }
-            return print_costs ? std::to_string(num) : " "s; 
+            return print_costs ? std::to_string(num) : " "s;
         };
         auto width = width_ * 2 + 3;
         auto edge = flux::single("|"s);
         auto h_edge = "+"s + std::string(width - 2, '-') + "+\n"s;
         auto out = std::ostream_iterator<std::string>(s);
-        
+
         s << h_edge;
         for (auto&& row: flux::ref(fields_).map(to_char).chunk(width_)) {
             intersperse(flux::chain(flux::ref(edge), FLUX_FWD(row), flux::ref(edge)), " "s).output_to(out);
@@ -108,15 +106,13 @@ class maze {
         std::vector<flux::optional<int>> costs(fields_.size());
         std::vector<flux::optional<size_t>> prevs(fields_.size());
 
-        auto valid = [this](std::size_t u) { 
-            return fields_[u] != wall; 
-        };
+        auto valid = [this](std::size_t u) { return fields_[u] != wall; };
 
         auto to_adjacent_edges = [this](std::size_t u) {
             auto to_edge = [](auto e) { return edge_t{std::get<0>(e), std::get<1>(e)}; };
             return flux::cartesian_product(flux::single(u), adjacent(u)).map(to_edge) ;
         };
-        
+
         bool updated = false;
         auto update_costs_and_prevs = [this, &costs, &prevs, &updated](edge_t e) {
             constexpr auto max = std::numeric_limits<int>::max();
@@ -131,7 +127,7 @@ class maze {
         do {
             updated = false;
             flux::iota(size_t{0}, fields_.size())
-                .filter(valid) 
+                .filter(valid)
                 .map(to_adjacent_edges)
                 .flatten()
                 .for_each(update_costs_and_prevs);
diff --git a/include/flux/adaptor/adjacent_filter.hpp b/include/flux/adaptor/adjacent_filter.hpp
index 9562e55b..fe8f7813 100644
--- a/include/flux/adaptor/adjacent_filter.hpp
+++ b/include/flux/adaptor/adjacent_filter.hpp
@@ -189,8 +189,8 @@ FLUX_EXPORT inline constexpr auto dedup = detail::dedup_fn{};
 
 template <typename D>
 template <typename Pred>
-    requires multipass_sequence<D> &&
-             std::predicate<Pred&, element_t<D>, element_t<D>>
+    requires multipass_sequence<D>
+    && std::predicate<Pred&, iterable_element_t<D>, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::adjacent_filter(Pred pred) &&
 {
     return flux::adjacent_filter(std::move(derived()), std::move(pred));
@@ -198,8 +198,7 @@ constexpr auto inline_sequence_base<D>::adjacent_filter(Pred pred) &&
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::dedup() &&
-    requires multipass_sequence<D> &&
-             std::equality_comparable<element_t<D>>
+    requires multipass_sequence<D> && std::equality_comparable<iterable_element_t<D>>
 {
     return flux::dedup(std::move(derived()));
 }
diff --git a/include/flux/adaptor/chunk_by.hpp b/include/flux/adaptor/chunk_by.hpp
index c3e5e31d..73e62932 100644
--- a/include/flux/adaptor/chunk_by.hpp
+++ b/include/flux/adaptor/chunk_by.hpp
@@ -136,8 +136,8 @@ FLUX_EXPORT inline constexpr auto chunk_by = detail::chunk_by_fn{};
 
 template <typename Derived>
 template <typename Pred>
-    requires multipass_sequence<Derived> &&
-             std::predicate<Pred&, element_t<Derived>, element_t<Derived>>
+    requires multipass_sequence<Derived>
+    && std::predicate<Pred&, iterable_element_t<Derived>, iterable_element_t<Derived>>
 constexpr auto inline_sequence_base<Derived>::chunk_by(Pred pred) &&
 {
     return flux::chunk_by(std::move(derived()), std::move(pred));
diff --git a/include/flux/adaptor/drop_while.hpp b/include/flux/adaptor/drop_while.hpp
index 752af436..12038d8f 100644
--- a/include/flux/adaptor/drop_while.hpp
+++ b/include/flux/adaptor/drop_while.hpp
@@ -106,7 +106,7 @@ FLUX_EXPORT inline constexpr auto drop_while = detail::drop_while_fn{};
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::drop_while(Pred pred) &&
 {
     return flux::drop_while(std::move(derived()), std::move(pred));
diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index 83befc31..01f054a0 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -176,7 +176,7 @@ FLUX_EXPORT inline constexpr auto filter = detail::filter_fn{};
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::filter(Pred pred) &&
 {
     return detail::filter_adaptor<D, Pred>(std::move(derived()), std::move(pred));
diff --git a/include/flux/adaptor/filter_map.hpp b/include/flux/adaptor/filter_map.hpp
index c6fc3dda..4602b7e3 100644
--- a/include/flux/adaptor/filter_map.hpp
+++ b/include/flux/adaptor/filter_map.hpp
@@ -44,8 +44,8 @@ FLUX_EXPORT inline constexpr auto filter_map = detail::filter_map_fn{};
 
 template <typename D>
 template <typename Func>
-requires std::invocable<Func&, element_t<D>> &&
-         detail::optional_like<std::invoke_result_t<Func&, element_t<D>>>
+    requires std::invocable<Func&, iterable_element_t<D>>
+    && detail::optional_like<std::invoke_result_t<Func&, iterable_element_t<D>>>
 constexpr auto inline_sequence_base<D>::filter_map(Func func) &&
 {
     return flux::filter_map(derived(), std::move(func));
@@ -68,7 +68,8 @@ struct filter_deref_fn {
 FLUX_EXPORT inline constexpr auto filter_deref = detail::filter_deref_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::filter_deref() && requires detail::optional_like<value_t<D>>
+constexpr auto inline_sequence_base<D>::filter_deref() &&
+    requires detail::optional_like<iterable_value_t<D>>
 {
     return flux::filter_deref(derived());
 }
diff --git a/include/flux/adaptor/flatten.hpp b/include/flux/adaptor/flatten.hpp
index 577a227c..91abbd19 100644
--- a/include/flux/adaptor/flatten.hpp
+++ b/include/flux/adaptor/flatten.hpp
@@ -366,7 +366,7 @@ FLUX_EXPORT inline constexpr auto flatten = detail::flatten_fn{};
 
 template <typename Derived>
 constexpr auto inline_sequence_base<Derived>::flatten() &&
-        requires sequence<element_t<Derived>>
+    requires sequence<iterable_element_t<Derived>>
 {
     return flux::flatten(std::move(derived()));
 }
diff --git a/include/flux/adaptor/flatten_with.hpp b/include/flux/adaptor/flatten_with.hpp
index a66bcfca..c1d3e47c 100644
--- a/include/flux/adaptor/flatten_with.hpp
+++ b/include/flux/adaptor/flatten_with.hpp
@@ -499,9 +499,8 @@ FLUX_EXPORT inline constexpr auto flatten_with = detail::flatten_with_fn{};
 
 template <typename Derived>
 template <adaptable_sequence Pattern>
-    requires sequence<element_t<Derived>> &&
-             multipass_sequence<Pattern> &&
-             detail::flatten_with_compatible<element_t<Derived>, Pattern>
+    requires sequence<iterable_element_t<Derived>> && multipass_sequence<Pattern>
+    && detail::flatten_with_compatible<iterable_element_t<Derived>, Pattern>
 constexpr auto inline_sequence_base<Derived>::flatten_with(Pattern&& pattern) &&
 {
     return flux::flatten_with(std::move(derived()), FLUX_FWD(pattern));
@@ -509,8 +508,8 @@ constexpr auto inline_sequence_base<Derived>::flatten_with(Pattern&& pattern) &&
 
 template <typename Derived>
 template <typename Value>
-    requires sequence<element_t<Derived>> &&
-             std::constructible_from<value_t<element_t<Derived>>, Value&&>
+    requires sequence<iterable_element_t<Derived>>
+    && std::constructible_from<iterable_value_t<iterable_element_t<Derived>>, Value&&>
 constexpr auto inline_sequence_base<Derived>::flatten_with(Value value) &&
 {
     return flux::flatten_with(std::move(derived()), std::move(value));
diff --git a/include/flux/adaptor/map.hpp b/include/flux/adaptor/map.hpp
index 909fb608..c3d38139 100644
--- a/include/flux/adaptor/map.hpp
+++ b/include/flux/adaptor/map.hpp
@@ -134,7 +134,7 @@ FLUX_EXPORT inline constexpr auto map = detail::map_fn{};
 
 template <typename Derived>
 template <typename Func>
-    requires std::invocable<Func&, element_t<Derived>>
+    requires std::invocable<Func&, iterable_element_t<Derived>>
 constexpr auto inline_sequence_base<Derived>::map(Func func) &&
 {
     return detail::map_adaptor<Derived, Func>(std::move(derived()), std::move(func));
diff --git a/include/flux/adaptor/mask.hpp b/include/flux/adaptor/mask.hpp
index 407b4fad..f661a2be 100644
--- a/include/flux/adaptor/mask.hpp
+++ b/include/flux/adaptor/mask.hpp
@@ -196,7 +196,7 @@ FLUX_EXPORT inline constexpr auto mask = detail::mask_fn{};
 
 template <typename D>
 template <adaptable_sequence Mask>
-    requires detail::boolean_testable<element_t<Mask>>
+    requires detail::boolean_testable<iterable_element_t<Mask>>
 constexpr auto inline_sequence_base<D>::mask(Mask&& mask_) &&
 {
     return flux::mask(std::move(derived()), FLUX_FWD(mask_));
diff --git a/include/flux/adaptor/scan_first.hpp b/include/flux/adaptor/scan_first.hpp
index fc9ef7a7..86496d14 100644
--- a/include/flux/adaptor/scan_first.hpp
+++ b/include/flux/adaptor/scan_first.hpp
@@ -174,7 +174,7 @@ FLUX_EXPORT inline constexpr auto scan_first = detail::scan_first_fn{};
 
 template <typename Derived>
 template <typename Func>
-    requires foldable<Derived, Func, element_t<Derived>>
+    requires foldable<Derived, Func, iterable_element_t<Derived>>
 constexpr auto inline_sequence_base<Derived>::scan_first(Func func) &&
 {
     return flux::scan_first(std::move(derived()), std::move(func));
diff --git a/include/flux/adaptor/split.hpp b/include/flux/adaptor/split.hpp
index 56e132d0..65d02078 100644
--- a/include/flux/adaptor/split.hpp
+++ b/include/flux/adaptor/split.hpp
@@ -207,9 +207,8 @@ FLUX_EXPORT inline constexpr auto split = detail::split_fn{};
 
 template <typename Derived>
 template <typename Pattern>
-    requires multipass_sequence<Derived> &&
-             multipass_sequence<Pattern> &&
-             std::equality_comparable_with<element_t<Derived>, element_t<Pattern>>
+    requires multipass_sequence<Derived> && multipass_sequence<Pattern>
+    && std::equality_comparable_with<iterable_element_t<Derived>, iterable_element_t<Pattern>>
 constexpr auto inline_sequence_base<Derived>::split(Pattern&& pattern) &&
 {
     return flux::split(std::move(derived()), FLUX_FWD(pattern));
@@ -217,8 +216,8 @@ constexpr auto inline_sequence_base<Derived>::split(Pattern&& pattern) &&
 
 template <typename Derived>
 template <typename Delim>
-    requires multipass_sequence<Derived> &&
-             std::equality_comparable_with<element_t<Derived>, Delim const&>
+    requires multipass_sequence<Derived>
+    && std::equality_comparable_with<iterable_element_t<Derived>, Delim const&>
 constexpr auto inline_sequence_base<Derived>::split(Delim&& delim) &&
 {
     return flux::split(std::move(derived()), FLUX_FWD(delim));
@@ -226,8 +225,7 @@ constexpr auto inline_sequence_base<Derived>::split(Delim&& delim) &&
 
 template <typename Derived>
 template <typename Pred>
-    requires multipass_sequence<Derived> &&
-             std::predicate<Pred const&, element_t<Derived>>
+    requires multipass_sequence<Derived> && std::predicate<Pred const&, iterable_element_t<Derived>>
 constexpr auto inline_sequence_base<Derived>::split(Pred pred) &&
 {
     return flux::split(std::move(derived()), std::move(pred));
diff --git a/include/flux/adaptor/take_while.hpp b/include/flux/adaptor/take_while.hpp
index 83218630..1dbfa73b 100644
--- a/include/flux/adaptor/take_while.hpp
+++ b/include/flux/adaptor/take_while.hpp
@@ -127,7 +127,7 @@ FLUX_EXPORT inline constexpr auto take_while = detail::take_while_fn{};
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::take_while(Pred pred) &&
 {
     return flux::take_while(std::move(derived()), std::move(pred));
diff --git a/include/flux/algorithm/all_any_none.hpp b/include/flux/algorithm/all_any_none.hpp
index edb17574..6b18c3b6 100644
--- a/include/flux/algorithm/all_any_none.hpp
+++ b/include/flux/algorithm/all_any_none.hpp
@@ -54,7 +54,7 @@ FLUX_EXPORT inline constexpr any_t any {};
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::all(Pred pred)
 {
     return flux::all(derived(), std::move(pred));
@@ -62,7 +62,7 @@ constexpr auto inline_sequence_base<D>::all(Pred pred)
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::any(Pred pred)
 {
     return flux::any(derived(), std::move(pred));
@@ -70,7 +70,7 @@ constexpr auto inline_sequence_base<D>::any(Pred pred)
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::none(Pred pred)
 {
     return flux::none(derived(), std::move(pred));
diff --git a/include/flux/algorithm/contains.hpp b/include/flux/algorithm/contains.hpp
index 5096a3f5..52eb6e21 100644
--- a/include/flux/algorithm/contains.hpp
+++ b/include/flux/algorithm/contains.hpp
@@ -25,7 +25,7 @@ FLUX_EXPORT inline constexpr contains_t contains {};
 
 template <typename D>
 template <typename Value>
-    requires std::equality_comparable_with<element_t<D>, Value const&>
+    requires std::equality_comparable_with<iterable_element_t<D>, Value const&>
 constexpr auto inline_sequence_base<D>::contains(Value const& value) -> bool
 {
     return flux::contains(derived(), value);
diff --git a/include/flux/algorithm/count.hpp b/include/flux/algorithm/count.hpp
index e4831028..8b7fe1ba 100644
--- a/include/flux/algorithm/count.hpp
+++ b/include/flux/algorithm/count.hpp
@@ -68,7 +68,7 @@ constexpr auto inline_sequence_base<D>::count()
 
 template <typename D>
 template <typename Value>
-    requires std::equality_comparable_with<element_t<D>, Value const&>
+    requires std::equality_comparable_with<iterable_element_t<D>, Value const&>
 constexpr auto inline_sequence_base<D>::count_eq(Value const& value)
 {
     return flux::count_eq(derived(), value);
@@ -76,7 +76,7 @@ constexpr auto inline_sequence_base<D>::count_eq(Value const& value)
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::count_if(Pred pred)
 {
     return flux::count_if(derived(), std::move(pred));
diff --git a/include/flux/algorithm/ends_with.hpp b/include/flux/algorithm/ends_with.hpp
index 12c6d853..820279a2 100644
--- a/include/flux/algorithm/ends_with.hpp
+++ b/include/flux/algorithm/ends_with.hpp
@@ -44,9 +44,9 @@ FLUX_EXPORT inline constexpr auto ends_with = ends_with_t{};
 
 template <typename Derived>
 template <sequence Needle, typename Cmp>
-    requires std::predicate<Cmp&, element_t<Derived>, element_t<Needle>> &&
-             (multipass_sequence<Derived> || sized_sequence<Derived>) &&
-             (multipass_sequence<Needle> || sized_sequence<Needle>)
+    requires std::predicate<Cmp&, iterable_element_t<Derived>, iterable_element_t<Needle>>
+    && (multipass_sequence<Derived> || sized_sequence<Derived>)
+    && (multipass_sequence<Needle> || sized_sequence<Needle>)
 constexpr auto inline_sequence_base<Derived>::ends_with(Needle&& needle, Cmp cmp) -> bool
 {
     return flux::ends_with(derived(), FLUX_FWD(needle), std::move(cmp));
diff --git a/include/flux/algorithm/find.hpp b/include/flux/algorithm/find.hpp
index 6bf3f093..d1795cea 100644
--- a/include/flux/algorithm/find.hpp
+++ b/include/flux/algorithm/find.hpp
@@ -87,7 +87,7 @@ FLUX_EXPORT inline constexpr auto find_if_not = detail::find_if_not_fn{};
 
 template <typename D>
 template <typename Value>
-    requires std::equality_comparable_with<element_t<D>, Value const&>
+    requires std::equality_comparable_with<iterable_element_t<D>, Value const&>
 constexpr auto inline_sequence_base<D>::find(Value const& val)
 {
     return flux::find(derived(), val);
@@ -95,7 +95,7 @@ constexpr auto inline_sequence_base<D>::find(Value const& val)
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::find_if(Pred pred)
 {
     return flux::find_if(derived(), std::ref(pred));
@@ -103,7 +103,7 @@ constexpr auto inline_sequence_base<D>::find_if(Pred pred)
 
 template <typename D>
 template <typename Pred>
-    requires std::predicate<Pred&, element_t<D>>
+    requires std::predicate<Pred&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::find_if_not(Pred pred)
 {
     return flux::find_if_not(derived(), std::ref(pred));
diff --git a/include/flux/algorithm/fold.hpp b/include/flux/algorithm/fold.hpp
index 88f9fb8b..c237a63b 100644
--- a/include/flux/algorithm/fold.hpp
+++ b/include/flux/algorithm/fold.hpp
@@ -14,9 +14,9 @@ FLUX_EXPORT
 struct fold_t {
     template <iterable It, typename Func, std::movable Init = iterable_value_t<It>,
               typename R = fold_result_t<It, Func, Init>>
-        requires std::invocable<Func&, Init, element_t<It>>
-        && std::invocable<Func&, R, element_t<It>> && std::convertible_to<Init, R>
-        && std::assignable_from<Init&, std::invoke_result_t<Func&, R, element_t<It>>>
+        requires std::invocable<Func&, Init, iterable_element_t<It>>
+        && std::invocable<Func&, R, iterable_element_t<It>> && std::convertible_to<Init, R>
+        && std::assignable_from<Init&, std::invoke_result_t<Func&, R, iterable_element_t<It>>>
     [[nodiscard]]
     constexpr auto operator()(It&& it, Func func, Init init = Init{}) const -> R
     {
@@ -131,8 +131,9 @@ constexpr auto inline_sequence_base<Derived>::fold(Func func, Init init)
 
 template <typename Derived>
 template <typename D, typename Func>
-    requires std::invocable<Func&, value_t<D>, element_t<D>>
-    && std::assignable_from<value_t<D>&, std::invoke_result_t<Func&, value_t<D>, element_t<D>>>
+    requires std::invocable<Func&, iterable_value_t<D>, iterable_element_t<D>>
+    && std::assignable_from<iterable_value_t<D>&,
+                            std::invoke_result_t<Func&, iterable_value_t<D>, iterable_element_t<D>>>
 constexpr auto inline_sequence_base<Derived>::fold_first(Func func)
 {
     return flux::fold_first(derived(), std::move(func));
@@ -140,14 +141,16 @@ constexpr auto inline_sequence_base<Derived>::fold_first(Func func)
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::sum()
-    requires foldable<D, std::plus<>, value_t<D>> && std::default_initializable<value_t<D>>
+    requires foldable<D, std::plus<>, iterable_value_t<D>>
+    && std::default_initializable<iterable_value_t<D>>
 {
     return flux::sum(derived());
 }
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::product()
-    requires foldable<D, std::multiplies<>, value_t<D>> && requires { value_t<D>(1); }
+    requires foldable<D, std::multiplies<>, iterable_value_t<D>>
+    && requires { iterable_value_t<D>(1); }
 {
     return flux::product(derived());
 }
diff --git a/include/flux/algorithm/for_each.hpp b/include/flux/algorithm/for_each.hpp
index 5b3292d8..a1dc7675 100644
--- a/include/flux/algorithm/for_each.hpp
+++ b/include/flux/algorithm/for_each.hpp
@@ -28,7 +28,7 @@ FLUX_EXPORT inline constexpr for_each_t for_each {};
 
 template <typename D>
 template <typename Func>
-    requires std::invocable<Func&, element_t<D>>
+    requires std::invocable<Func&, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::for_each(Func func) -> Func
 {
     return flux::for_each(derived(), std::move(func));
diff --git a/include/flux/algorithm/output_to.hpp b/include/flux/algorithm/output_to.hpp
index 9b8f2fbd..ea439c42 100644
--- a/include/flux/algorithm/output_to.hpp
+++ b/include/flux/algorithm/output_to.hpp
@@ -67,7 +67,8 @@ FLUX_EXPORT inline constexpr output_to_t output_to{};
 
 template <typename D>
 template <typename Iter>
-    requires std::weakly_incrementable<Iter> && std::indirectly_writable<Iter, element_t<D>>
+    requires std::weakly_incrementable<Iter>
+    && std::indirectly_writable<Iter, iterable_element_t<D>>
 constexpr auto inline_sequence_base<D>::output_to(Iter iter) -> Iter
 {
     return flux::output_to(derived(), std::move(iter));
diff --git a/include/flux/algorithm/starts_with.hpp b/include/flux/algorithm/starts_with.hpp
index 36f44b14..1ab01fc1 100644
--- a/include/flux/algorithm/starts_with.hpp
+++ b/include/flux/algorithm/starts_with.hpp
@@ -47,7 +47,7 @@ FLUX_EXPORT inline constexpr starts_with_t starts_with{};
 
 template <typename Derived>
 template <sequence Needle, typename Cmp>
-    requires std::predicate<Cmp&, element_t<Derived>, element_t<Needle>>
+    requires std::predicate<Cmp&, iterable_element_t<Derived>, iterable_element_t<Needle>>
 constexpr auto inline_sequence_base<Derived>::starts_with(Needle&& needle, Cmp cmp) -> bool
 {
     return flux::starts_with(derived(), FLUX_FWD(needle), std::move(cmp));
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index c920603d..b58739b7 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -125,8 +125,8 @@ struct inline_sequence_base {
     constexpr auto usize() const requires sized_sequence<Derived const> { return flux::usize(derived()); }
 
     template <typename Pred>
-        requires std::invocable<Pred&, element_t<Derived>> &&
-        detail::boolean_testable<std::invoke_result_t<Pred&, element_t<Derived>>>
+        requires std::invocable<Pred&, iterable_element_t<Derived>>
+        && detail::boolean_testable<std::invoke_result_t<Pred&, iterable_element_t<Derived>>>
     constexpr auto for_each_while(Pred pred)
     {
         return flux::seq_for_each_while(derived(), std::ref(pred));
@@ -232,8 +232,8 @@ struct inline_sequence_base {
         requires multipass_sequence<Derived>;
 
     template <typename Pred>
-        requires multipass_sequence<Derived> &&
-                 std::predicate<Pred&, element_t<Derived>, element_t<Derived>>
+        requires multipass_sequence<Derived>
+        && std::predicate<Pred&, iterable_element_t<Derived>, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto adjacent_filter(Pred pred) &&;
 
@@ -251,8 +251,8 @@ struct inline_sequence_base {
     constexpr auto chunk(num::integral auto chunk_sz) &&;
 
     template <typename Pred>
-        requires multipass_sequence<Derived> &&
-                 std::predicate<Pred&, element_t<Derived>, element_t<Derived>>
+        requires multipass_sequence<Derived>
+        && std::predicate<Pred&, iterable_element_t<Derived>, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto chunk_by(Pred pred) &&;
 
@@ -268,55 +268,55 @@ struct inline_sequence_base {
 
     [[nodiscard]]
     constexpr auto dedup() &&
-        requires multipass_sequence<Derived> &&
-                 std::equality_comparable<element_t<Derived>>;
+        requires multipass_sequence<Derived>
+        && std::equality_comparable<iterable_element_t<Derived>>;
 
     [[nodiscard]]
     constexpr auto drop(num::integral auto count) &&;
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto drop_while(Pred pred) &&;
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto filter(Pred pred) &&;
 
     template <typename Func>
-        requires std::invocable<Func&, element_t<Derived>> &&
-                 detail::optional_like<std::invoke_result_t<Func&, element_t<Derived>>>
+        requires std::invocable<Func&, iterable_element_t<Derived>>
+        && detail::optional_like<std::invoke_result_t<Func&, iterable_element_t<Derived>>>
     [[nodiscard]]
     constexpr auto filter_map(Func func) &&;
 
     [[nodiscard]]
-    constexpr auto filter_deref() && requires detail::optional_like<value_t<Derived>>;
+    constexpr auto filter_deref() &&
+        requires detail::optional_like<iterable_value_t<Derived>>;
 
     [[nodiscard]]
-    constexpr auto flatten() && requires sequence<element_t<Derived>>;
+    constexpr auto flatten() &&
+        requires sequence<iterable_element_t<Derived>>;
 
     template <adaptable_sequence Pattern>
-        requires sequence<element_t<Derived>> &&
-                 multipass_sequence<Pattern> &&
-                 detail::flatten_with_compatible<element_t<Derived>, Pattern>
+        requires sequence<iterable_element_t<Derived>> && multipass_sequence<Pattern>
+        && detail::flatten_with_compatible<iterable_element_t<Derived>, Pattern>
     [[nodiscard]]
     constexpr auto flatten_with(Pattern&& pattern) &&;
 
-
     template <typename Value>
-        requires sequence<element_t<Derived>> &&
-                 std::constructible_from<value_t<element_t<Derived>>, Value&&>
+        requires sequence<iterable_element_t<Derived>>
+        && std::constructible_from<iterable_value_t<iterable_element_t<Derived>>, Value&&>
     [[nodiscard]]
     constexpr auto flatten_with(Value value) &&;
 
     template <typename Func>
-        requires std::invocable<Func&, element_t<Derived>>
+        requires std::invocable<Func&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto map(Func func) &&;
 
     template <adaptable_sequence Mask>
-        requires detail::boolean_testable<element_t<Mask>>
+        requires detail::boolean_testable<iterable_element_t<Mask>>
     [[nodiscard]]
     constexpr auto mask(Mask&& mask_) &&;
 
@@ -340,13 +340,13 @@ struct inline_sequence_base {
     constexpr auto reverse() &&
             requires bidirectional_sequence<Derived> && bounded_sequence<Derived>;
 
-    template <typename D = Derived, typename Func, typename Init = value_t<D>>
+    template <typename D = Derived, typename Func, typename Init = iterable_value_t<D>>
         requires foldable<Derived, Func, Init>
     [[nodiscard]]
     constexpr auto scan(Func func, Init init = Init{}) &&;
 
     template <typename Func>
-        requires foldable<Derived, Func, element_t<Derived>>
+        requires foldable<Derived, Func, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto scan_first(Func func) &&;
 
@@ -354,21 +354,20 @@ struct inline_sequence_base {
     constexpr auto slide(num::integral auto win_sz) && requires multipass_sequence<Derived>;
 
     template <typename Pattern>
-        requires multipass_sequence<Derived> &&
-                 multipass_sequence<Pattern> &&
-                 std::equality_comparable_with<element_t<Derived>, element_t<Pattern>>
+        requires multipass_sequence<Derived> && multipass_sequence<Pattern>
+        && std::equality_comparable_with<iterable_element_t<Derived>, iterable_element_t<Pattern>>
     [[nodiscard]]
     constexpr auto split(Pattern&& pattern) &&;
 
     template <typename Delim>
-        requires multipass_sequence<Derived> &&
-                 std::equality_comparable_with<element_t<Derived>, Delim const&>
+        requires multipass_sequence<Derived>
+        && std::equality_comparable_with<iterable_element_t<Derived>, Delim const&>
     [[nodiscard]]
     constexpr auto split(Delim&& delim) &&;
 
     template <typename Pred>
-        requires multipass_sequence<Derived> &&
-                 std::predicate<Pred const&, element_t<Derived>>
+        requires multipass_sequence<Derived>
+        && std::predicate<Pred const&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto split(Pred pred) &&;
 
@@ -383,7 +382,7 @@ struct inline_sequence_base {
     constexpr auto take(num::integral auto count) &&;
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto take_while(Pred pred) &&;
 
@@ -393,17 +392,17 @@ struct inline_sequence_base {
 
     /// Returns `true` if every element of the sequence satisfies the predicate
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto all(Pred pred);
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto any(Pred pred);
 
     template <typename Value>
-        requires std::equality_comparable_with<element_t<Derived>, Value const&>
+        requires std::equality_comparable_with<iterable_element_t<Derived>, Value const&>
     constexpr auto contains(Value const& value) -> bool;
 
     /// Returns the number of elements in the sequence
@@ -411,17 +410,17 @@ struct inline_sequence_base {
 
     /// Returns the number of elements in the sequence which are equal to `value`
     template <typename Value>
-        requires std::equality_comparable_with<element_t<Derived>, Value const&>
+        requires std::equality_comparable_with<iterable_element_t<Derived>, Value const&>
     constexpr auto count_eq(Value const& value);
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     constexpr auto count_if(Pred pred);
 
     template <sequence Needle, typename Cmp = std::ranges::equal_to>
-        requires std::predicate<Cmp&, element_t<Derived>, element_t<Needle>> &&
-                 (multipass_sequence<Derived> || sized_sequence<Derived>) &&
-                 (multipass_sequence<Needle> || sized_sequence<Needle>)
+        requires std::predicate<Cmp&, iterable_element_t<Derived>, iterable_element_t<Needle>>
+        && (multipass_sequence<Derived> || sized_sequence<Derived>)
+        && (multipass_sequence<Needle> || sized_sequence<Needle>)
     constexpr auto ends_with(Needle&& needle, Cmp cmp = {}) -> bool;
 
     template <typename Value>
@@ -430,17 +429,17 @@ struct inline_sequence_base {
 
     /// Returns a cursor pointing to the first occurrence of `value` in the sequence
     template <typename Value>
-        requires std::equality_comparable_with<element_t<Derived>, Value const&>
+        requires std::equality_comparable_with<iterable_element_t<Derived>, Value const&>
     [[nodiscard]]
     constexpr auto find(Value const&);
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto find_if(Pred pred);
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto find_if_not(Pred pred);
 
@@ -465,13 +464,15 @@ struct inline_sequence_base {
     constexpr auto fold(Func func, Init init) -> fold_result_t<D, Func, Init>;
 
     template <typename D = Derived, typename Func>
-        requires std::invocable<Func&, value_t<D>, element_t<D>> &&
-                 std::assignable_from<value_t<D>&, std::invoke_result_t<Func&, value_t<D>, element_t<D>>>
+        requires std::invocable<Func&, iterable_value_t<D>, iterable_element_t<D>>
+        && std::assignable_from<
+                     iterable_value_t<D>&,
+                     std::invoke_result_t<Func&, iterable_value_t<D>, iterable_element_t<D>>>
     [[nodiscard]]
     constexpr auto fold_first(Func func);
 
     template <typename Func>
-        requires std::invocable<Func&, element_t<Derived>>
+        requires std::invocable<Func&, iterable_element_t<Derived>>
     constexpr auto for_each(Func func) -> Func;
 
     constexpr auto inplace_reverse()
@@ -491,18 +492,18 @@ struct inline_sequence_base {
     constexpr auto minmax(Cmp cmp = Cmp{});
 
     template <typename Pred>
-        requires std::predicate<Pred&, element_t<Derived>>
+        requires std::predicate<Pred&, iterable_element_t<Derived>>
     [[nodiscard]]
     constexpr auto none(Pred pred);
 
     template <typename Iter>
-        requires std::weakly_incrementable<Iter> &&
-                 std::indirectly_writable<Iter, element_t<Derived>>
+        requires std::weakly_incrementable<Iter>
+        && std::indirectly_writable<Iter, iterable_element_t<Derived>>
     constexpr auto output_to(Iter iter) -> Iter;
 
     constexpr auto sum()
-        requires foldable<Derived, std::plus<>, value_t<Derived>> &&
-                 std::default_initializable<value_t<Derived>>;
+        requires foldable<Derived, std::plus<>, iterable_value_t<Derived>>
+        && std::default_initializable<iterable_value_t<Derived>>;
 
     template <typename Cmp = std::compare_three_way>
         requires random_access_sequence<Derived> &&
@@ -512,11 +513,11 @@ struct inline_sequence_base {
     constexpr void sort(Cmp cmp = {});
 
     constexpr auto product()
-        requires foldable<Derived, std::multiplies<>, value_t<Derived>> &&
-                 requires { value_t<Derived>(1); };
+        requires foldable<Derived, std::multiplies<>, iterable_value_t<Derived>>
+        && requires { iterable_value_t<Derived>(1); };
 
     template <sequence Needle, typename Cmp = std::ranges::equal_to>
-        requires std::predicate<Cmp&, element_t<Derived>, element_t<Needle>>
+        requires std::predicate<Cmp&, iterable_element_t<Derived>, iterable_element_t<Needle>>
     constexpr auto starts_with(Needle&& needle, Cmp cmp = Cmp{}) -> bool;
 
     template <typename Container, typename... Args>

From be0dc9d3721c28858d2872e4893ccbc9c19e3fe7 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 17:42:53 +0100
Subject: [PATCH 50/66] Fix generator errors on MSVC

Maybe...
---
 include/flux/sequence/generator.hpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/include/flux/sequence/generator.hpp b/include/flux/sequence/generator.hpp
index 34f8078f..229958d9 100644
--- a/include/flux/sequence/generator.hpp
+++ b/include/flux/sequence/generator.hpp
@@ -33,7 +33,14 @@ struct generator : inline_sequence_base<generator<ElemT>> {
             return generator(handle_type::from_promise(*this));
         }
 
-        auto yield_value(yielded_type elem)
+        auto yield_value(ElemT& elem)
+        {
+            ptr_ = std::addressof(elem);
+            return std::suspend_always{};
+        }
+
+        auto yield_value(ElemT&& elem)
+            requires(!std::is_lvalue_reference_v<ElemT>)
         {
             ptr_ = std::addressof(elem);
             return std::suspend_always{};

From 3a1a09be6ae145d88b647730307cf555aa8335ff Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 13 Aug 2025 19:06:15 +0100
Subject: [PATCH 51/66] Make from_istream iterable only

...which apparently turned up lots of other bugs
---
 include/flux/adaptor/filter.hpp         | 22 ++++----
 include/flux/algorithm/to.hpp           | 19 ++++---
 include/flux/core/as_range.hpp          |  3 +-
 include/flux/core/iterable_concepts.hpp | 23 ++++++++
 include/flux/core/ref.hpp               | 26 ++++-----
 include/flux/sequence/istream.hpp       | 75 ++++++++-----------------
 test/test_istream.cpp                   | 22 +++++---
 test/test_scan.cpp                      | 15 +----
 8 files changed, 98 insertions(+), 107 deletions(-)

diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index 01f054a0..349239e8 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -87,52 +87,53 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
         };
 
     public:
-        using value_type = value_t<Base>;
+        using value_type = iterable_value_t<Base>;
 
         static constexpr bool disable_multipass = !multipass_sequence<Base>;
 
-        static constexpr auto first(auto& self) -> cursor_type
+        static constexpr auto first(auto& self)
+            requires sequence<Base>
         {
             return cursor_type{flux::find_if(self.base_, std::ref(self.pred_))};
         }
 
-        static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+        static constexpr auto is_last(auto& self, auto const& cur) -> bool
         {
             return flux::is_last(self.base_, cur.base_cur);
         }
 
-        static constexpr auto read_at(auto& self, cursor_type const& cur)
+        static constexpr auto read_at(auto& self, auto const& cur)
             -> decltype(flux::read_at(self.base_, cur.base_cur))
         {
             return flux::read_at(self.base_, cur.base_cur);
         }
 
-        static constexpr auto read_at_unchecked(auto& self, cursor_type const& cur)
+        static constexpr auto read_at_unchecked(auto& self, auto const& cur)
             -> decltype(flux::read_at_unchecked(self.base_, cur.base_cur))
         {
             return flux::read_at_unchecked(self.base_, cur.base_cur);
         }
 
-        static constexpr auto move_at(auto& self, cursor_type const& cur)
+        static constexpr auto move_at(auto& self, auto const& cur)
             -> decltype(flux::move_at(self.base_, cur.base_cur))
         {
             return flux::move_at(self.base_, cur.base_cur);
         }
 
-        static constexpr auto move_at_unchecked(auto& self, cursor_type const& cur)
+        static constexpr auto move_at_unchecked(auto& self, auto const& cur)
             -> decltype(flux::move_at_unchecked(self.base_, cur.base_cur))
         {
             return flux::move_at_unchecked(self.base_, cur.base_cur);
         }
 
-        static constexpr auto inc(auto& self, cursor_type& cur) -> void
+        static constexpr auto inc(auto& self, auto& cur) -> void
         {
             flux::inc(self.base_, cur.base_cur);
             cur.base_cur = flux::slice(self.base_, std::move(cur).base_cur, flux::last)
                                .find_if(std::ref(self.pred_));
         }
 
-        static constexpr auto dec(auto& self, cursor_type& cur) -> void
+        static constexpr auto dec(auto& self, auto& cur) -> void
             requires bidirectional_sequence<Base>
         {
             do {
@@ -140,14 +141,13 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
             } while(!std::invoke(self.pred_, flux::read_at(self.base_, cur.base_cur)));
         }
 
-        static constexpr auto last(auto& self) -> cursor_type
+        static constexpr auto last(auto& self)
             requires bounded_sequence<Base>
         {
             return cursor_type{flux::last(self.base_)};
         }
 
         static constexpr auto for_each_while(auto& self, auto&& func)
-            -> cursor_type
         {
             return cursor_type {flux::seq_for_each_while(self.base_, [&](auto&& elem) {
                 if (std::invoke(self.pred_, elem)) {
diff --git a/include/flux/algorithm/to.hpp b/include/flux/algorithm/to.hpp
index 874f9830..6d4fd04c 100644
--- a/include/flux/algorithm/to.hpp
+++ b/include/flux/algorithm/to.hpp
@@ -142,8 +142,8 @@ consteval auto deduce_container_type()
         using I = common_iterator_t<Seq>;
         return type_t<decltype(C(FLUX_DECLVAL(I), FLUX_DECLVAL(I), FLUX_DECLVAL(Args)...))>{};
     } else {
-        static_assert(requires { typename C<value_t<Seq>>; });
-        return type_t<C<value_t<Seq>>>{};
+        static_assert(requires { typename C<iterable_value_t<Seq>>; });
+        return type_t<C<iterable_value_t<Seq>>>{};
     }
 }
 
@@ -161,7 +161,8 @@ template <typename Container, iterable It, typename... Args>
     || iterable<iterable_element_t<It>>
 constexpr auto to(It&& it, Args&&... args) -> Container
 {
-    if constexpr (std::convertible_to<element_t<It>, detail::container_value_t<Container>>) {
+    if constexpr (std::convertible_to<iterable_element_t<It>,
+                                      detail::container_value_t<Container>>) {
         if constexpr (detail::direct_iterable_constructible<Container, It, Args...>) {
             return Container(FLUX_FWD(it), FLUX_FWD(args)...);
         } else if constexpr (detail::from_iterable_constructible<Container, It, Args...>) {
@@ -193,13 +194,13 @@ constexpr auto to(It&& it, Args&&... args) -> Container
 }
 
 FLUX_EXPORT
-template <template <typename...> typename Container, sequence Seq, typename... Args>
-    requires detail::can_deduce_container_type<Container, Seq, Args...> &&
-             detail::container_convertible<
-                 detail::deduced_container_t<Container, Seq, Args...>, Seq, Args...>
-constexpr auto to(Seq&& seq, Args&&... args)
+template <template <typename...> typename Container, iterable It, typename... Args>
+    requires detail::can_deduce_container_type<Container, It, Args...>
+    && detail::container_convertible<detail::deduced_container_t<Container, It, Args...>, It,
+                                     Args...>
+constexpr auto to(It&& seq, Args&&... args)
 {
-    using C_ = detail::deduced_container_t<Container, Seq, Args...>;
+    using C_ = detail::deduced_container_t<Container, It, Args...>;
     return flux::to<C_>(FLUX_FWD(seq), FLUX_FWD(args)...);
 }
 
diff --git a/include/flux/core/as_range.hpp b/include/flux/core/as_range.hpp
index 158c1699..2ef08365 100644
--- a/include/flux/core/as_range.hpp
+++ b/include/flux/core/as_range.hpp
@@ -75,7 +75,8 @@ struct as_range_t {
             return FLUX_FWD(it);
         } else {
             if constexpr (std::is_lvalue_reference_v<It>) {
-                return detail::iterable_range<std::reference_wrapper<It>>(std::ref(it));
+                return detail::iterable_range<std::reference_wrapper<std::remove_reference_t<It>>>(
+                    std::ref(it));
             } else {
                 return detail::iterable_range<It>(FLUX_FWD(it));
             }
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 7af6a86a..04296108 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -516,6 +516,29 @@ FLUX_EXPORT template <typename I>
 concept adaptable_iterable = iterable<std::decay_t<I>>
     && (detail::movable_rvalue<I> || detail::trivially_copyable_lvalue<I>);
 
+/*
+ * MARK: Default implementations
+ */
+template <iterable It>
+struct iterable_traits<std::reference_wrapper<It>> {
+
+    using self_t = std::reference_wrapper<It>;
+
+    static constexpr auto iterate(self_t self) { return flux::iterate(self.get()); }
+
+    static constexpr auto reverse_iterate(self_t self)
+        requires reverse_iterable<It>
+    {
+        return flux::reverse_iterate(self.get());
+    }
+
+    static constexpr auto size(self_t self)
+        requires sized_iterable<It>
+    {
+        return flux::iterable_size(self.get());
+    }
+};
+
 } // namespace flux
 
 #endif // FLUX_CORE_ITERABLE_CONCEPTS_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/core/ref.hpp b/include/flux/core/ref.hpp
index 9bbdd124..b7e9ceb8 100644
--- a/include/flux/core/ref.hpp
+++ b/include/flux/core/ref.hpp
@@ -219,32 +219,32 @@ struct owning_adaptor : inline_sequence_base<owning_adaptor<Base>> {
 };
 
 struct from_fn {
-    template <adaptable_sequence Seq>
+    template <adaptable_iterable It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const
+    constexpr auto operator()(It&& it) const
     {
-        if constexpr (derived_from_inline_sequence_base<Seq>) {
-            return FLUX_FWD(seq);
+        if constexpr (derived_from_inline_sequence_base<It>) {
+            return FLUX_FWD(it);
         } else {
-            return owning_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq));
+            return owning_adaptor<std::decay_t<It>>(FLUX_FWD(it));
         }
     }
 };
 
 struct from_fwd_ref_fn {
-    template <sequence Seq>
-        requires adaptable_sequence<Seq> || std::is_lvalue_reference_v<Seq>
+    template <iterable It>
+        requires adaptable_iterable<It> || std::is_lvalue_reference_v<It>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const
+    constexpr auto operator()(It&& it) const
     {
-        if constexpr (std::is_lvalue_reference_v<Seq>) {
-            if constexpr (std::is_const_v<std::remove_reference_t<Seq>>) {
-                return ref_fn{}(seq);
+        if constexpr (std::is_lvalue_reference_v<It>) {
+            if constexpr (std::is_const_v<std::remove_reference_t<It>>) {
+                return ref_fn{}(it);
             } else {
-                return mut_ref_fn{}(seq);
+                return mut_ref_fn{}(it);
             }
         } else {
-            return from_fn{}(seq);
+            return from_fn{}(it);
         }
     }
 };
diff --git a/include/flux/sequence/istream.hpp b/include/flux/sequence/istream.hpp
index dc8e4960..60c45656 100644
--- a/include/flux/sequence/istream.hpp
+++ b/include/flux/sequence/istream.hpp
@@ -15,76 +15,45 @@ namespace flux {
 namespace detail {
 
 template <typename T, typename CharT, typename Traits>
-    requires std::default_initializable<T>
-class istream_adaptor : public inline_sequence_base<istream_adaptor<T, CharT, Traits>> {
-    using istream_type = std::basic_istream<CharT, Traits>;
-    istream_type* is_ = nullptr;
-    T val_ = T();
+struct istream_adaptor : inline_sequence_base<istream_adaptor<T, CharT, Traits>> {
+    std::basic_istream<CharT, Traits>* stream;
 
-    friend struct sequence_traits<istream_adaptor>;
+    struct context_type : immovable {
+        std::basic_istream<CharT, Traits>* stream_;
+        T elem_ = T{};
 
-public:
-    explicit istream_adaptor(istream_type& is)
-        : is_(std::addressof(is))
-    {}
+        using element_type = T const&;
 
+        explicit context_type(istream_adaptor& adaptor) : stream_(adaptor.stream) { }
+
+        auto run_while(auto&& pred) -> iteration_result
+        {
+            while (*stream_ >> elem_) {
+                if (!std::invoke(pred, static_cast<element_type>(elem_))) {
+                    return iteration_result::incomplete;
+                }
+            }
+            return iteration_result::complete;
+        }
+    };
+
+    explicit istream_adaptor(std::basic_istream<CharT, Traits>& is) : stream(std::addressof(is)) { }
+
+    auto iterate() { return context_type{*this}; }
 };
 
 template <std::default_initializable T>
 struct from_istream_fn {
-
     template <typename CharT, typename Traits>
     [[nodiscard]]
     auto operator()(std::basic_istream<CharT, Traits>& is) const
     {
         return istream_adaptor<T, CharT, Traits>(is);
     }
-
 };
 
 } // namespace detail
 
-template <typename T, typename CharT, typename Traits>
-struct sequence_traits<detail::istream_adaptor<T, CharT, Traits>> : default_sequence_traits
-{
-private:
-    struct cursor_type {
-        cursor_type(cursor_type&&) = default;
-        cursor_type& operator=(cursor_type&&) = default;
-    private:
-        friend struct sequence_traits;
-        explicit cursor_type() = default;
-    };
-
-    using self_t = detail::istream_adaptor<T, CharT, Traits>;
-
-public:
-    static auto first(self_t& self) -> cursor_type
-    {
-        cursor_type cur{};
-        inc(self, cur);
-        return cur;
-    }
-
-    static auto is_last(self_t& self, cursor_type const&) -> bool
-    {
-        return !(self.is_ && static_cast<bool>(*self.is_));
-    }
-
-    static auto read_at(self_t& self, cursor_type const&) -> T const&
-    {
-        return self.val_;
-    }
-
-    static auto inc(self_t& self, cursor_type& cur) -> cursor_type&
-    {
-        if (!(self.is_ && (*self.is_ >> self.val_))) {
-            self.is_ = nullptr;
-        }
-        return cur;
-    }
-};
-
 FLUX_EXPORT
 template <std::default_initializable T>
 inline constexpr auto from_istream = detail::from_istream_fn<T>{};
diff --git a/test/test_istream.cpp b/test/test_istream.cpp
index c435a5c8..107fe9b3 100644
--- a/test/test_istream.cpp
+++ b/test/test_istream.cpp
@@ -16,13 +16,13 @@ TEST_CASE("istream")
 
         using S = decltype(seq);
 
-        static_assert(flux::sequence<S>);
+        static_assert(flux::iterable<S>);
         static_assert(not flux::multipass_sequence<S>);
         static_assert(not flux::sized_sequence<S>);
         static_assert(not flux::bounded_sequence<S>);
 
-        static_assert(std::same_as<flux::element_t<S>, int const&>);
-        static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
+        static_assert(std::same_as<flux::iterable_element_t<S>, int const&>);
+        static_assert(std::same_as<flux::iterable_value_t<S>, int>);
 
         REQUIRE(check_equal(seq, {0, 1, 2, 3, 4}));
     }
@@ -35,15 +35,21 @@ TEST_CASE("istream")
                       .map([](int i) { return i * 2; })
                       .take(3);
 
-        static_assert(flux::sequence<decltype(seq)>);
-        static_assert(not flux::multipass_sequence<decltype(seq)>);
+        static_assert(flux::iterable<decltype(seq)>);
 
         REQUIRE(check_equal(seq, {10, 12, 14}));
     }
 
+    SUBCASE("take(5) with istream")
     {
-        std::istringstream iss;
-        auto seq = flux::from_istream<double>(iss);
-        REQUIRE(flux::is_last(seq, flux::first(seq)));
+        std::istringstream iss("1 2 3 4 5 6 7 8 9 10");
+
+        auto it = flux::from_istream<int>(iss).take(5);
+
+        REQUIRE(check_equal(it, {1, 2, 3, 4, 5}));
+
+        int i = 0;
+        iss >> i;
+        REQUIRE(i == 6);
     }
 }
\ No newline at end of file
diff --git a/test/test_scan.cpp b/test/test_scan.cpp
index a2fd3fcc..1bd9fabd 100644
--- a/test/test_scan.cpp
+++ b/test/test_scan.cpp
@@ -262,10 +262,7 @@ TEST_CASE("scan")
 
         auto seq = flux::from_istream<int>(iss).scan(std::plus<>{}, 100);
 
-        static_assert(flux::sequence<decltype(seq)>);
-        static_assert(not flux::multipass_sequence<decltype(seq)>);
-        static_assert(not flux::sized_sequence<decltype(seq)>);
-        static_assert(not flux::bounded_sequence<decltype(seq)>);
+        static_assert(flux::iterable<decltype(seq)>);
 
         REQUIRE(check_equal(seq, {101, 103, 106, 110, 115}));
     }
@@ -277,10 +274,7 @@ TEST_CASE("scan")
         auto seq = flux::prescan(flux::from_istream<int>(iss),
                                         std::plus<>{}, 100);
 
-        static_assert(flux::sequence<decltype(seq)>);
-        static_assert(not flux::multipass_sequence<decltype(seq)>);
-        static_assert(not flux::sized_sequence<decltype(seq)>);
-        static_assert(not flux::bounded_sequence<decltype(seq)>);
+        static_assert(flux::iterable<decltype(seq)>);
 
         REQUIRE(check_equal(seq, {100, 101, 103, 106, 110, 115}));
     }
@@ -291,10 +285,7 @@ TEST_CASE("scan")
 
         auto seq = flux::from_istream<int>(iss).scan_first(std::plus<>{});
 
-        static_assert(flux::sequence<decltype(seq)>);
-        static_assert(not flux::multipass_sequence<decltype(seq)>);
-        static_assert(not flux::sized_sequence<decltype(seq)>);
-        static_assert(not flux::bounded_sequence<decltype(seq)>);
+        static_assert(flux::iterable<decltype(seq)>);
 
         REQUIRE(check_equal(seq, {1, 3, 6, 10, 15}));
     }

From 531e40c29b90cf0e07af4b7e077451507a048ce4 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 11:32:04 +0100
Subject: [PATCH 52/66] Fix broken examples

---
 example/docs/count.cpp          | 2 +-
 example/word_count.cpp          | 6 ++----
 include/flux/adaptor/filter.hpp | 1 +
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/example/docs/count.cpp b/example/docs/count.cpp
index 51d431f1..57fb3ea8 100644
--- a/example/docs/count.cpp
+++ b/example/docs/count.cpp
@@ -27,5 +27,5 @@ int main()
     std::istringstream iss("1 2 3");
     auto seq = flux::from_istream<int>(iss);
     assert(flux::count(seq) == 3);
-    assert(flux::is_last(seq, flux::first(seq))); // No more elements!
+    assert(!iss); // No more elements!
 }
\ No newline at end of file
diff --git a/example/word_count.cpp b/example/word_count.cpp
index 26a8754d..b9c006f0 100644
--- a/example/word_count.cpp
+++ b/example/word_count.cpp
@@ -17,11 +17,9 @@ struct stats_t
     bool is_last_space = true;
 };
 
-auto collect_stats = [](flux::sequence auto&& seq)
-{
+auto collect_stats = [](flux::iterable auto&& seq) {
     stats_t stats;
-    flux::for_each(FLUX_FWD(seq), [&stats](char val) 
-    {
+    flux::for_each(FLUX_FWD(seq), [&stats](char val) {
         stats.chars++;
         if (not stats.is_last_space and std::isspace(val)) {
             stats.words++;
diff --git a/include/flux/adaptor/filter.hpp b/include/flux/adaptor/filter.hpp
index 349239e8..413d44a8 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -92,6 +92,7 @@ class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>> {
         static constexpr bool disable_multipass = !multipass_sequence<Base>;
 
         static constexpr auto first(auto& self)
+            -> decltype(cursor_type{flux::find_if(self.base_, std::ref(self.pred_))})
             requires sequence<Base>
         {
             return cursor_type{flux::find_if(self.base_, std::ref(self.pred_))};

From f7375642ea9face5881b0acff23afc599b2d54cd Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 12:04:49 +0100
Subject: [PATCH 53/66] Make getlines() iterable only

---
 example/shortest_path.cpp          |  7 ++-
 include/flux/adaptor/zip.hpp       |  6 +--
 include/flux/core/as_range.hpp     |  2 +-
 include/flux/sequence/getlines.hpp | 68 +++++++++++-------------------
 test/test_getlines.cpp             | 18 +++-----
 5 files changed, 38 insertions(+), 63 deletions(-)

diff --git a/example/shortest_path.cpp b/example/shortest_path.cpp
index a612d60d..a157876e 100644
--- a/example/shortest_path.cpp
+++ b/example/shortest_path.cpp
@@ -139,8 +139,11 @@ class maze {
     }
 };
 
-void print_side_by_side(std::istream& s1, std::istream& s2) {
-    for (auto [line1, line2]: flux::zip(flux::getlines(s1, '\n'), flux::getlines(s2, '\n'))) {
+void print_side_by_side(std::istream& s1, std::istream& s2)
+{
+    // FIXME: Remove as_range when we can
+    for (auto [line1, line2] :
+         flux::as_range(flux::zip(flux::getlines(s1, '\n'), flux::getlines(s2, '\n')))) {
         std::cout << line1 << "  " << line2 << '\n';
     }
 }
diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index a1407038..332c71ee 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -329,9 +329,8 @@ struct zip_map_fn {
 
 } // namespace detail
 
-template <typename... Bases>
-struct sequence_traits<detail::zip_adaptor<Bases...>> : zip_traits_base<Bases...>
-{
+template <sequence... Bases>
+struct sequence_traits<detail::zip_adaptor<Bases...>> : zip_traits_base<Bases...> {
 private:
     using base = zip_traits_base<Bases...>;
 
@@ -380,7 +379,6 @@ struct sequence_traits<detail::zip_adaptor<Bases...>> : zip_traits_base<Bases...
     {
         return read_(flux::move_at_unchecked, self, cur);
     }
-
 };
 
 template <typename Func, typename... Bases>
diff --git a/include/flux/core/as_range.hpp b/include/flux/core/as_range.hpp
index 2ef08365..59e41144 100644
--- a/include/flux/core/as_range.hpp
+++ b/include/flux/core/as_range.hpp
@@ -69,7 +69,7 @@ struct iterable_range : std::ranges::view_interface<iterable_range<It>> {
 FLUX_EXPORT
 struct as_range_t {
     template <iterable It>
-    constexpr auto operator()(It&& it) const -> std::ranges::input_range decltype(auto)
+    constexpr auto operator()(It&& it) const -> decltype(auto)
     {
         if constexpr (std::ranges::input_range<It>) {
             return FLUX_FWD(it);
diff --git a/include/flux/sequence/getlines.hpp b/include/flux/sequence/getlines.hpp
index ca4926ca..a088c98d 100644
--- a/include/flux/sequence/getlines.hpp
+++ b/include/flux/sequence/getlines.hpp
@@ -16,78 +16,58 @@ namespace flux {
 namespace detail {
 
 template <typename CharT, typename Traits>
-struct getlines_sequence : inline_sequence_base<getlines_sequence<CharT, Traits>> {
+struct getlines_iterable : inline_sequence_base<getlines_iterable<CharT, Traits>> {
 private:
     using istream_type = std::basic_istream<CharT, Traits>;
     using string_type = std::basic_string<CharT, Traits>;
     using char_type = CharT;
 
     istream_type* is_ = nullptr;
-    string_type str_;
     char_type delim_{};
 
-public:
-    getlines_sequence() = default;
-
-    getlines_sequence(istream_type& is, char_type delim)
-        : is_(std::addressof(is)),
-          delim_(delim)
-    {}
-
-    getlines_sequence(getlines_sequence&&) = default;
-    getlines_sequence& operator=(getlines_sequence&&) = default;
+    struct context_type : immovable {
+        istream_type* is_;
+        string_type str_;
+        char_type delim_;
 
-    struct flux_sequence_traits : default_sequence_traits {
-    private:
-        struct cursor_type {
-            explicit cursor_type() = default;
-            cursor_type(cursor_type&&) = default;
-            cursor_type& operator=(cursor_type&&) = default;
-        };
-
-        using self_t = getlines_sequence;
-
-    public:
-        static constexpr auto first(self_t& self) -> cursor_type
-        {
-            cursor_type cur{};
-            inc(self, cur);
-            return cur;
-        }
+        using element_type = string_type const&;
 
-        static constexpr auto is_last(self_t& self, cursor_type const&) -> bool
+        explicit context_type(getlines_iterable& iterable)
+            : is_(iterable.is_),
+              delim_(iterable.delim_)
         {
-            return !(self.is_ && static_cast<bool>(*self.is_));
         }
 
-        static constexpr auto inc(self_t& self, cursor_type& cur) -> cursor_type&
+        auto run_while(auto&& pred) -> iteration_result
         {
-            flux::assert_(self.is_ != nullptr,
-                         "flux::getlines::inc(): attempt to iterate after stream EOF");
-            if (!std::getline(*self.is_, self.str_, self.delim_)) {
-                self.is_ = nullptr;
+            while (std::getline(*is_, str_, delim_)) {
+                if (!std::invoke(pred, static_cast<element_type>(str_))) {
+                    return iteration_result::incomplete;
+                }
             }
-            return cur;
-        }
-
-        static constexpr auto read_at(self_t& self, cursor_type const&) -> string_type const&
-        {
-            return self.str_;
+            return iteration_result::complete;
         }
     };
+
+public:
+    getlines_iterable(istream_type& is, char_type delim)
+        : is_(std::addressof(is)),
+          delim_(delim) { }
+
+    auto iterate() { return context_type{*this}; }
 };
 
 struct getlines_fn {
     template <typename CharT, typename Traits>
     constexpr auto operator()(std::basic_istream<CharT, Traits>& istream, CharT delim) const
     {
-        return getlines_sequence<CharT, Traits>(istream, delim);
+        return getlines_iterable<CharT, Traits>(istream, delim);
     }
 
     template <typename CharT, typename Traits>
     constexpr auto operator()(std::basic_istream<CharT, Traits>& istream) const
     {
-        return getlines_sequence<CharT, Traits>(istream, istream.widen('\n'));
+        return getlines_iterable<CharT, Traits>(istream, istream.widen('\n'));
     }
 };
 
diff --git a/test/test_getlines.cpp b/test/test_getlines.cpp
index 6b0d0b0c..1cee4250 100644
--- a/test/test_getlines.cpp
+++ b/test/test_getlines.cpp
@@ -18,20 +18,14 @@ TEST_CASE("getlines")
 
     auto seq = flux::getlines(iss);
 
-    static_assert(flux::sequence<decltype(seq)>);
+    static_assert(flux::iterable<decltype(seq)>);
     static_assert(!flux::multipass_sequence<decltype(seq)>);
 
-    auto cur = seq.first();
-    REQUIRE(seq[cur] == "Line1");
-    seq.inc(cur);
-    REQUIRE(seq[cur] == "Line2");
-    seq.inc(cur);
-    REQUIRE(seq[cur] == "Line3");
-    seq.inc(cur);
-    REQUIRE(seq.is_last(cur));
-
-    // Make sure assertion fires
-    REQUIRE_THROWS_AS(seq.inc(cur), flux::unrecoverable_error);
+    auto ctx = seq.iterate();
+    REQUIRE(flux::next_element(ctx).value() == "Line1");
+    REQUIRE(flux::next_element(ctx).value() == "Line2");
+    REQUIRE(flux::next_element(ctx).value() == "Line3");
+    REQUIRE(flux::next_element(ctx).has_value() == false);
 }
 
 TEST_CASE("getlines to vector")

From 2259b11ed39d1e071cb7027d250e5cf22c589478 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 13:10:12 +0100
Subject: [PATCH 54/66] Make iterables work with range-for

STL iterators are required to be at least movable. Since iteration contexts are typically non-copyable and non-movable, we cannot store one inside a valid iterator. This means that in order to use plain iterables with STL algorithms we need to use the `as_range` adaptor, which can hold the iter_ctx and hand out movable iterators which hold a pointer back to it.

However, range-for loops have considerably weaker requirements than the standard library concepts. So to enable iterables to be directly used with range-for loops, this commit adds "pseudoiterators" which meet the bare minimum requirements that the range-for needs. These pseudoiterators won't work with standard library algorithms, and in fact we deliberately don't add extra typedefs and things just to try to emphasise that they're not real iterators.
---
 example/shortest_path.cpp                  |  3 +-
 include/flux/core/inline_sequence_base.hpp | 12 ++---
 include/flux/core/iterable_concepts.hpp    |  2 +-
 include/flux/core/sequence_iterator.hpp    | 63 ++++++++++++++++++----
 test/test_generator.cpp                    |  7 ++-
 5 files changed, 63 insertions(+), 24 deletions(-)

diff --git a/example/shortest_path.cpp b/example/shortest_path.cpp
index a157876e..b7c21026 100644
--- a/example/shortest_path.cpp
+++ b/example/shortest_path.cpp
@@ -142,8 +142,7 @@ class maze {
 void print_side_by_side(std::istream& s1, std::istream& s2)
 {
     // FIXME: Remove as_range when we can
-    for (auto [line1, line2] :
-         flux::as_range(flux::zip(flux::getlines(s1, '\n'), flux::getlines(s2, '\n')))) {
+    for (auto [line1, line2] : flux::zip(flux::getlines(s1, '\n'), flux::getlines(s2, '\n'))) {
         std::cout << line1 << "  " << line2 << '\n';
     }
 }
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index b58739b7..5d98d1ab 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -212,15 +212,15 @@ struct inline_sequence_base {
     /*
      * Iterator support
      */
-    constexpr auto begin() &
-        requires sequence<Derived>;
+    constexpr auto begin() &;
 
-    constexpr auto begin() const& requires sequence<Derived const>;
+    constexpr auto begin() const&
+        requires iterable<Derived const>;
 
-    constexpr auto end() &
-        requires sequence<Derived>;
+    constexpr auto end() &;
 
-    constexpr auto end() const& requires sequence<Derived const>;
+    constexpr auto end() const&
+        requires iterable<Derived const>;
 
     /*
      * Adaptors
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
index 04296108..6b141a3f 100644
--- a/include/flux/core/iterable_concepts.hpp
+++ b/include/flux/core/iterable_concepts.hpp
@@ -132,7 +132,7 @@ concept has_member_iterate = requires(T& t) {
 
 template <typename T>
 concept can_iterate = has_valid_iter_traits<T> || has_member_iterate<T> || sequence<T>
-    || std::ranges::input_range<T>;
+    || (!derived_from_inline_sequence_base<T> && std::ranges::input_range<T>);
 
 template <std::ranges::input_range R>
 struct range_iteration_context : immovable {
diff --git a/include/flux/core/sequence_iterator.hpp b/include/flux/core/sequence_iterator.hpp
index cb8f6d5b..0058e8db 100644
--- a/include/flux/core/sequence_iterator.hpp
+++ b/include/flux/core/sequence_iterator.hpp
@@ -6,6 +6,7 @@
 #define FLUX_CORE_SEQUENCE_ITERATOR_HPP_INCLUDED
 
 #include <flux/core/concepts.hpp>
+#include <flux/core/iterable_concepts.hpp>
 #include <flux/core/sequence_access.hpp>
 
 namespace flux {
@@ -28,6 +29,40 @@ consteval auto get_iterator_tag()
     }
 }
 
+/*
+ * As this type is not copyable or movable, it does not satsify the
+ * `std::input_iterator` requirements, and so cannot be used with
+ * standard algorithms.
+ *
+ * It is intended to be used with range-for loops, which do not
+ * need to copy or move the iterator.
+ */
+template <iterable It>
+struct pseudoiterator {
+private:
+    It* iterable_;
+    iteration_context_t<It> ctx_ = iterate(*iterable_);
+    using opt_t = decltype(next_element(ctx_));
+    opt_t next_ = next_element(ctx_);
+    using elem_t = iterable_element_t<It>;
+
+public:
+    constexpr pseudoiterator(It& iterable) : iterable_(std::addressof(iterable)) { }
+
+    constexpr auto operator*() -> elem_t { return static_cast<elem_t>(next_.value()); };
+
+    constexpr auto operator++() -> pseudoiterator&
+    {
+        next_ = next_element(ctx_);
+        return *this;
+    }
+
+    constexpr auto operator==(std::default_sentinel_t) const -> bool
+    {
+        return !static_cast<bool>(next_);
+    }
+};
+
 template <sequence S>
 struct sequence_iterator {
 private:
@@ -180,20 +215,28 @@ struct sequence_iterator {
 };
 
 struct begin_fn {
-    template <sequence S>
-    constexpr auto operator()(S& seq) const
+    template <iterable It>
+    constexpr auto operator()(It& it) const
     {
-        return sequence_iterator<S>(seq, flux::first(seq));
+        if constexpr (sequence<It>) {
+            return sequence_iterator<It>(it, flux::first(it));
+        } else {
+            return pseudoiterator<It>(it);
+        }
     }
 };
 
 struct end_fn {
-    template <sequence S>
-    constexpr auto operator()(S& seq) const
+    template <iterable It>
+    constexpr auto operator()(It& it) const
     {
         // Ranges requires sentinels to be copy-constructible
-        if constexpr (bounded_sequence<S> && std::copy_constructible<cursor_t<S>>) {
-            return sequence_iterator(seq, flux::last(seq));
+        if constexpr (bounded_sequence<It>) {
+            if constexpr (std::copy_constructible<cursor_t<It>>) {
+                return sequence_iterator(it, flux::last(it));
+            } else {
+                return std::default_sentinel;
+            }
         } else {
             return std::default_sentinel;
         }
@@ -207,28 +250,26 @@ FLUX_EXPORT inline constexpr auto end = detail::end_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::begin() &
-    requires sequence<D>
 {
     return flux::begin(derived());
 }
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::begin() const&
-    requires sequence<D const>
+    requires iterable<D const>
 {
     return flux::begin(derived());
 };
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::end() &
-    requires sequence<D>
 {
     return flux::end(derived());
 }
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::end() const&
-requires sequence<D const>
+    requires iterable<D const>
 {
     return flux::end(derived());
 };
diff --git a/test/test_generator.cpp b/test/test_generator.cpp
index 60760d98..c46b4067 100644
--- a/test/test_generator.cpp
+++ b/test/test_generator.cpp
@@ -38,10 +38,9 @@ auto fib(int a, int b) -> generator<int const&>
 
 auto pythagorean_triples() -> generator<std::tuple<int, int, int>>
 {
-    // TODO: Remove as_range from here when iterables can use range-for directly
-    for (int z : flux::as_range(ints(1))) {
-        for (int y : flux::as_range(ints(1, z))) {
-            for (int x : flux::as_range(ints(1, y))) {
+    for (int z : ints(1)) {
+        for (int y : ints(1, z)) {
+            for (int x : ints(1, y)) {
                 if (x*x + y*y == z*z) {
                     co_yield {x, y, z};
                 }

From 2e6719f08ece4699d6250f46003f3f04c57e7f50 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 15:04:31 +0100
Subject: [PATCH 55/66] Make unfold() iterable-only

---
 include/flux/adaptor/take.hpp    | 211 ++++++++++++++++---------------
 include/flux/sequence/unfold.hpp |  85 ++++++-------
 test/test_unfold.cpp             |  25 +---
 3 files changed, 148 insertions(+), 173 deletions(-)

diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index 2079b541..3f0820d7 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -19,6 +19,8 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
     Base base_;
     int_t count_;
 
+    friend struct sequence_traits<take_adaptor>;
+
 public:
     constexpr take_adaptor(decays_to<Base> auto&& base, int_t count)
         : base_(FLUX_FWD(base)),
@@ -68,142 +70,141 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>> {
     {
         return (cmp::min)(flux::iterable_size(base_), count_);
     }
+};
 
-    struct flux_sequence_traits {
-    private:
-        struct cursor_type {
-            cursor_t<Base> base_cur;
-            int_t length;
+struct take_fn {
+    template <adaptable_iterable It>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it, num::integral auto count) const
+    {
+        auto count_ = num::checked_cast<int_t>(count);
+        if (count_ < 0) {
+            runtime_error("Negative argument passed to take()");
+        }
 
-            friend bool operator==(cursor_type const&, cursor_type const&) = default;
-            friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs) = default;
-        };
+        return take_adaptor<std::decay_t<It>>(FLUX_FWD(it), count_);
+    }
+};
 
-    public:
-        using value_type = value_t<Base>;
+} // namespace detail
 
-        static constexpr auto first(auto& self) -> cursor_type
-        {
-            return cursor_type{.base_cur = flux::first(self.base_), .length = self.count_};
-        }
+template <sequence Base>
+struct sequence_traits<detail::take_adaptor<Base>> {
+private:
+    struct cursor_type {
+        cursor_t<Base> base_cur;
+        int_t length;
 
-        static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
-        {
-            return cur.length <= 0 || flux::is_last(self.base_, cur.base_cur);
-        }
+        friend bool operator==(cursor_type const&, cursor_type const&) = default;
+        friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs) = default;
+    };
 
-        static constexpr auto inc(auto& self, cursor_type& cur)
-        {
-            flux::inc(self.base_, cur.base_cur);
-            cur.length = num::sub(cur.length, int_t{1});
-        }
+public:
+    using value_type = value_t<Base>;
 
-        static constexpr auto read_at(auto& self, cursor_type const& cur)
-            -> decltype(flux::read_at(self.base_, cur.base_cur))
-        {
-            return flux::read_at(self.base_, cur.base_cur);
-        }
+    static constexpr auto first(auto& self) -> cursor_type
+    {
+        return cursor_type{.base_cur = flux::first(self.base_), .length = self.count_};
+    }
 
-        static constexpr auto move_at(auto& self, cursor_type const& cur)
-            -> decltype(flux::move_at(self.base_, cur.base_cur))
-        {
-            return flux::move_at(self.base_, cur.base_cur);
-        }
+    static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+    {
+        return cur.length <= 0 || flux::is_last(self.base_, cur.base_cur);
+    }
 
-        static constexpr auto read_at_unchecked(auto& self, cursor_type const& cur)
-            -> decltype(flux::read_at_unchecked(self.base_, cur.base_cur))
-        {
-            return flux::read_at_unchecked(self.base_, cur.base_cur);
-        }
+    static constexpr auto inc(auto& self, cursor_type& cur)
+    {
+        flux::inc(self.base_, cur.base_cur);
+        cur.length = num::sub(cur.length, int_t{1});
+    }
 
-        static constexpr auto move_at_unchecked(auto& self, cursor_type const& cur)
-            -> decltype(flux::move_at_unchecked(self.base_, cur.base_cur))
-        {
-            return flux::move_at_unchecked(self.base_, cur.base_cur);
-        }
+    static constexpr auto read_at(auto& self, cursor_type const& cur)
+        -> decltype(flux::read_at(self.base_, cur.base_cur))
+    {
+        return flux::read_at(self.base_, cur.base_cur);
+    }
 
-        static constexpr auto dec(auto& self, cursor_type& cur)
-            requires bidirectional_sequence<Base>
-        {
-            flux::dec(self.base_, cur.base_cur);
-            cur.length = num::add(cur.length, int_t{1});
-        }
+    static constexpr auto move_at(auto& self, cursor_type const& cur)
+        -> decltype(flux::move_at(self.base_, cur.base_cur))
+    {
+        return flux::move_at(self.base_, cur.base_cur);
+    }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, int_t offset)
-            requires random_access_sequence<Base>
-        {
-            flux::inc(self.base_, cur.base_cur, offset);
-            cur.length = num::sub(cur.length, offset);
-        }
+    static constexpr auto read_at_unchecked(auto& self, cursor_type const& cur)
+        -> decltype(flux::read_at_unchecked(self.base_, cur.base_cur))
+    {
+        return flux::read_at_unchecked(self.base_, cur.base_cur);
+    }
 
-        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> int_t
-            requires random_access_sequence<Base>
-        {
-            return (cmp::min)(flux::distance(self.base_, from.base_cur, to.base_cur),
-                              num::sub(from.length, to.length));
-        }
+    static constexpr auto move_at_unchecked(auto& self, cursor_type const& cur)
+        -> decltype(flux::move_at_unchecked(self.base_, cur.base_cur))
+    {
+        return flux::move_at_unchecked(self.base_, cur.base_cur);
+    }
 
-        static constexpr auto data(auto& self) -> decltype(flux::data(self.base_))
-            requires contiguous_sequence<Base>
-        {
-            return flux::data(self.base_);
-        }
+    static constexpr auto dec(auto& self, cursor_type& cur)
+        requires bidirectional_sequence<Base>
+    {
+        flux::dec(self.base_, cur.base_cur);
+        cur.length = num::add(cur.length, int_t{1});
+    }
 
-        static constexpr auto size(auto& self)
-            requires sized_sequence<Base> || infinite_sequence<Base>
-        {
-            if constexpr (infinite_sequence<Base>) {
-                return self.count_;
-            } else {
-                return (cmp::min)(flux::size(self.base_), self.count_);
-            }
-        }
+    static constexpr auto inc(auto& self, cursor_type& cur, int_t offset)
+        requires random_access_sequence<Base>
+    {
+        flux::inc(self.base_, cur.base_cur, offset);
+        cur.length = num::sub(cur.length, offset);
+    }
 
-        static constexpr auto last(auto& self) -> cursor_type
-            requires(random_access_sequence<Base> && sized_sequence<Base>)
-            || infinite_sequence<Base>
-        {
-            return cursor_type{.base_cur
-                               = flux::next(self.base_, flux::first(self.base_), size(self)),
-                               .length = 0};
-        }
+    static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
+        -> int_t
+        requires random_access_sequence<Base>
+    {
+        return (cmp::min)(flux::distance(self.base_, from.base_cur, to.base_cur),
+                          num::sub(from.length, to.length));
+    }
 
-        static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
-        {
-            int_t len = self.count_;
-            auto cur = flux::seq_for_each_while(self.base_, [&](auto&& elem) {
-                return (len-- > 0) && std::invoke(pred, FLUX_FWD(elem));
-            });
+    static constexpr auto data(auto& self) -> decltype(flux::data(self.base_))
+        requires contiguous_sequence<Base>
+    {
+        return flux::data(self.base_);
+    }
 
-            return cursor_type{.base_cur = std::move(cur), .length = ++len};
+    static constexpr auto size(auto& self)
+        requires sized_sequence<Base> || infinite_sequence<Base>
+    {
+        if constexpr (infinite_sequence<Base>) {
+            return self.count_;
+        } else {
+            return (cmp::min)(flux::size(self.base_), self.count_);
         }
-    };
-};
+    }
 
-struct take_fn {
-    template <adaptable_iterable It>
-    [[nodiscard]]
-    constexpr auto operator()(It&& it, num::integral auto count) const
+    static constexpr auto last(auto& self) -> cursor_type
+        requires(random_access_sequence<Base> && sized_sequence<Base>) || infinite_sequence<Base>
     {
-        auto count_ = num::checked_cast<int_t>(count);
-        if (count_ < 0) {
-            runtime_error("Negative argument passed to take()");
-        }
+        return cursor_type{.base_cur = flux::next(self.base_, flux::first(self.base_), size(self)),
+                           .length = 0};
+    }
 
-        return take_adaptor<std::decay_t<It>>(FLUX_FWD(it), count_);
+    static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
+    {
+        int_t len = self.count_;
+        auto cur = flux::seq_for_each_while(self.base_, [&](auto&& elem) {
+            return (len-- > 0) && std::invoke(pred, FLUX_FWD(elem));
+        });
+
+        return cursor_type{.base_cur = std::move(cur), .length = ++len};
     }
 };
 
-} // namespace detail
-
 FLUX_EXPORT inline constexpr auto take = detail::take_fn{};
 
 template <typename Derived>
 constexpr auto inline_sequence_base<Derived>::take(num::integral auto count) &&
 {
     return flux::take(std::move(derived()), count);
-}
+    }
 
 } // namespace flux
 
diff --git a/include/flux/sequence/unfold.hpp b/include/flux/sequence/unfold.hpp
index e9f80e39..f1616658 100644
--- a/include/flux/sequence/unfold.hpp
+++ b/include/flux/sequence/unfold.hpp
@@ -13,72 +13,63 @@ namespace flux {
 namespace detail {
 
 template <typename R, typename Func>
-struct unfold_sequence : inline_sequence_base<unfold_sequence<R, Func>> {
-private:
+struct unfold_iterable : inline_sequence_base<unfold_iterable<R, Func>> {
     R state_;
-    Func func_;
+    FLUX_NO_UNIQUE_ADDRESS Func func_;
 
-public:
-    template <typename T>
-        requires std::constructible_from<R, T>
-    constexpr explicit unfold_sequence(Func&& func, T&& seed)
-        : state_(FLUX_FWD(seed)),
-          func_(std::move(func))
-    {}
-
-    struct flux_sequence_traits : default_sequence_traits {
-    private:
-        struct cursor_type {
-            friend struct flux_sequence_traits;
-            cursor_type(cursor_type&&) = default;
-            cursor_type& operator=(cursor_type&&) = default;
-        private:
-            cursor_type() = default;
-        };
-
-        using self_t = unfold_sequence;
+    struct context_type : immovable {
+        using element_type = R const&;
 
-    public:
-        static constexpr bool is_infinite = true;
+        R* state_;
+        std::reference_wrapper<Func> func_;
+        bool inc_next_ = false;
 
-        static constexpr auto first(self_t&) -> cursor_type { return {}; }
-
-        static constexpr auto is_last(self_t&, cursor_type const&) -> bool { return false; }
-
-        static constexpr auto inc(self_t& self, cursor_type&) -> void
-        {
-            self.state_ = std::invoke(self.func_, std::move(self.state_));
-        }
-
-        static constexpr auto read_at(self_t& self, cursor_type const&) -> R const&
+        constexpr explicit context_type(unfold_iterable& self)
+            : state_(std::addressof(self.state_)),
+              func_(std::ref(self.func_))
         {
-            return self.state_;
         }
 
-        static constexpr auto for_each_while(self_t& self, auto&& pred) -> cursor_type
+        constexpr auto run_while(auto&& pred) -> iteration_result
         {
+            if (inc_next_) {
+                *state_ = std::invoke(func_, std::move(*state_));
+            }
             while (true) {
-                if (!std::invoke(pred, self.state_)) {
-                    break;
-                }
-                self.state_ = std::invoke(self.func_, std::move(self.state_));
+                if (!std::invoke(pred, *state_)) {
+                    inc_next_ = true;
+                    return iteration_result::incomplete;
+                };
+                *state_ = std::invoke(func_, std::move(*state_));
             }
-
-            return {};
         }
     };
+
+public:
+    template <typename T>
+        requires std::constructible_from<R, T>
+    constexpr unfold_iterable(Func&& func, T&& seed)
+        : state_(FLUX_FWD(seed)),
+          func_(std::move(func))
+    {
+    }
+
+    [[nodiscard]]
+    constexpr auto iterate()
+    {
+        return context_type{*this};
+    }
 };
 
 struct unfold_fn {
     template <typename Func, typename Seed,
               typename R = std::decay_t<std::invoke_result_t<Func&, Seed>>>
-        requires std::constructible_from<R, Seed> &&
-                 std::invocable<Func&, R> &&
-                 std::assignable_from<R&, std::invoke_result_t<Func&, R>>
+        requires std::constructible_from<R, Seed> && std::invocable<Func&, R>
+        && std::assignable_from<R&, std::invoke_result_t<Func&, R>>
     [[nodiscard]]
-    constexpr auto operator()(Func func, Seed&& seed) const -> sequence auto
+    constexpr auto operator()(Func func, Seed&& seed) const -> iterable auto
     {
-        return unfold_sequence<R, Func>(std::move(func), FLUX_FWD(seed));
+        return unfold_iterable<R, Func>(std::move(func), FLUX_FWD(seed));
     }
 };
 
diff --git a/test/test_unfold.cpp b/test/test_unfold.cpp
index afb353fb..59a94e7a 100644
--- a/test/test_unfold.cpp
+++ b/test/test_unfold.cpp
@@ -17,28 +17,13 @@ constexpr bool test_unfold()
         auto seq = flux::unfold([](int i) { return ++i; }, 0);
 
         using S = decltype(seq);
-        static_assert(flux::sequence<S>);
+        static_assert(flux::iterable<S>);
         static_assert(not flux::multipass_sequence<S>);
-        static_assert(flux::infinite_sequence<S>);
         static_assert(not flux::sized_sequence<S>);
 
         STATIC_CHECK(check_equal(flux::take(seq, 10), flux::ints().take(10)));
     }
 
-    // unfold -> take is a finite sequence
-    {
-        auto seq = flux::unfold([](int i) { return ++i; }, 0).take(10);
-
-        using S = decltype(seq);
-        static_assert(flux::sequence<S>);
-        static_assert(not flux::multipass_sequence<S>);
-        static_assert(not flux::infinite_sequence<S>);
-        static_assert(flux::sized_sequence<S>);
-
-        STATIC_CHECK(flux::size(seq) == 10);
-        STATIC_CHECK(check_equal(seq, flux::ints().take(10)));
-    }
-
     // unfold can be used to implement repeat()
     {
         auto repeat = flux::unfold(std::identity{}, std::string_view("hello"));
@@ -57,13 +42,11 @@ constexpr bool test_unfold()
 
     // internal iteration works as expected
     {
-        auto seq = flux::unfold([](int i) { return ++i; }, 0);
+        auto seq = flux::unfold([](int i) { return ++i; }, 1);
 
-        auto cur = seq.find(5);
+        auto sum = flux::take(seq, 5).sum();
 
-        STATIC_CHECK(seq[cur] == 5);
-        seq.inc(cur);
-        STATIC_CHECK(seq[cur] == 6);
+        STATIC_CHECK(sum == 15);
     }
 
     return true;

From c9f3fa22491f1f94cc2eccf4e880c0eb57223fd4 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 16:17:59 +0100
Subject: [PATCH 56/66] Remove from_range() and from_crange()

Instead, use flux::ref(), flux::mut_ref() or flux::from().

Under the new model, all ranges are at least iterable. Sized, random-access ranges will also become collections. However, the new collection requirements will mean that we will no longer be able to treat non-RA ranges as collections (even if we were willing to do so unsafely).
---
 include/flux/adaptor/reverse.hpp           | 219 ++++----
 include/flux/core/as_range.hpp             |   2 +-
 include/flux/core/inline_sequence_base.hpp |   2 +-
 include/flux/core/ref.hpp                  |   2 +-
 include/flux/sequence.hpp                  |   1 -
 include/flux/sequence/range.hpp            | 243 ---------
 test/CMakeLists.txt                        |   1 -
 test/test_bitset.cpp                       |  13 -
 test/test_chunk.cpp                        |  16 -
 test/test_drop.cpp                         |   4 +-
 test/test_from_range.cpp                   | 606 ---------------------
 test/test_range_iface.cpp                  |  21 +-
 test/test_sort.cpp                         |   7 +-
 test/test_stride.cpp                       |  15 -
 test/test_take.cpp                         |   4 +-
 test/test_to.cpp                           |  12 +-
 test/test_unchecked.cpp                    |   2 +-
 17 files changed, 139 insertions(+), 1031 deletions(-)
 delete mode 100644 include/flux/sequence/range.hpp
 delete mode 100644 test/test_from_range.cpp

diff --git a/include/flux/adaptor/reverse.hpp b/include/flux/adaptor/reverse.hpp
index 528db747..d5441f4c 100644
--- a/include/flux/adaptor/reverse.hpp
+++ b/include/flux/adaptor/reverse.hpp
@@ -17,10 +17,10 @@ struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
 
+    friend struct sequence_traits<reverse_adaptor>;
+
 public:
-    constexpr explicit reverse_adaptor(decays_to<Base> auto&& base)
-        : base_(FLUX_FWD(base))
-    {}
+    constexpr explicit reverse_adaptor(decays_to<Base> auto&& base) : base_(FLUX_FWD(base)) { }
 
     [[nodiscard]] constexpr auto base() const& -> Base const& { return base_; }
     [[nodiscard]] constexpr auto base() && -> Base&& { return std::move(base_); }
@@ -44,144 +44,145 @@ struct reverse_adaptor : inline_sequence_base<reverse_adaptor<Base>> {
             return flux::iterable_size(self.base_);
         }
     };
+};
 
-    struct flux_sequence_traits {
-    private:
-        struct cursor_type {
-            cursor_t<Base> base_cur;
+template <typename>
+inline constexpr bool is_reverse_adaptor = false;
 
-            friend bool operator==(cursor_type const&, cursor_type const&)
-                requires std::equality_comparable<cursor_t<Base>>
-            = default;
+template <typename Base>
+inline constexpr bool is_reverse_adaptor<reverse_adaptor<Base>> = true;
 
-            friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs)
-                -> std::strong_ordering
-                requires std::three_way_comparable<cursor_t<Base>, std::strong_ordering>
-            {
-                return rhs.base_cur <=> lhs.base_cur;
-            }
-        };
+struct reverse_fn {
+    template <adaptable_iterable It>
+        requires reverse_iterable<It>
+    [[nodiscard]]
+    constexpr auto operator()(It&& it) const -> reverse_iterable auto
+    {
+        if constexpr (is_reverse_adaptor<std::decay_t<It>>) {
+            return FLUX_FWD(it).base();
+        } else {
+            return reverse_adaptor<std::decay_t<It>>(FLUX_FWD(it));
+        }
+    }
+};
 
-    public:
-        using value_type = value_t<Base>;
+} // namespace detail
 
-        static constexpr auto first(auto& self) -> cursor_type
-        {
-            return cursor_type(flux::last(self.base_));
-        }
+template <sequence Base>
+struct sequence_traits<detail::reverse_adaptor<Base>> : default_sequence_traits {
+private:
+    struct cursor_type {
+        cursor_t<Base> base_cur;
 
-        static constexpr auto last(auto& self) -> cursor_type
-        {
-            return cursor_type(flux::first(self.base_));
-        }
+        friend bool operator==(cursor_type const&, cursor_type const&)
+            requires std::equality_comparable<cursor_t<Base>>
+        = default;
 
-        static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+        friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs)
+            -> std::strong_ordering
+            requires std::three_way_comparable<cursor_t<Base>, std::strong_ordering>
         {
-            return cur.base_cur == flux::first(self.base_);
+            return rhs.base_cur <=> lhs.base_cur;
         }
+    };
 
-        template <typename Self>
-        static constexpr auto read_at(Self& self, cursor_type const& cur)
-            -> element_t<decltype((self.base_))>
-        {
-            return flux::read_at(self.base_, flux::prev(self.base_, cur.base_cur));
-        }
+public:
+    using value_type = value_t<Base>;
 
-        template <typename Self>
-        static constexpr auto read_at_unchecked(Self& self, cursor_type const& cur)
-            -> element_t<decltype((self.base_))>
-        {
-            return flux::read_at_unchecked(self.base_, flux::prev(self.base_, cur.base_cur));
-        }
+    static constexpr auto first(auto& self) -> cursor_type
+    {
+        return cursor_type(flux::last(self.base_));
+    }
 
-        template <typename Self>
-        static constexpr auto move_at(Self& self, cursor_type const& cur)
-            -> rvalue_element_t<decltype((self.base_))>
-        {
-            return flux::move_at(self.base_, flux::prev(self.base_, cur.base_cur));
-        }
+    static constexpr auto last(auto& self) -> cursor_type
+    {
+        return cursor_type(flux::first(self.base_));
+    }
 
-        template <typename Self>
-        static constexpr auto move_at_unchecked(Self& self, cursor_type const& cur)
-            -> rvalue_element_t<decltype((self.base_))>
-        {
-            return flux::move_at_unchecked(self.base_, flux::prev(self.base_, cur.base_cur));
-        }
+    static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+    {
+        return cur.base_cur == flux::first(self.base_);
+    }
 
-        static constexpr auto inc(auto& self, cursor_type& cur) -> void
-        {
-            flux::dec(self.base_, cur.base_cur);
-        }
+    template <typename Self>
+    static constexpr auto read_at(Self& self, cursor_type const& cur)
+        -> element_t<decltype((self.base_))>
+    {
+        return flux::read_at(self.base_, flux::prev(self.base_, cur.base_cur));
+    }
 
-        static constexpr auto dec(auto& self, cursor_type& cur) -> void
-        {
-            flux::inc(self.base_, cur.base_cur);
-        }
+    template <typename Self>
+    static constexpr auto read_at_unchecked(Self& self, cursor_type const& cur)
+        -> element_t<decltype((self.base_))>
+    {
+        return flux::read_at_unchecked(self.base_, flux::prev(self.base_, cur.base_cur));
+    }
 
-        static constexpr auto inc(auto& self, cursor_type& cur, int_t dist) -> void
-        {
-            flux::inc(self.base_, cur.base_cur, num::neg(dist));
-        }
+    template <typename Self>
+    static constexpr auto move_at(Self& self, cursor_type const& cur)
+        -> rvalue_element_t<decltype((self.base_))>
+    {
+        return flux::move_at(self.base_, flux::prev(self.base_, cur.base_cur));
+    }
 
-        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> int_t
-        {
-            return flux::distance(self.base_, to.base_cur, from.base_cur);
-        }
+    template <typename Self>
+    static constexpr auto move_at_unchecked(Self& self, cursor_type const& cur)
+        -> rvalue_element_t<decltype((self.base_))>
+    {
+        return flux::move_at_unchecked(self.base_, flux::prev(self.base_, cur.base_cur));
+    }
 
-        static constexpr auto size(auto& self) -> int_t
-            requires sized_sequence<decltype((self.base_))>
-        {
-            return flux::size(self.base_);
-        }
+    static constexpr auto inc(auto& self, cursor_type& cur) -> void
+    {
+        flux::dec(self.base_, cur.base_cur);
+    }
 
-        static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
-            requires bidirectional_sequence<decltype((self.base_))> &&
-                     bounded_sequence<decltype((self.base_))>
-        {
-            auto cur = flux::last(self.base_);
-            const auto end = flux::first(self.base_);
-
-            while (cur != end) {
-                flux::dec(self.base_, cur);
-                if (!std::invoke(pred, flux::read_at(self.base_, cur))) {
-                    flux::inc(self.base_, cur);
-                    break;
-                }
-            }
+    static constexpr auto dec(auto& self, cursor_type& cur) -> void
+    {
+        flux::inc(self.base_, cur.base_cur);
+    }
 
-            return cursor_type(cur);
-        }
-    };
-};
+    static constexpr auto inc(auto& self, cursor_type& cur, int_t dist) -> void
+    {
+        flux::inc(self.base_, cur.base_cur, num::neg(dist));
+    }
 
-template <typename>
-inline constexpr bool is_reverse_adaptor = false;
+    static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
+        -> int_t
+    {
+        return flux::distance(self.base_, to.base_cur, from.base_cur);
+    }
 
-template <typename Base>
-inline constexpr bool is_reverse_adaptor<reverse_adaptor<Base>> = true;
+    static constexpr auto size(auto& self) -> int_t
+        requires sized_sequence<decltype((self.base_))>
+    {
+        return flux::size(self.base_);
+    }
 
-struct reverse_fn {
-    template <adaptable_iterable It>
-        requires reverse_iterable<It>
-    [[nodiscard]]
-    constexpr auto operator()(It&& it) const -> reverse_iterable auto
+    static constexpr auto for_each_while(auto& self, auto&& pred) -> cursor_type
+        requires bidirectional_sequence<decltype((self.base_))>
+        && bounded_sequence<decltype((self.base_))>
     {
-        if constexpr (is_reverse_adaptor<std::decay_t<It>>) {
-            return FLUX_FWD(it).base();
-        } else {
-            return reverse_adaptor<std::decay_t<It>>(FLUX_FWD(it));
+        auto cur = flux::last(self.base_);
+        const auto end = flux::first(self.base_);
+
+        while (cur != end) {
+            flux::dec(self.base_, cur);
+            if (!std::invoke(pred, flux::read_at(self.base_, cur))) {
+                flux::inc(self.base_, cur);
+                break;
+            }
         }
+
+        return cursor_type(cur);
     }
 };
 
-} // namespace detail
-
 FLUX_EXPORT inline constexpr auto reverse = detail::reverse_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::reverse() &&
-    requires bidirectional_sequence<D> && bounded_sequence<D>
+    requires reverse_iterable<D>
 {
     return flux::reverse(std::move(derived()));
 }
diff --git a/include/flux/core/as_range.hpp b/include/flux/core/as_range.hpp
index 59e41144..1d3cb368 100644
--- a/include/flux/core/as_range.hpp
+++ b/include/flux/core/as_range.hpp
@@ -32,7 +32,7 @@ struct iterable_range : std::ranges::view_interface<iterable_range<It>> {
 
         iterator() = default;
 
-        explicit iterator(iterable_range& parent) : parent_(std::addressof(parent)) { }
+        constexpr explicit iterator(iterable_range& parent) : parent_(std::addressof(parent)) { }
 
         iterator(iterator&&) = default;
         iterator& operator=(iterator&&) = default;
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index 5d98d1ab..4d2d69c3 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -338,7 +338,7 @@ struct inline_sequence_base {
 
     [[nodiscard]]
     constexpr auto reverse() &&
-            requires bidirectional_sequence<Derived> && bounded_sequence<Derived>;
+        requires reverse_iterable<Derived>;
 
     template <typename D = Derived, typename Func, typename Init = iterable_value_t<D>>
         requires foldable<Derived, Func, Init>
diff --git a/include/flux/core/ref.hpp b/include/flux/core/ref.hpp
index b7e9ceb8..9c95b257 100644
--- a/include/flux/core/ref.hpp
+++ b/include/flux/core/ref.hpp
@@ -152,7 +152,7 @@ struct ref_adaptor : inline_sequence_base<ref_adaptor<Base>> {
     }
 
     struct flux_sequence_traits : passthrough_traits_base {
-        using value_type = value_t<Base>;
+        using value_type = iterable_value_t<Base>;
     };
 };
 
diff --git a/include/flux/sequence.hpp b/include/flux/sequence.hpp
index 14e13a65..347580de 100644
--- a/include/flux/sequence.hpp
+++ b/include/flux/sequence.hpp
@@ -14,7 +14,6 @@
 #include <flux/sequence/iota.hpp>
 #include <flux/sequence/istream.hpp>
 #include <flux/sequence/istreambuf.hpp>
-#include <flux/sequence/range.hpp>
 #include <flux/sequence/repeat.hpp>
 #include <flux/sequence/single.hpp>
 #include <flux/sequence/unfold.hpp>
diff --git a/include/flux/sequence/range.hpp b/include/flux/sequence/range.hpp
deleted file mode 100644
index a3d4d699..00000000
--- a/include/flux/sequence/range.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-
-// Copyright (c) 2023 Tristan Brindle (tcbrindle at gmail dot com)
-// 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 FLUX_SEQUENCE_RANGE_HPP_INCLUDED
-#define FLUX_SEQUENCE_RANGE_HPP_INCLUDED
-
-#include <flux/core/concepts.hpp>
-
-#include <ranges>
-
-namespace flux {
-
-namespace detail {
-
-template <typename R>
-concept can_const_iterate =
-    std::ranges::input_range<R> && std::ranges::input_range<R const> &&
-    std::same_as<std::ranges::iterator_t<R>, std::ranges::iterator_t<R const>>;
-
-template <typename R, bool IsConst>
-struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
-private:
-    R rng_;
-
-    using V = std::conditional_t<IsConst, R const, R>;
-
-public:
-    struct flux_sequence_traits : default_sequence_traits {
-    private:
-        class cursor_type {
-
-            std::ranges::iterator_t<V> iter;
-
-            friend struct flux_sequence_traits;
-
-            constexpr explicit cursor_type(std::ranges::iterator_t<V> iter) : iter(std::move(iter)) {}
-        public:
-            cursor_type() = default;
-            cursor_type(cursor_type&&) = default;
-            cursor_type& operator=(cursor_type&&) = default;
-            cursor_type(cursor_type const&) requires std::ranges::forward_range<V>
-                = default;
-            cursor_type& operator=(cursor_type const&) requires std::ranges::forward_range<V>
-                = default;
-
-            friend auto operator==(cursor_type const&, cursor_type const&) -> bool = default;
-
-            friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs)
-                -> std::strong_ordering
-                = default;
-
-        };
-
-    public:
-        using value_type = std::ranges::range_value_t<R>;
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto first(Self& self) -> cursor_type
-        {
-            if constexpr (IsConst) {
-                return cursor_type{std::ranges::cbegin(self.rng_)};
-            } else {
-                return cursor_type{std::ranges::begin(self.rng_)};
-            }
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto is_last(Self& self, cursor_type const& cur) -> bool
-        {
-            if constexpr (IsConst) {
-                return cur.iter == std::ranges::cend(self.rng_);
-            } else {
-                return cur.iter == std::ranges::end(self.rng_);
-            }
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto inc(Self& self, cursor_type& cur)
-        {
-            bounds_check(!is_last(self, cur));
-            ++cur.iter;
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto read_at(Self& self, cursor_type const& cur) -> decltype(auto)
-        {
-            bounds_check(!is_last(self, cur));
-            return *cur.iter;
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto move_at(Self& self, cursor_type const& cur) -> decltype(auto)
-        {
-            bounds_check(!is_last(self, cur));
-            return std::ranges::iter_move(cur.iter);
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto dec(Self& self, cursor_type& cur)
-            requires std::ranges::bidirectional_range<R>
-        {
-            bounds_check(cur != first(self));
-            --cur.iter;
-        }
-
-        template <typename Self>
-            requires(!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto inc(Self& self, cursor_type& cur, int_t offset)
-            requires std::ranges::random_access_range<R>
-        {
-            if (offset < 0) {
-                bounds_check(num::add(offset, distance(self, first(self), cur)) >= 0);
-            } else if (offset > 0) {
-                bounds_check(offset <= distance(self, cur, last(self)));
-            }
-
-            cur.iter += num::cast<std::ranges::range_difference_t<V>>(offset);
-        }
-
-        template <typename Self>
-            requires(!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto distance(Self&, cursor_type const& from, cursor_type const& to)
-            -> int_t
-            requires std::ranges::random_access_range<R>
-        {
-            return num::cast<int_t>(std::ranges::distance(from.iter, to.iter));
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto data(Self& self)
-            requires std::ranges::contiguous_range<R>
-        {
-            if constexpr (IsConst) {
-                return std::ranges::cdata(self.rng_);
-            } else {
-                return std::ranges::data(self.rng_);
-            }
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto last(Self& self) -> cursor_type
-            requires std::ranges::common_range<R>
-        {
-            return cursor_type{std::ranges::end(self.rng_)};
-        }
-
-        template <typename Self>
-            requires(!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto size(Self& self) -> int_t
-            requires std::ranges::sized_range<R>
-        {
-            return num::cast<int_t>(std::ranges::ssize(self.rng_));
-        }
-
-        template <typename Self>
-            requires (!std::is_const_v<Self> || can_const_iterate<V>)
-        static constexpr auto for_each_while(Self& self, auto&& pred) -> cursor_type
-        {
-            auto iter = std::ranges::begin(self.rng_);
-            auto const end = std::ranges::end(self.rng_);
-
-            while (iter != end) {
-                if (!std::invoke(pred, *iter)) {
-                    break;
-                }
-                ++iter;
-            }
-            return cursor_type{std::move(iter)};
-        }
-    };
-
-    constexpr explicit range_sequence(R rng) : rng_(std::move(rng)) {}
-
-    constexpr auto begin()
-    {
-        if constexpr (IsConst) {
-            return std::ranges::cbegin(rng_);
-        } else {
-            return std::ranges::begin(rng_);
-        }
-    }
-
-    constexpr auto begin() const requires std::ranges::range<R const>
-    {
-        return std::ranges::begin(rng_);
-    }
-
-    constexpr auto end()
-    {
-        if constexpr (IsConst) {
-            return std::ranges::cend(rng_);
-        } else {
-            return std::ranges::end(rng_);
-        }
-    }
-
-    constexpr auto end() const requires std::ranges::range<R const>
-    {
-        return std::ranges::end(rng_);
-    }
-};
-
-struct from_range_fn {
-    template <std::ranges::viewable_range R>
-    requires std::ranges::input_range<R>
-    constexpr auto operator()(R&& rng) const
-    {
-        return range_sequence<std::views::all_t<R>, false>(std::views::all(FLUX_FWD(rng)));
-    }
-};
-
-struct from_crange_fn {
-    template <typename R, typename C = std::remove_reference_t<R> const&>
-        requires std::ranges::input_range<C> &&
-                 std::ranges::viewable_range<C>
-    constexpr auto operator()(R&& rng) const
-    {
-        if constexpr (std::is_lvalue_reference_v<R>) {
-            return range_sequence<std::views::all_t<C>, true>(std::views::all(static_cast<C>(rng)));
-        } else {
-            return range_sequence<std::views::all_t<R>, true>(std::views::all(FLUX_FWD(rng)));
-        }
-    }
-};
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto from_range = detail::from_range_fn{};
-FLUX_EXPORT inline constexpr auto from_crange = detail::from_crange_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_RANGE_HPP_INCLUDED
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3d1a6853..905ca946 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -88,7 +88,6 @@ add_executable(test-flux
     test_array_ptr.cpp
     test_bitset.cpp
     test_empty.cpp
-    test_from_range.cpp
     test_getlines.cpp
     test_iota.cpp
     test_istream.cpp
diff --git a/test/test_bitset.cpp b/test/test_bitset.cpp
index 44023946..00587443 100644
--- a/test/test_bitset.cpp
+++ b/test/test_bitset.cpp
@@ -72,19 +72,6 @@ TEST_CASE("bitset")
         REQUIRE(check_equal(seq2, {false, true}));
     }
 
-    // Swapping bits with another proxy reference type
-    {
-        auto seq1 = flux::from(std::bitset<2>{0b00});
-        auto vec = std::vector<bool>{true, true};
-        auto seq2 = flux::from_range(vec);
-
-        flux::swap_with(seq1, flux::first(seq1),
-                       seq2, flux::first(seq2));
-
-        REQUIRE(seq1.base() == std::bitset<2>{0b01});
-        REQUIRE(check_equal(seq2, {false, true}));
-    }
-
     // FIXME: GCC 14
 #if 0
     // swap_elements between two bitsets
diff --git a/test/test_chunk.cpp b/test/test_chunk.cpp
index d36f2977..2dfb707c 100644
--- a/test/test_chunk.cpp
+++ b/test/test_chunk.cpp
@@ -529,20 +529,4 @@ TEST_CASE("chunk")
 
         REQUIRE(out.str() == "[[1, 2], [3, 4], [5]]");
     }
-
-    SUBCASE("...with bidir only sequence")
-    {
-        std::list<int> list{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-
-        auto seq = flux::from_range(list).chunk(3).reverse();
-
-        auto cur = seq.first();
-        REQUIRE(check_equal(seq[cur], {10}));
-        REQUIRE(check_equal(seq[seq.inc(cur)], {7, 8, 9}));
-        REQUIRE(check_equal(seq[seq.inc(cur)], {4, 5, 6}));
-        REQUIRE(check_equal(seq[seq.inc(cur)], {1, 2, 3}));
-
-        REQUIRE(seq.is_last(seq.inc(cur)));
-        REQUIRE(cur == seq.last());
-    }
 }
\ No newline at end of file
diff --git a/test/test_drop.cpp b/test/test_drop.cpp
index c55b9a0b..12ad805e 100644
--- a/test/test_drop.cpp
+++ b/test/test_drop.cpp
@@ -224,9 +224,9 @@ TEST_CASE("drop")
     {
         std::list list{1, 2, 3, 4, 5};
 
-        REQUIRE_THROWS_AS(flux::drop(flux::from_range(list), -1), flux::unrecoverable_error);
+        REQUIRE_THROWS_AS(flux::drop(flux::ref(list), -1), flux::unrecoverable_error);
 
-        REQUIRE_THROWS_AS(flux::from_range(list).drop(-1000), flux::unrecoverable_error);
+        REQUIRE_THROWS_AS(flux::ref(list).drop(-1000), flux::unrecoverable_error);
     }
 
     issue_132b();
diff --git a/test/test_from_range.cpp b/test/test_from_range.cpp
deleted file mode 100644
index fa1698fe..00000000
--- a/test/test_from_range.cpp
+++ /dev/null
@@ -1,606 +0,0 @@
-
-// Copyright (c) 2023 Tristan Brindle (tcbrindle at gmail dot com)
-// 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)
-
-#include <array>
-#include <forward_list>
-#include <list>
-#include <map>
-#include <ranges>
-#include <sstream>
-#include <utility>
-#include <vector>
-
-#include "test_utils.hpp"
-
-#if defined(_GLIBCXX_RELEASE)
-#  if _GLIBCXX_RELEASE < 12
-#    define RVALUE_VIEWS_NOT_SUPPORTED
-#  endif
-#endif
-
-namespace {
-
-constexpr bool test_from_range()
-{
-    {
-        std::array<int, 4> arr{10, 2, 3, 4};
-
-        auto seq = flux::from_range(flux::ref(arr));
-
-        using S = decltype(seq);
-
-        static_assert(flux::sequence<S>);
-        static_assert(flux::multipass_sequence<S>);
-        static_assert(flux::bidirectional_sequence<S>);
-        static_assert(flux::random_access_sequence<S>);
-        static_assert(flux::contiguous_sequence<S>);
-        static_assert(flux::sized_sequence<S>);
-        static_assert(flux::bounded_sequence<S>);
-
-        STATIC_CHECK(flux::read_at(seq, flux::first(seq)) == 10);
-        STATIC_CHECK(flux::move_at(seq, flux::prev(seq, flux::last(seq))) == 4);
-        STATIC_CHECK(flux::usize(seq) == arr.size());
-        STATIC_CHECK(flux::data(seq)[0] == 10);
-    }
-
-    return true;
-}
-static_assert(test_from_range());
-
-// https://github.com/tcbrindle/flux/issues/244
-constexpr bool issue_244()
-{
-    std::string_view str("abcdefghijklmnopqrstuvwxyz");
-
-    auto chunks = flux::from_range(str).chunk(3);
-
-    std::string out;
-
-    flux::for_each(chunks, [&out](auto c) { flux::for_each(c, [&out](char n) { out += n; }); });
-
-    return out == str;
-}
-static_assert(issue_244());
-}
-
-TEST_CASE("from range")
-{
-    REQUIRE(test_from_range());
-    REQUIRE(issue_244());
-
-    SUBCASE("bounds checking") {
-        std::vector<int> vec{0, 1, 2, 3, 4};
-
-        auto seq = flux::from_range(vec);
-
-        SUBCASE("Can read in-bounds")
-        {
-            auto cur = seq.first();
-            REQUIRE(seq[cur] == 0);
-            REQUIRE(seq.move_at(cur) == 0);
-        }
-
-        SUBCASE("Can advance within bounds")
-        {
-            auto cur = seq.first();
-            for (; !seq.is_last(cur); seq.inc(cur)) {}
-            REQUIRE(seq.is_last(cur));
-        }
-
-        SUBCASE("Reading past the end is an error")
-        {
-            auto cur = seq.last();
-            REQUIRE_THROWS_AS(seq[cur], flux::unrecoverable_error);
-            REQUIRE_THROWS_AS(seq.move_at(cur), flux::unrecoverable_error);
-        }
-
-        SUBCASE("Advancing past the end is an error")
-        {
-            auto cur = seq.last();
-            REQUIRE_THROWS_AS(seq.next(cur), flux::unrecoverable_error);
-        }
-
-        SUBCASE("Can decrement within bounds")
-        {
-            auto cur = seq.last();
-            while(seq.dec(cur) != seq.first()) {}
-            REQUIRE(cur == seq.first());
-        }
-
-        SUBCASE("Decrementing before the start is an error")
-        {
-            auto cur = seq.first();
-            REQUIRE_THROWS_AS(seq.dec(cur), flux::unrecoverable_error);
-        }
-
-        SUBCASE("Random-access movements are bounds-checked")
-        {
-            auto cur = seq.first();
-            REQUIRE_THROWS_AS(seq.inc(cur, 100), flux::unrecoverable_error);
-
-            REQUIRE_THROWS_AS(seq.inc(cur, -200), flux::unrecoverable_error);
-        }
-    }
-
-    SUBCASE("...with std::list...") {
-        std::list<int> list{1, 2, 3, 4, 5};
-
-        SUBCASE("non-const argument, non-const seq, non-const from_range")
-        {
-            auto seq = flux::from_range(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("non-const argument, const seq, non-const from_range")
-        {
-            auto const seq = flux::from_range(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, non-const seq, non-const from_range")
-        {
-            auto seq = flux::from_range(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, const seq, non-const from_range")
-        {
-            auto const seq = flux::from_range(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-#ifndef RVALUE_VIEWS_NOT_SUPPORTED
-        SUBCASE("prvalue argument, non-const seq, non-const from_range")
-        {
-            auto seq = flux::from_range(flux::copy(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-            static_assert(not flux::sequence<S const>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-#endif
-
-        SUBCASE("non-const argument, non-const seq, from_crange")
-        {
-            auto seq = flux::from_crange(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("non-const argument, const seq, from_crange")
-        {
-            auto const seq = flux::from_crange(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, non-const seq, from_crange")
-        {
-            auto seq = flux::from_crange(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, const seq, from_crange")
-        {
-            auto const seq = flux::from_crange(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-#ifndef RVALUE_VIEWS_NOT_SUPPORTED
-        SUBCASE("prvalue argument, non-const seq, from_crange")
-        {
-            auto seq = flux::from_crange(flux::copy(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("prvalue argument, const seq, from_crange")
-        {
-            auto const seq = flux::from_crange(flux::copy(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-#endif
-    }
-
-    SUBCASE("...with std::forward_list...") {
-        std::forward_list<int> list{1, 2, 3, 4, 5};
-
-        SUBCASE("non-const argument, non-const seq, non-const from_range")
-        {
-            auto seq = flux::from_range(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("non-const argument, const seq, non-const from_range")
-        {
-            auto const seq = flux::from_range(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, non-const seq, non-const from_range")
-        {
-            auto seq = flux::from_range(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, const seq, non-const from_range")
-        {
-            auto const seq = flux::from_range(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-#ifndef RVALUE_VIEWS_NOT_SUPPORTED
-        SUBCASE("prvalue argument, non-const seq, non-const from_range")
-        {
-            auto seq = flux::from_range(flux::copy(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-            static_assert(not flux::sequence<S const>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-#endif
-
-        SUBCASE("non-const argument, non-const seq, from_crange")
-        {
-            auto seq = flux::from_crange(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("non-const argument, const seq, from_crange")
-        {
-            auto const seq = flux::from_crange(list);
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, non-const seq, from_crange")
-        {
-            auto seq = flux::from_crange(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("const argument, const seq, from_crange")
-        {
-            auto const seq = flux::from_crange(std::as_const(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-#ifndef RVALUE_VIEWS_NOT_SUPPORTED
-        SUBCASE("prvalue argument, non-const seq, from_crange")
-        {
-            auto seq = flux::from_crange(flux::copy(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-
-        SUBCASE("prvalue argument, const seq, from_crange")
-        {
-            auto const seq = flux::from_crange(flux::copy(list));
-
-            using S = decltype(seq);
-            static_assert(flux::sequence<S>);
-            static_assert(flux::multipass_sequence<S>);
-            static_assert(not flux::bidirectional_sequence<S>);
-            static_assert(not flux::random_access_sequence<S>);
-            static_assert(not flux::contiguous_sequence<S>);
-            static_assert(flux::bounded_sequence<S>);
-            static_assert(not flux::sized_sequence<S>);
-
-            static_assert(std::same_as<flux::value_t<S>, int>);
-            static_assert(std::same_as<flux::element_t<S>, int const&>);
-            static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-
-            REQUIRE(check_equal(seq, {1, 2, 3, 4, 5}));
-        }
-#endif
-    }
-
-    SUBCASE("with input range") {
-
-        std::istringstream iss("1 2 3 4 5");
-        auto view = std::ranges::basic_istream_view<int, char>(iss);
-
-        auto seq = flux::from_range(view);
-
-        using S = decltype(seq);
-
-        static_assert(flux::sequence<S>);
-        static_assert(not flux::multipass_sequence<S>);
-        static_assert(not flux::sized_sequence<S>);
-        static_assert(not flux::bounded_sequence<S>);
-
-        static_assert(not flux::sequence<S const>);
-
-        static_assert(not std::copyable<flux::cursor_t<S>>);
-    }
-
-}
\ No newline at end of file
diff --git a/test/test_range_iface.cpp b/test/test_range_iface.cpp
index 78e30f31..ba533a6b 100644
--- a/test/test_range_iface.cpp
+++ b/test/test_range_iface.cpp
@@ -116,21 +116,20 @@ constexpr bool test_range_iface()
         STATIC_CHECK(rng::equal(seq, arr));
     }
 
-
-    // Range -> Sequence -> View -> Sequence -> View (!)
     {
-        auto arr = std::array{1, 2, 3, 4, 5};
-        auto view1 = arr | std::views::filter([](int i) { return i % 2 == 0; });
-        auto seq = flux::from_range(view1);
-        auto view2 = seq | std::views::transform([](int i) { return i * 2; });
-        auto view3 = flux::from_range(std::move(view2));
+        auto iter = iterable_only(std::array{1, 2, 3, 4, 5});
 
-        using V = decltype(view3);
+        auto r = flux::as_range(iter);
 
-        static_assert(rng::view<V>);
-        static_assert(rng::bidirectional_range<V>);
+        using R = decltype(r);
+        static_assert(rng::input_range<R>);
+        static_assert(not rng::forward_range<R>);
+        static_assert(std::same_as<rng::range_reference_t<R>, int&>);
+        static_assert(std::same_as<rng::range_value_t<R>, int>);
+        static_assert(std::same_as<rng::range_rvalue_reference_t<R>, int&&>);
+        static_assert(std::same_as<rng::range_difference_t<R>, flux::int_t>);
 
-        STATIC_CHECK(rng::equal(view3, std::array{4, 8}));
+        STATIC_CHECK(rng::equal(r, std::array{1, 2, 3, 4, 5}));
     }
 
     return true;
diff --git a/test/test_sort.cpp b/test/test_sort.cpp
index 0e8d70d3..ae9f3fa8 100644
--- a/test/test_sort.cpp
+++ b/test/test_sort.cpp
@@ -180,6 +180,8 @@ void test_heapsort(unsigned sz)
 }
 #endif
 
+// FIXME: Re-enable when deque becomes a collection
+#if 0
 void test_adapted_deque_sort(unsigned sz)
 {
     std::deque<std::string> deque(sz);
@@ -196,7 +198,7 @@ void test_adapted_deque_sort(unsigned sz)
 
     CHECK(std::is_sorted(deque.cbegin(), deque.cbegin() + sz/2));
 }
-
+#endif
 }
 
 TEST_CASE("sort")
@@ -218,7 +220,8 @@ TEST_CASE("sort")
     test_sort_projected(100);
     test_sort_projected(100'000);
 
-    test_adapted_deque_sort(100'000);
+    // FIXME
+    // test_adapted_deque_sort(100'000);
 
 #ifndef USE_MODULES
     // Test our heapsort implementation, because I don't know how to
diff --git a/test/test_stride.cpp b/test/test_stride.cpp
index 0e637374..f13673b8 100644
--- a/test/test_stride.cpp
+++ b/test/test_stride.cpp
@@ -430,21 +430,6 @@ TEST_CASE("stride")
     res = test_stride_bidir();
     REQUIRE(res);
 
-    // Test with bidir-but-not-RA sequence
-    {
-        auto list = std::list<int>{1, 2, 3, 4, 5, 6, 7, 8, 9};
-        auto seq = flux::from_range(list).stride(3);
-
-        REQUIRE(seq.size() == 3);
-        REQUIRE(check_equal(seq, {1, 4, 7}));
-        REQUIRE(seq.sum() == 12);
-
-        auto rev = std::move(seq).reverse();
-
-        REQUIRE(check_equal(rev, {7, 4, 1}));
-        REQUIRE(rev.sum() == 12);
-    }
-
 #ifndef USE_MODULES
     // detail::advance tests to keep CodeCov happy
     {
diff --git a/test/test_take.cpp b/test/test_take.cpp
index 702ec6ba..5d4fd7b7 100644
--- a/test/test_take.cpp
+++ b/test/test_take.cpp
@@ -197,8 +197,8 @@ TEST_CASE("take")
     {
         std::list list{1, 2, 3, 4, 5};
 
-        REQUIRE_THROWS_AS(flux::take(flux::from_range(list), -1000), flux::unrecoverable_error);
+        REQUIRE_THROWS_AS(flux::take(flux::ref(list), -1000), flux::unrecoverable_error);
 
-        REQUIRE_THROWS_AS(flux::from_range(list).take(-1000), flux::unrecoverable_error);
+        REQUIRE_THROWS_AS(flux::ref(list).take(-1000), flux::unrecoverable_error);
     }
 }
\ No newline at end of file
diff --git a/test/test_to.cpp b/test/test_to.cpp
index 10604220..e3f294a4 100644
--- a/test/test_to.cpp
+++ b/test/test_to.cpp
@@ -148,14 +148,14 @@ TEST_CASE("to")
             {
                 std::istringstream iss{"1 2 3 4 5"};
                 auto list = flux::from_istream<int>(iss).to<std::list<int>>();
-                CHECK(check_equal(flux::from_range(list), {1, 2, 3, 4, 5}));
+                CHECK(check_equal(list, {1, 2, 3, 4, 5}));
             }
 
             SUBCASE("...to set")
             {
                 std::istringstream iss{"5 4 3 2 1"};
                 auto set = flux::from_istream<int>(iss).to<std::set<int>>();
-                CHECK(check_equal(flux::from_range(set), {1, 2, 3, 4, 5}));
+                CHECK(check_equal(set, {1, 2, 3, 4, 5}));
             }
         }
 
@@ -174,7 +174,7 @@ TEST_CASE("to")
             {
                 std::istringstream iss{"1 2 3 4 5"};
                 auto list = flux::from_istream<int>(iss).to<std::list<int, A>>(A{});
-                CHECK(check_equal(flux::from_range(list), {1, 2, 3, 4, 5}));
+                CHECK(check_equal(list, {1, 2, 3, 4, 5}));
             }
 
             SUBCASE("...to set")
@@ -182,7 +182,7 @@ TEST_CASE("to")
                 std::istringstream iss{"5 4 3 2 1"};
                 auto set = flux::from_istream<int>(iss)
                               .to<std::set<int, std::less<>, A>>(A{});
-                CHECK(check_equal(flux::from_range(set), {1, 2, 3, 4, 5}));
+                CHECK(check_equal(set, {1, 2, 3, 4, 5}));
             }
         }
 
@@ -330,7 +330,7 @@ TEST_CASE("to")
                 auto list = flux::from_istream<int>(iss).to<std::list>();
                 using L = decltype(list);
                 static_assert(std::same_as<typename L::value_type, int>);
-                CHECK(check_equal(flux::from_range(list), {1, 2, 3, 4, 5}));
+                CHECK(check_equal(list, {1, 2, 3, 4, 5}));
             }
 
             SUBCASE("...to set")
@@ -339,7 +339,7 @@ TEST_CASE("to")
                 auto set = flux::from_istream<int>(iss).to<std::set>();
                 using S = decltype(set);
                 static_assert(std::same_as<typename S::value_type, int>);
-                CHECK(check_equal(flux::from_range(set), {1, 2, 3, 4, 5}));
+                CHECK(check_equal(set, {1, 2, 3, 4, 5}));
             }
         }
     }
diff --git a/test/test_unchecked.cpp b/test/test_unchecked.cpp
index 78d60f1e..741daa66 100644
--- a/test/test_unchecked.cpp
+++ b/test/test_unchecked.cpp
@@ -31,7 +31,7 @@ constexpr bool test_unchecked()
         auto ints = std::array{5, 4, 3, 2, 1};
         auto doubles = std::array{3.0, 2.0, 1.0};
 
-        auto seq = unchecked(zip(mut_ref(ints), mut_ref(doubles)));
+        auto seq = zip(mut_ref(ints), mut_ref(doubles));
 
         using S = decltype(seq);
 

From 391ab0cfa6658be16816e09a713e2a37d0a5988f Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 16:28:12 +0100
Subject: [PATCH 57/66] Require mulitpass for the various set adaptors

Whereas the translation to iterables has simplified most adaptors, these seem a bit tricky to move to the new API, as they require comparing the same element multiple times (and therefore internal caching).

For now we'll just require their bases to be multipass sequences.
---
 include/flux/adaptor/set_adaptors.hpp | 53 +++++++++++++--------------
 1 file changed, 26 insertions(+), 27 deletions(-)

diff --git a/include/flux/adaptor/set_adaptors.hpp b/include/flux/adaptor/set_adaptors.hpp
index 80ceb366..008ed57f 100644
--- a/include/flux/adaptor/set_adaptors.hpp
+++ b/include/flux/adaptor/set_adaptors.hpp
@@ -12,10 +12,8 @@
 
 namespace flux::detail {
 
-template <sequence Base1, sequence Base2, typename Cmp>
-struct set_union_adaptor
-    : flux::inline_sequence_base<set_union_adaptor<Base1, Base2, Cmp>>
-{
+template <multipass_sequence Base1, multipass_sequence Base2, typename Cmp>
+struct set_union_adaptor : flux::inline_sequence_base<set_union_adaptor<Base1, Base2, Cmp>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base1 base1_;
     FLUX_NO_UNIQUE_ADDRESS Base2 base2_;
@@ -145,10 +143,9 @@ struct set_union_adaptor
     };
 };
 
-template <sequence Base1, sequence Base2, typename Cmp>
+template <multipass_sequence Base1, multipass_sequence Base2, typename Cmp>
 struct set_difference_adaptor
-    : flux::inline_sequence_base<set_difference_adaptor<Base1, Base2, Cmp>>
-{
+    : flux::inline_sequence_base<set_difference_adaptor<Base1, Base2, Cmp>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base1 base1_;
     FLUX_NO_UNIQUE_ADDRESS Base2 base2_;
@@ -248,10 +245,9 @@ struct set_difference_adaptor
     };
 };
 
-template <sequence Base1, sequence Base2, typename Cmp>
+template <multipass_sequence Base1, multipass_sequence Base2, typename Cmp>
 struct set_symmetric_difference_adaptor
-    : flux::inline_sequence_base<set_symmetric_difference_adaptor<Base1, Base2, Cmp>>
-{
+    : flux::inline_sequence_base<set_symmetric_difference_adaptor<Base1, Base2, Cmp>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base1 base1_;
     FLUX_NO_UNIQUE_ADDRESS Base2 base2_;
@@ -398,10 +394,9 @@ struct set_symmetric_difference_adaptor
     };
 };
 
-template <sequence Base1, sequence Base2, typename Cmp>
+template <multipass_sequence Base1, multipass_sequence Base2, typename Cmp>
 struct set_intersection_adaptor
-    : flux::inline_sequence_base<set_intersection_adaptor<Base1, Base2, Cmp>>
-{
+    : flux::inline_sequence_base<set_intersection_adaptor<Base1, Base2, Cmp>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base1 base1_;
     FLUX_NO_UNIQUE_ADDRESS Base2 base2_;
@@ -507,10 +502,11 @@ concept set_op_compatible =
     requires { typename std::common_type_t<value_t<T1>, value_t<T2>>; };
 
 struct set_union_fn {
-    template <adaptable_sequence Seq1, adaptable_sequence Seq2, typename Cmp = std::compare_three_way>
-        requires set_op_compatible<Seq1, Seq2> &&
-                 weak_ordering_for<Cmp, Seq1> &&
-                 weak_ordering_for<Cmp, Seq2>
+    template <adaptable_sequence Seq1, adaptable_sequence Seq2,
+              typename Cmp = std::compare_three_way>
+        requires multipass_sequence<Seq1> && multipass_sequence<Seq2>
+        && set_op_compatible<Seq1, Seq2> && weak_ordering_for<Cmp, Seq1>
+        && weak_ordering_for<Cmp, Seq2>
     [[nodiscard]]
     constexpr auto operator()(Seq1&& seq1, Seq2&& seq2, Cmp cmp = {}) const
     {
@@ -519,9 +515,10 @@ struct set_union_fn {
 };
 
 struct set_difference_fn {
-    template <adaptable_sequence Seq1, adaptable_sequence Seq2, typename Cmp = std::compare_three_way>
-        requires weak_ordering_for<Cmp, Seq1> &&
-                 weak_ordering_for<Cmp, Seq2>
+    template <adaptable_sequence Seq1, adaptable_sequence Seq2,
+              typename Cmp = std::compare_three_way>
+        requires multipass_sequence<Seq1> && multipass_sequence<Seq2>
+        && weak_ordering_for<Cmp, Seq1> && weak_ordering_for<Cmp, Seq2>
     [[nodiscard]]
     constexpr auto operator()(Seq1&& seq1, Seq2&& seq2, Cmp cmp = {}) const
     {
@@ -530,10 +527,11 @@ struct set_difference_fn {
 };
 
 struct set_symmetric_difference_fn {
-    template <adaptable_sequence Seq1, adaptable_sequence Seq2, typename Cmp = std::compare_three_way>
-        requires set_op_compatible<Seq1, Seq2> &&
-                 weak_ordering_for<Cmp, Seq1> &&
-                 weak_ordering_for<Cmp, Seq2>
+    template <adaptable_sequence Seq1, adaptable_sequence Seq2,
+              typename Cmp = std::compare_three_way>
+        requires multipass_sequence<Seq1> && multipass_sequence<Seq2>
+        && set_op_compatible<Seq1, Seq2> && weak_ordering_for<Cmp, Seq1>
+        && weak_ordering_for<Cmp, Seq2>
     [[nodiscard]]
     constexpr auto operator()(Seq1&& seq1, Seq2&& seq2, Cmp cmp = {}) const
     {
@@ -542,9 +540,10 @@ struct set_symmetric_difference_fn {
 };
 
 struct set_intersection_fn {
-    template <adaptable_sequence Seq1, adaptable_sequence Seq2, typename Cmp = std::compare_three_way>
-        requires weak_ordering_for<Cmp, Seq1> &&
-                 weak_ordering_for<Cmp, Seq2>
+    template <adaptable_sequence Seq1, adaptable_sequence Seq2,
+              typename Cmp = std::compare_three_way>
+        requires multipass_sequence<Seq1> && multipass_sequence<Seq2>
+        && weak_ordering_for<Cmp, Seq1> && weak_ordering_for<Cmp, Seq2>
     [[nodiscard]]
     constexpr auto operator()(Seq1&& seq1, Seq2&& seq2, Cmp cmp = {}) const
     {

From 2fbea608bbf378de8998fe84313ec6c203d23db0 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 16:37:26 +0100
Subject: [PATCH 58/66] Remove flux::array_ptr

Use std::span instead (begrudgingly)
---
 include/flux/sequence.hpp           |   1 -
 include/flux/sequence/array_ptr.hpp | 164 ----------
 test/CMakeLists.txt                 |   1 -
 test/test_array_ptr.cpp             | 481 ----------------------------
 4 files changed, 647 deletions(-)
 delete mode 100644 include/flux/sequence/array_ptr.hpp
 delete mode 100644 test/test_array_ptr.cpp

diff --git a/include/flux/sequence.hpp b/include/flux/sequence.hpp
index 347580de..69ca21e4 100644
--- a/include/flux/sequence.hpp
+++ b/include/flux/sequence.hpp
@@ -6,7 +6,6 @@
 #ifndef FLUX_SEQUENCE_HPP_INCLUDED
 #define FLUX_SEQUENCE_HPP_INCLUDED
 
-#include <flux/sequence/array_ptr.hpp>
 #include <flux/sequence/bitset.hpp>
 #include <flux/sequence/empty.hpp>
 #include <flux/sequence/generator.hpp>
diff --git a/include/flux/sequence/array_ptr.hpp b/include/flux/sequence/array_ptr.hpp
deleted file mode 100644
index dbcd3de4..00000000
--- a/include/flux/sequence/array_ptr.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-
-// Copyright (c) 2023 Tristan Brindle (tcbrindle at gmail dot com)
-// 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 FLUX_SEQUENCE_ARRAY_PTR_HPP_INCLUDED
-#define FLUX_SEQUENCE_ARRAY_PTR_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-namespace flux {
-
-namespace detail {
-
-template <typename From, typename To>
-concept non_slicing_ptr_convertible = std::convertible_to<From (*)[], To (*)[]>;
-
-struct make_array_ptr_unchecked_fn;
-
-}
-
-FLUX_EXPORT
-template <typename T>
-    requires (std::is_object_v<T> && !std::is_abstract_v<T>)
-struct array_ptr : inline_sequence_base<array_ptr<T>> {
-private:
-    T* data_ = nullptr;
-    int_t sz_ = 0;
-
-    friend struct detail::make_array_ptr_unchecked_fn;
-
-    constexpr array_ptr(T* ptr, int_t sz) noexcept : data_(ptr), sz_(sz) { }
-
-public:
-    array_ptr() = default;
-
-    template <typename U>
-        requires (!std::same_as<U, T> &&
-                  detail::non_slicing_ptr_convertible<U, T>)
-    constexpr explicit(false) array_ptr(array_ptr<U> const& other) noexcept
-        : data_(flux::data(other)),
-          sz_(flux::size(other))
-    {}
-
-    template <typename Seq>
-        requires (!decays_to<Seq, array_ptr> &&
-                  contiguous_sequence<Seq> &&
-                  sized_sequence<Seq> &&
-                  detail::non_slicing_ptr_convertible<std::remove_reference_t<element_t<Seq>>, T>)
-    constexpr explicit array_ptr(Seq& seq)
-        : data_(flux::data(seq)),
-          sz_(flux::size(seq))
-    {}
-
-    template <typename Seq>
-        requires (contiguous_sequence<Seq> &&
-                  sized_sequence<Seq> &&
-                  detail::non_slicing_ptr_convertible<std::remove_reference_t<element_t<Seq>>, T>)
-    constexpr array_ptr(detail::ref_adaptor<Seq> ref)
-        : data_(flux::data(ref)),
-          sz_(flux::size(ref))
-    {}
-
-    array_ptr(array_ptr&&) = default;
-    array_ptr& operator=(array_ptr&&) = default;
-    ~array_ptr() = default;
-
-    array_ptr(array_ptr const&) requires std::is_const_v<T> = default;
-    array_ptr& operator=(array_ptr const&) requires std::is_const_v<T> = default;
-
-    friend constexpr auto operator==(array_ptr const& lhs, array_ptr const&  rhs) -> bool
-    {
-        return std::ranges::equal_to{}(lhs.data_, rhs.data_) && lhs.sz_ == rhs.sz_;
-    }
-
-    struct flux_sequence_traits : default_sequence_traits {
-
-        static constexpr auto first(array_ptr const&) -> index_t { return 0; }
-
-        static constexpr auto is_last(array_ptr const& self, index_t idx) -> bool
-        {
-            return idx >= self.sz_;
-        }
-
-        static constexpr auto inc(array_ptr const& self, index_t& idx) -> void
-        {
-            FLUX_DEBUG_ASSERT(idx < self.sz_);
-            idx = num::add(idx, int_t {1});
-        }
-
-        static constexpr auto read_at(array_ptr const& self, index_t idx) -> T&
-        {
-            indexed_bounds_check(idx, self.sz_);
-            return self.data_[idx];
-        }
-
-        static constexpr auto read_at_unchecked(array_ptr const& self, index_t idx) -> T&
-        {
-            return self.data_[idx];
-        }
-
-        static constexpr auto dec(array_ptr const& , index_t& idx) -> void
-        {
-            FLUX_DEBUG_ASSERT(idx > 0);
-            --idx;
-        }
-
-        static constexpr auto last(array_ptr const& self) -> index_t { return self.sz_; }
-
-        static constexpr auto inc(array_ptr const& self, index_t& idx, int_t offset) -> void
-        {
-            index_t nxt = num::add(idx, offset);
-            FLUX_DEBUG_ASSERT(nxt >= 0);
-            FLUX_DEBUG_ASSERT(nxt <= self.sz_);
-            idx = nxt;
-        }
-
-        static constexpr auto distance(array_ptr const&, index_t from, index_t to) -> int_t
-        {
-            return num::sub(to, from);
-        }
-
-        static constexpr auto size(array_ptr const& self) -> int_t { return self.sz_; }
-
-        static constexpr auto data(array_ptr const& self) -> T* { return self.data_; }
-
-        static constexpr auto for_each_while(array_ptr const& self, auto&& pred)
-        {
-            index_t idx = 0;
-            for (; idx < self.sz_; idx++) {
-                if (!std::invoke(pred, self.data_[idx])) {
-                    break;
-                }
-            }
-            return idx;
-        }
-    };
-};
-
-template <contiguous_sequence Seq>
-array_ptr(Seq&) -> array_ptr<std::remove_reference_t<element_t<Seq>>>;
-
-template <contiguous_sequence Seq>
-array_ptr(detail::ref_adaptor<Seq>) -> array_ptr<std::remove_reference_t<element_t<Seq>>>;
-
-namespace detail {
-
-struct make_array_ptr_unchecked_fn {
-    template <typename T>
-        requires (std::is_object_v<T> && !std::is_abstract_v<T>)
-    constexpr auto operator()(T* ptr, num::integral auto size) const -> array_ptr<T>
-    {
-        return array_ptr<T>(ptr, num::checked_cast<int_t>(size));
-    }
-};
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto make_array_ptr_unchecked =
-    detail::make_array_ptr_unchecked_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_ARRAY_PTR_HPP_INCLUDED
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 905ca946..c8d428ff 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -85,7 +85,6 @@ add_executable(test-flux
     test_zip_map.cpp
     test_zip_algorithms.cpp
 
-    test_array_ptr.cpp
     test_bitset.cpp
     test_empty.cpp
     test_getlines.cpp
diff --git a/test/test_array_ptr.cpp b/test/test_array_ptr.cpp
deleted file mode 100644
index 3d2cbce5..00000000
--- a/test/test_array_ptr.cpp
+++ /dev/null
@@ -1,481 +0,0 @@
-
-// Copyright (c) 2023 Tristan Brindle (tcbrindle at gmail dot com)
-// 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)
-
-#include <array>
-#include <algorithm>
-#include <numeric>
-#include <utility>
-
-#include "test_utils.hpp"
-
-namespace {
-
-struct Base {
-    int i = 999;
-};
-
-struct Derived : Base {
-    int j = 1;
-};
-
-struct ConvertibleToBaseStar {
-    operator Base*() const { return nullptr; }
-};
-
-struct Abstract {
-    virtual void fn() = 0;
-};
-
-template <typename T>
-concept can_array_ptr = requires { typename flux::array_ptr<T>; };
-
-// We can't even mention the type array_ptr<T> for abstract, incomplete or non-object T
-static_assert(not can_array_ptr<Abstract>);
-static_assert(not can_array_ptr<void>);
-static_assert(not can_array_ptr<int&>);
-
-constexpr bool test_array_ptr_ctor()
-{
-    // Default constructor
-    {
-        flux::array_ptr<int> ptr{};
-
-        STATIC_CHECK(ptr.data() == nullptr);
-        STATIC_CHECK(ptr.size() == 0);
-    }
-
-    // From-sequence constructor, basic
-    {
-        std::array arr{1, 2, 3, 4, 5};
-        flux::array_ptr<int> ptr(arr);
-
-        STATIC_CHECK(ptr.usize() == arr.size());
-        STATIC_CHECK(ptr.data() == arr.data());
-    }
-
-    // From-sequence constructor, non-const -> const
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        flux::array_ptr<int const> ptr(arr);
-
-        STATIC_CHECK(ptr.size() == 5);
-        STATIC_CHECK(ptr.data() == arr);
-
-        // constructor is explicit
-        auto fn = [](flux::array_ptr<int>) {};
-        (void) fn(flux::array_ptr<int>{arr});
-        static_assert(not std::invocable<decltype(fn), std::array<int, 3>&>);
-    }
-
-    // empty sequences are handled correctly
-    {
-        auto const& e = flux::empty<int>;
-        flux::array_ptr<int> ptr(e);
-
-        STATIC_CHECK(ptr.size() == 0);
-        STATIC_CHECK(ptr.is_empty());
-        STATIC_CHECK(ptr.data() == nullptr);
-    }
-
-    // Cannot construct array_ptr<int> from sequence of const int&
-    static_assert(not std::constructible_from<flux::array_ptr<int>, std::array<int, 3> const&>);
-
-    // Cannot construct array_ptr<Base> from sequence of Derived&
-    static_assert(std::constructible_from<Base*, Derived*>);
-    static_assert(not std::constructible_from<flux::array_ptr<Base>, std::array<Derived, 3>&>);
-
-    // Weird conversion operators are correctly ignored
-    static_assert(std::constructible_from<Base*, ConvertibleToBaseStar&>);
-    static_assert(not std::constructible_from<flux::array_ptr<Base>, std::array<ConvertibleToBaseStar, 3>&>);
-
-    // We are trivially copyable, movable, *-assignable and destructible
-    {
-        using AP = flux::array_ptr<int const>;
-        std::array arr{1, 2, 3};
-        AP p1(arr);
-
-        auto p2 = p1;
-        STATIC_CHECK(p2.usize() == arr.size());
-        STATIC_CHECK(p2.data() == arr.data());
-        static_assert(std::is_trivially_copy_constructible_v<AP>);
-        static_assert(std::is_nothrow_copy_constructible_v<AP>);
-
-        auto p3 = std::move(p1);
-        STATIC_CHECK(p3.usize() == arr.size());
-        STATIC_CHECK(p3.data() == arr.data());
-        static_assert(std::is_trivially_move_constructible_v<AP>);
-        static_assert(std::is_nothrow_move_constructible_v<AP>);
-
-        int arr2[] = {1, 2, 3, 4, 5};
-        auto p4 = flux::array_ptr<int>(arr2);
-
-        p2 = p4;
-        STATIC_CHECK(p2.size() == 5);
-        STATIC_CHECK(p2.data() == arr2);
-        static_assert(std::is_trivially_copy_assignable_v<AP>);
-        static_assert(std::is_nothrow_copy_assignable_v<AP>);
-
-
-        p2 = std::move(p4);
-        STATIC_CHECK(p2.size() == 5);
-        STATIC_CHECK(p2.data() == arr2);
-        static_assert(std::is_trivially_move_assignable_v<AP>);
-        static_assert(std::is_nothrow_move_assignable_v<AP>);
-
-        static_assert(std::is_trivially_destructible_v<AP>);
-    }
-
-    // Converting constructor
-    {
-        std::array arr{1, 2, 3};
-        flux::array_ptr<int> ptr(arr);
-
-        flux::array_ptr<int const> cptr = ptr;
-        STATIC_CHECK(cptr.usize() == arr.size());
-        STATIC_CHECK(cptr.data() == arr.data());
-
-        static_assert(std::is_nothrow_convertible_v<flux::array_ptr<int>, flux::array_ptr<int const>>);
-
-        flux::array_ptr<int const volatile> cvptr = cptr;
-        STATIC_CHECK(cvptr.usize() == arr.size());
-        STATIC_CHECK(cvptr.data() == arr.data());
-
-        auto fn = [](flux::array_ptr<double const>) {};
-        static_assert(std::invocable<decltype(fn), flux::array_ptr<double>&>);
-    }
-
-    // Cannot lessen CV qualifiers or do derived->base conversion
-    static_assert(not std::is_convertible_v<flux::array_ptr<int const>, flux::array_ptr<int>>);
-    static_assert(not std::is_convertible_v<flux::array_ptr<int const volatile>, flux::array_ptr<int const>>);
-    static_assert(not std::is_convertible_v<flux::array_ptr<Derived>, flux::array_ptr<Base>>);
-    static_assert(not std::is_convertible_v<flux::array_ptr<Base>, flux::array_ptr<Derived>>);
-
-    return true;
-}
-static_assert(test_array_ptr_ctor());
-
-constexpr bool test_array_ptr_ctad()
-{
-    {
-        std::array<int, 3> arr{1, 2, 3};
-
-        auto ap = flux::array_ptr(arr);
-        static_assert(std::same_as<flux::array_ptr<int>, decltype(ap)>);
-
-        auto ap2 = flux::array_ptr(std::as_const(arr));
-        static_assert(std::same_as<flux::array_ptr<int const>, decltype(ap2)>);
-    }
-
-    {
-        int volatile arr[] = {1, 2, 3};
-
-        auto ap = flux::array_ptr(arr);
-        static_assert(std::same_as<flux::array_ptr<int volatile>, decltype(ap)>);
-
-        auto ap2 = flux::array_ptr(std::as_const(arr));
-        static_assert(std::same_as<flux::array_ptr<int volatile const>, decltype(ap2)>);
-    }
-
-    return true;
-}
-static_assert(test_array_ptr_ctad());
-
-constexpr bool test_array_ptr_conversion_from_ref()
-{
-    auto takes_mut_ptr = [](flux::array_ptr<int>) {};
-    auto takes_const_ptr = [](flux::array_ptr<int const>) {};
-
-    // Non-const array
-    {
-        std::array arr{1, 2, 3, 4, 5};
-
-        using A = decltype(arr);
-        using CFn = decltype(takes_const_ptr);
-        using MFn = decltype(takes_mut_ptr);
-
-        // We can't call either function directly with arr, whether lvalue or rvalue
-        static_assert(not std::invocable<CFn, A&>);
-        static_assert(not std::invocable<CFn, A>);
-        static_assert(not std::invocable<MFn, A&>);
-        static_assert(not std::invocable<MFn, A>);
-
-        // We can call takes_const_ptr(ref(arr)), but not takes_mut_ptr()
-        auto r = flux::ref(arr);
-        using R = decltype(r);
-
-        static_assert(std::invocable<CFn, R&>);
-        static_assert(std::invocable<CFn, R>);
-        static_assert(not std::invocable<MFn, R&>);
-        static_assert(not std::invocable<MFn, R>);
-
-        // We can call both takes_const_ptr and takes_mut_ptr with a mut_ref
-        // (but only as an rvalue)
-        auto m = flux::mut_ref(arr);
-        using M = decltype(m);
-
-        static_assert(not std::invocable<CFn, M&>);
-        static_assert(std::invocable<CFn, M>);
-        static_assert(not std::invocable<MFn, M&>);
-        static_assert(std::invocable<MFn, M>);
-
-        // Test CTAD
-        auto ptr = flux::array_ptr(r);
-        static_assert(std::same_as<decltype(ptr), flux::array_ptr<int const>>);
-
-        auto mptr = flux::array_ptr(std::move(m));
-        static_assert(std::same_as<decltype(mptr), flux::array_ptr<int>>);
-    }
-
-    // Now the same again with a const array
-    {
-        std::array const arr{1, 2, 3, 4, 5};
-
-        using A = decltype(arr);
-        using CFn = decltype(takes_const_ptr);
-        using MFn = decltype(takes_mut_ptr);
-
-        // We can't call either function directly with arr, whether lvalue or rvalue
-        static_assert(not std::invocable<CFn, A&>);
-        static_assert(not std::invocable<CFn, A>);
-        static_assert(not std::invocable<MFn, A&>);
-        static_assert(not std::invocable<MFn, A>);
-
-        // We can call takes_const_ptr(ref(arr)), but not takes_mut_ptr()
-        auto r = flux::ref(arr);
-        using R = decltype(r);
-
-        static_assert(std::invocable<CFn, R&>);
-        static_assert(std::invocable<CFn, R>);
-        static_assert(not std::invocable<MFn, R&>);
-        static_assert(not std::invocable<MFn, R>);
-
-        // We cannot call mut_ref(arr)
-        static_assert(not std::invocable<decltype(flux::mut_ref), A&>);
-
-        // Test CTAD
-        auto ptr = flux::array_ptr(r);
-        static_assert(std::same_as<decltype(ptr), flux::array_ptr<int const>>);
-    }
-
-    return true;
-}
-static_assert(test_array_ptr_conversion_from_ref());
-
-// Controversial, this one
-constexpr bool test_array_ptr_equality()
-{
-    // Pointers to different arrays are different
-    {
-        int arr[] = {1, 2, 3};
-        int arr2[] = {1, 2, 3};
-
-        auto ap = flux::array_ptr(arr);
-        auto ap2 = flux::array_ptr(arr2);
-
-        STATIC_CHECK(ap == ap);
-        STATIC_CHECK(not (ap != ap));
-        STATIC_CHECK(not (ap == ap2));
-        STATIC_CHECK(ap != ap2);
-    }
-
-    // Pointers to the same array with different sizes are different
-    {
-        int arr[] = {1, 2, 3};
-
-        auto ap = flux::make_array_ptr_unchecked(arr, 3);
-        auto ap2 = flux::make_array_ptr_unchecked(arr, 2);
-
-        STATIC_CHECK(ap == ap);
-        STATIC_CHECK(not (ap != ap));
-        STATIC_CHECK(not (ap == ap2));
-        STATIC_CHECK(ap != ap2);
-
-        std::array arr2{1, 2, 3};
-        auto take2 = flux::take(arr2, 2);
-
-        STATIC_CHECK(flux::array_ptr(arr2) != flux::array_ptr(take2));
-    }
-
-    // Default-constructed ptrs (of the same type) are equal
-    {
-        flux::array_ptr<int> arr1;
-        flux::array_ptr<int> arr2;
-
-        STATIC_CHECK(arr1 == arr2);
-    }
-
-    // Can use the converting constructor to compare const and non-const
-    {
-        int arr[] = {1, 2, 3};
-        int const arr2[] = {4, 5, 6};
-
-        STATIC_CHECK(flux::array_ptr<int>(arr) == flux::array_ptr<int const>(arr));
-        STATIC_CHECK(flux::array_ptr(arr) != flux::array_ptr(arr2));
-    }
-
-    return true;
-}
-static_assert(test_array_ptr_equality());
-
-constexpr bool test_array_ptr_sequence_impl()
-{
-    {
-        using S = flux::array_ptr<int>;
-        static_assert(flux::contiguous_sequence<S>);
-        static_assert(flux::sized_sequence<S>);
-        static_assert(flux::bounded_sequence<S>);
-        static_assert(not flux::infinite_sequence<S>);
-        static_assert(std::same_as<flux::value_t<S>, int>);
-        static_assert(std::same_as<flux::element_t<S>, int&>);
-        static_assert(std::same_as<flux::rvalue_element_t<S>, int&&>);
-
-        static_assert(flux::contiguous_sequence<S const>);
-        static_assert(flux::sized_sequence<S const>);
-        static_assert(flux::bounded_sequence<S const>);
-        static_assert(not flux::infinite_sequence<S const>);
-        static_assert(std::same_as<flux::value_t<S const>, int>);
-        static_assert(std::same_as<flux::element_t<S const>, int&>);
-        static_assert(std::same_as<flux::rvalue_element_t<S const>, int&&>);
-
-        using C = flux::array_ptr<int const>;
-        static_assert(flux::contiguous_sequence<C>);
-        static_assert(flux::sized_sequence<C>);
-        static_assert(flux::bounded_sequence<C>);
-        static_assert(not flux::infinite_sequence<C>);
-        static_assert(std::same_as<flux::value_t<C>, int>);
-        static_assert(std::same_as<flux::element_t<C>, int const&>);
-        static_assert(std::same_as<flux::rvalue_element_t<C>, int const&&>);
-
-        static_assert(flux::contiguous_sequence<C const>);
-        static_assert(flux::sized_sequence<C const>);
-        static_assert(flux::bounded_sequence<C const>);
-        static_assert(not flux::infinite_sequence<C const>);
-        static_assert(std::same_as<flux::value_t<C const>, int>);
-        static_assert(std::same_as<flux::element_t<C const>, int const&>);
-        static_assert(std::same_as<flux::rvalue_element_t<C const>, int const&&>);
-    }
-
-    auto do_sum = []<typename T>(flux::array_ptr<T> arr) {
-        flux::value_t<decltype(arr)> sum{};
-        for (auto c = arr.first(); !arr.is_last(c); arr.inc(c)) {
-            sum += arr[c];
-        }
-        return sum;
-    };
-
-    // Basic iteration works okay
-    {
-        std::array arr{1, 2, 3};
-
-        STATIC_CHECK(do_sum(flux::array_ptr(arr)) == 6);
-        STATIC_CHECK(do_sum(flux::array_ptr(std::as_const(arr))) == 6);
-    }
-
-    // We can mutate via an array_ptr (even one declared const)
-    {
-        std::array arr{1, 2, 3};
-        auto const ptr = flux::array_ptr(arr);
-
-        flux::fill(ptr, 9);
-
-        STATIC_CHECK(check_equal(arr, {9, 9, 9}));
-    }
-
-    // ...but not an array_ptr to const
-    static_assert(not std::invocable<decltype(flux::fill), flux::array_ptr<int const>&>);
-
-    // We can sort an array ptr, exercising most of the random-access interface
-    {
-        std::array<int, 100> arr{};
-        std::iota(arr.begin(), arr.end(), 0);
-        std::ranges::reverse(arr);
-
-        STATIC_CHECK(not std::ranges::is_sorted(arr));
-
-        auto const ptr = flux::array_ptr(arr);
-        flux::sort(ptr);
-
-        STATIC_CHECK(std::ranges::is_sorted(arr));
-    }
-
-    // Internal iteration works as expected
-    {
-        std::array const arr{0, 1, 2, 3, 4};
-        auto ptr = flux::array_ptr(arr);
-
-        STATIC_CHECK(flux::sum(ptr) == 10);
-
-        auto idx = ptr.find(3);
-        STATIC_CHECK(idx == 3);
-    }
-
-    // Range interface works as expected
-    {
-        std::array arr{5, 4, 3, 2, 1};
-        auto ptr = flux::array_ptr(arr);
-        std::ranges::sort(ptr);
-        static_assert(std::ranges::contiguous_range<flux::array_ptr<int>>);
-        STATIC_CHECK(std::ranges::is_sorted(arr));
-    }
-
-    return true;
-}
-static_assert(test_array_ptr_sequence_impl());
-
-constexpr bool test_make_array_ptr()
-{
-    {
-        int* p = nullptr;
-        auto arr = flux::make_array_ptr_unchecked(p, 0);
-
-        STATIC_CHECK(arr.size() == 0);
-        STATIC_CHECK(arr.data() == nullptr);
-    }
-
-    {
-        int arr[] = {5, 4, 3, 2, 1};
-        auto ap = flux::make_array_ptr_unchecked(arr, 4);
-        STATIC_CHECK(ap.size() == 4);
-        STATIC_CHECK(ap.data() == arr);
-
-        std::ranges::sort(ap);
-
-        STATIC_CHECK(check_equal(arr, {2, 3, 4, 5, 1}));
-    }
-
-    return true;
-}
-static_assert(test_make_array_ptr());
-
-}
-
-TEST_CASE("array_ptr")
-{
-    REQUIRE(test_array_ptr_ctor());
-    REQUIRE(test_array_ptr_ctad());
-    REQUIRE(test_array_ptr_conversion_from_ref());
-    REQUIRE(test_array_ptr_equality());
-    REQUIRE(test_array_ptr_sequence_impl());
-    REQUIRE(test_make_array_ptr());
-
-    SUBCASE("bounds checking") {
-        int arr[] = {0, 1, 2};
-        auto ptr = flux::array_ptr(arr);
-
-        // In-bounds reads are okay
-        REQUIRE(ptr[0] == 0);
-
-        // Out-of-bounds reads are an error
-        REQUIRE_THROWS_AS(ptr[-1], flux::unrecoverable_error);
-        REQUIRE_THROWS_AS(ptr[100], flux::unrecoverable_error);
-
-        // Advancing a cursor to the end is okay...
-        auto cur = ptr.first();
-        ptr.inc(cur, ptr.size());
-
-        // ...but reading from it is an error...
-        REQUIRE_THROWS_AS(ptr[cur], flux::unrecoverable_error);
-    }
-}
\ No newline at end of file

From e63d308f4a3216327a60e5307b33bc6456674d93 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Thu, 14 Aug 2025 18:24:34 +0100
Subject: [PATCH 59/66] Update flux::iota for new concepts

For an incrementable type, iota(i) gives an infinite iterable, and iota(i, j) gives an iterable that will iterate until i == j.

If the type is additionally decrementable, then iota(i, j) will additionally be reverse iterable. If the type is additionally advanceable, then iota(i, j) will also be sized.

If the type is strongly ordered (with op<=>) then it is a multipass sequence (and in future, a collection), plus bidir if decrementable and RA if advancable.

Finally, for a type which is `std::is_arithmetic_v<T>`, iota(a) is equivalent to `iota(a, numeric_limits<T>::max())` -- that is, we treat it as a bounded collection rather than an infinite iterable.
---
 include/flux/sequence/iota.hpp  | 217 ++++++++++++++++++--------------
 test/test_cartesian_product.cpp |  70 +++++++----
 test/test_iota.cpp              | 179 ++++++++++++++++++--------
 test/test_mask.cpp              |   2 -
 4 files changed, 292 insertions(+), 176 deletions(-)

diff --git a/include/flux/sequence/iota.hpp b/include/flux/sequence/iota.hpp
index 97792c93..94682b77 100644
--- a/include/flux/sequence/iota.hpp
+++ b/include/flux/sequence/iota.hpp
@@ -30,11 +30,8 @@ concept decrementable =
     };
 
 template <typename T>
-concept advancable =
-    decrementable<T> &&
-    std::totally_ordered<T> &&
-    std::weakly_incrementable<T> && // iter_difference_t exists
-    requires (T t, T const u, std::iter_difference_t<T> o) {
+concept advancable = decrementable<T> && std::weakly_incrementable<T> && // iter_difference_t exists
+    requires(T t, T const u, std::iter_difference_t<T> o) {
         { t += o } -> std::same_as<T&>;
         { t -= o } -> std::same_as<T&>;
         T(u + o);
@@ -43,144 +40,172 @@ concept advancable =
         { u - u } -> std::convertible_to<int_t>;
     };
 
-struct iota_traits {
-    bool has_start;
-    bool has_end;
-};
+template <incrementable T>
+struct iota_iterable : inline_sequence_base<iota_iterable<T>> {
+    T from;
 
-template <incrementable T, iota_traits Traits>
-struct iota_sequence_traits : default_sequence_traits {
-    using cursor_type = T;
+    struct iteration_context : immovable {
+        T value;
 
-    static constexpr bool is_infinite = !Traits.has_end;
+        using element_type = T;
 
-    static constexpr auto first(auto& self) -> cursor_type
-    {
-        if constexpr (Traits.has_start) {
-            return self.start_;
-        } else {
-            return cursor_type{};
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            while (true) {
+                if (!pred(value++)) {
+                    return iteration_result::incomplete;
+                }
+            }
         }
-    }
+    };
 
-    static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
-    {
-        if constexpr (Traits.has_end) {
-            return cur == self.end_;
-        } else {
-            return false;
+    constexpr auto iterate() const -> iteration_context { return iteration_context{.value = from}; }
+};
+
+template <incrementable T>
+struct bounded_iota_iterable : inline_sequence_base<bounded_iota_iterable<T>> {
+    T from;
+    T to;
+
+    struct iteration_context : immovable {
+        T value;
+        T last;
+
+        using element_type = T;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            while (value != last) {
+                if (!pred(value++)) {
+                    return iteration_result::incomplete;
+                }
+            }
+            return iteration_result::complete;
         }
-    }
+    };
 
-    static constexpr auto inc(auto&, cursor_type& cur) -> cursor_type&
-    {
-        return ++cur;
-    }
+    struct reverse_iteration_context : immovable {
+        T value;
+        T first;
 
-    static constexpr auto read_at(auto&, cursor_type const& cur) -> T
-    {
-        return cur;
-    }
+        using element_type = T;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            while (value != first) {
+                if (!pred(static_cast<T>(--value))) {
+                    return iteration_result::incomplete;
+                }
+            }
+            return iteration_result::complete;
+        }
+    };
 
-    static constexpr auto last(auto& self) -> cursor_type
-        requires (Traits.has_end)
+    constexpr auto iterate() const -> iteration_context
     {
-        return self.end_;
+        return iteration_context{.value = from, .last = to};
     }
 
-    static constexpr auto dec(auto&, cursor_type& cur) -> cursor_type&
+    constexpr auto reverse_iterate() const -> reverse_iteration_context
         requires decrementable<T>
     {
-        return --cur;
+        return reverse_iteration_context{.value = to, .first = from};
     }
 
-    static constexpr auto inc(auto&, cursor_type& cur, int_t offset) -> cursor_type&
+    constexpr auto size() const -> int_t
         requires advancable<T>
     {
-        return cur += num::cast<std::iter_difference_t<T>>(offset);
+        return num::cast<int_t>(to - from);
     }
+};
 
-    static constexpr auto distance(auto&, cursor_type const& from, cursor_type const& to)
-        requires advancable<T>
-    {
-        return from <= to ? num::cast<int_t>(to - from) : -num::cast<int_t>(from - to);
-    }
+template <incrementable T>
+    requires std::totally_ordered<T>
+struct iota_sequence : inline_sequence_base<iota_sequence<T>> {
+    T from;
+    T to;
 
-    static constexpr auto size(auto& self) -> int_t
-        requires advancable<T> && (Traits.has_start && Traits.has_end)
-    {
-        return num::cast<int_t>(self.end_ - self.start_);
-    }
-};
+    struct flux_sequence_traits : default_sequence_traits {
+        using self_t = iota_sequence;
 
-template <typename T>
-struct basic_iota_sequence : inline_sequence_base<basic_iota_sequence<T>> {
-    using flux_sequence_traits = iota_sequence_traits<T, iota_traits{}>;
-    friend flux_sequence_traits;
-};
+        struct cursor_type {
+            T current;
 
-template <typename T>
-struct iota_sequence : inline_sequence_base<iota_sequence<T>> {
-private:
-    T start_;
+            friend auto operator<=>(cursor_type const&, cursor_type const&) -> std::strong_ordering
+                = default;
+        };
 
-    static constexpr iota_traits traits{.has_start = true, .has_end = false};
+        static constexpr auto first(self_t const& self) -> cursor_type { return {self.from}; }
 
-public:
-    inline constexpr explicit iota_sequence(T from)
-        : start_(std::move(from))
-    {}
+        static constexpr auto last(self_t const& self) -> cursor_type { return {self.to}; }
 
-    using flux_sequence_traits = iota_sequence_traits<T, traits>;
-    friend flux_sequence_traits;
-};
+        static constexpr auto is_last(self_t const& self, cursor_type const& cur) -> bool
+        {
+            return cur.current == self.to;
+        }
 
-template <typename T>
-struct bounded_iota_sequence : inline_sequence_base<bounded_iota_sequence<T>> {
-    T start_;
-    T end_;
+        static constexpr void inc(self_t const&, cursor_type& cur) { ++cur.current; }
+
+        static constexpr void dec(self_t const&, cursor_type& cur)
+            requires decrementable<T>
+        {
+            --cur.current;
+        }
 
-    static constexpr iota_traits traits{.has_start = true, .has_end = true};
+        static constexpr auto read_at(self_t const&, cursor_type const& cur) -> T
+        {
+            return cur.current;
+        }
 
-public:
-    inline constexpr bounded_iota_sequence(T from, T to)
-        : start_(std::move(from)),
-          end_(std::move(to))
-    {}
+        static constexpr void inc(self_t const&, cursor_type& cur, int_t offset)
+            requires advancable<T>
+        {
+            cur.current += num::cast<std::iter_difference_t<T>>(offset);
+        }
 
-    using flux_sequence_traits = iota_sequence_traits<T, traits>;
-    friend flux_sequence_traits;
+        static constexpr auto distance(self_t const&, cursor_type const& from,
+                                       cursor_type const& to) -> int_t
+            requires advancable<T>
+        {
+            return num::cast<int_t>(to.current - from.current);
+        }
+    };
 };
 
-struct iota_fn {
+struct iota_t {
     template <incrementable T>
-    constexpr auto operator()(T from) const
+    constexpr auto operator()(T from, T to) const
     {
-        return iota_sequence<T>(std::move(from));
+        if constexpr (std::three_way_comparable<T, std::strong_ordering>) {
+            return iota_sequence<T>{.from = from, .to = to};
+        } else {
+            return bounded_iota_iterable<T>{.from = from, .to = to};
+        }
     }
 
     template <incrementable T>
-    constexpr auto operator()(T from, T to) const
+    constexpr auto operator()(T from) const
     {
-        return bounded_iota_sequence<T>(std::move(from), std::move(to));
+        if constexpr (std::is_arithmetic_v<T>) {
+            return (*this)(from, std::numeric_limits<T>::max());
+        } else {
+            return iota_iterable<T>{.from = from};
+        }
     }
 };
 
-struct ints_fn {
-    inline constexpr auto operator()() const { return basic_iota_sequence<int_t>(); }
+struct ints_t {
+    inline constexpr auto operator()() const { return iota_t{}(int_t{}); }
 
-    inline constexpr auto operator()(int_t from) const { return iota_sequence<int_t>(from); }
+    inline constexpr auto operator()(int_t from) const { return iota_t{}(from); }
 
-    inline constexpr auto operator()(int_t from, int_t to) const
-    {
-        return bounded_iota_sequence<int_t>(from, to);
-    }
+    inline constexpr auto operator()(int_t from, int_t to) const { return iota_t{}(from, to); }
 };
 
 } // namespace detail
 
-FLUX_EXPORT inline constexpr auto iota = detail::iota_fn{};
-FLUX_EXPORT inline constexpr auto ints = detail::ints_fn{};
+FLUX_EXPORT inline constexpr auto iota = detail::iota_t{};
+FLUX_EXPORT inline constexpr auto ints = detail::ints_t{};
 
 } // namespace flux
 
diff --git a/test/test_cartesian_product.cpp b/test/test_cartesian_product.cpp
index 81751ace..9cb93e99 100644
--- a/test/test_cartesian_product.cpp
+++ b/test/test_cartesian_product.cpp
@@ -401,30 +401,54 @@ constexpr bool test_cartesian_product()
 
         STATIC_CHECK(flux::distance(cart, cart.first(), cart.last()) == 4 * 2 * 3);
 
+        using pos_t = flux::cursor_t<decltype(flux::ints(0, 4))>;
+
         {
-            STATIC_CHECK(flux::next(cart, cart.first(), 6) == std::tuple{1, 0, 0});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6),  1) == std::tuple{1, 0, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6),  2) == std::tuple{1, 0, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6),  3) == std::tuple{1, 1, 0});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6),  4) == std::tuple{1, 1, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6),  5) == std::tuple{1, 1, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -1) == std::tuple{0, 1, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -2) == std::tuple{0, 1, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -3) == std::tuple{0, 1, 0});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -4) == std::tuple{0, 0, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -5) == std::tuple{0, 0, 1});
-
-            STATIC_CHECK(flux::next(cart, cart.first(), 11) == std::tuple{1, 1, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11),  1) == std::tuple{2, 0, 0});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11),  2) == std::tuple{2, 0, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11),  3) == std::tuple{2, 0, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11),  4) == std::tuple{2, 1, 0});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11),  5) == std::tuple{2, 1, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -1) == std::tuple{1, 1, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -2) == std::tuple{1, 1, 0});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -3) == std::tuple{1, 0, 2});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -4) == std::tuple{1, 0, 1});
-            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -5) == std::tuple{1, 0, 0});
+            STATIC_CHECK(flux::next(cart, cart.first(), 6)
+                         == std::tuple(pos_t{1}, pos_t{0}, pos_t{0}));
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), 1)
+                         == std::tuple{pos_t{1}, pos_t{0}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), 2)
+                         == std::tuple{pos_t{1}, pos_t{0}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), 3)
+                         == std::tuple{pos_t{1}, pos_t{1}, pos_t{0}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), 4)
+                         == std::tuple{pos_t{1}, pos_t{1}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), 5)
+                         == std::tuple{pos_t{1}, pos_t{1}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -1)
+                         == std::tuple{pos_t{0}, pos_t{1}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -2)
+                         == std::tuple{pos_t{0}, pos_t{1}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -3)
+                         == std::tuple{pos_t{0}, pos_t{1}, pos_t{0}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -4)
+                         == std::tuple{pos_t{0}, pos_t{0}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 6), -5)
+                         == std::tuple{pos_t{0}, pos_t{0}, pos_t{1}});
+
+            STATIC_CHECK(flux::next(cart, cart.first(), 11)
+                         == std::tuple{pos_t{1}, pos_t{1}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), 1)
+                         == std::tuple{pos_t{2}, pos_t{0}, pos_t{0}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), 2)
+                         == std::tuple{pos_t{2}, pos_t{0}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), 3)
+                         == std::tuple{pos_t{2}, pos_t{0}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), 4)
+                         == std::tuple{pos_t{2}, pos_t{1}, pos_t{0}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), 5)
+                         == std::tuple{pos_t{2}, pos_t{1}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -1)
+                         == std::tuple{pos_t{1}, pos_t{1}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -2)
+                         == std::tuple{pos_t{1}, pos_t{1}, pos_t{0}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -3)
+                         == std::tuple{pos_t{1}, pos_t{0}, pos_t{2}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -4)
+                         == std::tuple{pos_t{1}, pos_t{0}, pos_t{1}});
+            STATIC_CHECK(flux::next(cart, flux::next(cart, cart.first(), 11), -5)
+                         == std::tuple{pos_t{1}, pos_t{0}, pos_t{0}});
         }
 
         flux::int_t sum_i = 0;
diff --git a/test/test_iota.cpp b/test/test_iota.cpp
index ceaff7f6..7fcc8ba1 100644
--- a/test/test_iota.cpp
+++ b/test/test_iota.cpp
@@ -9,94 +9,163 @@
 
 namespace {
 
-constexpr bool test_iota_basic()
+struct incrementable_only {
+    int i = 0;
+
+    bool operator==(incrementable_only const&) const = default;
+    constexpr auto& operator++()
+    {
+        ++i;
+        return *this;
+    }
+    constexpr auto operator++(int)
+    {
+        auto tmp = *this;
+        ++*this;
+        return tmp;
+    }
+};
+
+struct decrementable {
+    int i = 0;
+
+    bool operator==(decrementable const&) const = default;
+    constexpr auto& operator++()
+    {
+        ++i;
+        return *this;
+    }
+    constexpr auto operator++(int)
+    {
+        auto tmp = *this;
+        ++*this;
+        return tmp;
+    }
+    constexpr auto& operator--()
+    {
+        --i;
+        return *this;
+    }
+    constexpr auto operator--(int)
+    {
+        auto tmp = *this;
+        --*this;
+        return tmp;
+    }
+};
+
+constexpr bool test_iota_unbounded()
 {
-    auto f = flux::ints();
+    {
+        auto f = flux::iota(incrementable_only{0});
 
-    using F = decltype(f);
+        using F = decltype(f);
 
-    static_assert(sizeof(f) == 1);
-    static_assert(flux::sequence<F>);
-    static_assert(flux::bidirectional_sequence<F>);
-    static_assert(flux::random_access_sequence<F>);
-    static_assert(flux::infinite_sequence<F>);
-    static_assert(not flux::bounded_sequence<F>);
-    static_assert(not flux::sized_sequence<F>);
+        static_assert(flux::iterable<F>);
+        static_assert(not flux::sized_iterable<F>);
+        static_assert(not flux::reverse_iterable<F>);
+        static_assert(not flux::multipass_sequence<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, incrementable_only>);
 
-    STATIC_CHECK(check_equal(flux::take(f, 5), {0, 1, 2, 3, 4}));
+        using I = incrementable_only;
+        STATIC_CHECK(check_equal(flux::take(f, 5), {I{0}, I{1}, I{2}, I{3}, I{4}}));
+    }
 
-    return true;
-}
-static_assert(test_iota_basic());
-
-constexpr bool test_iota_from()
-{
-    auto f = flux::iota(1u);
+    {
+        auto f = flux::iota(decrementable{0});
 
-    using F = decltype(f);
+        using F = decltype(f);
 
-    static_assert(sizeof(f) == sizeof(unsigned));
-    static_assert(flux::sequence<F>);
-    static_assert(flux::bidirectional_sequence<F>);
-    static_assert(flux::random_access_sequence<F>);
-    static_assert(flux::infinite_sequence<F>);
-    static_assert(not flux::bounded_sequence<F>);
-    static_assert(not flux::sized_sequence<F>);
+        static_assert(flux::iterable<F>);
+        static_assert(not flux::sized_iterable<F>);
+        static_assert(not flux::reverse_iterable<F>); // Unbounded
+        static_assert(not flux::multipass_sequence<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, decrementable>);
 
-    STATIC_CHECK(check_equal(flux::take(f, 5), {1u, 2u, 3u, 4u, 5u}));
+        using D = decrementable;
+        STATIC_CHECK(check_equal(flux::take(f, 5), {D{0}, D{1}, D{2}, D{3}, D{4}}));
+    }
 
     return true;
 }
-static_assert(test_iota_from());
+static_assert(test_iota_unbounded());
 
 constexpr bool test_iota_bounded()
 {
-    auto f = flux::iota(1u, 6u);
+    {
+        using I = incrementable_only;
+        auto f = flux::iota(I{0}, I{5});
+
+        using F = decltype(f);
+
+        static_assert(flux::iterable<F>);
+        static_assert(not flux::sized_iterable<F>);
+        static_assert(not flux::reverse_iterable<F>);
+        static_assert(not flux::multipass_sequence<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, I>);
+
+        STATIC_CHECK(check_equal(f, {I{0}, I{1}, I{2}, I{3}, I{4}}));
+    }
 
-    using F = decltype(f);
+    {
+        using D = decrementable;
+        auto f = flux::iota(D{0}, D{5});
 
-    static_assert(flux::sequence<F>);
-    static_assert(flux::bidirectional_sequence<F>);
-    static_assert(flux::random_access_sequence<F>);
-    static_assert(not flux::infinite_sequence<F>);
-    static_assert(flux::bounded_sequence<F>);
-    static_assert(flux::sized_sequence<F>);
+        using F = decltype(f);
 
-    STATIC_CHECK(f.size() == 5);
-    STATIC_CHECK(check_equal(f, {1u, 2u, 3u, 4u, 5u}));
+        static_assert(flux::iterable<F>);
+        static_assert(not flux::sized_iterable<F>);
+        static_assert(flux::reverse_iterable<F>);
+        static_assert(not flux::multipass_sequence<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, D>);
+
+        STATIC_CHECK(check_equal(flux::reverse(f), {D{4}, D{3}, D{2}, D{1}, D{0}}));
+    }
 
     return true;
 }
 static_assert(test_iota_bounded());
 
-constexpr bool test_iota_custom_type()
+constexpr bool test_iota_sequence()
 {
-    using namespace std::chrono_literals;
+    {
+        auto f = flux::ints();
+
+        using F = decltype(f);
+
+        static_assert(flux::iterable<F>);
+        static_assert(flux::sized_iterable<F>);
+        static_assert(flux::reverse_iterable<F>);
+        static_assert(flux::random_access_sequence<F>);
+        static_assert(std::same_as<flux::iterable_element_t<F>, flux::int_t>);
 
-    auto f = flux::iota(1s, 6s);
+        STATIC_CHECK(check_equal(flux::take(f, 5), {0, 1, 2, 3, 4}));
+    }
 
-    using F = decltype(f);
+    {
+        using namespace std::chrono_literals;
 
-    static_assert(flux::sequence<F>);
-    static_assert(flux::bidirectional_sequence<F>);
-    static_assert(not flux::random_access_sequence<F>); // no iter_difference_t
-    static_assert(not flux::infinite_sequence<F>);
-    static_assert(flux::bounded_sequence<F>);
-    static_assert(not flux::sized_sequence<F>); // !
+        auto f = flux::iota(0s, 5s);
 
-    STATIC_CHECK(f.count() == 5);
-    STATIC_CHECK(check_equal(f, {1s, 2s, 3s, 4s, 5s}));
+        using F = decltype(f);
+
+        static_assert(flux::iterable<F>);
+        static_assert(not flux::sized_iterable<F>); // no difference_type
+        static_assert(flux::reverse_iterable<F>);
+        static_assert(not flux::random_access_sequence<F>); // no difference_type
+        static_assert(std::same_as<flux::iterable_element_t<F>, std::chrono::seconds>);
+
+        STATIC_CHECK(check_equal(flux::reverse(f), {4s, 3s, 2s, 1s, 0s}));
+    }
 
     return true;
 }
-static_assert(test_iota_custom_type());
-
+static_assert(test_iota_sequence());
 }
 
 TEST_CASE("iota")
 {
-    REQUIRE(test_iota_basic());
-    REQUIRE(test_iota_from());
+    REQUIRE(test_iota_unbounded());
     REQUIRE(test_iota_bounded());
-    REQUIRE(test_iota_custom_type());
+    REQUIRE(test_iota_sequence());
 }
diff --git a/test/test_mask.cpp b/test/test_mask.cpp
index 049f9403..7bb4e14c 100644
--- a/test/test_mask.cpp
+++ b/test/test_mask.cpp
@@ -138,7 +138,6 @@ constexpr bool test_mask()
         using S = decltype(masked);
         static_assert(flux::multipass_sequence<S>);
         static_assert(flux::bidirectional_sequence<S>);
-        static_assert(not flux::bounded_sequence<S>);
         static_assert(not flux::infinite_sequence<S>);
 
         STATIC_CHECK(check_equal(masked, {0, 2}));
@@ -152,7 +151,6 @@ constexpr bool test_mask()
         static_assert(flux::multipass_sequence<S>);
         static_assert(flux::bidirectional_sequence<S>);
         static_assert(not flux::bounded_sequence<S>);
-        static_assert(flux::infinite_sequence<S>);
 
         flux::cursor auto cur = flux::first(masked);
         STATIC_CHECK(masked[cur] == 1);

From 069050b8f42d151f614deb4520a2dae65d3cce45 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 15 Aug 2025 11:11:47 +0100
Subject: [PATCH 60/66] Make infinite repeat() iterable-only

This is an interesting one, because we're actually removing functionality -- infinite repeat was previously random-access, but we can't do that when we move to collections.

It does raise the question of whether impls should be able to override (certain? all?) algorithms -- because now `repeat(x).take(n)` is iterable-only, whereas we want it to work the same as `repeat(x, n)`, i.e. be random-access. Also, repeat(x).drop(n) could be a no-op, and stride() and reverse() and...
---
 example/docs/repeat.cpp          |  18 ++---
 include/flux/sequence/repeat.hpp | 123 +++++++++++++------------------
 test/test_cursors.cpp            |  20 -----
 test/test_mask.cpp               |   6 +-
 test/test_repeat.cpp             |  90 ++++------------------
 5 files changed, 81 insertions(+), 176 deletions(-)

diff --git a/example/docs/repeat.cpp b/example/docs/repeat.cpp
index 75c9779e..a00573f6 100644
--- a/example/docs/repeat.cpp
+++ b/example/docs/repeat.cpp
@@ -13,21 +13,21 @@ using namespace std::string_view_literals;
 
 int main()
 {
-    // flux::repeat(val) is a random-access sequence which endlessly repeats
+    // flux::repeat(val) is an iterable which endlessly repeats
     // the given value
-    auto seq = flux::repeat(3);
+    auto rep = flux::repeat(3);
 
-    auto cursor = flux::first(seq);
-    assert(flux::read_at(seq, cursor) == 3);
-    // fast-forward the cursor a lot...
-    cursor = flux::next(seq, cursor, 1'000'000);
-    assert(flux::read_at(seq, cursor) == 3); // still returning 3!
+    auto ctx = flux::iterate(rep);
+    assert(flux::next_element(ctx).value() == 3);
+    assert(flux::next_element(ctx).value() == 3);
+    assert(flux::next_element(ctx).value() == 3); // still returning 3!
 
     // We could use the take adaptor to make a repeat sequence finite...
-    auto taken = flux::take(seq, 5);
+    auto taken = flux::take(rep, 5);
     assert(flux::equal(taken, std::array{3, 3, 3, 3, 3}));
 
-    // ...but it's easier to use repeat(val, count) instead
+    // ...but it's better to use repeat(val, count) instead, as this is random-access
     auto police = flux::repeat("hello"sv, 3);
     assert(flux::equal(police, std::array{"hello", "hello", "hello"}));
+    static_assert(flux::random_access_sequence<decltype(police)>);
 }
\ No newline at end of file
diff --git a/include/flux/sequence/repeat.hpp b/include/flux/sequence/repeat.hpp
index 5d7e937b..c8d95e93 100644
--- a/include/flux/sequence/repeat.hpp
+++ b/include/flux/sequence/repeat.hpp
@@ -12,29 +12,46 @@ namespace flux {
 
 namespace detail {
 
-template <bool>
-struct repeat_data {};
+template <typename T>
+struct repeat_iterable : inline_sequence_base<repeat_iterable<T>> {
+private:
+    T obj_;
+
+    struct context_type : immovable {
+    private:
+        T const* ptr_;
+
+    public:
+        constexpr explicit context_type(T const& obj) : ptr_(std::addressof(obj)) { }
+
+        using element_type = T const&;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            while (true) {
+                if (!pred(*ptr_)) {
+                    return iteration_result::incomplete;
+                }
+            }
+        }
+    };
+
+public:
+    constexpr explicit repeat_iterable(decays_to<T> auto&& value) : obj_(FLUX_FWD(value)) { }
 
-template <>
-struct repeat_data<false> { std::size_t count; };
+    constexpr auto iterate() const { return context_type(obj_); }
+};
 
-template <std::movable T, bool IsInfinite>
-struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
-{
+template <typename T>
+struct repeat_sequence : inline_sequence_base<repeat_sequence<T>> {
 private:
     T obj_;
-    FLUX_NO_UNIQUE_ADDRESS repeat_data<IsInfinite> data_;
+    int_t count_;
 
 public:
-    constexpr explicit repeat_sequence(decays_to<T> auto&& obj)
-        requires IsInfinite
-        : obj_(FLUX_FWD(obj))
-    {}
-
-    constexpr repeat_sequence(decays_to<T> auto&& obj, std::size_t count)
-        requires (!IsInfinite)
+    constexpr repeat_sequence(decays_to<T> auto&& obj, int_t count)
         : obj_(FLUX_FWD(obj)),
-          data_{count}
+          count_(count)
     {}
 
     struct flux_sequence_traits : default_sequence_traits {
@@ -42,76 +59,43 @@ struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
         using self_t = repeat_sequence;
 
     public:
-        static inline constexpr bool is_infinite = IsInfinite;
+        static constexpr auto first(self_t const&) -> int_t { return 0; }
 
-        static constexpr auto first(self_t const&) -> std::size_t { return 0; }
-
-        static constexpr auto is_last(self_t const& self, std::size_t cur) -> bool
+        static constexpr auto is_last(self_t const& self, int_t cur) -> bool
         {
-            if constexpr (IsInfinite) {
-                return false;
-            } else {
-                return cur >= self.data_.count;
-            }
+            return cur >= self.count_;
         }
 
-        static constexpr auto inc(self_t const&, std::size_t& cur) -> void
-        {
-            ++cur;
-        }
+        static constexpr auto inc(self_t const&, int_t& cur) -> void { ++cur; }
 
-        static constexpr auto read_at(self_t const& self, std::size_t) -> T const&
-        {
-            return self.obj_;
-        }
+        static constexpr auto read_at(self_t const& self, int_t) -> T const& { return self.obj_; }
 
-        static constexpr auto dec(self_t const&, std::size_t& cur) -> void
-        {
-            --cur;
-        }
+        static constexpr auto dec(self_t const&, int_t& cur) -> void { --cur; }
 
-        static constexpr auto inc(self_t const&, std::size_t& cur, int_t offset) -> void
+        static constexpr auto inc(self_t const&, int_t& cur, int_t offset) -> void
         {
-            cur += static_cast<std::size_t>(offset);
+            cur = num::add(cur, offset);
         }
 
-        static constexpr auto distance(self_t const&, std::size_t from, std::size_t to) -> int_t
+        static constexpr auto distance(self_t const&, int_t from, int_t to) -> int_t
         {
-            return num::cast<int_t>(to) - num::cast<int_t>(from);
+            return to - from;
         }
 
-        static constexpr auto for_each_while(self_t const& self, auto&& pred) -> std::size_t
+        static constexpr auto for_each_while(self_t const& self, auto&& pred) -> int_t
         {
-            if constexpr (IsInfinite) {
-                std::size_t idx = 0;
-                while (true) {
-                    if (!std::invoke(pred, std::as_const(self.obj_))) {
-                        return idx;
-                    }
-                    ++idx;
+            int_t idx = 0;
+            for (; idx < self.count_; ++idx) {
+                if (!std::invoke(pred, std::as_const(self.obj_))) {
+                    break;
                 }
-            } else {
-                std::size_t idx = 0;
-                for ( ; idx < self.data_.count; ++idx) {
-                    if (!std::invoke(pred, std::as_const(self.obj_))) {
-                        break;
-                    }
-                }
-                return idx;
             }
+            return idx;
         }
 
-        static constexpr auto last(self_t const& self) -> std::size_t
-            requires (!IsInfinite)
-        {
-            return self.data_.count;
-        }
+        static constexpr auto last(self_t const& self) -> int_t { return self.count_; }
 
-        static constexpr auto size(self_t const& self) -> int_t
-            requires(!IsInfinite)
-        {
-            return num::cast<int_t>(self.data_.count);
-        }
+        static constexpr auto size(self_t const& self) -> int_t { return self.count_; }
     };
 };
 
@@ -120,7 +104,7 @@ struct repeat_fn {
         requires std::movable<std::decay_t<T>>
     constexpr auto operator()(T&& obj) const
     {
-        return repeat_sequence<std::decay_t<T>, true>(FLUX_FWD(obj));
+        return repeat_iterable<std::decay_t<T>>(FLUX_FWD(obj));
     }
 
     template <typename T>
@@ -131,8 +115,7 @@ struct repeat_fn {
         if (c < 0) {
             runtime_error("Negative count passed to repeat()");
         }
-        return repeat_sequence<std::decay_t<T>, false>(
-            FLUX_FWD(obj), num::checked_cast<std::size_t>(c));
+        return repeat_sequence<std::decay_t<T>>(FLUX_FWD(obj), c);
     }
 };
 
diff --git a/test/test_cursors.cpp b/test/test_cursors.cpp
index f5f864e9..58067890 100644
--- a/test/test_cursors.cpp
+++ b/test/test_cursors.cpp
@@ -41,26 +41,6 @@ constexpr bool test_cursors()
         STATIC_CHECK(check_equal(rev, {4, 3, 2, 1, 0}));
     }
 
-    // Cursors adaptor works with infinite sequences
-    {
-        auto seq = flux::repeat(10);
-
-        auto curs = std::move(seq).cursors();
-
-        using S = decltype(curs);
-
-        static_assert(flux::random_access_sequence<S>);
-        static_assert(not flux::bounded_sequence<S>);
-        static_assert(not flux::sized_sequence<S>);
-        static_assert(flux::infinite_sequence<S>);
-        static_assert(std::same_as<flux::element_t<S>, std::size_t>);
-        static_assert(std::same_as<flux::rvalue_element_t<S>, std::size_t>);
-        static_assert(std::same_as<flux::const_element_t<S>, std::size_t>);
-        static_assert(std::same_as<flux::value_t<S>, std::size_t>);
-
-        STATIC_CHECK(check_equal(flux::take(curs, 5), {0u, 1u, 2u, 3u, 4u}));
-    }
-
     // Cursors adaptor works with adapted sequences
     {
         auto const arr = std::array{101, 102, 103, 104, 105, 106, 107, 108, 109, 110};
diff --git a/test/test_mask.cpp b/test/test_mask.cpp
index 7bb4e14c..26e64e53 100644
--- a/test/test_mask.cpp
+++ b/test/test_mask.cpp
@@ -169,7 +169,7 @@ constexpr bool test_mask()
 
     // mask with empty values sequence is empty
     {
-        auto masked = flux::mask(flux::empty<double>, flux::repeat(true));
+        auto masked = flux::mask(flux::empty<double>, flux::repeat(true, 10));
 
         STATIC_CHECK(masked.is_empty());
     }
@@ -178,7 +178,7 @@ constexpr bool test_mask()
     {
         std::array values{1, 2, 3, 4, 5};
 
-        auto masked = flux::ref(values).mask(flux::repeat(true));
+        auto masked = flux::ref(values).mask(flux::repeat(true, 10));
 
         STATIC_CHECK(check_equal(values, masked));
     }
@@ -187,7 +187,7 @@ constexpr bool test_mask()
     {
         std::array values{1, 2, 3, 4, 5};
 
-        auto masked = flux::ref(values).mask(flux::repeat(false));
+        auto masked = flux::ref(values).mask(flux::repeat(false, 10));
 
         STATIC_CHECK(masked.is_empty());
     }
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index bc56743f..db54bd1e 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -28,29 +28,20 @@ constexpr bool test_repeat()
 
         using S = decltype(seq);
 
-        static_assert(flux::random_access_sequence<S>);
-        static_assert(flux::infinite_sequence<S>);
+        static_assert(flux::iterable<S>);
+        static_assert(not flux::sequence<S>);
         static_assert(not flux::sized_sequence<S>);
         static_assert(not flux::bounded_sequence<S>);
-        static_assert(std::same_as<flux::element_t<S>, int const&>);
-        static_assert(std::same_as<flux::value_t<S>, int>);
-        static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-        static_assert(std::same_as<flux::const_element_t<S>, int const&>);
+        static_assert(std::same_as<flux::iterable_element_t<S>, int const&>);
+        static_assert(std::same_as<flux::iterable_value_t<S>, int>);
+        static_assert(std::same_as<flux::iterable_const_element_t<S>, int const&>);
 
         static_assert(std::is_trivially_copyable_v<S>);
 
         // Check a few elements just to make sure
-        auto cur = flux::first(seq);
+        auto ctx = flux::iterate(seq);
         for (int i = 0; i < 100; i++) {
-            STATIC_CHECK(seq[cur] == 3);
-            seq.inc(cur);
-        }
-
-        // Check that internal iteration works as expected
-        {
-            auto counter = 0;
-            auto inner_cur = flux::seq_for_each_while(seq, [&](int) { return counter++ < 5; });
-            STATIC_CHECK(inner_cur == 5);
+            STATIC_CHECK(flux::next_element(ctx).value() == 3);
         }
     }
 
@@ -60,22 +51,20 @@ constexpr bool test_repeat()
 
         using S = decltype(seq);
 
-        static_assert(flux::random_access_sequence<S>);
-        static_assert(flux::infinite_sequence<S>);
+        static_assert(flux::iterable<S>);
+        static_assert(not flux::sequence<S>);
         static_assert(not flux::sized_sequence<S>);
         static_assert(not flux::bounded_sequence<S>);
-        static_assert(std::same_as<flux::element_t<S>, int const&>);
-        static_assert(std::same_as<flux::value_t<S>, int>);
-        static_assert(std::same_as<flux::rvalue_element_t<S>, int const&&>);
-        static_assert(std::same_as<flux::const_element_t<S>, int const&>);
+        static_assert(std::same_as<flux::iterable_element_t<S>, int const&>);
+        static_assert(std::same_as<flux::iterable_value_t<S>, int>);
+        static_assert(std::same_as<flux::iterable_const_element_t<S>, int const&>);
 
         static_assert(std::is_trivially_copyable_v<S>);
 
         // Check a few elements just to make sure
-        auto cur = flux::first(seq);
+        auto ctx = flux::iterate(seq);
         for (int i = 0; i < 100; i++) {
-            STATIC_CHECK(flux::read_at(seq, cur) == 3);
-            flux::inc(seq, cur);
+            STATIC_CHECK(flux::next_element(ctx).value() == 3);
         }
     }
 
@@ -85,47 +74,12 @@ constexpr bool test_repeat()
 
         using S = decltype(seq);
 
-        static_assert(flux::random_access_sequence<S>);
-        static_assert(flux::sized_sequence<S>);
-        static_assert(flux::bounded_sequence<S>);
+        static_assert(flux::iterable<S>);
+        static_assert(not flux::sequence<S>);
 
         STATIC_CHECK(check_equal(seq, {3, 3, 3, 3, 3}));
     }
 
-    // repeat can wrap around safely
-    {
-        auto seq = flux::repeat(std::string_view("test"));
-
-        auto cur = std::numeric_limits<std::size_t>::max();
-
-        STATIC_CHECK(seq[cur] == "test");
-
-        seq.inc(cur);
-        STATIC_CHECK(cur == std::numeric_limits<std::size_t>::lowest());
-        STATIC_CHECK(seq[cur] == "test");
-
-        seq.dec(cur);
-        STATIC_CHECK(cur == std::numeric_limits<std::size_t>::max());
-        STATIC_CHECK(seq[cur] == "test");
-    }
-
-    // random-access increment works
-    {
-        auto seq = flux::repeat(1.0);
-
-        constexpr auto max_idx = std::numeric_limits<flux::int_t>::max();
-        constexpr auto min_idx = std::numeric_limits<flux::int_t>::lowest();
-
-        auto cur = flux::next(seq, seq.first(), max_idx);
-
-        STATIC_CHECK(seq[cur] == 1.0);
-        STATIC_CHECK(seq.distance(cur, seq.first()) == -max_idx);
-
-        cur = flux::next(seq, seq.first(), min_idx);
-
-        STATIC_CHECK(seq[cur] == 1.0);
-    }
-
     // repeat works with move-only types
     {
         auto seq = flux::repeat(S(3)).take(5);
@@ -258,16 +212,4 @@ TEST_CASE("repeat")
         REQUIRE_THROWS_AS(flux::repeat(3, -100),
                           flux::unrecoverable_error);
     }
-
-    SUBCASE("Unrepresentable distance is caught debug mode")
-    {
-        if constexpr (flux::config::enable_debug_asserts) {
-            auto seq = flux::repeat(3);
-
-            auto cur = std::numeric_limits<std::size_t>::max();
-
-            REQUIRE_THROWS_AS(flux::distance(seq, 0, cur),
-                              flux::unrecoverable_error);
-        }
-    }
 }
\ No newline at end of file

From 4fb790322a0e3d5dd45c46ec11071a3e4ba606ff Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 15 Aug 2025 11:17:20 +0100
Subject: [PATCH 61/66] Make infinite repeat reverse_iterable

That was easy
---
 include/flux/sequence/repeat.hpp |  2 ++
 test/test_repeat.cpp             | 10 ++++++++++
 2 files changed, 12 insertions(+)

diff --git a/include/flux/sequence/repeat.hpp b/include/flux/sequence/repeat.hpp
index c8d95e93..ed1f703c 100644
--- a/include/flux/sequence/repeat.hpp
+++ b/include/flux/sequence/repeat.hpp
@@ -40,6 +40,8 @@ struct repeat_iterable : inline_sequence_base<repeat_iterable<T>> {
     constexpr explicit repeat_iterable(decays_to<T> auto&& value) : obj_(FLUX_FWD(value)) { }
 
     constexpr auto iterate() const { return context_type(obj_); }
+
+    constexpr auto reverse_iterate() const { return context_type(obj_); }
 };
 
 template <typename T>
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index db54bd1e..cca601d3 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -87,6 +87,16 @@ constexpr bool test_repeat()
         STATIC_CHECK(check_equal(seq, {S(3), S(3), S(3), S(3), S(3)}));
     }
 
+    // repeat looks the same backwards and forwards
+    {
+        auto rep = flux::repeat(3);
+
+        auto ctx = flux::reverse_iterate(rep);
+        for (int i = 0; i < 100; i++) {
+            STATIC_CHECK(flux::next_element(ctx).value() == 3);
+        }
+    }
+
     return true;
 }
 static_assert(test_repeat());

From 5273f43ab0e544d9880dc7e0a2fc614d5bbd97e2 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 22 Oct 2025 11:50:52 +0100
Subject: [PATCH 62/66] Disable GCC 15 module builds for now

It's causing odd linker errors relating to flux::detail::unreachable, not really sure what the problem is
---
 .github/workflows/linux.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index 0e6845e9..d0788325 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -22,6 +22,8 @@ jobs:
             test_with: Module
           - compiler: GCC-14
             test_with: Module
+          - compiler: GCC-15
+            test_with: Module
           - compiler: Clang-17
             test_with: Module
 

From 21f21478b06674e50b457f9e9e6b51fc06172a10 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 22 Oct 2025 12:56:28 +0100
Subject: [PATCH 63/66] Fix Codecov CI build failure

Apparently consistency errors with code inlining lambdas is a known problem
---
 include/flux/algorithm/count.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/flux/algorithm/count.hpp b/include/flux/algorithm/count.hpp
index 8b7fe1ba..2d46e303 100644
--- a/include/flux/algorithm/count.hpp
+++ b/include/flux/algorithm/count.hpp
@@ -20,7 +20,9 @@ struct count_t {
             return flux::iterable_size(it);
         } else {
             int_t counter = 0;
+            // LCOV_EXCL_START
             for_each(it, [&](auto&&) { counter = num::add(counter, int_t{1}); });
+            // LCOV_EXCL_STOP
             return counter;
         }
     }

From 284377ffafd580e24cec2cb36547f751b8bed90c Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Wed, 22 Oct 2025 15:12:14 +0100
Subject: [PATCH 64/66] Don't try to count coverage for unreachable()

The whole point of it is that it never gets called...
---
 include/flux/core/utils.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 7d1bd5f1..abf4833e 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -45,6 +45,7 @@ struct copy_fn {
 
 FLUX_EXPORT inline constexpr auto copy = detail::copy_fn{};
 
+FLUX_EXPORT
 struct immovable {
     immovable() = default;
     ~immovable() = default;
@@ -145,6 +146,7 @@ struct emplace_from {
 template <typename Fn>
 emplace_from(Fn) -> emplace_from<Fn>;
 
+// LCOV_EXCL_START
 [[noreturn]] inline void unreachable()
 {
     if constexpr (config::enable_debug_asserts) {
@@ -161,6 +163,7 @@ emplace_from(Fn) -> emplace_from<Fn>;
     std::abort();
 #endif
 }
+// LCOV_EXCL_STOP
 
 } // namespace detail
 

From 16dfcb01c05057b85e1201b5eb5864e48d954985 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 24 Oct 2025 10:58:51 +0100
Subject: [PATCH 65/66] Move bitset sequence impl to default_impls.hpp

---
 include/flux/core/default_impls.hpp | 43 +++++++++++++++++
 include/flux/sequence.hpp           |  1 -
 include/flux/sequence/bitset.hpp    | 73 -----------------------------
 3 files changed, 43 insertions(+), 74 deletions(-)
 delete mode 100644 include/flux/sequence/bitset.hpp

diff --git a/include/flux/core/default_impls.hpp b/include/flux/core/default_impls.hpp
index 2c7bc1b4..c328e1f4 100644
--- a/include/flux/core/default_impls.hpp
+++ b/include/flux/core/default_impls.hpp
@@ -9,6 +9,7 @@
 #include <flux/core/numeric.hpp>
 #include <flux/core/sequence_access.hpp>
 
+#include <bitset>
 #include <functional>
 #include <ranges>
 
@@ -244,6 +245,48 @@ struct sequence_traits<R> : default_sequence_traits {
     }
 };
 
+// Default implementation for std::bitset
+template <std::size_t N>
+struct sequence_traits<std::bitset<N>> : default_sequence_traits {
+
+    using value_type = bool;
+
+    using self_t = std::bitset<N>;
+
+    static constexpr auto first(self_t const&) -> std::size_t { return 0; }
+
+    static constexpr auto is_last(self_t const&, std::size_t idx) { return idx == N; }
+
+    static constexpr auto read_at(self_t& self, std::size_t idx) ->
+        typename std::bitset<N>::reference
+    {
+        return self[idx];
+    }
+
+    static constexpr auto read_at(self_t const& self, std::size_t idx) -> bool { return self[idx]; }
+
+    static constexpr auto move_at(self_t const& self, std::size_t idx) -> bool { return self[idx]; }
+
+    static constexpr auto inc(self_t const&, std::size_t& idx) -> std::size_t& { return ++idx; }
+
+    static constexpr auto dec(self_t const&, std::size_t& idx) -> std::size_t& { return --idx; }
+
+    static constexpr auto inc(self_t const&, std::size_t& idx, std::ptrdiff_t off) -> std::size_t&
+    {
+        return idx += static_cast<std::size_t>(off);
+    }
+
+    static constexpr auto distance(self_t const&, std::size_t from, std::size_t to)
+        -> std::ptrdiff_t
+    {
+        return static_cast<std::ptrdiff_t>(to) - static_cast<std::ptrdiff_t>(from);
+    }
+
+    static constexpr auto last(self_t const&) -> std::size_t { return N; }
+
+    static constexpr auto size(self_t const&) -> std::ptrdiff_t { return N; }
+};
+
 } // namespace flux
 
 #endif // FLUX_CORE_DEFAULT_IMPLS_HPP_INCLUDED
diff --git a/include/flux/sequence.hpp b/include/flux/sequence.hpp
index 69ca21e4..200c691d 100644
--- a/include/flux/sequence.hpp
+++ b/include/flux/sequence.hpp
@@ -6,7 +6,6 @@
 #ifndef FLUX_SEQUENCE_HPP_INCLUDED
 #define FLUX_SEQUENCE_HPP_INCLUDED
 
-#include <flux/sequence/bitset.hpp>
 #include <flux/sequence/empty.hpp>
 #include <flux/sequence/generator.hpp>
 #include <flux/sequence/getlines.hpp>
diff --git a/include/flux/sequence/bitset.hpp b/include/flux/sequence/bitset.hpp
deleted file mode 100644
index 2411494b..00000000
--- a/include/flux/sequence/bitset.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-
-// Copyright (c) 2022 Tristan Brindle (tcbrindle at gmail dot com)
-// 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 FLUX_SEQUENCE_BITSET_HPP_INCLUDED
-#define FLUX_SEQUENCE_BITSET_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-#include <bitset>
-
-namespace flux {
-
-template <std::size_t N>
-struct sequence_traits<std::bitset<N>> : default_sequence_traits {
-
-    using value_type = bool;
-
-    using self_t = std::bitset<N>;
-
-    static constexpr auto first(self_t const&) -> std::size_t { return 0; }
-
-    static constexpr auto is_last(self_t const&, std::size_t idx) { return idx == N; }
-
-    static constexpr auto read_at(self_t& self, std::size_t idx)
-        -> typename std::bitset<N>::reference
-    {
-        return self[idx];
-    }
-
-    static constexpr auto read_at(self_t const& self, std::size_t idx) -> bool
-    {
-        return self[idx];
-    }
-
-    static constexpr auto move_at(self_t const& self, std::size_t idx) -> bool
-    {
-        return self[idx];
-    }
-
-    static constexpr auto inc(self_t const&, std::size_t& idx) -> std::size_t&
-    {
-        return ++idx;
-    }
-
-    static constexpr auto dec(self_t const&, std::size_t& idx) -> std::size_t&
-    {
-        return --idx;
-    }
-
-    static constexpr auto inc(self_t const&, std::size_t& idx, std::ptrdiff_t off)
-        -> std::size_t&
-    {
-        return idx += static_cast<std::size_t>(off);
-    }
-
-    static constexpr auto distance(self_t const&, std::size_t from, std::size_t to)
-        -> std::ptrdiff_t
-    {
-        return static_cast<std::ptrdiff_t>(to) - static_cast<std::ptrdiff_t>(from);
-    }
-
-    static constexpr auto last(self_t const&) -> std::size_t { return N; }
-
-    static constexpr auto size(self_t const&) -> std::ptrdiff_t { return N; }
-
-};
-
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_BITSET_HPP_INCLUDED

From c4a5513990b52335fe443fe24379525e7a3a4a09 Mon Sep 17 00:00:00 2001
From: Tristan Brindle <t.c.brindle@gmail.com>
Date: Fri, 24 Oct 2025 11:10:14 +0100
Subject: [PATCH 66/66] Rename sequence source dir to factory

---
 ...tidimensional_memset_benchmark_kernels.cpp |  2 +-
 include/flux.hpp                              |  2 +-
 include/flux/adaptor/adjacent.hpp             |  2 +-
 include/flux/adaptor/flatten_with.hpp         |  2 +-
 include/flux/adaptor/split.hpp                |  2 +-
 include/flux/adaptor/zip.hpp                  |  2 +-
 include/flux/factory.hpp                      | 19 +++++++++++
 include/flux/{sequence => factory}/empty.hpp  | 20 +++++------
 .../flux/{sequence => factory}/generator.hpp  | 23 ++++++-------
 .../flux/{sequence => factory}/getlines.hpp   |  6 ++--
 include/flux/{sequence => factory}/iota.hpp   | 26 ++++++--------
 .../flux/{sequence => factory}/istream.hpp    |  6 ++--
 .../flux/{sequence => factory}/istreambuf.hpp |  8 ++---
 include/flux/{sequence => factory}/repeat.hpp |  9 ++---
 include/flux/{sequence => factory}/single.hpp | 34 ++++++++-----------
 include/flux/{sequence => factory}/unfold.hpp |  6 ++--
 include/flux/sequence.hpp                     | 19 -----------
 test/test_empty.cpp                           |  2 +-
 18 files changed, 90 insertions(+), 100 deletions(-)
 create mode 100644 include/flux/factory.hpp
 rename include/flux/{sequence => factory}/empty.hpp (86%)
 rename include/flux/{sequence => factory}/generator.hpp (83%)
 rename include/flux/{sequence => factory}/getlines.hpp (93%)
 rename include/flux/{sequence => factory}/iota.hpp (92%)
 rename include/flux/{sequence => factory}/istream.hpp (92%)
 rename include/flux/{sequence => factory}/istreambuf.hpp (88%)
 rename include/flux/{sequence => factory}/repeat.hpp (96%)
 rename include/flux/{sequence => factory}/single.hpp (89%)
 rename include/flux/{sequence => factory}/unfold.hpp (94%)
 delete mode 100644 include/flux/sequence.hpp

diff --git a/benchmark/multidimensional_memset_benchmark_kernels.cpp b/benchmark/multidimensional_memset_benchmark_kernels.cpp
index 69ce8ba6..ee74ec92 100644
--- a/benchmark/multidimensional_memset_benchmark_kernels.cpp
+++ b/benchmark/multidimensional_memset_benchmark_kernels.cpp
@@ -5,7 +5,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <flux/adaptor/cartesian_product.hpp>
-#include <flux/sequence/iota.hpp>
+#include <flux/factory/iota.hpp>
 #include <flux/algorithm/for_each.hpp>
 #include <flux/adaptor/filter.hpp>
 
diff --git a/include/flux.hpp b/include/flux.hpp
index a2b348d5..8db9205f 100644
--- a/include/flux.hpp
+++ b/include/flux.hpp
@@ -9,6 +9,6 @@
 #include <flux/adaptor.hpp>
 #include <flux/algorithm.hpp>
 #include <flux/core.hpp>
-#include <flux/sequence.hpp>
+#include <flux/factory.hpp>
 
 #endif
diff --git a/include/flux/adaptor/adjacent.hpp b/include/flux/adaptor/adjacent.hpp
index acabacb9..5191fe19 100644
--- a/include/flux/adaptor/adjacent.hpp
+++ b/include/flux/adaptor/adjacent.hpp
@@ -10,7 +10,7 @@
 
 #include <flux/adaptor/reverse.hpp>
 #include <flux/adaptor/zip.hpp>
-#include <flux/sequence/iota.hpp>
+#include <flux/factory/iota.hpp>
 
 #include <array>
 
diff --git a/include/flux/adaptor/flatten_with.hpp b/include/flux/adaptor/flatten_with.hpp
index c1d3e47c..ef88fa56 100644
--- a/include/flux/adaptor/flatten_with.hpp
+++ b/include/flux/adaptor/flatten_with.hpp
@@ -8,7 +8,7 @@
 
 #include <flux/core.hpp>
 
-#include <flux/sequence/single.hpp>
+#include <flux/factory/single.hpp>
 
 namespace flux {
 
diff --git a/include/flux/adaptor/split.hpp b/include/flux/adaptor/split.hpp
index 65d02078..659b5d69 100644
--- a/include/flux/adaptor/split.hpp
+++ b/include/flux/adaptor/split.hpp
@@ -9,7 +9,7 @@
 #include <flux/core.hpp>
 #include <flux/algorithm/find.hpp>
 #include <flux/algorithm/search.hpp>
-#include <flux/sequence/single.hpp>
+#include <flux/factory/single.hpp>
 
 namespace flux {
 
diff --git a/include/flux/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index 332c71ee..fed36b13 100644
--- a/include/flux/adaptor/zip.hpp
+++ b/include/flux/adaptor/zip.hpp
@@ -7,7 +7,7 @@
 #define FLUX_ADAPTOR_ZIP_HPP_INCLUDED
 
 #include <flux/core.hpp>
-#include <flux/sequence/empty.hpp>
+#include <flux/factory/empty.hpp>
 
 #include <algorithm> // for std::min({ilist...})
 
diff --git a/include/flux/factory.hpp b/include/flux/factory.hpp
new file mode 100644
index 00000000..c0014441
--- /dev/null
+++ b/include/flux/factory.hpp
@@ -0,0 +1,19 @@
+
+// Copyright (c) 2024 Tristan Brindle (tcbrindle at gmail dot com)
+// 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 FLUX_FACTORY_HPP_INCLUDED
+#define FLUX_FACTORY_HPP_INCLUDED
+
+#include <flux/factory/empty.hpp>
+#include <flux/factory/generator.hpp>
+#include <flux/factory/getlines.hpp>
+#include <flux/factory/iota.hpp>
+#include <flux/factory/istream.hpp>
+#include <flux/factory/istreambuf.hpp>
+#include <flux/factory/repeat.hpp>
+#include <flux/factory/single.hpp>
+#include <flux/factory/unfold.hpp>
+
+#endif // FLUX_FACTORY_HPP_INCLUDED
diff --git a/include/flux/sequence/empty.hpp b/include/flux/factory/empty.hpp
similarity index 86%
rename from include/flux/sequence/empty.hpp
rename to include/flux/factory/empty.hpp
index 4ca1f527..0e7de8d9 100644
--- a/include/flux/sequence/empty.hpp
+++ b/include/flux/factory/empty.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_EMPTY_HPP_INCLUDED
-#define FLUX_SEQUENCE_EMPTY_HPP_INCLUDED
+#ifndef FLUX_FACTORY_EMPTY_HPP_INCLUDED
+#define FLUX_FACTORY_EMPTY_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -31,19 +31,19 @@ struct empty_sequence : inline_sequence_base<empty_sequence<T>> {
             return cur;
         }
 
-        static constexpr auto dec(empty_sequence, cursor_type& cur) -> cursor_type&
-        {
-            return cur;
-        }
+        static constexpr auto dec(empty_sequence, cursor_type& cur) -> cursor_type& { return cur; }
 
-        static constexpr auto distance(empty_sequence, cursor_type, cursor_type)
-            -> std::ptrdiff_t
+        static constexpr auto distance(empty_sequence, cursor_type, cursor_type) -> std::ptrdiff_t
         {
             return 0;
         }
 
         static constexpr auto size(empty_sequence) -> std::ptrdiff_t { return 0; }
-        static constexpr auto data(empty_sequence) -> std::add_pointer_t<T> requires std::is_object_v<T> { return nullptr; }
+        static constexpr auto data(empty_sequence) -> std::add_pointer_t<T>
+            requires std::is_object_v<T>
+        {
+            return nullptr;
+        }
 
         [[noreturn]]
         static constexpr auto read_at(empty_sequence, cursor_type) -> T&
@@ -61,4 +61,4 @@ inline constexpr auto empty = detail::empty_sequence<T>{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_EMPTY_HPP_INCLUDED
+#endif // FLUX_FACTORY_EMPTY_HPP_INCLUDED
diff --git a/include/flux/sequence/generator.hpp b/include/flux/factory/generator.hpp
similarity index 83%
rename from include/flux/sequence/generator.hpp
rename to include/flux/factory/generator.hpp
index 229958d9..956f8071 100644
--- a/include/flux/sequence/generator.hpp
+++ b/include/flux/factory/generator.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_GENERATOR_HPP_INCLUDED
-#define FLUX_SEQUENCE_GENERATOR_HPP_INCLUDED
+#ifndef FLUX_FACTORY_GENERATOR_HPP_INCLUDED
+#define FLUX_FACTORY_GENERATOR_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -28,10 +28,7 @@ struct generator : inline_sequence_base<generator<ElemT>> {
 
         auto final_suspend() noexcept { return std::suspend_always{}; }
 
-        auto get_return_object()
-        {
-            return generator(handle_type::from_promise(*this));
-        }
+        auto get_return_object() { return generator(handle_type::from_promise(*this)); }
 
         auto yield_value(ElemT& elem)
         {
@@ -48,7 +45,7 @@ struct generator : inline_sequence_base<generator<ElemT>> {
 
         auto unhandled_exception() { throw; }
 
-        void return_void() noexcept {}
+        void return_void() noexcept { }
 
         std::add_pointer_t<yielded_type> ptr_;
     };
@@ -76,14 +73,12 @@ struct generator : inline_sequence_base<generator<ElemT>> {
 private:
     handle_type coro_;
 
-    explicit generator(handle_type&& handle) : coro_(std::move(handle)) {}
+    explicit generator(handle_type&& handle) : coro_(std::move(handle)) { }
 
     friend struct sequence_traits<generator>;
 
 public:
-    generator(generator&& other) noexcept
-        : coro_(std::exchange(other.coro_, {}))
-    {}
+    generator(generator&& other) noexcept : coro_(std::exchange(other.coro_, {})) { }
 
     generator& operator=(generator&& other) noexcept
     {
@@ -93,7 +88,9 @@ struct generator : inline_sequence_base<generator<ElemT>> {
 
     ~generator()
     {
-        if (coro_) { coro_.destroy(); }
+        if (coro_) {
+            coro_.destroy();
+        }
     }
 
     auto iterate() -> iteration_context_type { return iteration_context_type(coro_); }
@@ -101,4 +98,4 @@ struct generator : inline_sequence_base<generator<ElemT>> {
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_GENERATOR_HPP_INCLUDED
\ No newline at end of file
+#endif // FLUX_FACTORY_GENERATOR_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/sequence/getlines.hpp b/include/flux/factory/getlines.hpp
similarity index 93%
rename from include/flux/sequence/getlines.hpp
rename to include/flux/factory/getlines.hpp
index a088c98d..ead95ef3 100644
--- a/include/flux/sequence/getlines.hpp
+++ b/include/flux/factory/getlines.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_GETLINES_HPP_INCLUDED
-#define FLUX_SEQUENCE_GETLINES_HPP_INCLUDED
+#ifndef FLUX_FACTORY_GETLINES_HPP_INCLUDED
+#define FLUX_FACTORY_GETLINES_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -77,4 +77,4 @@ FLUX_EXPORT inline constexpr auto getlines = detail::getlines_fn{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_GETLINES_HPP_INCLUDED
+#endif // FLUX_FACTORY_GETLINES_HPP_INCLUDED
diff --git a/include/flux/sequence/iota.hpp b/include/flux/factory/iota.hpp
similarity index 92%
rename from include/flux/sequence/iota.hpp
rename to include/flux/factory/iota.hpp
index 94682b77..017a8f09 100644
--- a/include/flux/sequence/iota.hpp
+++ b/include/flux/factory/iota.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_IOTA_HPP_INCLUDED
-#define FLUX_SEQUENCE_IOTA_HPP_INCLUDED
+#ifndef FLUX_FACTORY_IOTA_HPP_INCLUDED
+#define FLUX_FACTORY_IOTA_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -14,20 +14,16 @@ namespace detail {
 
 // These concepts mirror the standard ones, except that iter_difference_t is not required
 template <typename T>
-concept incrementable =
-    std::regular<T> &&
-    requires (T t) {
-        { ++t } -> std::same_as<T&>;
-        { t++ } -> std::same_as<T>;
-    };
+concept incrementable = std::regular<T> && requires(T t) {
+    { ++t } -> std::same_as<T&>;
+    { t++ } -> std::same_as<T>;
+};
 
 template <typename T>
-concept decrementable =
-    incrementable<T> &&
-    requires (T t) {
-        { --t } -> std::same_as<T&>;
-        { t-- } -> std::same_as<T>;
-    };
+concept decrementable = incrementable<T> && requires(T t) {
+    { --t } -> std::same_as<T&>;
+    { t-- } -> std::same_as<T>;
+};
 
 template <typename T>
 concept advancable = decrementable<T> && std::weakly_incrementable<T> && // iter_difference_t exists
@@ -209,4 +205,4 @@ FLUX_EXPORT inline constexpr auto ints = detail::ints_t{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_IOTA_HPP_INCLUDED
+#endif // FLUX_FACTORY_IOTA_HPP_INCLUDED
diff --git a/include/flux/sequence/istream.hpp b/include/flux/factory/istream.hpp
similarity index 92%
rename from include/flux/sequence/istream.hpp
rename to include/flux/factory/istream.hpp
index 60c45656..5ce99551 100644
--- a/include/flux/sequence/istream.hpp
+++ b/include/flux/factory/istream.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_FROM_ISTREAM_HPP_INCLUDED
-#define FLUX_SEQUENCE_FROM_ISTREAM_HPP_INCLUDED
+#ifndef FLUX_FACTORY_FROM_ISTREAM_HPP_INCLUDED
+#define FLUX_FACTORY_FROM_ISTREAM_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -60,4 +60,4 @@ inline constexpr auto from_istream = detail::from_istream_fn<T>{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_ISTREAM_HPP_INCLUDED
+#endif // FLUX_FACTORY_ISTREAM_HPP_INCLUDED
diff --git a/include/flux/sequence/istreambuf.hpp b/include/flux/factory/istreambuf.hpp
similarity index 88%
rename from include/flux/sequence/istreambuf.hpp
rename to include/flux/factory/istreambuf.hpp
index b0369385..2c1f16b4 100644
--- a/include/flux/sequence/istreambuf.hpp
+++ b/include/flux/factory/istreambuf.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_ISTREAMBUF_HPP_INCLUDED
-#define FLUX_SEQUENCE_ISTREAMBUF_HPP_INCLUDED
+#ifndef FLUX_FACTORY_ISTREAMBUF_HPP_INCLUDED
+#define FLUX_FACTORY_ISTREAMBUF_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -18,7 +18,7 @@ template <typename CharT, typename Traits>
 void derives_from_streambuf_test(std::basic_streambuf<CharT, Traits>&);
 
 template <typename T>
-concept derives_from_streambuf = requires (T& t) { derives_from_streambuf_test(t); };
+concept derives_from_streambuf = requires(T& t) { derives_from_streambuf_test(t); };
 
 } // namespace detail
 
@@ -63,4 +63,4 @@ struct iterable_traits<Streambuf> {
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_ISTREAMBUF_HPP_INCLUDED
+#endif // FLUX_FACTORY_ISTREAMBUF_HPP_INCLUDED
diff --git a/include/flux/sequence/repeat.hpp b/include/flux/factory/repeat.hpp
similarity index 96%
rename from include/flux/sequence/repeat.hpp
rename to include/flux/factory/repeat.hpp
index ed1f703c..c9346350 100644
--- a/include/flux/sequence/repeat.hpp
+++ b/include/flux/factory/repeat.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_REPEAT_HPP_INCLUDED
-#define FLUX_SEQUENCE_REPEAT_HPP_INCLUDED
+#ifndef FLUX_FACTORY_REPEAT_HPP_INCLUDED
+#define FLUX_FACTORY_REPEAT_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -54,7 +54,8 @@ struct repeat_sequence : inline_sequence_base<repeat_sequence<T>> {
     constexpr repeat_sequence(decays_to<T> auto&& obj, int_t count)
         : obj_(FLUX_FWD(obj)),
           count_(count)
-    {}
+    {
+    }
 
     struct flux_sequence_traits : default_sequence_traits {
     private:
@@ -127,4 +128,4 @@ FLUX_EXPORT inline constexpr auto repeat = detail::repeat_fn{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_REPEAT_HPP_INCLUDED
+#endif // FLUX_FACTORY_REPEAT_HPP_INCLUDED
diff --git a/include/flux/sequence/single.hpp b/include/flux/factory/single.hpp
similarity index 89%
rename from include/flux/sequence/single.hpp
rename to include/flux/factory/single.hpp
index 00009215..2d92c89c 100644
--- a/include/flux/sequence/single.hpp
+++ b/include/flux/factory/single.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_SINGLE_HPP_INCLUDED
-#define FLUX_SEQUENCE_SINGLE_HPP_INCLUDED
+#ifndef FLUX_FACTORY_SINGLE_HPP_INCLUDED
+#define FLUX_FACTORY_SINGLE_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -26,19 +26,22 @@ struct single_sequence : inline_sequence_base<single_sequence<T>> {
 
     constexpr explicit single_sequence(T const& obj)
         requires std::copy_constructible<T>
-    : obj_(obj)
-    {}
+        : obj_(obj)
+    {
+    }
 
     constexpr explicit single_sequence(T&& obj)
         requires std::move_constructible<T>
-    : obj_(std::move(obj))
-    {}
+        : obj_(std::move(obj))
+    {
+    }
 
     template <typename... Args>
     constexpr explicit single_sequence(std::in_place_t, Args&&... args)
         requires std::constructible_from<T, Args...>
-    : obj_(FLUX_FWD(args)...)
-    {}
+        : obj_(FLUX_FWD(args)...)
+    {
+    }
 
     constexpr auto value() -> T& { return obj_; }
     constexpr auto value() const -> T const& { return obj_; }
@@ -55,15 +58,13 @@ struct single_fn {
 } // namespace detail
 
 template <typename T>
-struct sequence_traits<detail::single_sequence<T>> : default_sequence_traits
-{
+struct sequence_traits<detail::single_sequence<T>> : default_sequence_traits {
 private:
     using self_t = detail::single_sequence<T>;
 
     enum class cursor_type : bool { valid, done };
 
 public:
-
     static constexpr auto first(self_t const&) { return cursor_type::valid; }
 
     static constexpr auto last(self_t const&) { return cursor_type::done; }
@@ -105,8 +106,7 @@ struct sequence_traits<detail::single_sequence<T>> : default_sequence_traits
         return cur;
     }
 
-    static constexpr auto distance(self_t const&, cursor_type from,
-                                   cursor_type to)
+    static constexpr auto distance(self_t const&, cursor_type from, cursor_type to)
         -> std::ptrdiff_t
     {
         return static_cast<int>(to) - static_cast<int>(from);
@@ -114,20 +114,16 @@ struct sequence_traits<detail::single_sequence<T>> : default_sequence_traits
 
     static constexpr auto size(self_t const&) { return 1; }
 
-    static constexpr auto data(auto& self)
-    {
-        return std::addressof(self.obj_);
-    }
+    static constexpr auto data(auto& self) { return std::addressof(self.obj_); }
 
     static constexpr auto for_each_while(auto& self, auto&& pred)
     {
         return std::invoke(pred, self.obj_) ? cursor_type::done : cursor_type::valid;
     }
-
 };
 
 FLUX_EXPORT inline constexpr auto single = detail::single_fn{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_SINGLE_HPP_INCLUDED
+#endif // FLUX_FACTORY_SINGLE_HPP_INCLUDED
diff --git a/include/flux/sequence/unfold.hpp b/include/flux/factory/unfold.hpp
similarity index 94%
rename from include/flux/sequence/unfold.hpp
rename to include/flux/factory/unfold.hpp
index f1616658..6fdbfbab 100644
--- a/include/flux/sequence/unfold.hpp
+++ b/include/flux/factory/unfold.hpp
@@ -3,8 +3,8 @@
 // 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 FLUX_SEQUENCE_UNFOLD_HPP_INCLUDED
-#define FLUX_SEQUENCE_UNFOLD_HPP_INCLUDED
+#ifndef FLUX_FACTORY_UNFOLD_HPP_INCLUDED
+#define FLUX_FACTORY_UNFOLD_HPP_INCLUDED
 
 #include <flux/core.hpp>
 
@@ -79,4 +79,4 @@ FLUX_EXPORT inline constexpr auto unfold = detail::unfold_fn{};
 
 } // namespace flux
 
-#endif // FLUX_SEQUENCE_UNFOLD_INCLUDED
+#endif // FLUX_FACTORY_UNFOLD_INCLUDED
diff --git a/include/flux/sequence.hpp b/include/flux/sequence.hpp
deleted file mode 100644
index 200c691d..00000000
--- a/include/flux/sequence.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-
-// Copyright (c) 2024 Tristan Brindle (tcbrindle at gmail dot com)
-// 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 FLUX_SEQUENCE_HPP_INCLUDED
-#define FLUX_SEQUENCE_HPP_INCLUDED
-
-#include <flux/sequence/empty.hpp>
-#include <flux/sequence/generator.hpp>
-#include <flux/sequence/getlines.hpp>
-#include <flux/sequence/iota.hpp>
-#include <flux/sequence/istream.hpp>
-#include <flux/sequence/istreambuf.hpp>
-#include <flux/sequence/repeat.hpp>
-#include <flux/sequence/single.hpp>
-#include <flux/sequence/unfold.hpp>
-
-#endif // FLUX_SEQUENCE_HPP_INCLUDED
diff --git a/test/test_empty.cpp b/test/test_empty.cpp
index 602b40df..b50a573f 100644
--- a/test/test_empty.cpp
+++ b/test/test_empty.cpp
@@ -11,7 +11,7 @@
 #ifdef USE_MODULES
 import flux;
 #else
-#include <flux/sequence/empty.hpp>
+#    include <flux/factory/empty.hpp>
 #endif
 
 namespace {