[OUTDATED] Add iterable concept

.clang-format

@@ -19,4 +19,5 @@ InsertBraces: true
 NamespaceIndentation: None
 PackConstructorInitializers: CurrentLine
 SortIncludes: Never
+SpaceBeforeCpp11BracedList: false
 TabWidth: 4

.gitignore

@@ -11,6 +11,7 @@ CMakeLists.txt.user
 cmake-build*/
 
 # VS Code
+.cache/
 .vscode/
 
 # VS

example/docs/read_only.cpp

@@ -11,7 +11,7 @@
 
 // We can use the read_only_sequence concept to statically require a sequence
 // whose elements are immutable
-bool contains_a_two(flux::read_only_sequence auto&& seq)
+bool contains_a_two(flux::read_only_iterable auto&& seq)
 {
     for (auto&& elem : seq) {
         if (elem == 2) { // What if we wrote `elem = 2` (assignment) by mistake?

example/top10/08_three_consecutive_odds.cpp

@@ -16,16 +16,14 @@ namespace version1 {
 
 auto const tco = [](std::initializer_list<int> nums)
 {
-    int odd_count = 0;
-    auto idx = flux::for_each_while(nums, [&](int i) {
+    return !flux::iterate(nums, [odd_count = 0](int i) mutable {
         if (i % 2 != 0) {
             ++odd_count;
         } else {
             odd_count = 0;
         }
         return odd_count < 3; // true => keep iterating
     });
-    return !flux::is_last(nums, idx);
 };
 
 static_assert(tco({}) == false);

include/flux/adaptor/adjacent.hpp

@@ -20,7 +20,7 @@ namespace flux {
 namespace detail {
 
 template <typename Base, distance_t N>
-struct adjacent_sequence_traits_base : default_sequence_traits {
+struct adjacent_sequence_traits_base : default_iter_traits {
 protected:
     struct cursor_type {
         std::array<cursor_t<Base>, N> arr{};
@@ -107,15 +107,15 @@ struct adjacent_sequence_traits_base : default_sequence_traits {
     }
 
     static constexpr auto size(auto& self) -> distance_t
-        requires sized_sequence<Base>
+        requires sized_iterable<Base>
     {
         auto s = (flux::size(self.base_) - N) + 1;
         return (cmp::max)(s, distance_t{0});
     }
 };
 
 template <typename Base, distance_t N>
-struct adjacent_adaptor : inline_sequence_base<adjacent_adaptor<Base, N>> {
+struct adjacent_adaptor : inline_iter_base<adjacent_adaptor<Base, N>> {
 private:
     Base base_;
 
@@ -126,7 +126,7 @@ struct adjacent_adaptor : inline_sequence_base<adjacent_adaptor<Base, N>> {
         : base_(FLUX_FWD(base))
     {}
 
-    struct flux_sequence_traits : adjacent_sequence_traits_base<Base, N> {
+    struct flux_iter_traits : adjacent_sequence_traits_base<Base, N> {
     private:
 
         using cursor_type = adjacent_sequence_traits_base<Base, N>::cursor_type;
@@ -176,7 +176,7 @@ struct adjacent_adaptor : inline_sequence_base<adjacent_adaptor<Base, N>> {
 };
 
 template <typename Base, distance_t N, typename Func>
-struct adjacent_map_adaptor : inline_sequence_base<adjacent_map_adaptor<Base, N, Func>> {
+struct adjacent_map_adaptor : inline_iter_base<adjacent_map_adaptor<Base, N, Func>> {
 private:
     Base base_;
     Func func_;
@@ -189,7 +189,7 @@ struct adjacent_map_adaptor : inline_sequence_base<adjacent_map_adaptor<Base, N,
           func_(std::move(func))
     {}
 
-    struct flux_sequence_traits : adjacent_sequence_traits_base<Base, N> {
+    struct flux_iter_traits : adjacent_sequence_traits_base<Base, N> {
         template <typename Self>
         static constexpr auto read_at(Self& self, cursor_t<Self> const& cur)
             -> decltype(auto)
@@ -244,14 +244,14 @@ FLUX_EXPORT inline constexpr auto pairwise_map = adjacent_map<2>;
 
 template <typename D>
 template <distance_t N>
-constexpr auto inline_sequence_base<D>::adjacent() &&
+constexpr auto inline_iter_base<D>::adjacent() &&
     requires multipass_sequence<D>
 {
     return flux::adjacent<N>(std::move(derived()));
 }
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::pairwise() &&
+constexpr auto inline_iter_base<D>::pairwise() &&
     requires multipass_sequence<D>
 {
     return flux::pairwise(std::move(derived()));
@@ -260,15 +260,15 @@ constexpr auto inline_sequence_base<D>::pairwise() &&
 template <typename D>
 template <distance_t N, typename Func>
     requires multipass_sequence<D>
-constexpr auto inline_sequence_base<D>::adjacent_map(Func func) &&
+constexpr auto inline_iter_base<D>::adjacent_map(Func func) &&
 {
     return flux::adjacent_map<N>(std::move(derived()), std::move(func));
 }
 
 template <typename D>
 template <typename Func>
     requires multipass_sequence<D>
-constexpr auto inline_sequence_base<D>::pairwise_map(Func func) &&
+constexpr auto inline_iter_base<D>::pairwise_map(Func func) &&
 {
     return flux::pairwise_map(std::move(derived()), std::move(func));
 }

include/flux/adaptor/adjacent_filter.hpp

@@ -14,7 +14,7 @@ namespace detail {
 
 template <multipass_sequence Base, typename Pred>
 struct adjacent_filter_adaptor
-    : inline_sequence_base<adjacent_filter_adaptor<Base, Pred>> {
+    : inline_iter_base<adjacent_filter_adaptor<Base, Pred>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Pred pred_;
@@ -25,7 +25,7 @@ struct adjacent_filter_adaptor
           pred_(std::move(pred))
     {}
 
-    struct flux_sequence_traits : default_sequence_traits {
+    struct flux_iter_traits : default_iter_traits {
     private:
         struct cursor_type {
             cursor_t<Base> base_cur;
@@ -145,13 +145,13 @@ template <typename D>
 template <typename Pred>
     requires multipass_sequence<D> &&
              std::predicate<Pred&, element_t<D>, element_t<D>>
-constexpr auto inline_sequence_base<D>::adjacent_filter(Pred pred) &&
+constexpr auto inline_iter_base<D>::adjacent_filter(Pred pred) &&
 {
     return flux::adjacent_filter(std::move(derived()), std::move(pred));
 }
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::dedup() &&
+constexpr auto inline_iter_base<D>::dedup() &&
     requires multipass_sequence<D> &&
              std::equality_comparable<element_t<D>>
 {

include/flux/adaptor/cache_last.hpp

@@ -13,7 +13,7 @@ namespace flux {
 namespace detail {
 
 template <sequence Base>
-struct cache_last_adaptor : inline_sequence_base<cache_last_adaptor<Base>>
+struct cache_last_adaptor : inline_iter_base<cache_last_adaptor<Base>>
 {
 private:
     Base base_;
@@ -28,7 +28,7 @@ struct cache_last_adaptor : inline_sequence_base<cache_last_adaptor<Base>>
         : base_(FLUX_FWD(base))
     {}
 
-    struct flux_sequence_traits : detail::passthrough_traits_base {
+    struct flux_iter_traits : detail::passthrough_traits_base {
 
         using value_type = value_t<Base>;
         using self_t = cache_last_adaptor;
@@ -79,7 +79,7 @@ struct cache_last_fn {
 FLUX_EXPORT inline constexpr auto cache_last = detail::cache_last_fn{};
 
 template <typename Derived>
-constexpr auto inline_sequence_base<Derived>::cache_last() &&
+constexpr auto inline_iter_base<Derived>::cache_last() &&
     requires bounded_sequence<Derived> ||
         (multipass_sequence<Derived> && not infinite_sequence<Derived>)
 {

include/flux/adaptor/cartesian_base.hpp

@@ -59,7 +59,7 @@ struct cartesian_traits_types<Arity, cartesian_kind::product, read_kind::tuple,
 };
 
 template <std::size_t Arity, cartesian_kind CartesianKind, read_kind ReadKind, typename... Bases>
-struct cartesian_traits_base_impl : default_sequence_traits {
+struct cartesian_traits_base_impl : default_iter_traits {
 private:
 
     template<std::size_t I, typename Self>
@@ -204,11 +204,37 @@ struct cartesian_traits_base_impl : default_sequence_traits {
         }
     }
 
+    template <std::size_t I, typename Self, typename Predicate,
+              typename... PartialElements>
+    static constexpr auto iterate_impl(Self& self, Predicate& pred,
+                                       PartialElements&&... partial_elements) -> bool
+    {
+        if constexpr (I == Arity - 1) {
+            return flux::iterate(get_base<I>(self), [&](auto&& elem) {
+                if constexpr (ReadKind == read_kind::tuple) {
+                    return std::invoke(pred, element_t<Self>(FLUX_FWD(partial_elements)..., FLUX_FWD(elem)));
+                } else {
+                    return std::invoke(pred, std::invoke(self.func_, FLUX_FWD(partial_elements)..., FLUX_FWD(elem)));
+                }
+            });
+        } else {
+            return flux::iterate(get_base<I>(self), [&](auto&& elem) {
+                return iterate_impl<I+1>(self, pred, FLUX_FWD(partial_elements)..., FLUX_FWD(elem));
+            });
+        }
+    }
+
 protected:
     using types = cartesian_traits_types<Arity, CartesianKind, ReadKind, Bases...>;
 
 public:
 
+    template <typename Self, typename Pred>
+    static constexpr auto iterate(Self& self, Pred&& pred) -> bool
+    {
+        return iterate_impl<0>(self, pred);
+    }
+
     template <typename Self>
     static constexpr auto first(Self& self)
         requires (CartesianKind == cartesian_kind::product)
@@ -233,7 +259,7 @@ 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> && ...))
+                  && (sized_iterable<Bases> && ...))
     {
         return std::apply([](auto& base0, auto&... bases) {
             distance_t sz = flux::size(base0);
@@ -245,7 +271,7 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     template <typename Self>
     static constexpr auto size(Self& self) -> distance_t
         requires (CartesianKind == cartesian_kind::power
-                  && (sized_sequence<Bases> && ...))
+                  && (sized_iterable<Bases> && ...))
     {
         return checked_pow(flux::size(self.base_), Arity);
     }
@@ -269,7 +295,7 @@ 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> && ...))
+                  (sized_iterable<Bases> && ...))
     {
         return ra_inc_impl<Arity - 1>(self, cur, offset);
     }
@@ -305,7 +331,7 @@ struct cartesian_traits_base_impl : default_sequence_traits {
                                         cursor_t<Self> const& from,
                                         cursor_t<Self> const& to) -> distance_t
         requires ((random_access_sequence<Bases> && ...) &&
-                  (sized_sequence<Bases> && ...))
+                  (sized_iterable<Bases> && ...))
     {
         return distance_impl<Arity - 1>(self, from, to);
     }
@@ -342,15 +368,15 @@ struct cartesian_traits_base_impl : default_sequence_traits {
         -> decltype(auto)
         requires (ReadKind == read_kind::map)
     {
-        return default_sequence_traits::move_at(self, cur);
+        return default_iter_traits::move_at(self, cur);
     }
 
     template <typename Self>
     static constexpr auto move_at_unchecked(Self& self, cursor_t<Self> const& cur)
         -> decltype(auto)
         requires (ReadKind == read_kind::map)
     {
-        return default_sequence_traits::move_at_unchecked(self, cur);
+        return default_iter_traits::move_at_unchecked(self, cur);
     }
 
     template <typename Self>
@@ -389,7 +415,7 @@ struct cartesian_traits_base_impl : default_sequence_traits {
     static constexpr auto for_each_while(Self& self, Function&& func) -> cursor_t<Self>
         requires (ReadKind == read_kind::map)
     {
-        return default_sequence_traits::for_each_while(self, FLUX_FWD(func));
+        return default_iter_traits::for_each_while(self, FLUX_FWD(func));
     }
 
 };

include/flux/adaptor/cartesian_power.hpp

@@ -20,7 +20,7 @@ namespace detail {
 
 template <std::size_t PowN, sequence Base>
 struct cartesian_power_adaptor
-    : inline_sequence_base<cartesian_power_adaptor<PowN, Base>> {
+    : inline_iter_base<cartesian_power_adaptor<PowN, Base>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
 
@@ -29,13 +29,13 @@ struct cartesian_power_adaptor
         : base_(FLUX_FWD(base))
     {}
 
-    using flux_sequence_traits = cartesian_traits_base<
+    using flux_iter_traits = cartesian_traits_base<
         PowN,
         cartesian_kind::power,
         read_kind::tuple,
         Base
     >;
-    friend flux_sequence_traits::impl;
+    friend flux_iter_traits::impl;
 };
 
 

include/flux/adaptor/cartesian_power_map.hpp

@@ -14,7 +14,7 @@ namespace detail {
 
 template <sequence Base, std::size_t PowN, typename Func>
 struct cartesian_power_map_adaptor
-    : inline_sequence_base<cartesian_power_map_adaptor<Base, PowN, Func>> {
+    : inline_iter_base<cartesian_power_map_adaptor<Base, PowN, Func>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Func func_;
@@ -25,13 +25,13 @@ struct cartesian_power_map_adaptor
           func_(FLUX_FWD(func))
     {}
 
-    using flux_sequence_traits = cartesian_traits_base<
+    using flux_iter_traits = cartesian_traits_base<
         PowN,
         cartesian_kind::power,
         read_kind::map,
         Base
     >;
-    friend flux_sequence_traits::impl;
+    friend flux_iter_traits::impl;
 };
 
 template <std::size_t PowN>

include/flux/adaptor/cartesian_product.hpp

@@ -20,7 +20,7 @@ namespace detail {
 
 template <sequence... Bases>
 struct cartesian_product_adaptor
-    : inline_sequence_base<cartesian_product_adaptor<Bases...>> {
+    : inline_iter_base<cartesian_product_adaptor<Bases...>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS std::tuple<Bases...> bases_;
 
@@ -29,13 +29,13 @@ struct cartesian_product_adaptor
         : bases_(FLUX_FWD(bases)...)
     {}
 
-    using flux_sequence_traits = cartesian_traits_base<
+    using flux_iter_traits = cartesian_traits_base<
         sizeof...(Bases),
         cartesian_kind::product,
         read_kind::tuple,
         Bases...
     >;
-    friend flux_sequence_traits::impl;
+    friend flux_iter_traits::impl;
 };
 
 struct cartesian_product_fn {