Add iterable concept

.clang-format

@@ -18,5 +18,6 @@ IndentPPDirectives: AfterHash
 InsertBraces: true
 NamespaceIndentation: None
 PackConstructorInitializers: CurrentLine
+SpaceBeforeCpp11BracedList: false
 SortIncludes: Never
 TabWidth: 4

.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
 

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>
 

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 =

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))

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!
 }

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)>);
 }

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';
     }
 }

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() {}

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 {

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() {}

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++;

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