algorithm: Add lambda helper function

Author: qookei

docs/meson.build

@@ -19,6 +19,7 @@ custom_target('build-doc',
 		'src/headers/algorithm/sequence.md',
 		'src/headers/algorithm/transform.md',
 		'src/headers/algorithm/when_all.md',
+		'src/headers/algorithm/lambda.md',
 		'src/headers/basic.md',
 		'src/headers/basic/any_receiver.md',
 		'src/headers/basic/detached.md',

docs/src/SUMMARY.md

@@ -15,6 +15,7 @@
     - [let](headers/algorithm/let.md)
     - [sequence](headers/algorithm/sequence.md)
     - [when\_all](headers/algorithm/when_all.md)
+    - [lambda](headers/algorithm/lambda.md)
   - [async/basic.hpp](headers/basic.md)
     - [co\_awaits\_to](headers/basic/co_awaits_to.md)
     - [sender\_awaiter](headers/basic/sender_awaiter.md)

docs/src/headers/algorithm/lambda.md

@@ -0,0 +1,63 @@
+# lambda
+
+`lambda` is a helper function which wraps a function-like object to
+extend it's lifetime for the duration of the async operation. Primarily
+intended to be used with lambdas with captures as arguments to
+`race_and_cancel` and such.
+
+The returned wrapper is callable with the same arguments as the
+original function object, and the arguments get forwarded to it.
+
+## Prototype
+
+```cpp
+template <typename Fn>
+lambda_callable sequence(Fn fn);
+```
+
+### Requirements
+
+`Fn` is a function-like object that produces a sender.
+
+### Arguments
+
+ - `fn` - the function-like object to wrap.
+
+### Return value
+
+This function returns a wrapper object that upon being called returns
+a sender of unspecified type. The sender forwards the return value
+from the sender returned by `fn`.
+
+## Examples
+
+```cpp
+
+auto x = std::make_shared<int>(1);
+
+async::run(
+	async::race_and_cancel(
+		async::lambda(
+			[x_ = std::make_shared<int>(1)] (async::cancellation_token ct)
+			-> async::result<void> {
+				// x_ is valid here
+				std::cout << *x_ << "\n";
+				co_return;
+				/* ... */
+			}
+		),
+		[x_ = std::make_shared<int>(2)] (async::cancellation_token ct)
+		-> async::result<void> {
+			// x_ is NOT valid here
+			// the hidden lambda `this` is out of scope!
+			// std::cout << *x_ << "\n"; // crash !
+			co_return;
+		}
+	)
+);
+```
+
+Output:
+```
+1
+```

include/async/algorithm.hpp

@@ -797,4 +797,59 @@ operator co_await(when_all_sender<Senders...> s) {
 	return {std::move(s)};
 }
 
+//---------------------------------------------------------------------------------------
+// lambda()
+//---------------------------------------------------------------------------------------
+
+template <typename R, typename Fn, typename ...Args>
+struct lambda_operation {
+	lambda_operation(R receiver, Fn fn, std::tuple<Args...> args)
+	: fn_{std::move(fn)}, op_{execution::connect(std::apply(fn, args), std::move(receiver))} { }
+
+	bool start_inline() {
+		return execution::start_inline(op_);
+	}
+
+	Fn fn_;
+	execution::operation_t<std::invoke_result_t<Fn, Args...>, R> op_;
+};
+
+template <typename Fn, typename ...Args>
+struct [[nodiscard]] lambda_sender {
+	using value_type = std::invoke_result_t<Fn, Args...>::value_type;
+
+	Fn fn;
+	std::tuple<Args...> args;
+
+	template<typename Receiver>
+	friend lambda_operation<Receiver, Fn, Args...>
+	connect(lambda_sender s, Receiver r) {
+		return {std::move(r), std::move(s.fn), std::move(s.args)};
+	}
+};
+
+template <typename Fn, typename ...Args>
+sender_awaiter<lambda_sender<Fn, Args...>, typename lambda_sender<Fn, Args...>::value_type>
+operator co_await(lambda_sender<Fn, Args...> s) {
+	return {std::move(s)};
+}
+
+template <typename Fn>
+struct [[nodiscard]] lambda_callable {
+	template <typename ...Args>
+	auto operator()(Args &&...args) {
+		return lambda_sender{
+			std::move(fn),
+			std::forward_as_tuple(std::forward<Args>(args)...)
+		};
+	}
+
+	Fn fn;
+};
+
+template <typename Fn>
+auto lambda(Fn fn) {
+	return lambda_callable<Fn>{std::move(fn)};
+}
+
 } // namespace async

tests/algorithm.cpp

@@ -47,3 +47,61 @@ TEST(Algorithm, Sequence) {
 	for (int i = 0; i < 4; i++)
 		ASSERT_EQ(steps[i], i);
 }
+
+
+struct dtor_counter {
+	friend void swap(dtor_counter &a, dtor_counter &b) {
+		std::swap(a.ctr_, b.ctr_);
+	}
+
+	dtor_counter() :ctr_{nullptr} { }
+	dtor_counter(int &ctr) :ctr_{&ctr} { }
+
+	~dtor_counter() {
+		if (ctr_) (*ctr_)++;
+	}
+
+	dtor_counter(const dtor_counter &) = delete;
+	dtor_counter(dtor_counter &&other) :dtor_counter{} {
+		swap(*this, other);
+	}
+
+	dtor_counter &operator=(dtor_counter other) {
+		swap(*this, other);
+		return *this;
+	}
+
+	int *ctr_;
+};
+
+// These are defined as global so they are visible in lambdas without captures.
+
+int g_lambda_ctr1;
+int g_lambda_ctr2;
+
+bool g_lambda_ok1;
+bool g_lambda_ok2;
+
+TEST(Algorithm, LambdaRaceAndCancel) {
+	async::run(
+		async::race_and_cancel(
+			[x = dtor_counter{g_lambda_ctr1}] (async::cancellation_token ct)
+			-> async::result<void> {
+				if (g_lambda_ctr1 == 1) g_lambda_ok1 = true;
+				co_return;
+			},
+			async::lambda(
+				[x = dtor_counter{g_lambda_ctr2}] (async::cancellation_token ct)
+				-> async::result<void> {
+					if (g_lambda_ctr2 == 0) g_lambda_ok2 = true;
+					co_return;
+				}
+			)
+		));
+
+	ASSERT_EQ(g_lambda_ctr1, 1);
+	ASSERT_TRUE(g_lambda_ok1);
+
+	ASSERT_EQ(g_lambda_ctr2, 1);
+	ASSERT_TRUE(g_lambda_ok2);
+}