Feat/cartesian power and map

include/flux.hpp

@@ -13,8 +13,11 @@
 #include <flux/op/all_any_none.hpp>
 #include <flux/op/begin_end.hpp>
 #include <flux/op/cache_last.hpp>
+#include <flux/op/cartesian_base.hpp>
+#include <flux/op/cartesian_power.hpp>
+#include <flux/op/cartesian_power_map.hpp>
 #include <flux/op/cartesian_product.hpp>
-#include <flux/op/cartesian_product_with.hpp>
+#include <flux/op/cartesian_product_map.hpp>
 #include <flux/op/chain.hpp>
 #include <flux/op/chunk.hpp>
 #include <flux/op/chunk_by.hpp>

include/flux/core/numeric.hpp

@@ -171,6 +171,20 @@ inline constexpr auto checked_mul =
   }
 };
 
+FLUX_EXPORT
+inline constexpr auto checked_pow =
+        []<std::signed_integral T, std::unsigned_integral U>(T base, U exponent,
+                                   std::source_location loc = std::source_location::current())
+                -> T
+{
+    T res{1};
+    for(U i{0}; i < exponent; i++) {
+        res = checked_mul(res, base, loc);
+    }
+    return res;
+};
+
+
 inline constexpr auto checked_div =
     []<std::signed_integral T>(T lhs, T rhs,
                                std::source_location loc = std::source_location::current())

include/flux/op/adjacent.hpp

@@ -10,6 +10,7 @@
 
 #include <flux/op/begin_end.hpp>
 #include <flux/op/reverse.hpp>
+#include <flux/op/requirements.hpp>
 #include <flux/op/zip.hpp>
 #include <flux/source/iota.hpp>
 
@@ -176,19 +177,6 @@ struct adjacent_adaptor : inline_sequence_base<adjacent_adaptor<Base, N>> {
     };
 };
 
-template <typename Func, typename E, distance_t N>
-struct adjacent_invocable_helper {
-    template <std::size_t I>
-    using repeater = E;
-
-    static inline constexpr bool value = []<std::size_t... Is> (std::index_sequence<Is...>) consteval {
-        return std::regular_invocable<Func, repeater<Is>...>;
-    }(std::make_index_sequence<N>{});
-};
-
-template <typename Func, typename E, distance_t N>
-concept adjacent_invocable = adjacent_invocable_helper<Func, E, N>::value;
-
 template <typename Base, distance_t N, typename Func>
 struct adjacent_map_adaptor : inline_sequence_base<adjacent_map_adaptor<Base, N, Func>> {
 private:
@@ -207,7 +195,7 @@ struct adjacent_map_adaptor : inline_sequence_base<adjacent_map_adaptor<Base, N,
         template <typename Self>
         static constexpr auto read_at(Self& self, cursor_t<Self> const& cur)
             -> decltype(auto)
-            requires adjacent_invocable<decltype((self.func_)), element_t<decltype((self.base_))>, N>
+            requires repeated_invocable<decltype((self.func_)), element_t<decltype((self.base_))>, N>
         {
             return std::apply([&](auto const&... curs) {
                 return std::invoke(self.func_, flux::read_at(self.base_, curs)...);
@@ -231,7 +219,7 @@ template <distance_t N>
 struct adjacent_map_fn {
     template <adaptable_sequence Seq, typename Func>
         requires multipass_sequence<Seq> &&
-                 adjacent_invocable<Func, element_t<Seq>, N>
+                 repeated_invocable<Func, element_t<Seq>, N>
     [[nodiscard]]
     constexpr auto operator()(Seq&& seq, Func func) const -> multipass_sequence auto
     {