diff --git a/docs/.gitignore b/docs/.gitignore
index 378eac2..7294be0 100644
--- a/docs/.gitignore
+++ b/docs/.gitignore
@@ -1 +1,2 @@
 build
+book
diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index b1c8375..07b41b1 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -23,6 +23,10 @@
     - [run and run_forever](headers/basic/run.md)
     - [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)
diff --git a/docs/src/headers/basic/operation.md b/docs/src/headers/basic/operation.md
new file mode 100644
index 0000000..a347895
--- /dev/null
+++ b/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>>);
+```
diff --git a/docs/src/headers/basic/receives.md b/docs/src/headers/basic/receives.md
new file mode 100644
index 0000000..4529127
--- /dev/null
+++ b/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>);
+```
diff --git a/docs/src/headers/basic/run.md b/docs/src/headers/basic/run.md
index d9eed34..1893c88 100644
--- a/docs/src/headers/basic/run.md
+++ b/docs/src/headers/basic/run.md
@@ -7,13 +7,13 @@ via the IO service.
 ## Prototype
 
 ```cpp
-template<typename IoService>
+template<Waitable IoService>
 void run_forever(IoService ios); // (1) 
 
 template<typename Sender>
 Sender::value_type run(Sender s); // (2)
 
-template<typename Sender, typename IoService>
+template<typename Sender, Waitable IoService>
 Sender::value_type run(Sender s, IoService ios); // (3)
 ```
 
@@ -24,11 +24,13 @@ inline as there's no way to wait for it to complete.
 
 ### Requirements
 
-`IoService` is an [IO service](../../io-service.md), and `Sender` is a sender.
+`IoService` is an [IO service](../../io-service.md), and must be a
+[Waitable](./waitable.md), and `Sender` is a sender.
 
 ### Arguments
 
- - `IoService` - the IO service to use to wait for completion.
+ - `IoService` - the IO service to use to wait for completion. Must fulfill the
+   [Waitable](./waitable.md) concept.
  - `Sender` - the sender to start.
 
 ### Return value
diff --git a/docs/src/headers/basic/sender.md b/docs/src/headers/basic/sender.md
new file mode 100644
index 0000000..d5e678c
--- /dev/null
+++ b/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>);
+```
diff --git a/docs/src/headers/basic/waitable.md b/docs/src/headers/basic/waitable.md
new file mode 100644
index 0000000..e45652a
--- /dev/null
+++ b/docs/src/headers/basic/waitable.md
@@ -0,0 +1,33 @@
+# `concept Waitable`
+
+The `Waitable` concept holds all the requirements for an [IO
+service](/io-service.md). Presently, this is only a `wait()` method.
+
+## Prototype
+
+```cpp
+template<typename T>
+concept Waitable = ...;
+```
+
+### Requirements
+
+`T` provides a instance wait method that can be called on a value.
+
+## Examples
+
+```cpp
+struct io_service {
+/** \pre loop must still be alive */
+void wait() {
+    auto loop = m_loop.lock();
+    assert(loop);
+    loop->wait();
+}
+private:
+friend struct event;
+io_service(std::weak_ptr<event> e) : m_loop { std::move(e) } {}
+std::weak_ptr<event> m_loop;
+};
+static_assert(async::Waitable<io_service>);
+```
diff --git a/docs/src/headers/wait-group.md b/docs/src/headers/wait-group.md
new file mode 100644
index 0000000..6a02104
--- /dev/null
+++ b/docs/src/headers/wait-group.md
@@ -0,0 +1 @@
+# async/wait-group.hpp
diff --git a/docs/src/io-service.md b/docs/src/io-service.md
index 48ec3c6..4ed2306 100644
--- a/docs/src/io-service.md
+++ b/docs/src/io-service.md
@@ -7,6 +7,8 @@ The IO service must provide one method: `void wait()`. This method is called whe
 there is no more work to do currently. It waits for any event to happen, and wakes
 up the appropriate coroutine/operation which awaited the event.
 
+See also: the [Waitable](/headers/basic/waitable.md) concept.
+
 **Note:** `async::run` and `async::run_forever` (see [here](headers/basic/run.md#prototype))
 take the IO service by value, not by reference.
 
diff --git a/include/async/algorithm.hpp b/include/async/algorithm.hpp
index a0631e2..e95b6a6 100644
--- a/include/async/algorithm.hpp
+++ b/include/async/algorithm.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <algorithm>
+#include <concepts>
 
 #include <async/basic.hpp>
 #include <async/cancellation.hpp>
@@ -9,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>;
 
@@ -21,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)};
 }
@@ -58,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)};
 	}
@@ -141,7 +142,7 @@ template<typename Sender, typename F>
 struct [[nodiscard]] transform_sender;
 
 template<typename Sender, typename F>
-requires (!std::is_same_v<typename Sender::value_type, void>)
+requires (!std::same_as<typename Sender::value_type, void>)
 struct [[nodiscard]] transform_sender<Sender, F> {
 	using value_type = std::invoke_result_t<F, typename Sender::value_type>;
 
@@ -160,11 +161,11 @@ struct [[nodiscard]] transform_sender<Sender, F> {
 };
 
 template<typename Sender, typename F>
-requires std::is_same_v<typename Sender::value_type, void>
+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)});
@@ -233,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)};
 	}
@@ -248,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)};
 }
@@ -325,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,6 +337,10 @@ struct repeat_while_sender {
 };
 
 template<typename C, typename SF>
+requires std::move_constructible<C> && requires (C c, SF sf) {
+	{ c() } -> std::convertible_to<bool>;
+	{ sf() } -> Sender;
+}
 repeat_while_sender<C, SF> repeat_while(C cond, SF factory) {
 	return {std::move(cond), std::move(factory)};
 }
@@ -350,7 +356,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) {
@@ -449,7 +455,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 {{std::move(fs)...}};
 }
@@ -494,7 +501,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)};
@@ -510,7 +517,10 @@ operator co_await(let_sender<Pred, Func> s) {
 	return {std::move(s)};
 }
 
-template <typename Pred, typename Func>
+template <std::invocable<> Pred, typename Func>
+requires requires (Func func, Pred pred) {
+	func(std::declval<std::add_lvalue_reference_t<decltype(pred())>>());
+}
 let_sender<Pred, Func> let(Pred pred, Func func) {
 	return {std::move(pred), std::move(func)};
 }
@@ -684,7 +694,7 @@ struct [[nodiscard]] sequence_operation {
 	frg::aligned_storage<max_operation_size, max_operation_alignment> box_;
 };
 
-template <typename ...Senders> requires (sizeof...(Senders) > 0)
+template <Sender ...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;
 
@@ -697,12 +707,12 @@ struct [[nodiscard]] sequence_sender {
 	frg::tuple<Senders...> senders;
 };
 
-template <typename ...Senders> requires (sizeof...(Senders) > 0)
+template <Sender ...Senders> requires (sizeof...(Senders) > 0)
 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)};
@@ -777,7 +787,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)};
@@ -786,7 +796,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)...}};
 }
diff --git a/include/async/basic.hpp b/include/async/basic.hpp
index 2caf4b6..4313839 100644
--- a/include/async/basic.hpp
+++ b/include/async/basic.hpp
@@ -2,6 +2,7 @@
 
 #include <atomic>
 #include <concepts>
+#include <type_traits>
 
 #include <async/execution.hpp>
 #include <frg/list.hpp>
@@ -36,6 +37,57 @@ namespace corons = std::experimental;
 #endif
 
 namespace async {
+template<typename T, typename Value>
+concept Receives = std::movable<T>
+&& (std::same_as<Value, void> ?
+requires(T t) {
+	{ t.set_value_inline() } -> std::same_as<void>;
+	{ t.set_value_noinline() } -> std::same_as<void>;
+}
+: requires(T t) {
+	{ t.set_value_inline(std::declval<Value>()) } -> std::same_as<void>;
+	{ t.set_value_noinline(std::declval<Value>()) } -> std::same_as<void>;
+});
+
+namespace helpers {
+template<auto>
+struct dummy_receiver {
+	template<typename T>
+	requires (!std::same_as<T, void>)
+	void set_value_inline(T) {
+		assert(std::is_constant_evaluated());
+	}
+	void set_value_inline() {
+		assert(std::is_constant_evaluated());
+	}
+
+	template<typename T>
+	requires (!std::same_as<T, void>)
+	void set_value_noinline(T) {
+		assert(std::is_constant_evaluated());
+	}
+	void set_value_noinline() {
+		assert(std::is_constant_evaluated());
+	}
+};
+static_assert(Receives<dummy_receiver<[]{}>, void>);
+static_assert(Receives<dummy_receiver<[]{}>, int>);
+} /* namespace helpers */
+
+template<typename T>
+concept Operation = requires(T &t) {
+	{ execution::start_inline(t) } -> std::same_as<bool>;
+};
+
+/* We require move constructible, rather than movable, since lambdas can be
+ * move constructible but not movable
+ */
+template<typename T>
+concept Sender = std::move_constructible<T> && requires(T t) {
+	typename T::value_type;
+	{ execution::connect(std::move(t), helpers::dummy_receiver<[]{}>{}) }
+		-> Operation;
+};
 
 template<typename E>
 requires requires(E &&e) { operator co_await(std::forward<E>(e)); }
@@ -68,6 +120,9 @@ enum class maybe_awaited {
 // sender_awaiter template.
 // ----------------------------------------------------------------------------
 
+/* we can't declare S a sender here, since, if we do, it'd be impossible to
+ * declare a member co_await that returns a sender_awaiter
+ */
 template<typename S, typename T = void>
 struct [[nodiscard]] sender_awaiter {
 private:
@@ -156,11 +211,12 @@ struct [[nodiscard]] sender_awaiter<S, void> {
 template<typename T>
 struct any_receiver {
 	template<typename R>
+	requires (
+	   std::is_trivially_copyable_v<R>
+	&& sizeof(R) <= sizeof(void *)
+	&& alignof(R) <= alignof(void *)
+	)
 	any_receiver(R receiver) {
-		static_assert(std::is_trivially_copyable_v<R>);
-		static_assert(sizeof(R) <= sizeof(void *));
-		static_assert(alignof(R) <= alignof(void *));
-
 		new (stor_) R(receiver);
 		set_value_fptr_ = [] (void *p, T value) {
 			auto *rp = static_cast<R *>(p);
@@ -184,8 +240,12 @@ struct any_receiver {
 template<>
 struct any_receiver<void> {
 	template<typename R>
+	requires (
+	   std::is_trivially_copyable_v<R>
+	&& sizeof(R) <= sizeof(void *)
+	&& alignof(R) <= alignof(void *)
+	)
 	any_receiver(R receiver) {
-		static_assert(std::is_trivially_copyable_v<R>);
 		new (stor_) R(receiver);
 		set_value_fptr_ = [] (void *p) {
 			auto *rp = static_cast<R *>(p);
@@ -227,10 +287,13 @@ struct callback<R(Args...)> {
 	callback()
 	: _function(nullptr) { }
 
-	template<typename F, typename = std::enable_if_t<
-			sizeof(F) == sizeof(void *) && alignof(F) == alignof(void *)
-			&& std::is_trivially_copy_constructible<F>::value
-			&& std::is_trivially_destructible<F>::value>>
+	template<typename F>
+	requires (
+	   sizeof(F) <= sizeof(void*)
+	&& alignof(F) <= alignof(void*)
+	&& std::is_trivially_copy_constructible_v<F>
+	&& std::is_trivially_destructible_v<F>
+	)
 	callback(F functor)
 	: _function(&invoke<F>) {
 		new (&_object) F{std::move(functor)};
@@ -315,16 +378,21 @@ struct run_queue {
 // Top-level execution functions.
 // ----------------------------------------------------------------------------
 
-template<typename IoService>
+template<typename T>
+concept Waitable = requires (T t) {
+	t.wait();
+};
+
+template<Waitable IoService>
 void run_forever(IoService ios) {
 	while(true) {
 		ios.wait();
 	}
 }
 
-template<typename Sender>
-std::enable_if_t<std::is_same_v<typename Sender::value_type, void>, void>
-run(Sender s) {
+template<Sender Sender>
+requires std::same_as<typename Sender::value_type, void>
+void run(Sender s) {
 	struct receiver {
 		void set_value_inline() { }
 
@@ -338,10 +406,9 @@ run(Sender s) {
 	platform::panic("libasync: Operation hasn't completed and we don't know how to wait");
 }
 
-template<typename Sender>
-std::enable_if_t<!std::is_same_v<typename Sender::value_type, void>,
-		typename Sender::value_type>
-run(Sender s) {
+template<Sender Sender>
+requires (!std::same_as<typename Sender::value_type, void>)
+typename Sender::value_type run(Sender s) {
 	struct state {
 		frg::optional<typename Sender::value_type> value;
 	};
@@ -371,9 +438,9 @@ run(Sender s) {
 	platform::panic("libasync: Operation hasn't completed and we don't know how to wait");
 }
 
-template<typename Sender, typename IoService>
-std::enable_if_t<std::is_same_v<typename Sender::value_type, void>, void>
-run(Sender s, IoService ios) {
+template<Sender Sender, Waitable IoService>
+requires std::same_as<typename Sender::value_type, void>
+void run(Sender s, IoService ios) {
 	struct state {
 		bool done = false;
 	};
@@ -405,10 +472,9 @@ run(Sender s, IoService ios) {
 	}
 }
 
-template<typename Sender, typename IoService>
-std::enable_if_t<!std::is_same_v<typename Sender::value_type, void>,
-		typename Sender::value_type>
-run(Sender s, IoService ios) {
+template<Sender Sender, typename IoService>
+requires (!std::same_as<typename Sender::value_type, void>)
+typename Sender::value_type run(Sender s, IoService ios) {
 	struct state {
 		bool done = false;
 		frg::optional<typename Sender::value_type> value;
@@ -532,12 +598,12 @@ void detach_with_allocator(Allocator allocator, S sender) {
 	detach_with_allocator<Allocator, S>(std::move(allocator), std::move(sender), [] { });
 }
 
-template<typename S>
+template<Sender S>
 void detach(S sender) {
 	return detach_with_allocator(frg::stl_allocator{}, std::move(sender));
 }
 
-template<typename S, typename Cont>
+template<Sender S, typename Cont>
 void detach(S sender, Cont continuation) {
 	return detach_with_allocator(frg::stl_allocator{}, std::move(sender), std::move(continuation));
 }
diff --git a/include/async/execution.hpp b/include/async/execution.hpp
index 25d31a6..528bd3b 100644
--- a/include/async/execution.hpp
+++ b/include/async/execution.hpp
@@ -2,154 +2,125 @@
 
 #include <type_traits>
 #include <utility>
+#include <concepts>
 
-namespace async {
-
-// Detection pattern boilerplate.
-
-template<typename... Ts>
-using void_t = void;
-
-template<typename... Ts>
-constexpr bool dependent_false_t = false;
-
-template <template <typename...> typename Trait, typename Void, typename... Args>
-struct is_detected_helper : std::false_type { };
-
-template <template <typename...> typename Trait, typename... Args>
-struct is_detected_helper<Trait, void_t<Trait<Args...>>, Args...> : std::true_type { };
-
-template <template <typename...> typename Trait, typename... Args>
-constexpr bool is_detected_v = is_detected_helper<Trait, void, Args...>::value;
+#include <frg/detection.hpp>
 
+namespace async {
 namespace cpo_types {
-	// TODO: Rewrite this using concepts.
-	template<typename S, typename R>
-	using connect_member_t = decltype(std::declval<S>().connect(std::declval<R>()));
-
-	template<typename S, typename R>
-	constexpr bool has_connect_member_v = is_detected_v<connect_member_t, S, R>;
-
-	template<typename S, typename R>
-	using global_connect_t = decltype(connect(std::declval<S>(), std::declval<R>()));
-
-	template<typename S, typename R>
-	constexpr bool has_global_connect_v = is_detected_v<global_connect_t, S, R>;
-
-	struct connect_cpo {
-		template<typename Sender, typename Receiver>
-		auto operator() (Sender &&s, Receiver &&r) const {
-			if constexpr (has_connect_member_v<Sender, Receiver>)
-					return s.connect(r);
-			else if constexpr (has_global_connect_v<Sender, Receiver>)
-					return connect(std::forward<Sender>(s), std::forward<Receiver>(r));
-				else
-					static_assert(dependent_false_t<Sender, Receiver>,
-							"No connect() customization defined for sender type");
-		}
-	};
-
-	template<typename Op>
-	using start_member_t = decltype(std::declval<Op>().start());
-
-	template<typename Op>
-	constexpr bool has_start_member_v = is_detected_v<start_member_t, Op>;
-
-	template<typename Op>
-	using global_start_t = decltype(start(std::declval<Op>()));
-
-	template<typename Op>
-	constexpr bool has_global_start_v = is_detected_v<global_start_t, Op>;
-
-	struct start_inline_cpo {
-		template<typename Operation>
-		bool operator() (Operation &&op) const {
-			if constexpr (requires { op.start_inline(); }) {
-				return op.start_inline();
-			}else if constexpr (has_start_member_v<Operation>) {
-				op.start();
-				return false;
-			}else if constexpr (has_global_start_v<Operation>) {
-				start(std::forward<Operation>(op));
-				return false;
-			}else{
-				static_assert(dependent_false_t<Operation>,
-						"No start() customization defined for operation type");
-			}
-		}
-	};
-
-	struct set_value_cpo {
-		template<typename Receiver, typename T>
-		requires
-			requires(Receiver &&r, T &&value) { r.set_value_noinline(std::forward<T>(value)); }
-		void operator() (Receiver &&r, T &&value) {
-			if constexpr (requires { r.set_value_noinline(std::forward<T>(value)); })
-				r.set_value_noinline(std::forward<T>(value));
-			else
-				// This should have been caught by the concept.
-				static_assert(dependent_false_t<Receiver>);
-		}
-
-		template<typename Receiver>
-		requires
-			requires(Receiver &&r) { r.set_value_noinline(); }
-		void operator() (Receiver &&r) {
-			if constexpr (requires { r.set_value_noinline(); })
-				r.set_value_noinline();
-			else
-				// This should have been caught by the concept.
-				static_assert(dependent_false_t<Receiver>);
-		}
-	};
-
-	struct set_value_inline_cpo {
-		template<typename Receiver, typename T>
-		requires
-			requires(Receiver &&r, T &&value) { r.set_value_inline(std::forward<T>(value)); }
-		void operator() (Receiver &&r, T &&value) {
-			if constexpr (requires { r.set_value_inline(std::forward<T>(value)); })
-				r.set_value_inline(std::forward<T>(value));
-			else
-				// This should have been caught by the concept.
-				static_assert(dependent_false_t<Receiver>);
-		}
-
-		template<typename Receiver>
-		requires
-			requires(Receiver &&r) { r.set_value_inline(); }
-		void operator() (Receiver &&r) {
-			if constexpr (requires { r.set_value_inline(); })
-				r.set_value_inline();
-			else
-				// This should have been caught by the concept.
-				static_assert(dependent_false_t<Receiver>);
-		}
-	};
-
-	struct set_value_noinline_cpo {
-		template<typename Receiver, typename T>
-		requires
-			requires(Receiver &&r, T &&value) { r.set_value_noinline(std::forward<T>(value)); }
-		void operator() (Receiver &&r, T &&value) {
-			if constexpr (requires { r.set_value_noinline(std::forward<T>(value)); })
-				r.set_value_noinline(std::forward<T>(value));
-			else
-				// This should have been caught by the concept.
-				static_assert(dependent_false_t<Receiver>);
+template<typename Sender, typename Receiver>
+concept member_connect =  requires (Sender &&s, Receiver &&r) {
+	std::forward<Sender>(s).connect(std::forward<Receiver>(r));
+};
+
+template<typename Sender, typename Receiver>
+concept global_connect = requires (Sender &&s, Receiver &&r) {
+	connect(std::forward<Sender>(s), std::forward<Receiver>(r));
+};
+
+struct connect_cpo {
+	template<typename Sender, typename Receiver>
+	auto operator() (Sender &&s, Receiver &&r) const {
+		if constexpr (member_connect<Sender, Receiver>) {
+			return std::forward<Sender>(s).connect(std::forward<Receiver>(r));
+		} else if constexpr (global_connect<Sender, Receiver>) {
+			return connect(
+				std::forward<Sender>(s),
+				std::forward<Receiver>(r)
+			);
+		} else {
+			static_assert(frg::dependent_false_t<Sender, Receiver>,
+				"No connect() customization defined for S,R");
 		}
-
-		template<typename Receiver>
-		requires
-			requires(Receiver &&r) { r.set_value_noinline(); }
-		void operator() (Receiver &&r) {
-			if constexpr (requires { r.set_value_noinline(); })
-				r.set_value_noinline();
-			else
-				// This should have been caught by the concept.
-				static_assert(dependent_false_t<Receiver>);
+	}
+};
+
+template<typename Operation>
+concept inline_startable_operation = requires (Operation &&op) {
+	{ std::forward<Operation>(op).start_inline() } -> std::convertible_to<bool>;
+};
+
+template<typename Operation>
+concept member_start = requires (Operation &&op) {
+	std::forward<Operation>(op).start();
+};
+
+template<typename Operation>
+concept global_start = requires (Operation &&op) {
+	start(std::forward<Operation>(op));
+};
+
+struct start_inline_cpo {
+	template<typename Operation>
+	bool operator() (Operation &&op) const {
+		if constexpr (inline_startable_operation<Operation>) {
+			return op.start_inline();
+		}else if constexpr (member_start<Operation>) {
+			std::forward<Operation>(op).start();
+			return false;
+		}else if constexpr (global_start<Operation>) {
+			start(std::forward<Operation>(op));
+			return false;
+		}else{
+			static_assert(frg::dependent_false_t<Operation>,
+				"No start() customization defined for operation type");
 		}
-	};
+	}
+};
+
+struct set_value_cpo {
+	template<typename Receiver, typename T>
+	requires requires(Receiver &&r, T &&value) {
+		std::forward<Receiver>(r).set_value_noinline(std::forward<T>(value));
+	}
+	void operator() (Receiver &&r, T &&value) {
+		std::forward<Receiver>(r).set_value_noinline(std::forward<T>(value));
+	}
+
+	template<typename Receiver>
+	requires requires(Receiver &&r) {
+		std::forward<Receiver>(r).set_value_noinline();
+	}
+	void operator() (Receiver &&r) {
+		std::forward<Receiver>(r).set_value_noinline();
+	}
+};
+
+struct set_value_inline_cpo {
+	template<typename Receiver, typename T>
+	requires requires(Receiver &&r, T &&value) {
+		std::forward<Receiver>(r).set_value_inline(std::forward<T>(value));
+	}
+	void operator() (Receiver &&r, T &&value) {
+		std::forward<Receiver>(r).set_value_inline(std::forward<T>(value));
+	}
+
+	template<typename Receiver>
+	requires requires(Receiver &&r) {
+		std::forward<Receiver>(r).set_value_inline();
+	}
+	void operator() (Receiver &&r) {
+		std::forward<Receiver>(r).set_value_inline();
+	}
+};
+
+struct set_value_noinline_cpo {
+	template<typename Receiver, typename T>
+	requires requires(Receiver &&r, T &&value) {
+		std::forward<Receiver>(r).set_value_noinline(std::forward<T>(value));
+	}
+	void operator() (Receiver &&r, T &&value) {
+		std::forward<Receiver>(r).set_value_noinline(std::forward<T>(value));
+	}
+
+	template<typename Receiver>
+	requires requires(Receiver &&r) {
+		std::forward<Receiver>(r).set_value_noinline();
+	}
+	void operator() (Receiver &&r) {
+		std::forward<Receiver>(r).set_value_noinline();
+	}
+};
 }
 
 namespace execution {