basic: add Sender, Receives and Operation concepts

Author: ArsenArsen

docs/src/SUMMARY.md

@@ -22,6 +22,9 @@
     - [detached](headers/basic/detached.md)
     - [spawn](headers/basic/spawn.md)
     - [Waitable](headers/basic/waitable.md)
+    - [Sender](headers/basic/sender.md)
+    - [Operation](headers/basic/operation.md)
+    - [Receives<T>](headers/basic/receives.md)
   - [async/result.hpp](headers/result.md)
   - [async/oneshot.hpp](headers/oneshot-event.md)
   - [async/wait-group.hpp](headers/wait-group.md)

docs/src/headers/basic/operation.md

@@ -0,0 +1,41 @@
+# `concept Operation`
+
+The `Operation` concept holds all the requirements for an
+[operation](/sender-receiver.md).
+
+## Prototype
+
+```cpp
+template<typename T>
+concept Operation = ...;
+```
+
+### Requirements
+
+`T` can be started via the [start\_inline](/headers/execution.md) CPO.
+
+## Examples
+
+```cpp
+template <typename Receiver>
+struct write_operation {
+    write_operation(write_sender s, Receiver r)
+    : req_{}, handle_{s.handle}, bufs_{s.bufs}, nbufs_{s.nbufs}, r_{std::move(r)} { }
+
+    write_operation(const write_operation &) = delete;
+    write_operation &operator=(const write_operation &) = delete;
+    write_operation(write_operation &&) = delete;
+    write_operation &operator=(write_operation &&) = delete;
+
+    bool start_inline() { /* omitted for brevity */ }
+
+private:
+    uv_write_t req_;
+    uv_stream_t *handle_;
+    const uv_buf_t *bufs_;
+    size_t nbufs_;
+
+    Receiver r_;
+};
+static_assert(async::Operation<write_operation<noop_receiver>>);
+```

docs/src/headers/basic/receives.md

@@ -0,0 +1,42 @@
+# `concept Receives`
+
+The `Receives<T>` concept holds all the requirements for a
+[receiver](/sender-receiver.md) that can receive a `T` value (or none, when `T`
+is `void`).
+
+## Prototype
+
+```cpp
+template<typename T, typename Receives>
+concept Receives = ...;
+```
+
+### Requirements
+
+A `set_value_inline` and `set_value_noinline` members, which can be called with
+a `T&&` value, or no parameters, if `T` is `void`.
+
+## Examples
+
+```cpp
+struct discard_receiver {
+	template<typename T>
+	void set_value_inline(T) {
+		assert(std::is_constant_evaluated());
+	}
+	void set_value_inline() {
+		assert(std::is_constant_evaluated());
+	}
+
+	template<typename T>
+	void set_value_noinline(T) {
+		assert(std::is_constant_evaluated());
+	}
+	void set_value_noinline() {
+		assert(std::is_constant_evaluated());
+	}
+};
+static_assert(async::Receives<discard_receiver, void>);
+static_assert(async::Receives<discard_receiver, int>);
+static_assert(async::Receives<discard_receiver, std::string>);
+```

docs/src/headers/basic/sender.md

@@ -0,0 +1,35 @@
+# `concept Sender`
+
+The `Sender` concept holds all the requirements for a
+[sender](/sender-receiver.md).
+
+## Prototype
+
+```cpp
+template<typename T>
+concept Sender = ...;
+```
+
+### Requirements
+
+`T` has a `value_type`, is move constructible, and can be
+[connected](/headers/execution.md).
+
+## Examples
+
+```cpp
+struct [[nodiscard]] write_sender {
+    using value_type = int; // Status code
+
+    uv_stream_t *handle;
+    const uv_buf_t *bufs;
+    size_t nbufs;
+};
+
+/* operation omitted for brevity */
+template <typename Receiver>
+/*operation*/<Receiver> connect(write_sender s, Receiver r) {
+    return {s, std::move(r)};
+}
+static_assert(async::Sender<write_sender>);
+```

include/async/algorithm.hpp

@@ -10,7 +10,7 @@
 
 namespace async {
 
-template<typename Sender, typename Receiver>
+template<Sender Sender, Receives<typename Sender::value_type> Receiver>
 struct connect_helper {
 	using operation = execution::operation_t<Sender, Receiver>;
 
@@ -22,7 +22,7 @@ struct connect_helper {
 	Receiver r;
 };
 
-template<typename Sender, typename Receiver>
+template<Sender Sender, Receives<typename Sender::value_type> Receiver>
 connect_helper<Sender, Receiver> make_connect_helper(Sender s, Receiver r) {
 	return {std::move(s), std::move(r)};
 }
@@ -59,7 +59,7 @@ template<typename F>
 struct [[nodiscard]] invocable_sender {
 	using value_type = std::invoke_result_t<F>;
 
-	template<typename R>
+	template<Receives<value_type> R>
 	invocable_operation<F, R> connect(R r) {
 		return {std::move(f), std::move(r)};
 	}
@@ -165,7 +165,7 @@ requires std::same_as<typename Sender::value_type, void>
 struct [[nodiscard]] transform_sender<Sender, F> {
 	using value_type = std::invoke_result_t<F>;
 
-	template<typename Receiver>
+	template<Receives<value_type> Receiver>
 	friend auto connect(transform_sender s, Receiver dr) {
 		return execution::connect(std::move(s.ds),
 				void_transform_receiver<Receiver, F>{std::move(dr), std::move(s.f)});
@@ -234,7 +234,7 @@ struct [[nodiscard]] ite_sender {
 	ite_sender(C cond, ST then_s, SE else_s)
 	: cond_{std::move(cond)}, then_s_{std::move(then_s)}, else_s_{std::move(else_s)} { }
 
-	template<typename R>
+	template<Receives<value_type> R>
 	ite_operation<C, ST, SE, R> connect(R dr) {
 		return {std::move(cond_), std::move(then_s_), std::move(else_s_), std::move(dr)};
 	}
@@ -249,7 +249,8 @@ struct [[nodiscard]] ite_sender {
 	SE else_s_;
 };
 
-template<typename C, typename ST, typename SE>
+template<std::invocable<> C, Sender ST, Sender SE>
+requires std::same_as<typename ST::value_type, typename SE::value_type>
 ite_sender<C, ST, SE> ite(C cond, ST then_s, SE else_s) {
 	return {std::move(cond), std::move(then_s), std::move(else_s)};
 }
@@ -326,7 +327,7 @@ struct repeat_while_sender {
 		return {std::move(*this)};
 	}
 
-	template<typename R>
+	template<Receives<value_type> R>
 	repeat_while_operation<C, SF, R> connect(R receiver) {
 		return {std::move(cond), std::move(factory), std::move(receiver)};
 	}
@@ -335,7 +336,10 @@ struct repeat_while_sender {
 	SF factory;
 };
 
-template<typename C, typename SF>
+template<typename C, Sender SF>
+requires std::movable<C> && requires (C c) {
+	{ c() } -> std::convertible_to<bool>;
+}
 repeat_while_sender<C, SF> repeat_while(C cond, SF factory) {
 	return {std::move(cond), std::move(factory)};
 }
@@ -351,7 +355,7 @@ template<typename... Functors>
 struct race_and_cancel_sender {
 	using value_type = void;
 
-	template<typename Receiver>
+	template<Receives<value_type> Receiver>
 	friend race_and_cancel_operation<Receiver, frg::tuple<Functors...>,
 			std::index_sequence_for<Functors...>>
 	connect(race_and_cancel_sender s, Receiver r) {
@@ -450,7 +454,8 @@ operator co_await(race_and_cancel_sender<Functors...> s) {
 	return {std::move(s)};
 }
 
-template<typename... Functors>
+template<std::invocable<cancellation_token>... Functors>
+requires ((Sender<std::invoke_result_t<Functors, cancellation_token>>) && ...)
 race_and_cancel_sender<Functors...> race_and_cancel(Functors... fs) {
 	return {{fs...}};
 }
@@ -495,7 +500,7 @@ struct [[nodiscard]] let_sender {
 	using imm_type = std::invoke_result_t<Pred>;
 	using value_type = typename std::invoke_result_t<Func, std::add_lvalue_reference_t<imm_type>>::value_type;
 
-	template<typename Receiver>
+	template<Receives<value_type> Receiver>
 	friend let_operation<Receiver, Pred, Func>
 	connect(let_sender s, Receiver r) {
 		return {std::move(s.pred), std::move(s.func), std::move(r)};
@@ -511,7 +516,8 @@ operator co_await(let_sender<Pred, Func> s) {
 	return {std::move(s)};
 }
 
-template <typename Pred, typename Func>
+template <std::invocable<> Pred, typename Func>
+requires std::invocable<Func, std::add_lvalue_reference_t<std::invoke_result_t<Pred>>>
 let_sender<Pred, Func> let(Pred pred, Func func) {
 	return {std::move(pred), std::move(func)};
 }
@@ -689,7 +695,7 @@ template <typename ...Senders> requires (sizeof...(Senders) > 0)
 struct [[nodiscard]] sequence_sender {
 	using value_type = typename std::tuple_element_t<sizeof...(Senders) - 1, frg::tuple<Senders...>>::value_type;
 
-	template<typename Receiver>
+	template<Receives<value_type> Receiver>
 	friend sequence_operation<Receiver, Senders...>
 	connect(sequence_sender s, Receiver r) {
 		return {std::move(s.senders), std::move(r)};
@@ -703,7 +709,7 @@ sequence_sender<Senders...> sequence(Senders ...senders) {
 	return {frg::tuple<Senders...>{std::move(senders)...}};
 }
 
-template <typename ...Senders>
+template <Sender ...Senders>
 sender_awaiter<sequence_sender<Senders...>, typename sequence_sender<Senders...>::value_type>
 operator co_await(sequence_sender<Senders...> s) {
 	return {std::move(s)};
@@ -778,7 +784,7 @@ template <typename ...Senders> requires (sizeof...(Senders) > 0)
 struct [[nodiscard]] when_all_sender {
 	using value_type = void;
 
-	template<typename Receiver>
+	template<Receives<value_type> Receiver>
 	friend when_all_operation<Receiver, Senders...>
 	connect(when_all_sender s, Receiver r) {
 		return {std::move(s.senders), std::move(r)};
@@ -787,7 +793,8 @@ struct [[nodiscard]] when_all_sender {
 	frg::tuple<Senders...> senders;
 };
 
-template <typename ...Senders> requires (sizeof...(Senders) > 0)
+template <Sender ...Senders>
+requires (sizeof...(Senders) > 0)
 when_all_sender<Senders...> when_all(Senders ...senders) {
 	return {frg::tuple<Senders...>{std::move(senders)...}};
 }