Rename inline_sequence_base -> inline_iter_base

The new name is even worse than the old one. I really need to think of something better. Naming is hard...
tcbrindle · Nov 27, 2024 · 1822f09 · 1822f09
1 parent f45c4f7
commit 1822f09
Show file tree

Hide file tree

Showing 68 changed files with 141 additions and 141 deletions.
diff --git a/include/flux/adaptor/adjacent.hpp b/include/flux/adaptor/adjacent.hpp
@@ -115,7 +115,7 @@ struct adjacent_sequence_traits_base : default_iter_traits {
 };
 
 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_;
 
@@ -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_;
@@ -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));
 }

diff --git a/include/flux/adaptor/adjacent_filter.hpp b/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_;
@@ -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>>
 {

diff --git a/include/flux/adaptor/cache_last.hpp b/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_;
@@ -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>)
 {

diff --git a/include/flux/adaptor/cartesian_power.hpp b/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_;
 

diff --git a/include/flux/adaptor/cartesian_power_map.hpp b/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_;

diff --git a/include/flux/adaptor/cartesian_product.hpp b/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_;
 

diff --git a/include/flux/adaptor/cartesian_product_map.hpp b/include/flux/adaptor/cartesian_product_map.hpp
@@ -14,7 +14,7 @@ namespace detail {
 
 template <typename Func, sequence... Bases>
 struct cartesian_product_map_adaptor
-    : inline_sequence_base<cartesian_product_map_adaptor<Func, Bases...>> {
+    : inline_iter_base<cartesian_product_map_adaptor<Func, Bases...>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS std::tuple<Bases...> bases_;
     FLUX_NO_UNIQUE_ADDRESS Func func_;

diff --git a/include/flux/adaptor/chain.hpp b/include/flux/adaptor/chain.hpp
@@ -319,7 +319,7 @@ struct chain_sequence_traits_base : chain_iterable_traits_base<Bases...>
 };
 
 template <iterable... Bases>
-struct chain_adaptor : inline_sequence_base<chain_adaptor<Bases...>> {
+struct chain_adaptor : inline_iter_base<chain_adaptor<Bases...>> {
 private:
     std::tuple<Bases...> bases_;
 

diff --git a/include/flux/adaptor/chunk.hpp b/include/flux/adaptor/chunk.hpp
@@ -16,7 +16,7 @@ namespace flux {
 namespace detail {
 
 template <typename Base>
-struct chunk_adaptor : inline_sequence_base<chunk_adaptor<Base>> {
+struct chunk_adaptor : inline_iter_base<chunk_adaptor<Base>> {
 private:
     Base base_;
     distance_t chunk_sz_;
@@ -47,7 +47,7 @@ struct chunk_adaptor : inline_sequence_base<chunk_adaptor<Base>> {
         using self_t = chunk_adaptor;
 
     public:
-        struct value_type : inline_sequence_base<value_type> {
+        struct value_type : inline_iter_base<value_type> {
         private:
             chunk_adaptor* parent_;
             constexpr explicit value_type(chunk_adaptor& parent)
@@ -134,7 +134,7 @@ struct chunk_adaptor : inline_sequence_base<chunk_adaptor<Base>> {
 };
 
 template <multipass_sequence Base>
-struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
+struct chunk_adaptor<Base> : inline_iter_base<chunk_adaptor<Base>> {
 private:
     Base base_;
     distance_t chunk_sz_;
@@ -186,7 +186,7 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
 };
 
 template <bidirectional_sequence Base>
-struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
+struct chunk_adaptor<Base> : inline_iter_base<chunk_adaptor<Base>> {
 private:
     Base base_;
     distance_t chunk_sz_;
@@ -311,7 +311,7 @@ struct chunk_fn {
 FLUX_EXPORT inline constexpr auto chunk = detail::chunk_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::chunk(num::integral auto chunk_sz) &&
+constexpr auto inline_iter_base<D>::chunk(num::integral auto chunk_sz) &&
 {
     return flux::chunk(std::move(derived()), chunk_sz);
 }

diff --git a/include/flux/adaptor/chunk_by.hpp b/include/flux/adaptor/chunk_by.hpp
@@ -13,7 +13,7 @@ namespace flux {
 namespace detail {
 
 template <multipass_sequence Base, typename Pred>
-struct chunk_by_adaptor : inline_sequence_base<chunk_by_adaptor<Base, Pred>> {
+struct chunk_by_adaptor : inline_iter_base<chunk_by_adaptor<Base, Pred>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Pred pred_;
@@ -138,7 +138,7 @@ template <typename Derived>
 template <typename Pred>
     requires multipass_sequence<Derived> &&
              std::predicate<Pred&, element_t<Derived>, element_t<Derived>>
-constexpr auto inline_sequence_base<Derived>::chunk_by(Pred pred) &&
+constexpr auto inline_iter_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
@@ -13,7 +13,7 @@ namespace flux {
 namespace detail {
 
 template <typename Base>
-struct cursors_adaptor : inline_sequence_base<cursors_adaptor<Base>> {
+struct cursors_adaptor : inline_iter_base<cursors_adaptor<Base>> {
 private:
     Base base_;
 
@@ -95,7 +95,7 @@ struct cursors_fn {
 FLUX_EXPORT inline constexpr auto cursors = detail::cursors_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::cursors() &&
+constexpr auto inline_iter_base<D>::cursors() &&
     requires multipass_sequence<D>
 {
     return flux::cursors(std::move(derived()));

diff --git a/include/flux/adaptor/cycle.hpp b/include/flux/adaptor/cycle.hpp
@@ -21,7 +21,7 @@ template <>
 struct cycle_data<true> {};
 
 template <multipass_sequence Base, bool IsInfinite>
-struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
+struct cycle_adaptor : inline_iter_base<cycle_adaptor<Base, IsInfinite>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS cycle_data<IsInfinite> data_;
@@ -242,14 +242,14 @@ struct cycle_fn {
 FLUX_EXPORT inline constexpr auto cycle = detail::cycle_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::cycle() &&
+constexpr auto inline_iter_base<D>::cycle() &&
     requires infinite_sequence<D> || multipass_sequence<D>
 {
     return flux::cycle(std::move(derived()));
 }
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::cycle(num::integral auto count) &&
+constexpr auto inline_iter_base<D>::cycle(num::integral auto count) &&
     requires multipass_sequence<D>
 {
     return flux::cycle(std::move(derived()), count);

diff --git a/include/flux/adaptor/drop.hpp b/include/flux/adaptor/drop.hpp
@@ -14,7 +14,7 @@ namespace flux {
 namespace detail {
 
 template <iterable Base>
-struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
+struct drop_adaptor : inline_iter_base<drop_adaptor<Base>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     distance_t count_;
@@ -95,7 +95,7 @@ struct drop_fn {
 FLUX_EXPORT inline constexpr auto drop = detail::drop_fn{};
 
 template <typename Derived>
-constexpr auto inline_sequence_base<Derived>::drop(num::integral auto count) &&
+constexpr auto inline_iter_base<Derived>::drop(num::integral auto count) &&
 {
     return flux::drop(std::move(derived()), count);
 }

diff --git a/include/flux/adaptor/drop_while.hpp b/include/flux/adaptor/drop_while.hpp
@@ -13,7 +13,7 @@ namespace flux {
 namespace detail {
 
 template <iterable Base, typename Pred>
-struct drop_while_adaptor : inline_sequence_base<drop_while_adaptor<Base, Pred>> {
+struct drop_while_adaptor : inline_iter_base<drop_while_adaptor<Base, Pred>> {
 private:
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Pred pred_;
@@ -84,7 +84,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>>
-constexpr auto inline_sequence_base<D>::drop_while(Pred pred) &&
+constexpr auto inline_iter_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
@@ -14,7 +14,7 @@ namespace flux {
 namespace detail {
 
 template <iterable Base, typename Pred>
-class filter_adaptor : public inline_sequence_base<filter_adaptor<Base, Pred>>
+class filter_adaptor : public inline_iter_base<filter_adaptor<Base, Pred>>
 {
     FLUX_NO_UNIQUE_ADDRESS Base base_;
     FLUX_NO_UNIQUE_ADDRESS Pred pred_;
@@ -146,7 +146,7 @@ FLUX_EXPORT inline constexpr auto filter = detail::filter_fn{};
 template <typename D>
 template <typename Pred>
     requires std::predicate<Pred&, element_t<D>>
-constexpr auto inline_sequence_base<D>::filter(Pred pred) &&
+constexpr auto inline_iter_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
@@ -41,7 +41,7 @@ template <typename D>
 template <typename Func>
 requires std::invocable<Func&, element_t<D>> &&
          detail::optional_like<std::invoke_result_t<Func&, element_t<D>>>
-constexpr auto inline_sequence_base<D>::filter_map(Func func) &&
+constexpr auto inline_iter_base<D>::filter_map(Func func) &&
 {
     return flux::filter_map(derived(), std::move(func));
 }
@@ -63,7 +63,7 @@ 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_iter_base<D>::filter_deref() && requires detail::optional_like<value_t<D>>
 {
     return flux::filter_deref(derived());
 }

diff --git a/include/flux/adaptor/flatten.hpp b/include/flux/adaptor/flatten.hpp
@@ -13,7 +13,7 @@ namespace flux {
 namespace detail {
 
 template <iterable Base>
-struct flatten_adaptor : inline_sequence_base<flatten_adaptor<Base>> {
+struct flatten_adaptor : inline_iter_base<flatten_adaptor<Base>> {
 private:
     Base base_;
 
@@ -37,7 +37,7 @@ struct flatten_adaptor : inline_sequence_base<flatten_adaptor<Base>> {
 };
 
 template <sequence Base>
-struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
+struct flatten_adaptor<Base> : inline_iter_base<flatten_adaptor<Base>> {
 private:
     using InnerSeq = element_t<Base>;
 
@@ -120,7 +120,7 @@ struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
 template <multipass_sequence Base>
     requires std::is_reference_v<element_t<Base>> &&
              multipass_sequence<element_t<Base>>
-struct flatten_adaptor<Base> : inline_sequence_base<flatten_adaptor<Base>> {
+struct flatten_adaptor<Base> : inline_iter_base<flatten_adaptor<Base>> {
 private:
     Base base_;
 
@@ -269,7 +269,7 @@ struct flatten_fn {
 FLUX_EXPORT inline constexpr auto flatten = detail::flatten_fn{};
 
 template <typename Derived>
-constexpr auto inline_sequence_base<Derived>::flatten() &&
+constexpr auto inline_iter_base<Derived>::flatten() &&
         requires iterable<element_t<Derived>>
 {
     return flux::flatten(std::move(derived()));