[V4] Projected (#108)

* projected

projected

* naming in for each

* spell

* document indirect invocations concepts

* projected comments

* spell

* strip indirect value type

tmp

strip

Author: ConorWilliams

CMakeLists.txt

@@ -89,6 +89,7 @@ target_sources(libfork_libfork
       src/core/awaitables.cxx
       src/core/promise.cxx
       src/core/stop.cxx
+      src/core/projected.cxx
       # libfork.batteries
       src/batteries/batteries.cxx
       src/batteries/deque.cxx

src/algorithm/for_each.cxx

@@ -11,6 +11,10 @@ namespace lf {
 template <typename T>
 concept sized_random_access_range = std::ranges::random_access_range<T> && std::ranges::sized_range<T>;
 
+// TODO: relax the constraints?
+//
+// consider a projection if it makes the concept unifyable with fold etc
+
 struct for_each_impl {
  private:
   template <worker_context Context>
@@ -36,7 +40,7 @@ struct for_each_impl {
     LF_ASSUME(len >= 0);
 
     if (len <= n) {
-      if constexpr (indirectly_regular_unary_async_invocable<Fn, Context, I>) {
+      if constexpr (indirectly_async_regular_unary_invocable<Fn, Context, I>) {
         // Prefer async
         auto sc = co_await scope();
         for (; head != tail; ++head) {
@@ -71,7 +75,7 @@ struct for_each_impl {
       case 0:
         co_return;
       case 1:
-        if constexpr (indirectly_regular_unary_async_invocable<Fn, Context, I>) {
+        if constexpr (indirectly_async_regular_unary_invocable<Fn, Context, I>) {
           auto sc = co_await scope();
           co_await sc.call_drop(fn, *head);
           co_await sc.join();
@@ -81,6 +85,10 @@ struct for_each_impl {
         co_return;
     }
 
+    // TODO: round mid-point up
+    // Special case for (case 2/3) for async invocables to avoid the redundant task
+    // Benchmarks for ^ to see if it matters
+
     auto mid = head + (len / 2);
     auto sc = co_await scope();
     co_await sc.fork(for_each_impl{}, head, mid, fn);

src/core/concepts/indirect.cxx

@@ -1,39 +1,73 @@
-
 export module libfork.core:concepts_indirect;
 
 import std;
 
-import libfork.utils;
-
 import :concepts_invocable;
-
-/**
- * The purpose of this file is to define async versions of:
- *
- *  `indirectly_unary_invocable`
- *
- * This requires `indirect-value-t` which is in turn requires an async version
- * of `projected` which in turns requires an async version of
- * `indirect_result_t`
- *
- */
+import :concepts_context;
 
 namespace lf {
 
-// ========= Forward decl =========
+// A type can derive from this to opt-into indirect-value-t customization
+struct indirect_value_customization {};
 
-template <typename T>
+template <typename I>
 struct indirect_value {
-  using type = std::iter_value_t<T> &;
+  using type = std::iter_value_t<I> &;
 };
 
+// strip cv-ref qualifiers
 template <typename T>
-using indirect_value_t = indirect_value<T>::type;
+  requires (!std::same_as<T, std::remove_cvref_t<T>>)
+struct indirect_value<T> : indirect_value<std::remove_cvref_t<T>> {};
+
+// Specialization for types that customize
+template <std::derived_from<indirect_value_customization> T>
+  requires std::same_as<T, std::remove_cvref_t<T>>
+struct indirect_value<T> {
+  using type = T::indirect_value_type;
+};
+
+template <typename I>
+using indirect_value_t = indirect_value<I>::type;
 
 // ========= Core concepts =========
 
+/**
+ * @brief A version of `std::indirectly_unary_invocable` that supports
+ * libfork's projection type.
+ */
+export template <typename Fn, typename I>
+concept indirectly_sync_unary_invocable =                    //
+    std::indirectly_readable<I> &&                           //
+    std::copy_constructible<Fn> &&                           //
+    std::invocable<Fn &, indirect_value_t<I>> &&             //
+    std::invocable<Fn &, std::iter_reference_t<I>> &&        //
+    std::common_reference_with<                              //
+        std::invoke_result_t<Fn &, indirect_value_t<I>>,     //
+        std::invoke_result_t<Fn &, std::iter_reference_t<I>> //
+        >;                                                   //
+
+/**
+ * @brief A version of `std::indirectly_regular_unary_invocable` that supports
+ * libfork's projection type.
+ */
+export template <typename Fn, typename I>
+concept indirectly_sync_regular_unary_invocable =             //
+    std::indirectly_readable<I> &&                            //
+    std::copy_constructible<Fn> &&                            //
+    std::regular_invocable<Fn &, indirect_value_t<I>> &&      //
+    std::regular_invocable<Fn &, std::iter_reference_t<I>> && //
+    std::common_reference_with<                               //
+        std::invoke_result_t<Fn &, indirect_value_t<I>>,      //
+        std::invoke_result_t<Fn &, std::iter_reference_t<I>>  //
+        >;                                                    //
+
+/**
+ * @brief A variant of `std::indirectly_unary_invocable` that supports
+ * libfork's projection type and requires an async invocable.
+ */
 export template <typename Fn, typename Context, typename I>
-concept indirectly_unary_async_invocable =                      //
+concept indirectly_async_unary_invocable =                      //
     worker_context<Context> &&                                  //
     std::indirectly_readable<I> &&                              //
     std::copy_constructible<Fn> &&                              //
@@ -44,8 +78,12 @@ concept indirectly_unary_async_invocable =                      //
         async_result_t<Fn &, Context, std::iter_reference_t<I>> //
         >;                                                      //
 
+/**
+ * @brief A variant of `std::indirectly_regular_unary_invocable` that supports
+ * libfork's projection type and requires an async invocable.
+ */
 export template <typename Fn, typename Context, typename I>
-concept indirectly_regular_unary_async_invocable =
+concept indirectly_async_regular_unary_invocable =                      //
     worker_context<Context> &&                                          //
     std::indirectly_readable<I> &&                                      //
     std::copy_constructible<Fn> &&                                      //
@@ -56,77 +94,30 @@ concept indirectly_regular_unary_async_invocable =
         async_result_t<Fn &, Context, std::iter_reference_t<I>>         //
         >;                                                              //
 
-export template <typename Fn, typename Context, typename I>
-concept indirectly_unary_invocable =
-    indirectly_unary_async_invocable<Fn, Context, I> || std::indirectly_unary_invocable<Fn, I>;
-
-export template <typename Fn, typename Context, typename I>
-concept indirectly_regular_unary_invocable = indirectly_regular_unary_async_invocable<Fn, Context, I> ||
-                                             std::indirectly_regular_unary_invocable<Fn, I>;
-
-// ========= indirect_result =========
-
 /**
- * @brief A version of `std::invoke_result` that supports both regular invocables and async invocables.
+ * @brief A variant of `std::indirectly_unary_invocable` that supports either
+ * sync or async invocables.
  *
- * This gives preference to async invocation.
+ * In general if a function is both sync and async invocable it is expected
+ * that the async version will be preferred.
  */
-template <typename Proj, typename Context, typename... Args>
-struct invoke_result : std::invoke_result<Proj, Args...> {};
-
-// More constrained so should be selected if both regular and async invocations are possible.
-template <typename Proj, typename Context, typename... Args>
-  requires async_invocable<Proj, Context, Args...>
-struct invoke_result<Proj, Context, Args...> {
-  using type = async_result_t<Proj, Context, Args...>;
-};
-
-template <class F, typename Context, typename... Args>
-using invoke_result_t = invoke_result<F, Context, Args...>::type;
-
-template <class F, typename Context, std::indirectly_readable... Is>
-using indirect_result_t = invoke_result<F, Context, std::iter_reference_t<Is>...>::type;
-
-// ========= Projected =========
-
-// C++26 ADL firewalled implementation.
-
-struct hidden_projected_base {};
-
-template <bool WeaklyIncrementable, typename I, typename Proj, typename Context>
-struct projected_impl {
-
-  static_assert(!WeaklyIncrementable, "Should hit specialization for weakly incrementable");
-
-  struct type : hidden_projected_base {
-
-    // Used by indirect_value
-    using hidden_indirect_value = invoke_result<Proj &, Context, indirect_value_t<I>>;
-
-    using value_type = std::remove_cvref_t<indirect_result_t<Proj &, Context, I>>;
-    auto operator*() const -> indirect_result_t<Proj &, Context, I>;
-  };
-};
+export template <typename Fn, typename Context, typename I>
+concept indirectly_unary_invocable =
+    indirectly_async_unary_invocable<Fn, Context, I> || indirectly_sync_unary_invocable<Fn, I>;
 
-template <std::weakly_incrementable I, typename Proj, typename Context>
-struct projected_impl<true, I, Proj, Context> {
-  struct type : projected_impl<false, I, Proj, Context>::type {
-    using difference_type = std::iter_difference_t<I>;
-  };
-};
+// clang-format off
 
 /**
- * @brief A version of `std::projected` that supports both regular invocables and async invocables.
+ * @brief A variant of `std::indirectly_regular_unary_invocable` that supports
+ * either sync or async invocables.
  *
- * Note: this mandates regularly invocable projections.
+ * In general if a function is both sync and async invocable it is expected
+ * that the async version will be preferred.
  */
-export template <std::indirectly_readable I, typename Proj, worker_context Context>
-  requires indirectly_regular_unary_invocable<Proj, Context, I>
-using projected = projected_impl<std::weakly_incrementable<I>, I, Proj, Context>::type;
-
-// Specialization of indirect_value
-template <typename P>
-  requires std::derived_from<P, hidden_projected_base>
-struct indirect_value<P> : P::hidden_indirect_value {};
+export template <typename Fn, typename Context, typename I>
+concept indirectly_regular_unary_invocable = 
+    indirectly_async_regular_unary_invocable<Fn, Context, I> || indirectly_sync_regular_unary_invocable<Fn, I>;
+
+// clang-format on
 
 } // namespace lf

src/core/core.cxx

@@ -21,3 +21,4 @@ export import :stop;
 export import :exception;
 export import :final_suspend;
 export import :awaitables;
+export import :projected;

src/core/projected.cxx

@@ -0,0 +1,87 @@
+export module libfork.core:projected;
+
+import std;
+
+import :concepts_invocable;
+import :concepts_context;
+import :concepts_indirect;
+
+namespace lf {
+
+template <typename I>
+struct conditional_difference_type : indirect_value_customization {};
+
+template <std::weakly_incrementable I>
+struct conditional_difference_type<I> : indirect_value_customization {
+  using difference_type = std::iter_difference_t<I>;
+};
+
+// C++26 ADL firewalled implementation.
+template <typename I, typename Fn, typename Context>
+struct projected_impl;
+
+// sync
+template <typename I, typename Fn, typename>
+struct projected_impl {
+  struct type : conditional_difference_type<I> {
+   private:
+    friend struct indirect_value<type>;
+    using indirect_value_type = std::invoke_result_t<Fn &, indirect_value_t<I>>;
+
+    using reference_type = std::invoke_result_t<Fn &, std::iter_reference_t<I>>;
+
+   public:
+    using value_type = std::remove_cvref_t<reference_type>;
+    auto operator*() const -> reference_type;
+  };
+};
+
+// async
+template <typename I, typename Fn, typename Context>
+  requires indirectly_async_unary_invocable<Fn, Context, I>
+struct projected_impl<I, Fn, Context> {
+  struct type : conditional_difference_type<I> {
+   private:
+    friend struct indirect_value<type>;
+    using indirect_value_type = async_result_t<Fn &, Context, indirect_value_t<I>>;
+
+    using reference_type = async_result_t<Fn &, Context, std::iter_reference_t<I>>;
+
+   public:
+    using value_type = std::remove_cvref_t<reference_type>;
+    auto operator*() const -> reference_type;
+  };
+};
+
+template <typename Fn, typename Context, typename... T>
+concept async_defaultable =
+    ((async_invocable<Fn, Context, T> && std::default_initializable<async_result_t<Fn, Context, T>>) && ...);
+
+template <typename Fn, typename Context, typename I>
+concept async_defaultable_impl =
+    async_defaultable<Fn, Context, std::iter_reference_t<I>, indirect_value_t<I>>;
+
+template <typename Fn, typename Context, typename I>
+concept indirect_async_defaultable =
+    !indirectly_async_regular_unary_invocable<Fn, Context, I> || async_defaultable_impl<Fn, Context, I>;
+
+/**
+ * @brief Test if `I` can be projected through `Fn` in the context of `Context`
+ *
+ * This requires the standard indirectly regular invocable and, in addition,
+ * async projections must return a default initializable type.
+ *
+ * Projectable && indirectly_async_unary_invocable implies an async projection
+ * with default initializable async result type.
+ */
+export template <typename Fn, typename Context, typename I>
+concept projectable =
+    indirectly_regular_unary_invocable<Fn, Context, I> && indirect_async_defaultable<Fn, Context, I>;
+
+/**
+ * @brief A version of `std::projected` that supports both regular invocables and async invocables.
+ */
+export template <worker_context Context, std::indirectly_readable I, projectable<Context, I> Fn>
+using projected = projected_impl<I, Fn, Context>::type;
+
+} // namespace lf