rename set_scheduler to bind & launch

include/async++/scheduler.hpp

@@ -13,19 +13,36 @@ class scheduler {
 
 
 template <class T>
-    requires requires(T& t, scheduler& s) { t.set_scheduler(s); }
-T& set_scheduler(T& t, scheduler& s) {
-    t.set_scheduler(s);
+    requires requires(T& t, scheduler& s) { t.bind(s); }
+T& bind(T& t, scheduler& s) {
+    t.bind(s);
     return t;
 }
 
 
 template <class T>
-    requires requires(T&& t, scheduler& s) { t.set_scheduler(s); }
-T set_scheduler(T&& t, scheduler& s) {
-    t.set_scheduler(s);
+    requires requires(T&& t, scheduler& s) { t.bind(s); }
+T bind(T&& t, scheduler& s) {
+    t.bind(s);
     return std::move(t);
 }
 
 
+template <class T>
+    requires requires(T& t, scheduler& s) { bind(t, s); t.launch(); }
+T& launch(T& t, scheduler& s) {
+    bind(t, s);
+    t.launch();
+    return t;
+}
+
+
+template <class T>
+    requires requires(T&& t, scheduler& s) { bind(t, s); t.launch(); }
+T launch(T&& t, scheduler& s) {
+    bind(t, s);
+    t.launch();
+    return std::move(t);
+}
+
 } // namespace asyncpp

include/async++/shared_task.hpp

@@ -244,7 +244,7 @@ class shared_task {
         return impl_shared_task::awaitable<T>(m_promise);
     }
 
-    void set_scheduler(scheduler& scheduler) {
+    void bind(scheduler& scheduler) {
         if (m_promise) {
             m_promise->m_scheduler = &scheduler;
         }

include/async++/task.hpp

@@ -209,7 +209,7 @@ class [[nodiscard]] task {
         return impl_task::awaitable<T>(std::exchange(m_promise, nullptr));
     }
 
-    void set_scheduler(scheduler& scheduler) {
+    void bind(scheduler& scheduler) {
         if (m_promise) {
             m_promise->m_scheduler = &scheduler;
         }

test/test_shared_task.cpp

@@ -25,7 +25,7 @@ TEST_CASE("Shared task: interleave sync", "[Shared task]") {
     auto make_fixture = [&tester] {
         auto f = std::make_shared<fixture>();
         f->task = do_task(tester);
-        set_scheduler(f->task, f->sched);
+        bind(f->task, f->sched);
         return f;
     };
 
@@ -71,9 +71,9 @@ TEST_CASE("Shared task: interleaving co_await", "[Shared task]") {
     auto make_fixture = [&tester] {
         auto f = std::make_shared<fixture>();
         auto worker_task = do_worker_task(tester);
-        set_scheduler(worker_task, f->worker_sched);
+        bind(worker_task, f->worker_sched);
         f->main_task = do_main_task(std::move(worker_task));
-        f->main_task.set_scheduler(f->main_sched);
+        f->main_task.bind(f->main_sched);
         return f;
     };
 
@@ -114,7 +114,7 @@ TEST_CASE("Shared task: interleaving abandon", "[Shared task]") {
     auto make_fixture = [&tester] {
         auto f = std::make_shared<fixture>();
         f->task = do_task(tester);
-        set_scheduler(f->task, f->sched);
+        bind(f->task, f->sched);
         return f;
     };
 

test/test_task.cpp

@@ -23,7 +23,7 @@ TEST_CASE("Task: interleaving sync", "[Task]") {
     auto make_fixture = [&tester] {
         auto f = std::make_shared<fixture>();
         f->task = do_task(tester);
-        set_scheduler(f->task, f->sched);
+        bind(f->task, f->sched);
         return f;
     };
 
@@ -68,9 +68,9 @@ TEST_CASE("Task: interleaving co_await", "[Task]") {
     auto make_fixture = [&tester] {
         auto f = std::make_shared<fixture>();
         auto worker_task = do_worker_task(tester);
-        set_scheduler(worker_task, f->worker_sched);
+        bind(worker_task, f->worker_sched);
         f->main_task = do_main_task(std::move(worker_task));
-        f->main_task.set_scheduler(f->main_sched);
+        f->main_task.bind(f->main_sched);
         return f;
     };
 
@@ -111,7 +111,7 @@ TEST_CASE("Task: interleaving abandon", "[Task]") {
     auto make_fixture = [&tester] {
         auto f = std::make_shared<fixture>();
         f->task = do_task(tester);
-        set_scheduler(f->task, f->sched);
+        bind(f->task, f->sched);
         return f;
     };
 

test/test_thread_pool.cpp

@@ -28,11 +28,8 @@ TEST_CASE("Thread pool: perf test", "[Scheduler]") {
             co_return 1;
         }
         std::array<task<int64_t>, branching> children;
-        std::ranges::generate(children, [&] { return set_scheduler(self(self, depth - 1), sched); });
+        std::ranges::generate(children, [&] { return launch(self(self, depth - 1), sched); });
         int64_t sum = 0;
-        for (auto& tk : children) {
-            tk.launch();
-        }
         for (auto& tk : children) {
             sum += co_await tk;
         }
@@ -41,7 +38,7 @@ TEST_CASE("Thread pool: perf test", "[Scheduler]") {
 
     const auto count = int64_t(std::pow(branching, depth));
     const auto start = std::chrono::high_resolution_clock::now();
-    const auto result = set_scheduler(coro(coro, depth), sched).get();
+    const auto result = bind(coro(coro, depth), sched).get();
     const auto end = std::chrono::high_resolution_clock::now();
     std::cout << "performance: " << 1e9 * double(count) / std::chrono::nanoseconds(end - start).count() << " / s" << std::endl;
     REQUIRE(result == count);