[V4] Tuple and captured transform (#55)

* copy

* nameing

* use hof

* apply

* import/export

* in structure

* c++23 -> c++26

* fixups

* start

* double empty failinh

* simplify

* reorder

* constructors

* renames

* apply test

* structured binding in test

* order

* Revert "order"

This reverts commit c369056.

* more-tests

* lock/key

* no warn missing braces

* tmp

* correct type signature

* mimic tuple!

* move to shim

* try zero sized

* noexcept

* test gcc workaround

* compiler dep code paths

* try dropping zero sized (gcc)

* final tuple tweaks

* wip

* tmp working

* faster!

* restore test

* split package and call

* both co_await

* async concepts

* non-void promise/call

* renames

* return benchmark

* add no except etc

* wip use lock/key

* Revert "wip use lock/key"

This reverts commit bdce13c.

* try single await

* Revert "try single await"

This reverts commit cc580ab.

* immovable swap

* mark pkg as nodiscard

* drop lock/key

* Update test/src/tuple.cpp

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update test/src/tuple.cpp

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update src/core/concepts.cxx

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update src/core/tuple.cxx

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* compare with std::tuple

* correct noexcept

* clarify std

* spell

* abbreviate

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: ConorWilliams

AGENTS.md

@@ -6,13 +6,13 @@
 strict fork-join parallelism using C++20 coroutines.
 
 - **Type**: C++ library with module/`import std` support
-- **Languages**: C++23
+- **Languages**: C++26
 
 ## Critical Build Requirements
 
 ### Compiler & Module Support
 
-This project **requires C++23 `import std`** and **MUST** use the appropriate
+This project **requires C++23's `import std`** and **MUST** use the appropriate
 toolchain file:
 
 - **MacOS**: Use `-DCMAKE_TOOLCHAIN_FILE=cmake/llvm-brew-toolchain.cmake`
@@ -89,7 +89,7 @@ cmake --build --preset <preset-name>
 **Build warnings** (expected and safe):
 
 - "It is recommended to build benchmarks in Release mode" - only relevant for `ci-hardened`
-- CMake experimental `import std;` warning - expected for C++23 modules
+- CMake experimental `import std;` warning - expected for C++23's `import std`
 
 ### 3. Test
 
@@ -194,7 +194,6 @@ Strive to add tests for new features/bug fixes.
 - Add `.cpp` files to `test/src/`
 - Tests auto-discovered by CMake (GLOB_RECURSE)
 - Links against `libfork::libfork` and `Catch2::Catch2WithMain`
-- Uses `cxx_std_23` feature requirement
 
 ### Modifying Build Configuration
 

CMakeLists.txt

@@ -35,7 +35,7 @@ add_library(libfork::libfork ALIAS libfork_libfork)
 
 set_property(TARGET libfork_libfork PROPERTY EXPORT_NAME libfork)
 
-target_compile_features(libfork_libfork PUBLIC cxx_std_23)
+target_compile_features(libfork_libfork PUBLIC cxx_std_26)
 
 # Public headers
 target_sources(libfork_libfork
@@ -61,6 +61,7 @@ target_sources(libfork_libfork
       src/core/utility.cxx
       src/core/frame.cxx
       src/core/constants.cxx
+      src/core/tuple.cxx
     PRIVATE
       src/exception.cpp
 )

CMakePresets.json

@@ -32,7 +32,7 @@
       "displayName": "Debug with warnings and hardening",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_CXX_FLAGS": "-O2 -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wcast-qual -Wformat -Wformat=2 -Wundef -Werror=float-equal -Wshadow -Wcast-align -Wunused -Wnull-dereference -Wdouble-promotion -Wimplicit-fallthrough -Wextra-semi -Woverloaded-virtual -Wnon-virtual-dtor -Wold-style-cast -Werror=format-security -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3 -D_GLIBCXX_ASSERTIONS -fstrict-flex-arrays=3 -fstack-protector-strong"
+        "CMAKE_CXX_FLAGS": "-O2 -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wcast-qual -Wformat -Wformat=2 -Wundef -Werror=float-equal -Wshadow -Wcast-align -Wunused -Wnull-dereference -Wdouble-promotion -Wimplicit-fallthrough -Wextra-semi -Woverloaded-virtual -Wnon-virtual-dtor -Wold-style-cast -Werror=format-security -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3 -D_GLIBCXX_ASSERTIONS -fstrict-flex-arrays=3 -fstack-protector-strong -Wno-missing-braces"
       }
     },
     {

benchmark/src/libfork_benchmark/fib/lf_parts.cpp

@@ -46,8 +46,8 @@ constexpr auto await = [](this auto fib, std::int64_t *ret, std::int64_t n) -> l
   std::int64_t lhs = 0;
   std::int64_t rhs = 0;
 
-  co_await fib(&lhs, n - 1);
-  co_await fib(&rhs, n - 2);
+  co_await lf::call(fib, &lhs, n - 1);
+  co_await lf::call(fib, &rhs, n - 2);
 
   *ret = lhs + rhs;
 };
@@ -68,7 +68,13 @@ void fib(benchmark::State &state) {
     benchmark::DoNotOptimize(n);
     std::int64_t result = 0;
 
-    Fn(&result, n).promise->handle().resume();
+    if constexpr (requires { Fn(&result, n); }) {
+      Fn(&result, n).promise->handle().resume();
+    } else {
+      auto task = Fn(n);
+      task.promise->return_address = &result;
+      task.promise->handle().resume();
+    }
 
     CHECK_RESULT(result, expect);
     benchmark::DoNotOptimize(result);
@@ -79,6 +85,21 @@ void fib(benchmark::State &state) {
   }
 }
 
+template <lf::alloc_mixin StackPolicy>
+constexpr auto ret = [](this auto fib, std::int64_t n) -> lf::task<std::int64_t, StackPolicy> {
+  if (n < 2) {
+    co_return n;
+  }
+
+  std::int64_t lhs = 0;
+  std::int64_t rhs = 0;
+
+  co_await lf::call(&lhs, fib, n - 1);
+  co_await lf::call(&rhs, fib, n - 2);
+
+  co_return lhs + rhs;
+};
+
 } // namespace
 
 BENCHMARK(fib<no_await<stack_on_heap>>)->Name("test/libfork/fib/heap/no_await")->Arg(fib_test);
@@ -87,8 +108,11 @@ BENCHMARK(fib<no_await<stack_on_heap>>)->Name("base/libfork/fib/heap/no_await")-
 BENCHMARK(fib<await<stack_on_heap>>)->Name("test/libfork/fib/heap/await")->Arg(fib_test);
 BENCHMARK(fib<await<stack_on_heap>>)->Name("base/libfork/fib/heap/await")->Arg(fib_base);
 
-BENCHMARK(fib<no_await<fib_bump_allocator>>)->Name("test/libfork/fib/data/no_await")->Arg(fib_test);
-BENCHMARK(fib<no_await<fib_bump_allocator>>)->Name("base/libfork/fib/data/no_await")->Arg(fib_base);
+BENCHMARK(fib<no_await<fib_bump_allocator>>)->Name("test/libfork/fib/bump_alloc/no_await")->Arg(fib_test);
+BENCHMARK(fib<no_await<fib_bump_allocator>>)->Name("base/libfork/fib/bump_alloc/no_await")->Arg(fib_base);
+
+BENCHMARK(fib<await<fib_bump_allocator>>)->Name("test/libfork/fib/bump_alloc/await")->Arg(fib_test);
+BENCHMARK(fib<await<fib_bump_allocator>>)->Name("base/libfork/fib/bump_alloc/await")->Arg(fib_base);
 
-BENCHMARK(fib<await<fib_bump_allocator>>)->Name("test/libfork/fib/data/await")->Arg(fib_test);
-BENCHMARK(fib<await<fib_bump_allocator>>)->Name("base/libfork/fib/data/await")->Arg(fib_base);
+BENCHMARK(fib<ret<fib_bump_allocator>>)->Name("test/libfork/fib/bump_alloc/return")->Arg(fib_test);
+BENCHMARK(fib<ret<fib_bump_allocator>>)->Name("base/libfork/fib/bump_alloc/return")->Arg(fib_base);

src/core/concepts.cxx

@@ -22,4 +22,37 @@ concept alloc_mixin = mixinable<T> && requires (std::size_t n, T *ptr) {
   { T::operator delete(ptr, n) } noexcept -> std::same_as<void>;
 };
 
+template <typename T, template <typename...> typename Template>
+struct is_specialization_of : std::false_type {};
+
+template <template <typename...> typename Template, typename... Args>
+struct is_specialization_of<Template<Args...>, Template> : std::true_type {};
+
+/**
+ * @brief Test if `T` is a specialization of the template `Template`.
+ */
+template <typename T, template <typename...> typename Template>
+concept specialization_of = is_specialization_of<std::remove_cvref_t<T>, Template>::value;
+
+// Forward-decl
+export template <returnable T, alloc_mixin Stack>
+struct task;
+
+/**
+ * @brief Test if a callable `Fn` when invoked with `Args...` returns an `lf::task`.
+ */
+export template <typename Fn, typename... Args>
+concept async_invocable =
+    std::invocable<Fn, Args...> && specialization_of<std::invoke_result_t<Fn, Args...>, task>;
+
+/**
+ * @brief The result type of invoking an async function `Fn` with `Args...`.
+ */
+export template <typename Fn, typename... Args>
+  requires async_invocable<Fn, Args...>
+using async_result_t = std::invoke_result_t<Fn, Args...>::type;
+
+template <typename Fn, typename R, typename... Args>
+concept async_invocable_to = async_invocable<Fn, Args...> && std::same_as<async_result_t<Fn, Args...>, R>;
+
 } // namespace lf

src/core/core.cxx

@@ -6,3 +6,4 @@ export import :concepts;
 export import :utility;
 export import :frame;
 export import :constants;
+export import :tuple;

src/core/promise.cxx

@@ -2,6 +2,7 @@ module;
 #include <version>
 
 #include "libfork/__impl/assume.hpp"
+#include "libfork/__impl/exception.hpp"
 #include "libfork/__impl/utils.hpp"
 export module libfork.core:promise;
 
@@ -10,6 +11,7 @@ import std;
 import :concepts;
 import :utility;
 import :frame;
+import :tuple;
 
 namespace lf {
 
@@ -37,7 +39,7 @@ struct promise_type;
  * \endrst
  */
 export template <returnable T, alloc_mixin Stack>
-struct task {
+struct task : immovable, std::type_identity<T> {
   promise_type<T, Stack> *promise;
 };
 
@@ -46,6 +48,8 @@ struct task {
 [[nodiscard]]
 constexpr auto final_suspend(frame_type *frame) -> std::coroutine_handle<> {
 
+  // TODO: noexcept
+
   LF_ASSUME(frame != nullptr);
 
   frame_type *parent_frame = frame->parent;
@@ -68,13 +72,15 @@ struct final_awaitable : std::suspend_always {
   }
 };
 
-struct just_awaitable : std::suspend_always {
+struct call_awaitable : std::suspend_always {
 
   frame_type *child;
 
   template <typename... Us>
   auto await_suspend(std::coroutine_handle<promise_type<Us...>> parent) noexcept -> std::coroutine_handle<> {
 
+    // TODO: destroy on child if cannot launch i.e. scheduling failure
+
     LF_ASSUME(child != nullptr);
     LF_ASSUME(child->parent == nullptr);
 
@@ -84,6 +90,36 @@ struct just_awaitable : std::suspend_always {
   }
 };
 
+// clang-format off
+
+template <typename R, typename Fn, typename... Args>
+struct pkg {
+  R *return_address;
+  [[no_unique_address]] Fn fn;
+  [[no_unique_address]] tuple<Args...> args;
+};
+
+template <typename Fn, typename... Args>
+struct pkg<void, Fn, Args...> {
+  [[no_unique_address]] Fn fn;
+  [[no_unique_address]] tuple<Args...> args;
+};
+
+// clang-format on
+
+template <typename R, typename Fn, typename... Args>
+struct [[nodiscard("You should immediately co_await this!")]] call_pkg : pkg<R, Fn, Args...>, immovable {};
+
+export template <typename... Args, async_invocable_to<void, Args...> Fn>
+constexpr auto call(Fn &&fn, Args &&...args) noexcept -> call_pkg<void, Fn, Args &&...> {
+  return {LF_FWD(fn), {LF_FWD(args)...}};
+}
+
+export template <typename R, typename... Args, async_invocable_to<R, Args...> Fn>
+constexpr auto call(R *ret, Fn &&fn, Args &&...args) noexcept -> call_pkg<R, Fn, Args &&...> {
+  return {ret, LF_FWD(fn), {LF_FWD(args)...}};
+}
+
 struct mixin_frame {
 
   // === For internal use === //
@@ -99,8 +135,15 @@ struct mixin_frame {
 
   // === Called by the compiler === //
 
-  template <alloc_mixin P>
-  constexpr static auto await_transform(task<void, P> child) noexcept -> just_awaitable {
+  template <typename R, typename Fn, typename... Args>
+  constexpr static auto await_transform(call_pkg<R, Fn, Args...> &&pkg) noexcept -> call_awaitable {
+
+    task child = std::move(pkg.args).apply(std::move(pkg.fn));
+
+    if constexpr (!std::is_void_v<R>) {
+      child.promise->return_address = pkg.return_address;
+    }
+
     return {.child = &child.promise->frame};
   }
 
@@ -120,9 +163,9 @@ struct promise_type<void, StackPolicy> : StackPolicy, mixin_frame {
 
   frame_type frame;
 
-  constexpr auto get_return_object() -> task<void, StackPolicy> { return {.promise = this}; }
+  constexpr auto get_return_object() noexcept -> task<void, StackPolicy> { return {.promise = this}; }
 
-  constexpr static void return_void() {}
+  constexpr static void return_void() noexcept {}
 };
 
 struct dummy_alloc {
@@ -142,8 +185,17 @@ static_assert(std::is_standard_layout_v<promise_type<void, dummy_alloc>>);
 
 template <typename T, alloc_mixin StackPolicy>
 struct promise_type : StackPolicy, mixin_frame {
+
   frame_type frame;
   T *return_address;
+
+  constexpr auto get_return_object() noexcept -> task<T, StackPolicy> { return {.promise = this}; }
+
+  template <typename U = T>
+    requires std::assignable_from<T &, U &&>
+  constexpr void return_value(U &&value) noexcept(std::is_nothrow_assignable_v<T &, U &&>) {
+    *return_address = LF_FWD(value);
+  }
 };
 
 static_assert(alignof(promise_type<int, dummy_alloc>) == alignof(frame_type));