basic: add Waitable concept

Author: ArsenArsen

docs/src/SUMMARY.md

@@ -21,6 +21,7 @@
     - [run and run_forever](headers/basic/run.md)
     - [detached](headers/basic/detached.md)
     - [spawn](headers/basic/spawn.md)
+    - [Waitable](headers/basic/waitable.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/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

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>);
+```

docs/src/headers/wait-group.md

@@ -0,0 +1 @@
+# async/wait-group.hpp

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.
 

include/async/basic.hpp

@@ -309,7 +309,12 @@ 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();
@@ -364,7 +369,7 @@ typename Sender::value_type run(Sender s) {
 	platform::panic("libasync: Operation hasn't completed and we don't know how to wait");
 }
 
-template<typename Sender, typename IoService>
+template<typename Sender, Waitable IoService>
 requires std::same_as<typename Sender::value_type, void>
 void run(Sender s, IoService ios) {
 	struct state {