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/.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
 
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>
 
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..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>
 
@@ -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/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/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/example/shortest_path.cpp b/example/shortest_path.cpp
index 50e4681f..b7c21026 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);
@@ -143,8 +139,10 @@ 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::zip(flux::getlines(s1, '\n'), flux::getlines(s2, '\n'))) {
         std::cout << line1 << "  " << line2 << '\n';
     }
 }
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/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/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
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.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 5c5223da..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>
 
@@ -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/adjacent_filter.hpp b/include/flux/adaptor/adjacent_filter.hpp
index bed86d14..fe8f7813 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 {
@@ -143,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));
@@ -152,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/cartesian_base.hpp b/include/flux/adaptor/cartesian_base.hpp
index c61e4a42..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;
 };
@@ -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));
@@ -187,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;
+            });
         }
     }
 
@@ -231,21 +227,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 +263,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 +296,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..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>...>;
@@ -168,7 +242,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 +250,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));
         }
     }
 
@@ -208,9 +282,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 +372,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,13 +385,12 @@ 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);
     }
-
 };
 
 FLUX_EXPORT inline constexpr auto chain = detail::chain_fn{};
diff --git a/include/flux/adaptor/chunk.hpp b/include/flux/adaptor/chunk.hpp
index e215e91b..4e135832 100644
--- a/include/flux/adaptor/chunk.hpp
+++ b/include/flux/adaptor/chunk.hpp
@@ -15,16 +15,136 @@ 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_;
-    distance_t chunk_sz_;
+    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_;
     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)
     {}
@@ -47,18 +167,18 @@ struct chunk_adaptor : 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:
@@ -66,24 +186,24 @@ struct chunk_adaptor : 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_)) {
@@ -93,7 +213,7 @@ struct chunk_adaptor : 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_);
@@ -119,12 +239,12 @@ struct chunk_adaptor : 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) -> distance_t
+        static constexpr auto size(self_t& self) -> int_t
             requires sized_sequence<Base>
         {
             auto s = flux::size(self.base_);
@@ -137,10 +257,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 +296,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 +309,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 +321,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 +379,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 +395,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) {
@@ -295,14 +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<distance_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/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/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..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};
                     }
@@ -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..ca924f09 100644
--- a/include/flux/adaptor/drop.hpp
+++ b/include/flux/adaptor/drop.hpp
@@ -13,21 +13,103 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base>
+template <typename BaseCtx>
+struct drop_iteration_context : 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));
+            }
+        });
+    }
+};
+
+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) {
+            return base_ctx.run_while([&](auto&& elem) {
+                --remaining;
+                return pred(FLUX_FWD(elem)) && (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_;
-    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)
-    {}
+    {
+    }
 
     constexpr Base& base() & { return base_; }
     constexpr Base const& base() const& { return base_; }
 
+    [[nodiscard]] constexpr auto iterate()
+    {
+        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<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<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<reverse_iteration_context_t<Base const>>{
+            .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 sz > count_ ? sz - count_ : 0;
+    }
+
+    [[nodiscard]] constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        auto sz = flux::iterable_size(base_);
+        return sz > count_ ? sz - count_ : 0;
+    }
+
     struct flux_sequence_traits : passthrough_traits_base {
         using value_type = value_t<Base>;
 
@@ -43,8 +125,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)
@@ -61,16 +142,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<distance_t>(count);
+        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/include/flux/adaptor/drop_while.hpp b/include/flux/adaptor/drop_while.hpp
index ecd9c49b..12038d8f 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,20 +23,59 @@ 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<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<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 {
         static constexpr bool disable_multipass = !multipass_sequence<Base>;
 
         static constexpr auto first(auto& self)
+            requires sequence<decltype((self.base_))>
         {
-            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)
@@ -52,12 +91,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));
     }
 };
 
@@ -67,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 ba5ff208..413d44a8 100644
--- a/include/flux/adaptor/filter.hpp
+++ b/include/flux/adaptor/filter.hpp
@@ -13,12 +13,30 @@ namespace flux {
 
 namespace detail {
 
-template <sequence Base, typename Pred>
-class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>>
-{
+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, 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 +48,34 @@ 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<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<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<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<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 {
     private:
         struct cursor_type {
@@ -41,52 +87,54 @@ 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)
+            -> 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_))};
         }
 
-        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 {
@@ -94,16 +142,15 @@ 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::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 {
@@ -115,12 +162,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));
     }
 };
 
@@ -130,7 +177,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 f5d26e56..4602b7e3 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);
+                         });
     }
 };
 
@@ -39,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));
@@ -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); });
     }
 };
 
@@ -63,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 bd30e5a6..91abbd19 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:
@@ -187,8 +307,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),
@@ -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));
     }
 };
 
@@ -246,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 0b31a93e..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 {
 
@@ -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)));
     }
 };
 
@@ -368,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));
@@ -378,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 010ba45f..c3d38139 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,48 @@ 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
+    [[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_)};
+    }
+
+    [[nodiscard]] constexpr auto iterate() const
+        requires iterable<Base const>
+        && std::regular_invocable<Func&, iterable_element_t<Base const>>
     {
-        using value_type = std::remove_cvref_t<std::invoke_result_t<Func&, element_t<Base>>>;
+        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_)};
+    }
+
+    [[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>
+    {
+        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>;
 
@@ -57,7 +106,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)));
             });
         }
@@ -70,12 +119,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));
     }
 };
 
@@ -85,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 df7ad3b9..f661a2be 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
     {
@@ -157,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/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/adaptor/reverse.hpp b/include/flux/adaptor/reverse.hpp
index 2296692f..d5441f4c 100644
--- a/include/flux/adaptor/reverse.hpp
+++ b/include/flux/adaptor/reverse.hpp
@@ -12,160 +12,177 @@ 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_;
 
+    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_); }
 
-    struct flux_sequence_traits {
-    private:
-        struct cursor_type {
-            cursor_t<Base> base_cur;
-
-            friend bool operator==(cursor_type const&, cursor_type const&)
-                requires std::equality_comparable<cursor_t<Base>>
-            = default;
-
-            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;
-            }
-        };
-
-    public:
-        using value_type = value_t<Base>;
-
-        static constexpr auto first(auto& self) -> cursor_type
+    struct flux_iterable_traits {
+        static constexpr auto iterate(auto& self)
+            requires reverse_iterable<decltype((self.base_))>
         {
-            return cursor_type(flux::last(self.base_));
+            return flux::reverse_iterate(self.base_);
         }
 
-        static constexpr auto last(auto& self) -> cursor_type
+        static constexpr auto reverse_iterate(auto& self)
+            requires iterable<decltype((self.base_))>
         {
-            return cursor_type(flux::first(self.base_));
+            return flux::iterate(self.base_);
         }
 
-        static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+        static constexpr auto size(auto& self)
+            requires sized_iterable<decltype((self.base_))>
         {
-            return cur.base_cur == flux::first(self.base_);
+            return flux::iterable_size(self.base_);
         }
+    };
+};
 
-        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));
-        }
+template <typename>
+inline constexpr bool is_reverse_adaptor = false;
 
-        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));
-        }
+template <typename Base>
+inline constexpr bool is_reverse_adaptor<reverse_adaptor<Base>> = true;
 
-        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));
+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));
         }
+    }
+};
 
-        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));
-        }
+} // namespace detail
 
-        static constexpr auto inc(auto& self, cursor_type& cur) -> void
-        {
-            flux::dec(self.base_, cur.base_cur);
-        }
+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 dec(auto& self, cursor_type& cur) -> void
-        {
-            flux::inc(self.base_, cur.base_cur);
-        }
+        friend bool operator==(cursor_type const&, cursor_type const&)
+            requires std::equality_comparable<cursor_t<Base>>
+        = default;
 
-        static constexpr auto inc(auto& self, cursor_type& cur, distance_t dist) -> void
+        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>
         {
-            flux::inc(self.base_, cur.base_cur, num::neg(dist));
+            return rhs.base_cur <=> lhs.base_cur;
         }
+    };
 
-        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> distance_t
-        {
-            return flux::distance(self.base_, to.base_cur, from.base_cur);
-        }
+public:
+    using value_type = value_t<Base>;
 
-        static constexpr auto size(auto& self) -> distance_t
-            requires sized_sequence<decltype((self.base_))>
-        {
-            return flux::size(self.base_);
-        }
+    static constexpr auto first(auto& self) -> cursor_type
+    {
+        return cursor_type(flux::last(self.base_));
+    }
 
-        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 last(auto& self) -> cursor_type
+    {
+        return cursor_type(flux::first(self.base_));
+    }
 
-            return cursor_type(cur);
-        }
-    };
-};
+    static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
+    {
+        return cur.base_cur == flux::first(self.base_);
+    }
 
-template <typename>
-inline constexpr bool is_reverse_adaptor = false;
+    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));
+    }
 
-template <typename Base>
-inline constexpr bool is_reverse_adaptor<reverse_adaptor<Base>> = true;
+    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));
+    }
 
-struct reverse_fn {
-    template <adaptable_sequence Seq>
-        requires bidirectional_sequence<Seq> &&
-                 bounded_sequence<Seq>
-    [[nodiscard]]
-    constexpr auto operator()(Seq&& seq) const
-        -> sequence auto
+    template <typename Self>
+    static constexpr auto move_at(Self& self, cursor_type const& cur)
+        -> rvalue_element_t<decltype((self.base_))>
     {
-        if constexpr (is_reverse_adaptor<std::decay_t<Seq>>) {
-            return FLUX_FWD(seq).base();
-        } else {
-            return reverse_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq));
+        return flux::move_at(self.base_, flux::prev(self.base_, cur.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 inc(auto& self, cursor_type& cur) -> void
+    {
+        flux::dec(self.base_, cur.base_cur);
+    }
+
+    static constexpr auto dec(auto& self, cursor_type& cur) -> void
+    {
+        flux::inc(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));
+    }
+
+    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);
+    }
+
+    static constexpr auto size(auto& self) -> int_t
+        requires sized_sequence<decltype((self.base_))>
+    {
+        return flux::size(self.base_);
+    }
+
+    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;
+            }
         }
+
+        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/adaptor/scan.hpp b/include/flux/adaptor/scan.hpp
index d3ac9fb7..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:
 
@@ -128,11 +168,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_);
             }
@@ -141,7 +181,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_));
             }));
@@ -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 1c781e71..86496d14 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:
@@ -89,7 +134,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_);
@@ -97,7 +142,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_,
@@ -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));
     }
 };
 
@@ -130,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/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
     {
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/split.hpp b/include/flux/adaptor/split.hpp
index 56e132d0..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 {
 
@@ -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/stride.hpp b/include/flux/adaptor/stride.hpp
index c5f623f8..83e278e1 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);
@@ -61,14 +61,38 @@ 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_;
-    distance_t stride_;
+    int_t stride_;
+
+    friend struct sequence_traits<stride_adaptor>;
 
 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)
     {}
@@ -76,189 +100,220 @@ 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<iteration_context_t<Base>>{.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<iteration_context_t<Base const>>{
+            .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<reverse_iteration_context_t<Base>>{
+            .base_ctx = flux::reverse_iterate(base_), .stride = stride_, .skip = initial_skip};
+    }
 
-        static constexpr auto size(auto& self) -> distance_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<reverse_iteration_context_t<Base const>>{
+            .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_))>
-        {
-            distance_t n = self.stride_;
-            return 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));
-                }
-            });
-        }
+    [[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_;
-    distance_t stride_;
+} // namespace detail
 
-public:
-    constexpr stride_adaptor(decays_to<Base> auto&& base, distance_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{};
-            distance_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;
+
+    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);
+    }
 
-            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 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>
-        {
-            distance_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) -> distance_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) -> distance_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, distance_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_))>
-        {
-            distance_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));
-                }
-            });
-            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<distance_t>(by));
+        return stride_adaptor<std::decay_t<It>>(FLUX_FWD(it), num::checked_cast<int_t>(by));
     }
 };
 
diff --git a/include/flux/adaptor/take.hpp b/include/flux/adaptor/take.hpp
index 025a1c73..3f0820d7 100644
--- a/include/flux/adaptor/take.hpp
+++ b/include/flux/adaptor/take.hpp
@@ -7,20 +7,22 @@
 #define FLUX_ADAPTOR_TAKE_HPP_INCLUDED
 
 #include <flux/core.hpp>
+#include <flux/adaptor/drop.hpp>
 
 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_;
-    distance_t count_;
+    int_t count_;
+
+    friend struct sequence_traits<take_adaptor>;
 
 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)
     {}
@@ -28,136 +30,173 @@ 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_); }
 
-    struct flux_sequence_traits {
-    private:
-        struct cursor_type {
-            cursor_t<Base> base_cur;
-            distance_t length;
+    [[nodiscard]] constexpr auto iterate()
+    {
+        return take_iteration_context<iteration_context_t<Base>>{.base_ctx = flux::iterate(base_),
+                                                                 .remaining = count_};
+    }
 
-            friend bool operator==(cursor_type const&, cursor_type const&) = default;
-            friend auto operator<=>(cursor_type const& lhs, cursor_type const& rhs) = default;
-        };
+    [[nodiscard]] constexpr auto iterate() const
+        requires iterable<Base const>
+    {
+        return take_iteration_context<iteration_context_t<Base const>>{
+            .base_ctx = flux::iterate(base_), .remaining = count_};
+    }
 
-    public:
-        using value_type = value_t<Base>;
+    [[nodiscard]] constexpr auto reverse_iterate()
+        requires reverse_iterable<Base> && sized_iterable<Base>
+    {
+        int_t sz = flux::iterable_size(base_);
+        return drop_iteration_context<reverse_iteration_context_t<Base>>{
+            .base_ctx = flux::reverse_iterate(base_), .remaining = sz > count_ ? sz - count_ : 0};
+    }
 
-        static constexpr auto first(auto& self) -> cursor_type
-        {
-            return cursor_type{.base_cur = flux::first(self.base_),
-                               .length = self.count_};
-        }
+    [[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<reverse_iteration_context_t<Base const>>{
+            .base_ctx = flux::reverse_iterate(base_), .remaining = sz > count_ ? sz - count_ : 0};
+    }
 
-        static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
-        {
-            return cur.length <= 0 || flux::is_last(self.base_, cur.base_cur);
-        }
+    [[nodiscard]] constexpr auto size() -> int_t
+        requires sized_iterable<Base>
+    {
+        return (cmp::min)(flux::iterable_size(base_), count_);
+    }
 
-        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});
-        }
+    [[nodiscard]] constexpr auto size() const -> int_t
+        requires sized_iterable<Base const>
+    {
+        return (cmp::min)(flux::iterable_size(base_), count_);
+    }
+};
 
-        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);
+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()");
         }
 
-        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);
-        }
+        return take_adaptor<std::decay_t<It>>(FLUX_FWD(it), count_);
+    }
+};
 
-        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);
-        }
+} // namespace detail
 
-        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);
-        }
+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 dec(auto& self, cursor_type& cur)
-            requires bidirectional_sequence<Base>
-        {
-            flux::dec(self.base_, cur.base_cur);
-            cur.length = num::add(cur.length, distance_t{1});
-        }
+        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, distance_t offset)
-            requires random_access_sequence<Base>
-        {
-            flux::inc(self.base_, cur.base_cur, offset);
-            cur.length = num::sub(cur.length, offset);
-        }
+public:
+    using value_type = value_t<Base>;
 
-        static constexpr auto distance(auto& self, cursor_type const& from, cursor_type const& to)
-            -> distance_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 first(auto& self) -> cursor_type
+    {
+        return cursor_type{.base_cur = flux::first(self.base_), .length = self.count_};
+    }
 
-        static constexpr auto data(auto& self)
-            -> decltype(flux::data(self.base_))
-            requires contiguous_sequence<Base>
-        {
-            return flux::data(self.base_);
-        }
+    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 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)
+    {
+        flux::inc(self.base_, cur.base_cur);
+        cur.length = num::sub(cur.length, int_t{1});
+    }
 
-        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 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 for_each_while(auto& self, auto&& pred) -> cursor_type
-        {
-            distance_t len = self.count_;
-            auto cur = flux::for_each_while(self.base_, [&](auto&& elem) {
-                return (len-- > 0) && std::invoke(pred, FLUX_FWD(elem));
-            });
+    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);
+    }
 
-            return cursor_type{.base_cur = std::move(cur), .length = ++len};
-        }
-    };
-};
+    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);
+    }
 
-struct take_fn {
-    template <adaptable_sequence Seq>
-    [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, num::integral auto count) const
+    static constexpr auto move_at_unchecked(auto& self, cursor_type const& cur)
+        -> decltype(flux::move_at_unchecked(self.base_, cur.base_cur))
     {
-        auto count_ = num::checked_cast<distance_t>(count);
-        if (count_ < 0) {
-            runtime_error("Negative argument passed to take()");
+        return flux::move_at_unchecked(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 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 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 data(auto& self) -> decltype(flux::data(self.base_))
+        requires contiguous_sequence<Base>
+    {
+        return flux::data(self.base_);
+    }
+
+    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_);
         }
+    }
 
-        return take_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq), count_);
+    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};
     }
-};
 
-} // namespace detail
+    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};
+    }
+};
 
 FLUX_EXPORT inline constexpr auto take = detail::take_fn{};
 
@@ -165,7 +204,7 @@ 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/adaptor/take_while.hpp b/include/flux/adaptor/take_while.hpp
index 464968d0..1dbfa73b 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,73 @@ 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<iteration_context_t<Base>, copy_or_ref_t<Pred>>{
+            .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<iteration_context_t<Base const>, copy_or_ref_t<Pred const>>{
+            .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>;
@@ -73,7 +113,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 {
@@ -87,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/adaptor/zip.hpp b/include/flux/adaptor/zip.hpp
index 67c756b1..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...})
 
@@ -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), ...);
@@ -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,26 +142,92 @@ 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 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 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
+        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)...);
         }
     }
 };
 
-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_;
@@ -170,31 +236,101 @@ 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 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 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
+        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)...);
         }
     }
 };
 
 } // 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...>;
 
@@ -243,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/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/all_any_none.hpp b/include/flux/algorithm/all_any_none.hpp
index 6f0c8b44..6b18c3b6 100644
--- a/include/flux/algorithm/all_any_none.hpp
+++ b/include/flux/algorithm/all_any_none.hpp
@@ -6,64 +6,55 @@
 #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, 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, 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, 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>
-    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));
@@ -71,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));
@@ -79,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/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 95ec9ff9..52eb6e21 100644
--- a/include/flux/algorithm/contains.hpp
+++ b/include/flux/algorithm/contains.hpp
@@ -6,32 +6,26 @@
 #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::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>
-    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 756fd079..2d46e303 100644
--- a/include/flux/algorithm/count.hpp
+++ b/include/flux/algorithm/count.hpp
@@ -6,71 +6,61 @@
 #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 -> distance_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 {
-            distance_t counter = 0;
-            flux::for_each_while(seq, [&](auto&&) {
-                ++counter;
-                return true;
-            });
+            int_t counter = 0;
+            // LCOV_EXCL_START
+            for_each(it, [&](auto&&) { counter = num::add(counter, int_t{1}); });
+            // LCOV_EXCL_STOP
             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
-        -> distance_t
+    constexpr auto operator()(It&& it, Pred pred) const -> int_t
     {
-        distance_t counter = 0;
-        flux::for_each_while(seq, [&](auto&& elem) {
-            if (value == FLUX_FWD(elem)) {
+        int_t counter = 0;
+        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
-        -> distance_t
+    constexpr auto operator()(It&& it, Value const& value) const -> int_t
     {
-        distance_t counter = 0;
-        flux::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()
@@ -80,7 +70,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);
@@ -88,7 +78,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/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..820279a2 100644
--- a/include/flux/algorithm/ends_with.hpp
+++ b/include/flux/algorithm/ends_with.hpp
@@ -6,91 +6,47 @@
 #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 {
-            distance_t len1 = flux::count(haystack);
-            distance_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>
-    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/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.hpp b/include/flux/algorithm/find.hpp
index 06e0cfd9..d1795cea 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)); });
     }
 };
 
@@ -91,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);
@@ -99,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));
@@ -107,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/find_element.hpp b/include/flux/algorithm/find_element.hpp
new file mode 100644
index 00000000..331e7d86
--- /dev/null
+++ b/include/flux/algorithm/find_element.hpp
@@ -0,0 +1,42 @@
+// 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>>
+    [[nodiscard]]
+    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&>
+    [[nodiscard]]
+    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 8e01e75b..c237a63b 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, 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
     {
         R init_ = R(std::move(init));
-        flux::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,68 @@ 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&, 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));
@@ -132,16 +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 43a59917..a1dc7675 100644
--- a/include/flux/algorithm/for_each.hpp
+++ b/include/flux/algorithm/for_each.hpp
@@ -6,34 +6,29 @@
 #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::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>
-    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/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..ea439c42 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<iterable_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,16 @@ 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, iterable_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..1ab01fc1 100644
--- a/include/flux/algorithm/starts_with.hpp
+++ b/include/flux/algorithm/starts_with.hpp
@@ -10,41 +10,44 @@
 
 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>
-    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/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/to.hpp b/include/flux/algorithm/to.hpp
index 6f3d06c9..6d4fd04c 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,49 +75,75 @@ 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)...))>{};
     } 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>>>{};
     }
 }
 
@@ -119,44 +155,52 @@ 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<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...>) {
+            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)...);
     }
 }
 
 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/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 a53bacdc..c084acbc 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,25 +14,54 @@ 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::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;
-                    }
-                    (flux::inc(seqs, curs), ...);
+#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;
                 }
-                return std::tuple<cursor_t<Seqs>...>(std::move(curs)...);
+
+                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) {
+                        if (!(opts.has_value() && ...)) {
+                            return iteration_result::complete;
+                        }
+                        if (!std::invoke(pred, opts.value_unchecked()...)) {
+                            return iteration_result::incomplete;
+                        }
+                        ((opts = step(ctxs, std::identity {})), ...);
+                    }
+                }();
             }();
+#endif
         }
     }
 };
@@ -61,7 +91,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.hpp b/include/flux/core.hpp
index 67064f8f..617b1745 100644
--- a/include/flux/core.hpp
+++ b/include/flux/core.hpp
@@ -6,10 +6,12 @@
 #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>
 #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/as_range.hpp b/include/flux/core/as_range.hpp
new file mode 100644
index 00000000..1d3cb368
--- /dev/null
+++ b/include/flux/core/as_range.hpp
@@ -0,0 +1,91 @@
+// 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;
+
+        constexpr 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 -> 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<std::remove_reference_t<It>>>(
+                    std::ref(it));
+            } else {
+                return detail::iterable_range<It>(FLUX_FWD(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/concepts.hpp b/include/flux/core/concepts.hpp
index 21201932..8dd6b223 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
@@ -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>
@@ -403,7 +402,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..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>
 
@@ -38,7 +39,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 +47,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 +126,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 +151,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 +185,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 +202,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*
@@ -246,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/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index 735287d7..4d2d69c3 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`
     ///
@@ -122,11 +125,11 @@ 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::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
@@ -211,27 +214,30 @@ struct inline_sequence_base {
      */
     constexpr auto begin() &;
 
-    constexpr auto begin() const& requires sequence<Derived const>;
+    constexpr auto begin() const&
+        requires iterable<Derived const>;
 
     constexpr auto end() &;
 
-    constexpr auto end() const& requires sequence<Derived const>;
+    constexpr auto end() const&
+        requires iterable<Derived const>;
 
     /*
      * 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> &&
-                 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) &&;
 
-    template <distance_t N, typename Func>
+    template <int_t N, typename Func>
         requires multipass_sequence<Derived>
     [[nodiscard]]
     constexpr auto adjacent_map(Func func) &&;
@@ -245,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) &&;
 
@@ -262,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_) &&;
 
@@ -332,15 +338,15 @@ 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 = 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) &&;
 
@@ -348,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) &&;
 
@@ -377,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) &&;
 
@@ -387,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
@@ -405,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>
@@ -424,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);
 
@@ -459,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()
@@ -485,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> &&
@@ -506,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>
diff --git a/include/flux/core/iterable_concepts.hpp b/include/flux/core/iterable_concepts.hpp
new file mode 100644
index 00000000..6b141a3f
--- /dev/null
+++ b/include/flux/core/iterable_concepts.hpp
@@ -0,0 +1,544 @@
+// 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/numeric.hpp>
+#include <flux/core/optional.hpp>
+#include <flux/core/sequence_access.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) const
+    {
+        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{};
+
+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
+ */
+
+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> || sequence<T>
+    || (!derived_from_inline_sequence_base<T> && std::ranges::input_range<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_)) {
+            if (!pred(read_at_unchecked(*ptr_, cur_))) {
+                inc(*ptr_, cur_);
+                return iteration_result::incomplete;
+            }
+            inc(*ptr_, cur_);
+        }
+
+        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 detail::iter_traits_t<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 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 = typename T::value_type;
+};
+
+} // namespace detail
+
+FLUX_EXPORT template <typename I>
+using iterable_value_t = typename detail::iterable_value_type<I>::type;
+
+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) {
+    { iterate(it) } -> iteration_context;
+} && requires {
+    typename 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
+ */
+
+namespace detail {
+
+template <typename T>
+concept has_iterable_traits_size = requires(T& t) {
+    { iter_traits_t<T>::size(t) } -> num::integral;
+};
+
+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
+ */
+
+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 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>>>;
+
+/*
+ * 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>);
+
+/*
+ * 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/operation_requirements.hpp b/include/flux/core/operation_requirements.hpp
index a80d9b21..b178b4bb 100644
--- a/include/flux/core/operation_requirements.hpp
+++ b/include/flux/core/operation_requirements.hpp
@@ -7,23 +7,22 @@
 #define FLUX_CORE_OPERATION_REQUIREMENTS_HPP_INCLUDED
 
 #include <flux/core/concepts.hpp>
+#include <flux/core/iterable_concepts.hpp>
 
 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, distance_t N>
+template <typename Func, typename E, int_t N>
 struct repeated_invocable_helper {
     template <std::size_t I>
     using repeater = E;
@@ -33,34 +32,29 @@ 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>
-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
 
 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 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/ref.hpp b/include/flux/core/ref.hpp
index 81ed1449..9c95b257 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);
@@ -105,13 +105,13 @@ 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));
     }
 };
 
-template <sequence Base>
+template <iterable Base>
 struct ref_adaptor : inline_sequence_base<ref_adaptor<Base>> {
 private:
     Base* base_;
@@ -143,8 +143,16 @@ 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>;
+        using value_type = iterable_value_t<Base>;
     };
 };
 
@@ -155,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>
@@ -210,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/core/sequence_access.hpp b/include/flux/core/sequence_access.hpp
index 86bbc3b8..422e4306 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);
     }
@@ -161,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>>>
@@ -186,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 {
 
@@ -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..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:
@@ -39,7 +74,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>());
 
@@ -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;
         }
@@ -213,7 +256,7 @@ constexpr auto inline_sequence_base<D>::begin() &
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::begin() const&
-    requires sequence<D const>
+    requires iterable<D const>
 {
     return flux::begin(derived());
 };
@@ -226,7 +269,7 @@ constexpr auto inline_sequence_base<D>::end() &
 
 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/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index 44a12811..abf4833e 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -8,7 +8,9 @@
 
 #include <compare>
 #include <concepts>
+#include <functional>
 #include <type_traits>
+#include <utility>
 
 #include <flux/core/assert.hpp>
 
@@ -43,6 +45,16 @@ struct copy_fn {
 
 FLUX_EXPORT inline constexpr auto copy = detail::copy_fn{};
 
+FLUX_EXPORT
+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 +78,95 @@ 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;
+
+    constexpr ~defer_t() { fn(); }
+};
+
+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);
+    }
+}
+
+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>;
+
+// LCOV_EXCL_START
+[[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
+}
+// LCOV_EXCL_STOP
+
+} // namespace detail
+
 } // namespace flux
 
 #endif
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 83%
rename from include/flux/sequence/empty.hpp
rename to include/flux/factory/empty.hpp
index a32b5654..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>
 
@@ -26,25 +26,24 @@ 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;
         }
 
-        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&
@@ -62,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/factory/generator.hpp b/include/flux/factory/generator.hpp
new file mode 100644
index 00000000..956f8071
--- /dev/null
+++ b/include/flux/factory/generator.hpp
@@ -0,0 +1,101 @@
+
+// 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_FACTORY_GENERATOR_HPP_INCLUDED
+#define FLUX_FACTORY_GENERATOR_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+#include <coroutine>
+#include <utility>
+
+namespace flux {
+
+FLUX_EXPORT
+template <typename ElemT>
+struct generator : inline_sequence_base<generator<ElemT>> {
+
+    using yielded_type = ElemT&&;
+
+    struct promise_type;
+
+    using handle_type = std::coroutine_handle<promise_type>;
+
+    struct promise_type {
+        auto initial_suspend() { return std::suspend_always{}; }
+
+        auto final_suspend() noexcept { return std::suspend_always{}; }
+
+        auto get_return_object() { return generator(handle_type::from_promise(*this)); }
+
+        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{};
+        }
+
+        auto unhandled_exception() { throw; }
+
+        void return_void() noexcept { }
+
+        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_;
+
+    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& operator=(generator&& other) noexcept
+    {
+        std::swap(coro_, other.coro_);
+        return *this;
+    }
+
+    ~generator()
+    {
+        if (coro_) {
+            coro_.destroy();
+        }
+    }
+
+    auto iterate() -> iteration_context_type { return iteration_context_type(coro_); }
+};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_GENERATOR_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/factory/getlines.hpp b/include/flux/factory/getlines.hpp
new file mode 100644
index 00000000..ead95ef3
--- /dev/null
+++ b/include/flux/factory/getlines.hpp
@@ -0,0 +1,80 @@
+
+// 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_FACTORY_GETLINES_HPP_INCLUDED
+#define FLUX_FACTORY_GETLINES_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+#include <iosfwd>
+#include <string>
+
+namespace flux {
+
+namespace detail {
+
+template <typename CharT, typename 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;
+    char_type delim_{};
+
+    struct context_type : immovable {
+        istream_type* is_;
+        string_type str_;
+        char_type delim_;
+
+        using element_type = string_type const&;
+
+        explicit context_type(getlines_iterable& iterable)
+            : is_(iterable.is_),
+              delim_(iterable.delim_)
+        {
+        }
+
+        auto run_while(auto&& pred) -> iteration_result
+        {
+            while (std::getline(*is_, str_, delim_)) {
+                if (!std::invoke(pred, static_cast<element_type>(str_))) {
+                    return iteration_result::incomplete;
+                }
+            }
+            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_iterable<CharT, Traits>(istream, delim);
+    }
+
+    template <typename CharT, typename Traits>
+    constexpr auto operator()(std::basic_istream<CharT, Traits>& istream) const
+    {
+        return getlines_iterable<CharT, Traits>(istream, istream.widen('\n'));
+    }
+};
+
+} // namespace detail
+
+FLUX_EXPORT inline constexpr auto getlines = detail::getlines_fn{};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_GETLINES_HPP_INCLUDED
diff --git a/include/flux/factory/iota.hpp b/include/flux/factory/iota.hpp
new file mode 100644
index 00000000..017a8f09
--- /dev/null
+++ b/include/flux/factory/iota.hpp
@@ -0,0 +1,208 @@
+
+// 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_FACTORY_IOTA_HPP_INCLUDED
+#define FLUX_FACTORY_IOTA_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+namespace flux {
+
+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>;
+};
+
+template <typename 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
+    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);
+        T(o + u);
+        T(u - o);
+        { u - u } -> std::convertible_to<int_t>;
+    };
+
+template <incrementable T>
+struct iota_iterable : inline_sequence_base<iota_iterable<T>> {
+    T from;
+
+    struct iteration_context : immovable {
+        T value;
+
+        using element_type = T;
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            while (true) {
+                if (!pred(value++)) {
+                    return iteration_result::incomplete;
+                }
+            }
+        }
+    };
+
+    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;
+        }
+    };
+
+    struct reverse_iteration_context : immovable {
+        T value;
+        T first;
+
+        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;
+        }
+    };
+
+    constexpr auto iterate() const -> iteration_context
+    {
+        return iteration_context{.value = from, .last = to};
+    }
+
+    constexpr auto reverse_iterate() const -> reverse_iteration_context
+        requires decrementable<T>
+    {
+        return reverse_iteration_context{.value = to, .first = from};
+    }
+
+    constexpr auto size() const -> int_t
+        requires advancable<T>
+    {
+        return num::cast<int_t>(to - from);
+    }
+};
+
+template <incrementable T>
+    requires std::totally_ordered<T>
+struct iota_sequence : inline_sequence_base<iota_sequence<T>> {
+    T from;
+    T to;
+
+    struct flux_sequence_traits : default_sequence_traits {
+        using self_t = iota_sequence;
+
+        struct cursor_type {
+            T current;
+
+            friend auto operator<=>(cursor_type const&, cursor_type const&) -> std::strong_ordering
+                = default;
+        };
+
+        static constexpr auto first(self_t const& self) -> cursor_type { return {self.from}; }
+
+        static constexpr auto last(self_t const& self) -> cursor_type { return {self.to}; }
+
+        static constexpr auto is_last(self_t const& self, cursor_type const& cur) -> bool
+        {
+            return cur.current == self.to;
+        }
+
+        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 auto read_at(self_t const&, cursor_type const& cur) -> T
+        {
+            return cur.current;
+        }
+
+        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);
+        }
+
+        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_t {
+    template <incrementable T>
+    constexpr auto operator()(T from, T to) const
+    {
+        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) const
+    {
+        if constexpr (std::is_arithmetic_v<T>) {
+            return (*this)(from, std::numeric_limits<T>::max());
+        } else {
+            return iota_iterable<T>{.from = from};
+        }
+    }
+};
+
+struct ints_t {
+    inline constexpr auto operator()() const { return iota_t{}(int_t{}); }
+
+    inline constexpr auto operator()(int_t from) const { return iota_t{}(from); }
+
+    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_t{};
+FLUX_EXPORT inline constexpr auto ints = detail::ints_t{};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_IOTA_HPP_INCLUDED
diff --git a/include/flux/factory/istream.hpp b/include/flux/factory/istream.hpp
new file mode 100644
index 00000000..5ce99551
--- /dev/null
+++ b/include/flux/factory/istream.hpp
@@ -0,0 +1,63 @@
+
+// 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_FACTORY_FROM_ISTREAM_HPP_INCLUDED
+#define FLUX_FACTORY_FROM_ISTREAM_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+#include <iosfwd>
+
+namespace flux {
+
+namespace detail {
+
+template <typename T, typename CharT, typename Traits>
+struct istream_adaptor : inline_sequence_base<istream_adaptor<T, CharT, Traits>> {
+    std::basic_istream<CharT, Traits>* stream;
+
+    struct context_type : immovable {
+        std::basic_istream<CharT, Traits>* stream_;
+        T elem_ = T{};
+
+        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
+
+FLUX_EXPORT
+template <std::default_initializable T>
+inline constexpr auto from_istream = detail::from_istream_fn<T>{};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_ISTREAM_HPP_INCLUDED
diff --git a/include/flux/factory/istreambuf.hpp b/include/flux/factory/istreambuf.hpp
new file mode 100644
index 00000000..2c1f16b4
--- /dev/null
+++ b/include/flux/factory/istreambuf.hpp
@@ -0,0 +1,66 @@
+
+// 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_FACTORY_ISTREAMBUF_HPP_INCLUDED
+#define FLUX_FACTORY_ISTREAMBUF_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+#include <iosfwd>
+
+namespace flux {
+
+namespace detail {
+
+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); };
+
+} // namespace detail
+
+template <detail::derives_from_streambuf Streambuf>
+struct iterable_traits<Streambuf> {
+
+    template <typename CharT, typename Traits>
+    struct context_type : immovable {
+    private:
+        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;
+                }
+            }
+        }
+    };
+
+    template <typename CharT, typename Traits>
+    static auto iterate(std::basic_streambuf<CharT, Traits>& streambuf)
+        -> context_type<CharT, Traits>
+    {
+        return context_type<CharT, Traits>(streambuf);
+    }
+};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_ISTREAMBUF_HPP_INCLUDED
diff --git a/include/flux/factory/repeat.hpp b/include/flux/factory/repeat.hpp
new file mode 100644
index 00000000..c9346350
--- /dev/null
+++ b/include/flux/factory/repeat.hpp
@@ -0,0 +1,131 @@
+
+// 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_FACTORY_REPEAT_HPP_INCLUDED
+#define FLUX_FACTORY_REPEAT_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+namespace flux {
+
+namespace detail {
+
+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)) { }
+
+    constexpr auto iterate() const { return context_type(obj_); }
+
+    constexpr auto reverse_iterate() const { return context_type(obj_); }
+};
+
+template <typename T>
+struct repeat_sequence : inline_sequence_base<repeat_sequence<T>> {
+private:
+    T obj_;
+    int_t count_;
+
+public:
+    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:
+        using self_t = repeat_sequence;
+
+    public:
+        static constexpr auto first(self_t const&) -> int_t { return 0; }
+
+        static constexpr auto is_last(self_t const& self, int_t cur) -> bool
+        {
+            return cur >= self.count_;
+        }
+
+        static constexpr auto inc(self_t const&, int_t& cur) -> void { ++cur; }
+
+        static constexpr auto read_at(self_t const& self, int_t) -> T const& { return self.obj_; }
+
+        static constexpr auto dec(self_t const&, int_t& cur) -> void { --cur; }
+
+        static constexpr auto inc(self_t const&, int_t& cur, int_t offset) -> void
+        {
+            cur = num::add(cur, offset);
+        }
+
+        static constexpr auto distance(self_t const&, int_t from, int_t to) -> int_t
+        {
+            return to - from;
+        }
+
+        static constexpr auto for_each_while(self_t const& self, auto&& pred) -> int_t
+        {
+            int_t idx = 0;
+            for (; idx < self.count_; ++idx) {
+                if (!std::invoke(pred, std::as_const(self.obj_))) {
+                    break;
+                }
+            }
+            return idx;
+        }
+
+        static constexpr auto last(self_t const& self) -> int_t { return self.count_; }
+
+        static constexpr auto size(self_t const& self) -> int_t { return self.count_; }
+    };
+};
+
+struct repeat_fn {
+    template <typename T>
+        requires std::movable<std::decay_t<T>>
+    constexpr auto operator()(T&& obj) const
+    {
+        return repeat_iterable<std::decay_t<T>>(FLUX_FWD(obj));
+    }
+
+    template <typename T>
+        requires std::movable<std::decay_t<T>>
+    constexpr auto operator()(T&& obj, num::integral auto count) const
+    {
+        auto c = num::checked_cast<int_t>(count);
+        if (c < 0) {
+            runtime_error("Negative count passed to repeat()");
+        }
+        return repeat_sequence<std::decay_t<T>>(FLUX_FWD(obj), c);
+    }
+};
+
+} // namespace detail
+
+FLUX_EXPORT inline constexpr auto repeat = detail::repeat_fn{};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_REPEAT_HPP_INCLUDED
diff --git a/include/flux/sequence/single.hpp b/include/flux/factory/single.hpp
similarity index 86%
rename from include/flux/sequence/single.hpp
rename to include/flux/factory/single.hpp
index 273e8169..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; }
@@ -93,8 +94,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);
@@ -106,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);
@@ -115,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/factory/unfold.hpp b/include/flux/factory/unfold.hpp
new file mode 100644
index 00000000..6fdbfbab
--- /dev/null
+++ b/include/flux/factory/unfold.hpp
@@ -0,0 +1,82 @@
+
+// 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_FACTORY_UNFOLD_HPP_INCLUDED
+#define FLUX_FACTORY_UNFOLD_HPP_INCLUDED
+
+#include <flux/core.hpp>
+
+namespace flux {
+
+namespace detail {
+
+template <typename R, typename Func>
+struct unfold_iterable : inline_sequence_base<unfold_iterable<R, Func>> {
+    R state_;
+    FLUX_NO_UNIQUE_ADDRESS Func func_;
+
+    struct context_type : immovable {
+        using element_type = R const&;
+
+        R* state_;
+        std::reference_wrapper<Func> func_;
+        bool inc_next_ = false;
+
+        constexpr explicit context_type(unfold_iterable& self)
+            : state_(std::addressof(self.state_)),
+              func_(std::ref(self.func_))
+        {
+        }
+
+        constexpr auto run_while(auto&& pred) -> iteration_result
+        {
+            if (inc_next_) {
+                *state_ = std::invoke(func_, std::move(*state_));
+            }
+            while (true) {
+                if (!std::invoke(pred, *state_)) {
+                    inc_next_ = true;
+                    return iteration_result::incomplete;
+                };
+                *state_ = std::invoke(func_, std::move(*state_));
+            }
+        }
+    };
+
+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>>
+    [[nodiscard]]
+    constexpr auto operator()(Func func, Seed&& seed) const -> iterable auto
+    {
+        return unfold_iterable<R, Func>(std::move(func), FLUX_FWD(seed));
+    }
+};
+
+} // namespace detail
+
+FLUX_EXPORT inline constexpr auto unfold = detail::unfold_fn{};
+
+} // namespace flux
+
+#endif // FLUX_FACTORY_UNFOLD_INCLUDED
diff --git a/include/flux/sequence.hpp b/include/flux/sequence.hpp
deleted file mode 100644
index 14e13a65..00000000
--- a/include/flux/sequence.hpp
+++ /dev/null
@@ -1,22 +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/array_ptr.hpp>
-#include <flux/sequence/bitset.hpp>
-#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/range.hpp>
-#include <flux/sequence/repeat.hpp>
-#include <flux/sequence/single.hpp>
-#include <flux/sequence/unfold.hpp>
-
-#endif // FLUX_SEQUENCE_HPP_INCLUDED
diff --git a/include/flux/sequence/array_ptr.hpp b/include/flux/sequence/array_ptr.hpp
deleted file mode 100644
index 6ccc75e5..00000000
--- a/include/flux/sequence/array_ptr.hpp
+++ /dev/null
@@ -1,172 +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;
-    distance_t sz_ = 0;
-
-    friend struct detail::make_array_ptr_unchecked_fn;
-
-    constexpr array_ptr(T* ptr, distance_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, distance_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, distance_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)
-            -> distance_t
-        {
-            return num::sub(to, from);
-        }
-
-        static constexpr auto size(array_ptr const& self) -> distance_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<distance_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/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
diff --git a/include/flux/sequence/generator.hpp b/include/flux/sequence/generator.hpp
deleted file mode 100644
index 17dd045b..00000000
--- a/include/flux/sequence/generator.hpp
+++ /dev/null
@@ -1,114 +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_GENERATOR_HPP_INCLUDED
-#define FLUX_SEQUENCE_GENERATOR_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-#include <coroutine>
-#include <utility>
-
-namespace flux {
-
-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&>;
-
-    struct promise_type;
-
-    using handle_type = std::coroutine_handle<promise_type>;
-
-    struct promise_type {
-        auto initial_suspend() { return std::suspend_always{}; }
-
-        auto final_suspend() noexcept { return std::suspend_always{}; }
-
-        auto get_return_object()
-        {
-            return generator(handle_type::from_promise(*this));
-        }
-
-        auto yield_value(yielded_type elem)
-        {
-            ptr_ = std::addressof(elem);
-            return std::suspend_always{};
-        }
-
-        auto unhandled_exception() { throw; }
-
-        void return_void() noexcept {}
-
-        std::add_pointer_t<yielded_type> ptr_;
-    };
-
-private:
-    handle_type coro_;
-
-    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& operator=(generator&& other) noexcept
-    {
-        std::swap(coro_, other.coro_);
-        return *this;
-    }
-
-    ~generator()
-    {
-        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_);
-    }
-};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_GENERATOR_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/flux/sequence/getlines.hpp b/include/flux/sequence/getlines.hpp
deleted file mode 100644
index ca4926ca..00000000
--- a/include/flux/sequence/getlines.hpp
+++ /dev/null
@@ -1,100 +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_GETLINES_HPP_INCLUDED
-#define FLUX_SEQUENCE_GETLINES_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-#include <iosfwd>
-#include <string>
-
-namespace flux {
-
-namespace detail {
-
-template <typename CharT, typename Traits>
-struct getlines_sequence : inline_sequence_base<getlines_sequence<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 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;
-        }
-
-        static constexpr auto is_last(self_t& self, cursor_type const&) -> bool
-        {
-            return !(self.is_ && static_cast<bool>(*self.is_));
-        }
-
-        static constexpr auto inc(self_t& self, cursor_type& cur) -> cursor_type&
-        {
-            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;
-            }
-            return cur;
-        }
-
-        static constexpr auto read_at(self_t& self, cursor_type const&) -> string_type const&
-        {
-            return self.str_;
-        }
-    };
-};
-
-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);
-    }
-
-    template <typename CharT, typename Traits>
-    constexpr auto operator()(std::basic_istream<CharT, Traits>& istream) const
-    {
-        return getlines_sequence<CharT, Traits>(istream, istream.widen('\n'));
-    }
-};
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto getlines = detail::getlines_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_GETLINES_HPP_INCLUDED
diff --git a/include/flux/sequence/iota.hpp b/include/flux/sequence/iota.hpp
deleted file mode 100644
index 774e281b..00000000
--- a/include/flux/sequence/iota.hpp
+++ /dev/null
@@ -1,194 +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_IOTA_HPP_INCLUDED
-#define FLUX_SEQUENCE_IOTA_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-namespace flux {
-
-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>;
-    };
-
-template <typename 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::totally_ordered<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);
-        T(o + u);
-        T(u - o);
-        { u - u } -> std::convertible_to<distance_t>;
-    };
-
-struct iota_traits {
-    bool has_start;
-    bool has_end;
-};
-
-template <incrementable T, iota_traits Traits>
-struct iota_sequence_traits : default_sequence_traits {
-    using cursor_type = T;
-
-    static constexpr bool is_infinite = !Traits.has_end;
-
-    static constexpr auto first(auto& self) -> cursor_type
-    {
-        if constexpr (Traits.has_start) {
-            return self.start_;
-        } else {
-            return cursor_type{};
-        }
-    }
-
-    static constexpr auto is_last(auto& self, cursor_type const& cur) -> bool
-    {
-        if constexpr (Traits.has_end) {
-            return cur == self.end_;
-        } else {
-            return false;
-        }
-    }
-
-    static constexpr auto inc(auto&, cursor_type& cur) -> cursor_type&
-    {
-        return ++cur;
-    }
-
-    static constexpr auto read_at(auto&, cursor_type const& cur) -> T
-    {
-        return cur;
-    }
-
-    static constexpr auto last(auto& self) -> cursor_type
-        requires (Traits.has_end)
-    {
-        return self.end_;
-    }
-
-    static constexpr auto dec(auto&, cursor_type& cur) -> cursor_type&
-        requires decrementable<T>
-    {
-        return --cur;
-    }
-
-    static constexpr auto inc(auto&, cursor_type& cur, distance_t offset)
-        -> cursor_type&
-        requires advancable<T>
-    {
-        return cur += num::cast<std::iter_difference_t<T>>(offset);
-    }
-
-    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);
-    }
-
-    static constexpr auto size(auto& self) -> distance_t
-        requires advancable<T> && (Traits.has_start && Traits.has_end)
-    {
-        return num::cast<distance_t>(self.end_ - self.start_);
-    }
-};
-
-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;
-};
-
-template <typename T>
-struct iota_sequence : inline_sequence_base<iota_sequence<T>> {
-private:
-    T start_;
-
-    static constexpr iota_traits traits{.has_start = true, .has_end = false};
-
-public:
-    inline constexpr explicit iota_sequence(T from)
-        : start_(std::move(from))
-    {}
-
-    using flux_sequence_traits = iota_sequence_traits<T, traits>;
-    friend flux_sequence_traits;
-};
-
-template <typename T>
-struct bounded_iota_sequence : inline_sequence_base<bounded_iota_sequence<T>> {
-    T start_;
-    T end_;
-
-    static constexpr iota_traits traits{.has_start = true, .has_end = true};
-
-public:
-    inline constexpr bounded_iota_sequence(T from, T to)
-        : start_(std::move(from)),
-          end_(std::move(to))
-    {}
-
-    using flux_sequence_traits = iota_sequence_traits<T, traits>;
-    friend flux_sequence_traits;
-};
-
-struct iota_fn {
-    template <incrementable T>
-    constexpr auto operator()(T from) const
-    {
-        return iota_sequence<T>(std::move(from));
-    }
-
-    template <incrementable T>
-    constexpr auto operator()(T from, T to) const
-    {
-        return bounded_iota_sequence<T>(std::move(from), std::move(to));
-    }
-};
-
-struct ints_fn {
-    inline constexpr auto operator()() const
-    {
-        return basic_iota_sequence<distance_t>();
-    }
-
-    inline constexpr auto operator()(distance_t from) const
-    {
-        return iota_sequence<distance_t>(from);
-    }
-
-    inline constexpr auto operator()(distance_t from, distance_t to) const
-    {
-        return bounded_iota_sequence<distance_t>(from, to);
-    }
-};
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto iota = detail::iota_fn{};
-FLUX_EXPORT inline constexpr auto ints = detail::ints_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_IOTA_HPP_INCLUDED
diff --git a/include/flux/sequence/istream.hpp b/include/flux/sequence/istream.hpp
deleted file mode 100644
index dc8e4960..00000000
--- a/include/flux/sequence/istream.hpp
+++ /dev/null
@@ -1,94 +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_FROM_ISTREAM_HPP_INCLUDED
-#define FLUX_SEQUENCE_FROM_ISTREAM_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-#include <iosfwd>
-
-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();
-
-    friend struct sequence_traits<istream_adaptor>;
-
-public:
-    explicit istream_adaptor(istream_type& is)
-        : is_(std::addressof(is))
-    {}
-
-};
-
-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>{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_ISTREAM_HPP_INCLUDED
diff --git a/include/flux/sequence/istreambuf.hpp b/include/flux/sequence/istreambuf.hpp
deleted file mode 100644
index 582dd4e3..00000000
--- a/include/flux/sequence/istreambuf.hpp
+++ /dev/null
@@ -1,82 +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_ISTREAMBUF_HPP_INCLUDED
-#define FLUX_SEQUENCE_ISTREAMBUF_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-#include <iosfwd>
-
-namespace flux {
-
-namespace detail {
-
-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); };
-
-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;
-    private:
-        friend struct sequence_traits;
-        cursor_type() = default;
-    };
-
-    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
-    {
-        return traits_type::to_char_type(self.sgetc());
-    }
-};
-
-FLUX_EXPORT
-inline constexpr auto from_istreambuf = detail::from_istreambuf_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_ISTREAMBUF_HPP_INCLUDED
diff --git a/include/flux/sequence/range.hpp b/include/flux/sequence/range.hpp
deleted file mode 100644
index 7623ba83..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, distance_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)
-            -> distance_t
-            requires std::ranges::random_access_range<R>
-        {
-            return num::cast<distance_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) -> distance_t
-            requires std::ranges::sized_range<R>
-        {
-            return num::cast<distance_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/include/flux/sequence/repeat.hpp b/include/flux/sequence/repeat.hpp
deleted file mode 100644
index ebe4b464..00000000
--- a/include/flux/sequence/repeat.hpp
+++ /dev/null
@@ -1,145 +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_REPEAT_HPP_INCLUDED
-#define FLUX_SEQUENCE_REPEAT_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-namespace flux {
-
-namespace detail {
-
-template <bool>
-struct repeat_data {};
-
-template <>
-struct repeat_data<false> { std::size_t count; };
-
-template <std::movable T, bool IsInfinite>
-struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
-{
-private:
-    T obj_;
-    FLUX_NO_UNIQUE_ADDRESS repeat_data<IsInfinite> data_;
-
-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)
-        : obj_(FLUX_FWD(obj)),
-          data_{count}
-    {}
-
-    struct flux_sequence_traits : default_sequence_traits {
-    private:
-        using self_t = repeat_sequence;
-
-    public:
-        static inline constexpr bool is_infinite = IsInfinite;
-
-        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
-        {
-            if constexpr (IsInfinite) {
-                return false;
-            } else {
-                return cur >= self.data_.count;
-            }
-        }
-
-        static constexpr auto inc(self_t const&, std::size_t& cur) -> void
-        {
-            ++cur;
-        }
-
-        static constexpr auto read_at(self_t const& self, std::size_t) -> T const&
-        {
-            return self.obj_;
-        }
-
-        static constexpr auto dec(self_t const&, std::size_t& cur) -> void
-        {
-            --cur;
-        }
-
-        static constexpr auto inc(self_t const&, std::size_t& cur, distance_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
-        {
-            return num::cast<distance_t>(to) - num::cast<distance_t>(from);
-        }
-
-        static constexpr auto for_each_while(self_t const& self, auto&& pred) -> std::size_t
-        {
-            if constexpr (IsInfinite) {
-                std::size_t idx = 0;
-                while (true) {
-                    if (!std::invoke(pred, std::as_const(self.obj_))) {
-                        return idx;
-                    }
-                    ++idx;
-                }
-            } else {
-                std::size_t idx = 0;
-                for ( ; idx < self.data_.count; ++idx) {
-                    if (!std::invoke(pred, std::as_const(self.obj_))) {
-                        break;
-                    }
-                }
-                return idx;
-            }
-        }
-
-        static constexpr auto last(self_t const& self) -> std::size_t
-            requires (!IsInfinite)
-        {
-            return self.data_.count;
-        }
-
-        static constexpr auto size(self_t const& self) -> distance_t
-            requires (!IsInfinite)
-        {
-            return num::cast<distance_t>(self.data_.count);
-        }
-    };
-};
-
-struct repeat_fn {
-    template <typename T>
-        requires std::movable<std::decay_t<T>>
-    constexpr auto operator()(T&& obj) const
-    {
-        return repeat_sequence<std::decay_t<T>, true>(FLUX_FWD(obj));
-    }
-
-    template <typename T>
-        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);
-        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));
-    }
-};
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto repeat = detail::repeat_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_REPEAT_HPP_INCLUDED
diff --git a/include/flux/sequence/unfold.hpp b/include/flux/sequence/unfold.hpp
deleted file mode 100644
index e9f80e39..00000000
--- a/include/flux/sequence/unfold.hpp
+++ /dev/null
@@ -1,91 +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_UNFOLD_HPP_INCLUDED
-#define FLUX_SEQUENCE_UNFOLD_HPP_INCLUDED
-
-#include <flux/core.hpp>
-
-namespace flux {
-
-namespace detail {
-
-template <typename R, typename Func>
-struct unfold_sequence : inline_sequence_base<unfold_sequence<R, Func>> {
-private:
-    R state_;
-    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;
-
-    public:
-        static constexpr bool is_infinite = true;
-
-        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&
-        {
-            return self.state_;
-        }
-
-        static constexpr auto for_each_while(self_t& self, auto&& pred) -> cursor_type
-        {
-            while (true) {
-                if (!std::invoke(pred, self.state_)) {
-                    break;
-                }
-                self.state_ = std::invoke(self.func_, std::move(self.state_));
-            }
-
-            return {};
-        }
-    };
-};
-
-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>>
-    [[nodiscard]]
-    constexpr auto operator()(Func func, Seed&& seed) const -> sequence auto
-    {
-        return unfold_sequence<R, Func>(std::move(func), FLUX_FWD(seed));
-    }
-};
-
-} // namespace detail
-
-FLUX_EXPORT inline constexpr auto unfold = detail::unfold_fn{};
-
-} // namespace flux
-
-#endif // FLUX_SEQUENCE_UNFOLD_INCLUDED
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 13757184..c8d428ff 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
@@ -51,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
@@ -83,10 +85,8 @@ add_executable(test-flux
     test_zip_map.cpp
     test_zip_algorithms.cpp
 
-    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_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};
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_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
diff --git a/test/test_bitset.cpp b/test/test_bitset.cpp
index 89ec02b0..00587443 100644
--- a/test/test_bitset.cpp
+++ b/test/test_bitset.cpp
@@ -72,19 +72,8 @@ 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
     {
         std::bitset<16> seq1{};
@@ -110,6 +99,7 @@ TEST_CASE("bitset")
         REQUIRE(seq1.all());
         REQUIRE(flux::none(seq2, std::identity{}));
     }
+#endif
 
     // reversing a bitset in-place
     {
diff --git a/test/test_cartesian_product.cpp b/test/test_cartesian_product.cpp
index 284c2beb..9cb93e99 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);
 
@@ -395,40 +401,64 @@ 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::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 +531,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_chain.cpp b/test/test_chain.cpp
index e4326038..31ade93e 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -11,10 +11,46 @@
 
 #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()
 {
+    // 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};
@@ -154,8 +190,9 @@ constexpr bool test_chain()
 
     return true;
 }
+#ifndef NO_CONSTEXPR_VARIANT_EMPLACE
 static_assert(test_chain());
-
+#endif
 }
 
 TEST_CASE("chain")
diff --git a/test/test_chunk.cpp b/test/test_chunk.cpp
index 005c5f6f..2dfb707c 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};
@@ -243,7 +287,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 +416,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);
 
@@ -485,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_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_cycle.cpp b/test/test_cycle.cpp
index 6d41d245..8c133e37 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);
     }
 
@@ -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; });
 
@@ -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_drop.cpp b/test/test_drop.cpp
index eb8814a9..12ad805e 100644
--- a/test/test_drop.cpp
+++ b/test/test_drop.cpp
@@ -14,7 +14,73 @@
 
 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());
+    }
+
+    // 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};
@@ -158,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_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};
 
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 {
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_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}));
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
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{
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"};
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_generator.cpp b/test/test_generator.cpp
index fcb86136..c46b4067 100644
--- a/test/test_generator.cpp
+++ b/test/test_generator.cpp
@@ -36,7 +36,8 @@ auto fib(int a, int b) -> generator<int const&>
     }
 }
 
-auto pythagorean_triples() -> generator<std::tuple<int, int, int>> {
+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)) {
@@ -48,7 +49,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);
@@ -65,14 +66,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&&>);
+        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 +80,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_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(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 +117,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());
     }
 }
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")
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_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_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_iterable_concepts.cpp b/test/test_iterable_concepts.cpp
new file mode 100644
index 00000000..cdac2f68
--- /dev/null
+++ b/test/test_iterable_concepts.cpp
@@ -0,0 +1,246 @@
+// 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 <initializer_list>
+
+#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
+
+/*
+ * 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_map.cpp b/test/test_map.cpp
index 52431ad6..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"
 
@@ -13,6 +14,55 @@ 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}));
+    }
+
+    // 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};
 
diff --git a/test/test_mask.cpp b/test/test_mask.cpp
index 5cabbcac..26e64e53 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"
 
@@ -12,6 +13,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};
@@ -119,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}));
@@ -133,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);
@@ -152,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());
     }
@@ -161,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));
     }
@@ -170,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_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;
diff --git a/test/test_range_iface.cpp b/test/test_range_iface.cpp
index ed170e03..ba533a6b 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}));
 
@@ -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_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
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index e2528fa5..cca601d3 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -28,30 +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::for_each_while(seq, [&](int) { return counter++ < 5; });
-            STATIC_CHECK(inner_cur == 5);
+            STATIC_CHECK(flux::next_element(ctx).value() == 3);
         }
     }
 
@@ -61,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);
         }
     }
 
@@ -86,52 +74,27 @@ 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
+    // repeat works with move-only types
     {
-        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();
-
-        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);
+        auto seq = flux::repeat(S(3)).take(5);
 
-        STATIC_CHECK(seq[cur] == 1.0);
+        STATIC_CHECK(check_equal(seq, {S(3), S(3), S(3), S(3), S(3)}));
     }
 
-    // repeat works with move-only types
+    // repeat looks the same backwards and forwards
     {
-        auto seq = flux::repeat(S(3)).take(5);
+        auto rep = flux::repeat(3);
 
-        STATIC_CHECK(check_equal(seq, {S(3), S(3), S(3), S(3), S(3)}));
+        auto ctx = flux::reverse_iterate(rep);
+        for (int i = 0; i < 100; i++) {
+            STATIC_CHECK(flux::next_element(ctx).value() == 3);
+        }
     }
 
     return true;
@@ -164,15 +127,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);
         }
     }
@@ -260,16 +222,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
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}));
     }
diff --git a/test/test_scan.cpp b/test/test_scan.cpp
index 5e5b2892..1bd9fabd 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};
@@ -220,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}));
     }
@@ -235,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}));
     }
@@ -249,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}));
     }
diff --git a/test/test_sort.cpp b/test/test_sort.cpp
index b2ae5512..ae9f3fa8 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_; }
     };
@@ -179,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);
@@ -195,7 +198,7 @@ void test_adapted_deque_sort(unsigned sz)
 
     CHECK(std::is_sorted(deque.cbegin(), deque.cbegin() + sz/2));
 }
-
+#endif
 }
 
 TEST_CASE("sort")
@@ -217,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 851b90ac..f13673b8 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
@@ -116,7 +197,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 +340,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));
@@ -349,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 e41fae68..5d4fd7b7 100644
--- a/test/test_take.cpp
+++ b/test/test_take.cpp
@@ -13,6 +13,72 @@ 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);
+    }
+
+    // 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);
@@ -131,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_take_while.cpp b/test/test_take_while.cpp
index 8b391d80..11311bfa 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) == flux::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; });
 
diff --git a/test/test_to.cpp b/test/test_to.cpp
index 43501bb6..e3f294a4 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")
@@ -150,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}));
             }
         }
 
@@ -176,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")
@@ -184,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}));
             }
         }
 
@@ -332,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")
@@ -341,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);
 
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;
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index eb0e8958..ab64f6f9 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -24,33 +24,37 @@ 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:
     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));
     }
@@ -85,6 +89,49 @@ 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_);
+    }
+
+    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>
+iterable_only(Base) -> iterable_only<Base>;
 }
 
 template <typename Base>
@@ -127,9 +174,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>);
-}
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};
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};
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)