From ff0e4a57cccb2de28a8251bcf986373dea9ee38f Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Tue, 15 Aug 2023 10:37:10 -0700
Subject: [PATCH 01/17] Fix formatting.

---
 stlab/utility.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stlab/utility.hpp b/stlab/utility.hpp
index 4dd23304..e25703a5 100644
--- a/stlab/utility.hpp
+++ b/stlab/utility.hpp
@@ -118,10 +118,10 @@ void for_each_argument(F&& f, Args&&... args) {
 /// Returns a copy of the argument. Used to pass an lvalue to function taking an rvalue or to
 /// copy a type with an `explicit` copy-constructor.
 template <typename T>
-constexpr std::decay_t<T> copy(T&& value) noexcept(
-    noexcept(std::decay_t<T>{static_cast<T&&>(value)})) {
-  static_assert(!std::is_same<std::decay_t<T>, T>::value, "explicit copy of rvalue.");
-  return std::decay_t<T>{static_cast<T&&>(value)};
+constexpr std::decay_t<T> copy(T&& value) noexcept(noexcept(std::decay_t<T>{
+    static_cast<T&&>(value)})) {
+    static_assert(!std::is_same<std::decay_t<T>, T>::value, "explicit copy of rvalue.");
+    return std::decay_t<T>{static_cast<T&&>(value)};
 }
 
 /**************************************************************************************************/

From 500dfb71499904ebcad2b77702de907b98989bff Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 11:59:22 -0700
Subject: [PATCH 02/17] Requiring noexcept for executor tasks.

---
 stlab/concurrency/channel.hpp            | 128 +++++++++++------------
 stlab/concurrency/default_executor.hpp   |  18 ++--
 stlab/concurrency/executor_base.hpp      |  14 +--
 stlab/concurrency/future.hpp             |  16 +--
 stlab/concurrency/immediate_executor.hpp |   8 +-
 stlab/concurrency/main_executor.hpp      |  50 ++++-----
 stlab/concurrency/serial_queue.hpp       |  15 +--
 stlab/concurrency/system_timer.hpp       |  61 +++++------
 stlab/concurrency/task.hpp               |  64 +++++++-----
 test/channel_test_helper.cpp             |   2 +-
 test/channel_test_helper.hpp             |   2 +-
 test/executor_test.cpp                   |  26 ++---
 test/future_test_helper.hpp              |  15 +--
 test/future_when_any_arguments_tests.cpp |   2 +-
 test/serial_queue_test.cpp               |  24 ++---
 15 files changed, 223 insertions(+), 222 deletions(-)

diff --git a/stlab/concurrency/channel.hpp b/stlab/concurrency/channel.hpp
index 2e7ce9d4..470b985d 100755
--- a/stlab/concurrency/channel.hpp
+++ b/stlab/concurrency/channel.hpp
@@ -348,7 +348,7 @@ auto set_process_error(P& process, std::exception_ptr&& error)
 }
 
 template <typename P>
-auto set_process_error(P&, std::exception_ptr &&)
+auto set_process_error(P&, std::exception_ptr&&)
     -> std::enable_if_t<!has_set_process_error_v<unwrap_reference_t<P>>, void> {}
 
 /**************************************************************************************************/
@@ -597,8 +597,8 @@ template <typename Q, typename T, typename R, typename Arg, std::size_t I, typen
 struct shared_process_sender_indexed : public shared_process_sender<Arg> {
     shared_process<Q, T, R, Args...>& _shared_process;
 
-    explicit
-    shared_process_sender_indexed(shared_process<Q, T, R, Args...>& sp) : _shared_process(sp) {}
+    explicit shared_process_sender_indexed(shared_process<Q, T, R, Args...>& sp) :
+        _shared_process(sp) {}
 
     void add_sender() override { ++_shared_process._sender_count; }
 
@@ -652,9 +652,7 @@ struct shared_process_sender_helper;
 template <typename Q, typename T, typename R, std::size_t... I, typename... Args>
 struct shared_process_sender_helper<Q, T, R, std::index_sequence<I...>, Args...>
     : shared_process_sender_indexed<Q, T, R, Args, I, Args...>... {
-    
-    explicit
-    shared_process_sender_helper(shared_process<Q, T, R, Args...>& sp) :
+    explicit shared_process_sender_helper(shared_process<Q, T, R, Args...>& sp) :
         shared_process_sender_indexed<Q, T, R, Args, I, Args...>(sp)... {}
 };
 
@@ -768,8 +766,6 @@ struct shared_process
 
     const std::tuple<std::shared_ptr<shared_process_receiver<Args>>...> _upstream;
 
-
-
     template <typename E, typename F>
     shared_process(E&& e, F&& f) :
         shared_process_sender_helper<Q, T, R, std::make_index_sequence<sizeof...(Args)>, Args...>(
@@ -954,12 +950,12 @@ struct shared_process
                     std::chrono::nanoseconds::min())
                     broadcast(unwrap(*_process).yield());
                 else
-                    execute_at(duration,
-                               _executor)([_weak_this = make_weak_ptr(this->shared_from_this())] {
-                        auto _this = _weak_this.lock();
-                        if (!_this) return;
-                        _this->try_broadcast();
-                    });
+                    execute_at(duration, _executor)(
+                        [_weak_this = make_weak_ptr(this->shared_from_this())]() noexcept {
+                            auto _this = _weak_this.lock();
+                            if (!_this) return;
+                            _this->try_broadcast();
+                        });
             }
 
             /*
@@ -978,25 +974,25 @@ struct shared_process
             } else {
                 /* Schedule a timeout. */
                 _timeout_function_active = true;
-                execute_at(duration,
-                           _executor)([_weak_this = make_weak_ptr(this->shared_from_this())] {
-                    auto _this = _weak_this.lock();
-                    // It may be that the complete channel is gone in the meanwhile
-                    if (!_this) return;
-
-                    // try_lock can fail spuriously
-                    while (true) {
-                        lock_t lock(_this->_timeout_function_control, std::try_to_lock);
-                        if (!lock) continue;
-
-                        // we were cancelled
-                        if (get_process_state(_this->_process).first != process_state::yield) {
-                            _this->try_broadcast();
-                            _this->_timeout_function_active = false;
+                execute_at(duration, _executor)(
+                    [_weak_this = make_weak_ptr(this->shared_from_this())]() noexcept {
+                        auto _this = _weak_this.lock();
+                        // It may be that the complete channel is gone in the meanwhile
+                        if (!_this) return;
+
+                        // try_lock can fail spuriously
+                        while (true) {
+                            lock_t lock(_this->_timeout_function_control, std::try_to_lock);
+                            if (!lock) continue;
+
+                            // we were cancelled
+                            if (get_process_state(_this->_process).first != process_state::yield) {
+                                _this->try_broadcast();
+                                _this->_timeout_function_active = false;
+                            }
+                            return;
                         }
-                        return;
-                    }
-                });
+                    });
             }
         } catch (...) { // this catches exceptions during _process.await() and _process.yield()
             broadcast(std::move(std::current_exception()));
@@ -1038,12 +1034,12 @@ struct shared_process
                     std::chrono::nanoseconds::min())
                     broadcast(unwrap(*_process).yield());
                 else
-                    execute_at(duration,
-                               _executor)([_weak_this = make_weak_ptr(this->shared_from_this())] {
-                        auto _this = _weak_this.lock();
-                        if (!_this) return;
-                        _this->try_broadcast();
-                    });
+                    execute_at(duration, _executor)(
+                        [_weak_this = make_weak_ptr(this->shared_from_this())]() noexcept {
+                            auto _this = _weak_this.lock();
+                            if (!_this) return;
+                            _this->try_broadcast();
+                        });
             }
 
             /*
@@ -1062,25 +1058,25 @@ struct shared_process
             } else {
                 /* Schedule a timeout. */
                 _timeout_function_active = true;
-                execute_at(duration,
-                           _executor)([_weak_this = make_weak_ptr(this->shared_from_this())] {
-                    auto _this = _weak_this.lock();
-                    // It may be that the complete channel is gone in the meanwhile
-                    if (!_this) return;
-
-                    // try_lock can fail spuriously
-                    while (true) {
-                        lock_t lock(_this->_timeout_function_control, std::try_to_lock);
-                        if (!lock) continue;
-
-                        // we were cancelled
-                        if (get_process_state(_this->_process).first != process_state::yield) {
-                            _this->try_broadcast();
-                            _this->_timeout_function_active = false;
+                execute_at(duration, _executor)(
+                    [_weak_this = make_weak_ptr(this->shared_from_this())]() noexcept {
+                        auto _this = _weak_this.lock();
+                        // It may be that the complete channel is gone in the meanwhile
+                        if (!_this) return;
+
+                        // try_lock can fail spuriously
+                        while (true) {
+                            lock_t lock(_this->_timeout_function_control, std::try_to_lock);
+                            if (!lock) continue;
+
+                            // we were cancelled
+                            if (get_process_state(_this->_process).first != process_state::yield) {
+                                _this->try_broadcast();
+                                _this->_timeout_function_active = false;
+                            }
+                            return;
                         }
-                        return;
-                    }
-                });
+                    });
             }
         } catch (...) { // this catches exceptions during _process.await() and _process.yield()
             broadcast(std::move(std::current_exception()));
@@ -1098,10 +1094,12 @@ struct shared_process
         REVISIT (sparent) : See above comments on step() and ensure consistency.
 
         What is this code doing, if we don't have a yield then it also assumes no await?
+
+        This seems to be doing a lot for a (required) noexcept operation - are we sure?
     */
 
     template <typename U>
-    auto step() -> std::enable_if_t<!has_process_yield_v<unwrap_reference_t<U>>> {
+    auto step() noexcept -> std::enable_if_t<!has_process_yield_v<unwrap_reference_t<U>>> {
         using queue_t = typename Q::value_type;
         stlab::optional<queue_t> message;
         std::array<bool, sizeof...(Args)> do_cts;
@@ -1135,7 +1133,7 @@ struct shared_process
     }
 
     void run() {
-        _executor([_p = make_weak_ptr(this->shared_from_this())] {
+        _executor([_p = make_weak_ptr(this->shared_from_this())]() noexcept {
             auto p = _p.lock();
             if (p) p->template step<T>();
         });
@@ -1352,8 +1350,7 @@ auto zip(S s, R... r) {
 
 /**************************************************************************************************/
 
-struct buffer_size 
-{
+struct buffer_size {
     std::size_t _value;
     buffer_size(std::size_t b) : _value(b) {}
 };
@@ -1378,15 +1375,16 @@ struct annotated_process {
     F _f;
     annotations _annotations;
 
-    explicit annotated_process(executor_task_pair<F>&& etp) : _f(std::move(etp._f)), _annotations(std::move(etp._executor)) {}
+    explicit annotated_process(executor_task_pair<F>&& etp) :
+        _f(std::move(etp._f)), _annotations(std::move(etp._executor)) {}
 
     annotated_process(F f, const executor& e) : _f(std::move(f)), _annotations(e._executor) {}
     annotated_process(F f, buffer_size bs) : _f(std::move(f)), _annotations(bs._value) {}
 
     annotated_process(F f, executor&& e) : _f(std::move(f)), _annotations(std::move(e._executor)) {}
     annotated_process(F f, annotations&& a) : _f(std::move(f)), _annotations(std::move(a)) {}
-    annotated_process(executor_task_pair<F>&& etp, buffer_size bs) : _f(std::move(etp._f)), _annotations(std::move(etp._executor), bs) {}
-    
+    annotated_process(executor_task_pair<F>&& etp, buffer_size bs) :
+        _f(std::move(etp._f)), _annotations(std::move(etp._executor), bs) {}
 };
 
 template <typename B, typename E>
@@ -1553,8 +1551,8 @@ class STLAB_NODISCARD() receiver {
     }
 
     auto operator|(sender<T> send) {
-        return operator|
-            ([_send = std::move(send)](auto&& x) { _send(std::forward<decltype(x)>(x)); });
+        return operator|(
+            [_send = std::move(send)](auto&& x) { _send(std::forward<decltype(x)>(x)); });
     }
 };
 
diff --git a/stlab/concurrency/default_executor.hpp b/stlab/concurrency/default_executor.hpp
index a4a966fd..831ad461 100644
--- a/stlab/concurrency/default_executor.hpp
+++ b/stlab/concurrency/default_executor.hpp
@@ -91,7 +91,7 @@ struct executor_type {
     using result_type = void;
 
     template <typename F>
-    void operator()(F f) const {
+    auto operator()(F f) const -> std::enable_if_t<noexcept(f())> {
         using f_t = decltype(f);
 
         dispatch_group_async_f(detail::group()._group,
@@ -224,7 +224,7 @@ class waiter {
 class notification_queue {
     struct element_t {
         std::size_t _priority;
-        task<void()> _task;
+        task<void() noexcept> _task;
 
         template <class F>
         element_t(F&& f, std::size_t priority) : _priority{priority}, _task{std::forward<F>(f)} {}
@@ -250,7 +250,7 @@ class notification_queue {
     }
 
     // Must be called under a lock with a non-empty _q, always returns a valid task
-    auto pop_not_empty() -> task<void()> {
+    auto pop_not_empty() -> task<void() noexcept> {
         auto result = std::move(_q.front()._task);
         std::pop_heap(begin(_q), end(_q), element_t::greater());
         _q.pop_back();
@@ -258,7 +258,7 @@ class notification_queue {
     }
 
 public:
-    auto try_pop() -> task<void()> {
+    auto try_pop() -> task<void() noexcept> {
         lock_t lock{_mutex, std::try_to_lock};
         if (!lock || _q.empty()) return nullptr;
         return pop_not_empty();
@@ -275,7 +275,7 @@ class notification_queue {
         return true;
     }
 
-    auto pop() -> std::pair<bool, task<void()>> {
+    auto pop() -> std::pair<bool, task<void() noexcept>> {
         lock_t lock{_mutex};
         _waiting = true;
         while (_q.empty() && !_done && _waiting)
@@ -341,7 +341,7 @@ class priority_task_system {
     void run(unsigned i) {
         stlab::set_current_thread_name("cc.stlab.default_executor");
         while (true) {
-            task<void()> f;
+            task<void() noexcept> f;
 
             for (unsigned n = 0; n != _count && !f; ++n) {
                 f = _q[(i + n) % _count].try_pop();
@@ -408,7 +408,7 @@ class priority_task_system {
             stlab::set_current_thread_name("cc.stlab.default_executor.expansion");
 
             while (true) {
-                task<void()> f;
+                task<void() noexcept> f;
 
                 for (unsigned n = 0; n != _count && !f; ++n) {
                     f = _q[(i + n) % _count].try_pop();
@@ -458,7 +458,7 @@ template <executor_priority P = executor_priority::medium>
 struct executor_type {
     using result_type = void;
 
-    void operator()(task<void()> f) const {
+    void operator()(task<void() noexcept>&& f) const {
         static task_system<P> only_task_system{[] {
             at_pre_exit([]() noexcept { only_task_system.join(); });
             return task_system<P>{};
@@ -473,7 +473,7 @@ template <executor_priority P = executor_priority::medium>
 struct executor_type {
     using result_type = void;
 
-    void operator()(task<void()> f) const {
+    void operator()(task<void() noexcept>&& f) const {
         pts().execute<static_cast<std::size_t>(P)>(std::move(f));
     }
 };
diff --git a/stlab/concurrency/executor_base.hpp b/stlab/concurrency/executor_base.hpp
index e49a73a1..693a9cf7 100644
--- a/stlab/concurrency/executor_base.hpp
+++ b/stlab/concurrency/executor_base.hpp
@@ -24,7 +24,7 @@ namespace stlab {
 inline namespace v1 {
 /**************************************************************************************************/
 
-using executor_t = std::function<void(stlab::task<void()>)>;
+using executor_t = std::function<void(stlab::task<void() noexcept>)>;
 
 /*
  * returns an executor that will schedule any passed task to it to execute
@@ -35,16 +35,17 @@ template <typename Rep, typename Per = std::ratio<1>>
 executor_t execute_at(std::chrono::duration<Rep, Per> duration, executor_t executor) {
     return [_duration = std::move(duration), _executor = std::move(executor)](auto f) mutable {
         if (_duration != std::chrono::duration<Rep, Per>{})
-            system_timer(_duration, [_f = std::move(f), _executor = std::move(_executor)]() mutable {
-                _executor(std::move(_f));
-            });
+            system_timer(_duration,
+                         [_f = std::move(f), _executor = std::move(_executor)]() mutable noexcept {
+                             _executor(std::move(_f));
+                         });
         else
             _executor(std::move(f));
     };
 }
 
-[[deprecated("Use chrono::duration as parameter instead")]]
-inline executor_t execute_at(std::chrono::steady_clock::time_point when, executor_t executor) {
+[[deprecated("Use chrono::duration as parameter instead")]] inline executor_t execute_at(
+    std::chrono::steady_clock::time_point when, executor_t executor) {
     using namespace std::chrono;
     return execute_at(duration_cast<nanoseconds>(when - steady_clock::now()), std::move(executor));
 }
@@ -79,7 +80,6 @@ executor_task_pair<F> operator&(F&& f, executor e) {
     return executor_task_pair<F>{std::move(e._executor), std::forward<F>(f)};
 }
 
-
 /**************************************************************************************************/
 
 } // namespace v1
diff --git a/stlab/concurrency/future.hpp b/stlab/concurrency/future.hpp
index 392e2930..75982f55 100755
--- a/stlab/concurrency/future.hpp
+++ b/stlab/concurrency/future.hpp
@@ -256,7 +256,7 @@ struct shared_task {
 
 template <typename T>
 struct shared_base<T, enable_if_copyable<T>> : std::enable_shared_from_this<shared_base<T>> {
-    using then_t = std::vector<std::pair<executor_t, task<void()>>>;
+    using then_t = std::vector<std::pair<executor_t, task<void() noexcept>>>;
 
     executor_t _executor;
     stlab::optional<T> _result;
@@ -294,7 +294,7 @@ struct shared_base<T, enable_if_copyable<T>> : std::enable_shared_from_this<shar
 
     void _detach() {
         std::unique_lock<std::mutex> lock(_mutex);
-        if (!_ready) _then.emplace_back([](auto&&) {}, [_p = this->shared_from_this()] {});
+        if (!_ready) _then.emplace_back([](auto&&) {}, [_p = this->shared_from_this()]() noexcept {});
     }
 
     void set_exception(std::exception_ptr error) {
@@ -361,7 +361,7 @@ struct shared_base<T, enable_if_copyable<T>> : std::enable_shared_from_this<shar
 
 template <typename T>
 struct shared_base<T, enable_if_not_copyable<T>> : std::enable_shared_from_this<shared_base<T>> {
-    using then_t = std::pair<executor_t, task<void()>>;
+    using then_t = std::pair<executor_t, task<void() noexcept>>;
 
     executor_t _executor;
     stlab::optional<T> _result;
@@ -399,7 +399,7 @@ struct shared_base<T, enable_if_not_copyable<T>> : std::enable_shared_from_this<
 
     void _detach() {
         std::unique_lock<std::mutex> lock(_mutex);
-        if (!_ready) _then = then_t([](auto&&) {}, [_p = this->shared_from_this()] {});
+        if (!_ready) _then = then_t([](auto&&) {}, [_p = this->shared_from_this()] () noexcept {});
     }
 
     void set_exception(std::exception_ptr error) {
@@ -438,7 +438,7 @@ struct shared_base<T, enable_if_not_copyable<T>> : std::enable_shared_from_this<
 
 template <>
 struct shared_base<void> : std::enable_shared_from_this<shared_base<void>> {
-    using then_t = std::vector<std::pair<executor_t, task<void()>>>;
+    using then_t = std::vector<std::pair<executor_t, task<void() noexcept>>>;
     using result_type = void;
 
     executor_t _executor;
@@ -461,7 +461,7 @@ struct shared_base<void> : std::enable_shared_from_this<shared_base<void>> {
 
     void _detach() {
         std::unique_lock<std::mutex> lock(_mutex);
-        if (!_ready) _then.emplace_back([](auto&&) {}, [_p = this->shared_from_this()] {});
+        if (!_ready) _then.emplace_back([](auto&&) {}, [_p = this->shared_from_this()]() noexcept {});
     }
 
     void set_exception(std::exception_ptr error) {
@@ -518,7 +518,7 @@ struct shared<R(Args...)> : shared_base<R>, shared_task<Args...> {
 
     void add_promise() override { ++_promise_count; }
 
-    void operator()(Args... args) override {
+    void operator()(Args... args) noexcept override {
         if (!_f) return;
 
         try {
@@ -582,7 +582,7 @@ class packaged_task {
     packaged_task& operator=(packaged_task&& x) noexcept = default;
 
     template <typename... A>
-    void operator()(A&&... args) const {
+    void operator()(A&&... args) const noexcept {
         auto p = _p.lock();
         if (p) (*p)(std::forward<A>(args)...);
     }
diff --git a/stlab/concurrency/immediate_executor.hpp b/stlab/concurrency/immediate_executor.hpp
index 96f15edc..8f855bb1 100644
--- a/stlab/concurrency/immediate_executor.hpp
+++ b/stlab/concurrency/immediate_executor.hpp
@@ -10,6 +10,7 @@
 #define STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 
 #include <chrono>
+#include <type_traits>
 #include <utility>
 
 /**************************************************************************************************/
@@ -27,12 +28,7 @@ namespace detail {
 
 struct immediate_executor_type {
     template <typename F>
-    void operator()(F&& f) const {
-        std::forward<F>(f)();
-    }
-
-    template <typename F>
-    void operator()(std::chrono::steady_clock::time_point, F&& f) const {
+    auto operator()(F&& f) const -> std::enable_if_t<noexcept(f())> {
         std::forward<F>(f)();
     }
 };
diff --git a/stlab/concurrency/main_executor.hpp b/stlab/concurrency/main_executor.hpp
index 54d9ea9c..b4067699 100644
--- a/stlab/concurrency/main_executor.hpp
+++ b/stlab/concurrency/main_executor.hpp
@@ -9,20 +9,23 @@
 #ifndef STLAB_CONCURRENCY_MAIN_EXECUTOR_HPP
 #define STLAB_CONCURRENCY_MAIN_EXECUTOR_HPP
 
+#include <type_traits>
 #include <utility>
 
 #include <stlab/config.hpp>
 
 #if STLAB_MAIN_EXECUTOR(QT5) || STLAB_MAIN_EXECUTOR(QT6)
 #include <QtGlobal>
-#if (STLAB_MAIN_EXECUTOR(QT5) && (QT_VERSION < QT_VERSION_CHECK(5,0,0) || QT_VERSION >= QT_VERSION_CHECK(6,0,0)) || \
-     STLAB_MAIN_EXECUTOR(QT6) && (QT_VERSION < QT_VERSION_CHECK(6,0,0) || QT_VERSION >= QT_VERSION_CHECK(7,0,0)))
+#if (STLAB_MAIN_EXECUTOR(QT5) &&                                                                \
+         (QT_VERSION < QT_VERSION_CHECK(5, 0, 0) || QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)) || \
+     STLAB_MAIN_EXECUTOR(QT6) &&                                                                \
+         (QT_VERSION < QT_VERSION_CHECK(6, 0, 0) || QT_VERSION >= QT_VERSION_CHECK(7, 0, 0)))
 #error "Mismatching Qt versions"
 #endif
 #include <QCoreApplication>
 #include <QEvent>
-#include <stlab/concurrency/task.hpp>
 #include <memory>
+#include <stlab/concurrency/task.hpp>
 #elif STLAB_MAIN_EXECUTOR(LIBDISPATCH)
 #include <dispatch/dispatch.h>
 #elif STLAB_MAIN_EXECUTOR(EMSCRIPTEN)
@@ -82,7 +85,7 @@ class main_executor_type {
 
 public:
     template <typename F>
-    void operator()(F f) const {
+    auto operator()(F f) const -> std::enable_if_t<noexcept(f())> {
         auto event = std::make_unique<executor_event>();
         event->set_task(std::move(f));
         auto receiver = event->receiver();
@@ -98,7 +101,7 @@ struct main_executor_type {
     using result_type = void;
 
     template <typename F>
-    void operator()(F f) const {
+    auto operator()(F f) const -> std::enable_if_t<noexcept(f())> {
         using f_t = decltype(f);
 
         dispatch_async_f(dispatch_get_main_queue(), new f_t(std::move(f)), [](void* f_) {
@@ -115,33 +118,32 @@ struct main_executor_type {
     using result_type = void;
 
     template <class F>
-    void operator()(F&& f) const {
+    auto operator()(F&& f) const -> std::enable_if_t<noexcept(f())> {
         using function_type = typename std::remove_reference<F>::type;
         auto p = new function_type(std::forward<F>(f));
 
-         /*
-           `emscripten_async_run_in_main_runtime_thread()` schedules a function to run on the main
-            JS thread, however, the code can be executed at any POSIX thread cancelation point if
-            wasm code is executing on the JS main thread.
-            Executing the code from a POSIX thread cancelation point can cause problems, including
-            deadlocks and data corruption. Consider:
-            ```
-                mutex.lock();   // <-- If reentered, would deadlock here
-                new T;          // <-- POSIX cancelation point, could reenter
-            ```
-            The call to `emscripten_async_call()` bounces the call to execute as part of the main
-            run-loop on the current (main) thread. This avoids nasty reentrancy issues if executed
-            from a POSIX thread cancelation point.
-        */
+        /*
+          `emscripten_async_run_in_main_runtime_thread()` schedules a function to run on the main
+           JS thread, however, the code can be executed at any POSIX thread cancelation point if
+           wasm code is executing on the JS main thread.
+           Executing the code from a POSIX thread cancelation point can cause problems, including
+           deadlocks and data corruption. Consider:
+           ```
+               mutex.lock();   // <-- If reentered, would deadlock here
+               new T;          // <-- POSIX cancelation point, could reenter
+           ```
+           The call to `emscripten_async_call()` bounces the call to execute as part of the main
+           run-loop on the current (main) thread. This avoids nasty reentrancy issues if executed
+           from a POSIX thread cancelation point.
+       */
 
         emscripten_async_run_in_main_runtime_thread(
-            EM_FUNC_SIG_VI,
-            static_cast<void(*)(void*)>([](void* f_) {
+            EM_FUNC_SIG_VI, static_cast<void (*)(void*)>([](void* f_) {
                 emscripten_async_call(
                     [](void* f_) {
                         auto f = static_cast<function_type*>(f_);
                         // Note the absence of exception handling.
-                        // Operations queued to the task system cannot throw as a precondition. 
+                        // Operations queued to the task system cannot throw as a precondition.
                         // We use packaged tasks to marshal exceptions.
                         (*f)();
                         delete f;
@@ -159,7 +161,7 @@ struct main_executor_type {
     using result_type = void;
 
     template <typename F>
-    void operator()(F f) const { }
+    void operator()(F f) const {}
 };
 
 #endif
diff --git a/stlab/concurrency/serial_queue.hpp b/stlab/concurrency/serial_queue.hpp
index a8878bd5..2ca57a66 100644
--- a/stlab/concurrency/serial_queue.hpp
+++ b/stlab/concurrency/serial_queue.hpp
@@ -14,6 +14,7 @@
 #include <deque>
 #include <mutex>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
 #include <stlab/scope.hpp>
@@ -41,8 +42,8 @@ namespace detail {
 /**************************************************************************************************/
 
 class serial_instance_t : public std::enable_shared_from_this<serial_instance_t> {
-    using executor_t = std::function<void(task<void()>&&)>;
-    using queue_t = std::deque<task<void()>>;
+    using executor_t = std::function<void(task<void() noexcept>&&)>;
+    using queue_t = std::deque<task<void() noexcept>>;
     using lock_t = std::lock_guard<std::mutex>;
 
     std::mutex _m;
@@ -80,7 +81,7 @@ class serial_instance_t : public std::enable_shared_from_this<serial_instance_t>
             pop_front_unsafe(local_queue)();
         }
 
-        if (!empty()) _executor([_this(shared_from_this())]() { _this->all(); });
+        if (!empty()) _executor([_this(shared_from_this())]() noexcept { _this->all(); });
     }
 
     void single() {
@@ -90,7 +91,7 @@ class serial_instance_t : public std::enable_shared_from_this<serial_instance_t>
 
         f();
 
-        if (!empty()) _executor([_this(shared_from_this())]() { _this->single(); });
+        if (!empty()) _executor([_this(shared_from_this())]() noexcept { _this->single(); });
     }
 
     // The kickstart allows us to grab a pointer to either the single or all
@@ -125,7 +126,7 @@ class serial_instance_t : public std::enable_shared_from_this<serial_instance_t>
         });
 
         if (!running) {
-            _executor([_this(shared_from_this())]() { _this->kickstart(); });
+            _executor([_this(shared_from_this())]() noexcept { _this->kickstart(); });
         }
     }
 
@@ -149,7 +150,9 @@ class serial_queue_t {
             [_e = std::move(e)](auto&& f) { _e(std::forward<decltype(f)>(f)); }, mode)) {}
 
     auto executor() const {
-        return [_impl = _impl](auto&& f) { _impl->enqueue(std::forward<decltype(f)>(f)); };
+        return [_impl = _impl](auto&& f) -> std::enable_if_t<noexcept(f())> {
+            _impl->enqueue(std::forward<decltype(f)>(f));
+        };
     }
 
     template <typename F, typename... Args>
diff --git a/stlab/concurrency/system_timer.hpp b/stlab/concurrency/system_timer.hpp
index 6ac84f37..7ee9ac0b 100755
--- a/stlab/concurrency/system_timer.hpp
+++ b/stlab/concurrency/system_timer.hpp
@@ -11,11 +11,11 @@
 
 /**************************************************************************************************/
 
-#include <stlab/concurrency/task.hpp>
 #include <stlab/config.hpp>
 
 #include <chrono>
 #include <functional>
+#include <type_traits>
 
 #if STLAB_TASK_SYSTEM(LIBDISPATCH)
 #include <dispatch/dispatch.h>
@@ -23,18 +23,13 @@
 #include <Windows.h>
 #include <memory>
 #elif STLAB_TASK_SYSTEM(PORTABLE)
-
 #include <algorithm>
 #include <condition_variable>
 #include <thread>
 #include <vector>
+#endif
 
 #include <stlab/concurrency/task.hpp>
-// REVISIT (sparent) : for testing only
-#if 0 && __APPLE__
-#include <dispatch/dispatch.h>
-#endif
-#endif
 
 /**************************************************************************************************/
 
@@ -55,28 +50,27 @@ namespace detail {
 struct system_timer_type {
     using result_type = void;
 
-
     template <typename F>
-    [[deprecated("Use chrono::duration as parameter instead")]]
-    void operator()(std::chrono::steady_clock::time_point when, F f) const {
+    [[deprecated("Use chrono::duration as parameter instead")]] void operator()(
+        std::chrono::steady_clock::time_point when, F f) const {
         using namespace std::chrono;
         operator()(when - steady_clock::now(), std::move(f));
     }
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
-    void operator()(std::chrono::duration<Rep, Per> duration, F f) const {
+    auto operator()(std::chrono::duration<Rep, Per> duration, F f) const
+        -> std::enable_if_t<noexcept(f())> {
         using namespace std::chrono;
 
         using f_t = decltype(f);
 
-        dispatch_after_f(
-            dispatch_time(0, duration_cast<nanoseconds>(duration).count()),
-            dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), new f_t(std::move(f)),
-            [](void* f_) {
-                auto f = static_cast<f_t*>(f_);
-                (*f)();
-                delete f;
-            });
+        dispatch_after_f(dispatch_time(0, duration_cast<nanoseconds>(duration).count()),
+                         dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
+                         new f_t(std::move(f)), [](void* f_) {
+                             auto f = static_cast<f_t*>(f_);
+                             (*f)();
+                             delete f;
+                         });
     }
 };
 
@@ -108,16 +102,16 @@ class system_timer {
         CloseThreadpool(_pool);
     }
 
-
     template <typename F>
-    [[deprecated("Use chrono::duration as parameter instead")]]
-    void operator()(std::chrono::steady_clock::time_point when, F&& f) {
+    [[deprecated("Use chrono::duration as parameter instead")]] void operator()(
+        std::chrono::steady_clock::time_point when, F&& f) {
         using namespace std::chrono;
         operator()(when - steady_clock::now(), std::forward<F>(f));
     }
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
-    void operator()(std::chrono::duration<Rep, Per> duration, F&& f) {
+    auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
+        -> std::enable_if_f<noexcept(f())> {
         using namespace std::chrono;
         auto timer = CreateThreadpoolTimer(&timer_callback_impl<F>, new F(std::forward<F>(f)),
                                            &_callBackEnvironment);
@@ -140,7 +134,7 @@ class system_timer {
         (*f)();
     }
 
-    template <typename Rep, typename Per = std::ratio<1 >>
+    template <typename Rep, typename Per = std::ratio<1>>
     FILETIME duration_to_FILETIME(std::chrono::duration<Rep, Per> duration) const {
         using namespace std::chrono;
         FILETIME ft = {0, 0};
@@ -170,7 +164,7 @@ class system_timer {
 #elif STLAB_TASK_SYSTEM(PORTABLE)
 
 class system_timer {
-    using element_t = std::pair<std::chrono::steady_clock::time_point, task<void()>>;
+    using element_t = std::pair<std::chrono::steady_clock::time_point, task<void() noexcept>>;
     using queue_t = std::vector<element_t>;
     using lock_t = std::unique_lock<std::mutex>;
 
@@ -191,7 +185,7 @@ class system_timer {
 
     void timed_queue_run() {
         while (true) {
-            task<void()> task;
+            task<void() noexcept> task;
             {
                 lock_t lock(_timed_queue_mutex);
 
@@ -227,14 +221,15 @@ class system_timer {
     }
 
     template <typename F>
-    [[deprecated("Use chrono::duration as parameter instead")]]
-    void operator()(std::chrono::steady_clock::time_point when, F&& f) {
+    [[deprecated("Use chrono::duration as parameter instead")]] void operator()(
+        std::chrono::steady_clock::time_point when, F&& f) {
         using namespace std::chrono;
         operator()(when - steady_clock::now(), std::move(f));
     }
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
-    void operator()(std::chrono::duration<Rep, Per> duration, F&& f) {
+    void operator()(std::chrono::duration<Rep, Per> duration, F&& f)
+        ->std::enable_if_f<noexcept(f())> {
         lock_t lock(_timed_queue_mutex);
         _timed_queue.emplace_back(std::chrono::steady_clock::now() + duration, std::forward<F>(f));
         std::push_heap(std::begin(_timed_queue), std::end(_timed_queue), greater_first());
@@ -250,19 +245,19 @@ class system_timer {
 
 struct system_timer_type {
     using result_type = void;
-    
+
     static system_timer& get_system_timer() {
         static system_timer only_system_timer;
         return only_system_timer;
     }
 
-    [[deprecated("Use chrono::duration as parameter instead")]]
-    void operator()(std::chrono::steady_clock::time_point when, task<void()> f) const {
+    [[deprecated("Use chrono::duration as parameter instead")]] void operator()(
+        std::chrono::steady_clock::time_point when, task<void() noexcept>&& f) const {
         operator()(when - std::chrono::steady_clock().now(), std::move(f));
     }
 
     template <typename Rep, typename Per = std::ratio<1>>
-    void operator()(std::chrono::duration<Rep, Per> duration, task<void()> f) const {
+    void operator()(std::chrono::duration<Rep, Per> duration, task<void() noexcept>&& f) const {
         get_system_timer()(duration, std::move(f));
     }
 };
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 074f6b8d..cf515af6 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -37,8 +37,8 @@ inline namespace v1 {
 template <class>
 class task;
 
-template <class R, class... Args>
-class task<R(Args...)> {
+template <class R, class... Args, bool NoExcept>
+class task<R(Args...) noexcept(NoExcept)> {
     template <class F>
     constexpr static bool maybe_empty =
         std::is_pointer<std::decay_t<F>>::value || std::is_member_pointer<std::decay_t<F>>::value ||
@@ -55,14 +55,14 @@ class task<R(Args...)> {
     }
 
     struct concept_t {
-        void (*dtor)(void*);
+        void (*dtor)(void*) noexcept;
         void (*move_ctor)(void*, void*) noexcept;
         const std::type_info& (*target_type)() noexcept;
         void* (*pointer)(void*) noexcept;
         const void* (*const_pointer)(const void*) noexcept;
     };
 
-    using invoke_t = R (*)(void*, Args...);
+    using invoke_t = R (*)(void*, Args...) noexcept(NoExcept);
 
     template <class F, bool Small>
     struct model;
@@ -73,7 +73,7 @@ class task<R(Args...)> {
         model(G&& f) : _f(std::forward<G>(f)) {}
         model(model&&) noexcept = delete;
 
-        static void dtor(void* self) { static_cast<model*>(self)->~model(); }
+        static void dtor(void* self) noexcept { static_cast<model*>(self)->~model(); }
         static void move_ctor(void* self, void* p) noexcept {
             new (p) model(std::move(static_cast<model*>(self)->_f));
         }
@@ -85,7 +85,7 @@ class task<R(Args...)> {
             signature to the actual captured model.
         */
 
-        static auto invoke(void* self, Args... args) -> R {
+        static auto invoke(void* self, Args... args) noexcept(NoExcept) -> R {
             return (static_cast<model*>(self)->_f)(std::forward<Args>(args)...);
         }
 
@@ -110,7 +110,7 @@ class task<R(Args...)> {
         model(G&& f) : _p(std::make_unique<F>(std::forward<G>(f))) {}
         model(model&&) noexcept = default;
 
-        static void dtor(void* self) { static_cast<model*>(self)->~model(); }
+        static void dtor(void* self) noexcept { static_cast<model*>(self)->~model(); }
         static void move_ctor(void* self, void* p) noexcept {
             new (p) model(std::move(*static_cast<model*>(self)));
         }
@@ -122,11 +122,10 @@ class task<R(Args...)> {
             signature to the actual captured model.
         */
 
-        static auto invoke(void* self, Args... args) -> R {
+        static auto invoke(void* self, Args... args) noexcept(NoExcept) -> R {
             return (*static_cast<model*>(self)->_p)(std::forward<Args>(args)...);
         }
 
-
         static auto target_type() noexcept -> const std::type_info& { return typeid(F); }
         static auto pointer(void* self) noexcept -> void* {
             return static_cast<model*>(self)->_p.get();
@@ -147,9 +146,12 @@ class task<R(Args...)> {
     };
 
     // empty (default) vtable
-    static void dtor(void*) {}
+    static void dtor(void*) noexcept {}
     static void move_ctor(void*, void*) noexcept {}
-    static auto invoke(void*, Args...) -> R { throw std::bad_function_call(); }
+    static auto invoke(void*, Args...) noexcept(NoExcept) -> R {
+        if constexpr (NoExcept) std::terminate();
+        throw std::bad_function_call();
+    }
     static auto target_type_() noexcept -> const std::type_info& { return typeid(void); }
     static auto pointer(void*) noexcept -> void* { return nullptr; }
     static auto const_pointer(const void*) noexcept -> const void* { return nullptr; }
@@ -194,7 +196,9 @@ class task<R(Args...)> {
         _vtable_ptr->move_ctor(&x._model, &_model);
     }
 
-    template <class F, std::enable_if_t<!std::is_same<std::decay_t<F>, task>::value, bool> = true>
+    template <class F,
+              std::enable_if_t<!NoExcept || noexcept(std::declval<F>()(std::declval<Args>()...)),
+                               bool> = true>
     task(F&& f) {
         using small_t = model<std::decay_t<F>, true>;
         using large_t = model<std::decay_t<F>, false>;
@@ -224,7 +228,8 @@ class task<R(Args...)> {
     task& operator=(std::nullptr_t) noexcept { return *this = task(); }
 
     template <class F>
-    task& operator=(F&& f) {
+    auto operator=(F&& f)
+        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task&> {
         return *this = task(std::forward<F>(f));
     }
 
@@ -248,7 +253,9 @@ class task<R(Args...)> {
     }
 
     template <class... Brgs>
-    auto operator()(Brgs&&... brgs) { return _invoke(&_model, std::forward<Brgs>(brgs)...); }
+    auto operator()(Brgs&&... brgs) noexcept(NoExcept) {
+        return _invoke(&_model, std::forward<Brgs>(brgs)...);
+    }
 
     friend inline void swap(task& x, task& y) { return x.swap(y); }
     friend inline bool operator==(const task& x, std::nullptr_t) { return !static_cast<bool>(x); }
@@ -262,26 +269,31 @@ class task<R(Args...)> {
 // In C++17 constexpr implies inline and these definitions are deprecated
 
 #if defined(__GNUC__) && __GNUC__ < 7 && !defined(__clang__)
-template <class R, class... Args>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::_vtable = {
-    dtor, move_ctor, target_type_, pointer, const_pointer};
-
-template <class R, class... Args>
-const typename task<R(Args...)>::invoke_t task<R(Args...)>::_invoke = _invoke;
+template <class R, class... Args, bool NoExcept>
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::_vtable = {dtor, move_ctor, target_type_, pointer,
+                                                    const_pointer};
+
+template <class R, class... Args, bool NoExcept>
+const typename task<R(Args...) noexcept(NoExcept)>::invoke_t
+    task<R(Args...) noexcept(NoExcept)>::_invoke = _invoke;
 #else
-template <class R, class... Args>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::_vtable;
+template <class R, class... Args, bool NoExcept>
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::_vtable;
 #endif
 
 #ifdef _MSC_VER
 
-template <class R, class... Args>
+template <class R, class... Args, bool NoExcept>
 template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, false>::_vtable;
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::model<F, false>::_vtable;
 
-template <class R, class... Args>
+template <class R, class... Args, bool NoExcept>
 template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, true>::_vtable;
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::model<F, true>::_vtable;
 
 #else
 
diff --git a/test/channel_test_helper.cpp b/test/channel_test_helper.cpp
index 166cce27..3d538c02 100644
--- a/test/channel_test_helper.cpp
+++ b/test/channel_test_helper.cpp
@@ -8,7 +8,7 @@
 
 #include "channel_test_helper.hpp"
 
-std::queue<stlab::task<void()>> channel_test_helper::manual_scheduler::_tasks;
+std::queue<stlab::task<void() noexcept>> channel_test_helper::manual_scheduler::_tasks;
 std::mutex channel_test_helper::manual_scheduler::_mutex;
 
 int channel_test_helper::timed_sum::_x{0};
diff --git a/test/channel_test_helper.hpp b/test/channel_test_helper.hpp
index 29c8d145..f90128e8 100644
--- a/test/channel_test_helper.hpp
+++ b/test/channel_test_helper.hpp
@@ -25,7 +25,7 @@ namespace channel_test_helper {
 
 class manual_scheduler {
     static std::mutex _mutex;
-    static std::queue<stlab::task<void()>> _tasks;
+    static std::queue<stlab::task<void() noexcept>> _tasks;
 
 public:
     static void clear() {
diff --git a/test/executor_test.cpp b/test/executor_test.cpp
index 46bd559b..8e0bc888 100644
--- a/test/executor_test.cpp
+++ b/test/executor_test.cpp
@@ -74,12 +74,12 @@ BOOST_AUTO_TEST_CASE(all_low_prio_tasks_are_executed) {
     atomic_bool done{false};
 
     for (auto i = 0; i < 10; ++i) {
-        queue.executor()([_i = i, &m, &results] {
+        queue.executor()([_i = i, &m, &results]() noexcept {
             unique_lock<mutex> block{m};
             results.push_back(_i);
         });
     }
-    queue.executor()([&done] { done = true; });
+    queue.executor()([&done] () noexcept { done = true; });
 
     while (!done) {
         rest();
@@ -99,12 +99,12 @@ BOOST_AUTO_TEST_CASE(all_default_prio_tasks_get_executed) {
     atomic_bool done{false};
 
     for (auto i = 0; i < 10; ++i) {
-        queue.executor()([_i = i, &m, &results] {
+        queue.executor()([_i = i, &m, &results] () noexcept {
             unique_lock<mutex> block{m};
             results.push_back(_i);
         });
     }
-    queue.executor()([&done] { done = true; });
+    queue.executor()([&done] () noexcept { done = true; });
 
     while (!done) {
         rest();
@@ -124,12 +124,12 @@ BOOST_AUTO_TEST_CASE(all_high_prio_tasks_get_executed) {
     atomic_bool done{false};
 
     for (auto i = 0; i < 10; ++i) {
-        queue.executor()([_i = i, &m, &results] {
+        queue.executor()([_i = i, &m, &results] () noexcept {
             unique_lock<mutex> block{m};
             results.push_back(_i);
         });
     }
-    queue.executor()([&done] { done = true; });
+    queue.executor()([&done] () noexcept { done = true; });
 
     while (!done) {
         rest();
@@ -147,7 +147,7 @@ BOOST_AUTO_TEST_CASE(task_system_restarts_after_it_went_pending) {
     mutex m;
     condition_variable cv;
 
-    default_executor([&] {
+    default_executor([&] () noexcept {
         rest();
         {
             unique_lock<mutex> block{m};
@@ -163,7 +163,7 @@ BOOST_AUTO_TEST_CASE(task_system_restarts_after_it_went_pending) {
         }
     }
 
-    default_executor([&] {
+    default_executor([&] () noexcept {
         rest();
         {
             unique_lock<mutex> block{m};
@@ -226,7 +226,7 @@ struct check_task {
         return 0;
     }
 
-    void operator()() {
+    void operator()() noexcept {
         --_currentPrioCount;
 
         ++taskRunning;
@@ -298,17 +298,17 @@ BOOST_AUTO_TEST_CASE(MeasureTiming) {
     auto start = chrono::high_resolution_clock::now();
 
     for (auto i = 0; i < iterations; ++i) {
-        low_executor([_i = i, &results, &counter] {
+        low_executor([_i = i, &results, &counter] () noexcept  {
             results[_i] = 1;
             fibonacci<mpre::cpp_int>(fiboN);
             ++counter;
         });
-        default_executor([_i = i + iterations, &results, &counter] {
+        default_executor([_i = i + iterations, &results, &counter] () noexcept {
             results[_i] = 2;
             fibonacci<mpre::cpp_int>(fiboN);
             ++counter;
         });
-        high_executor([_i = i + iterations * 2, &results, &counter] {
+        high_executor([_i = i + iterations * 2, &results, &counter] () noexcept  {
             results[_i] = 3;
             fibonacci<mpre::cpp_int>(fiboN);
             ++counter;
@@ -316,7 +316,7 @@ BOOST_AUTO_TEST_CASE(MeasureTiming) {
     }
 
     mutex block;
-    low_executor([&] {
+    low_executor([&] () noexcept  {
         {
             unique_lock<mutex> lock{block};
             done = true;
diff --git a/test/future_test_helper.hpp b/test/future_test_helper.hpp
index 65628761..2a2b1179 100644
--- a/test/future_test_helper.hpp
+++ b/test/future_test_helper.hpp
@@ -28,7 +28,7 @@ template <std::size_t no>
 struct custom_scheduler {
     using result_type = void;
 
-    void operator()(stlab::task<void()> f) const {
+    void operator()(stlab::task<void() noexcept> f) const {
         ++counter();
         // The implementation on Windows or the mac uses a scheduler that allows many tasks in the
         // pool in parallel
@@ -43,9 +43,7 @@ struct custom_scheduler {
 
     static int usage_counter() { return counter().load(); }
 
-    static void reset() {
-        counter() = 0;
-    }
+    static void reset() { counter() = 0; }
 
     static std::atomic_int& counter() {
         static std::atomic_int counter;
@@ -56,16 +54,13 @@ struct custom_scheduler {
     size_t _id = no; // only used for debugging purpose
 };
 
-
-
 template <std::size_t I>
 stlab::executor_t make_executor() {
-    return [_executor = custom_scheduler<I>{}](stlab::task<void()> f) mutable {
+    return [_executor = custom_scheduler<I>{}](stlab::task<void() noexcept> f) mutable {
         _executor(std::move(f));
     };
 }
 
-
 class test_exception : public std::exception {
     std::string _error;
 
@@ -196,8 +191,8 @@ class test_functor_base : public P {
     std::atomic_int& _task_counter;
 
 public:
-    test_functor_base(F f, std::atomic_int& task_counter)
-        : _f(std::move(f)), _task_counter(task_counter) {}
+    test_functor_base(F f, std::atomic_int& task_counter) :
+        _f(std::move(f)), _task_counter(task_counter) {}
 
     ~test_functor_base() {}
 
diff --git a/test/future_when_any_arguments_tests.cpp b/test/future_when_any_arguments_tests.cpp
index a3057d6e..92a0aeb2 100644
--- a/test/future_when_any_arguments_tests.cpp
+++ b/test/future_when_any_arguments_tests.cpp
@@ -448,4 +448,4 @@ BOOST_AUTO_TEST_CASE(future_when_any_move_only_argument_with_one_argument) {
   BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
 }
 
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/serial_queue_test.cpp b/test/serial_queue_test.cpp
index 7ed34285..eec469cf 100644
--- a/test/serial_queue_test.cpp
+++ b/test/serial_queue_test.cpp
@@ -35,31 +35,31 @@ void test0(stlab::schedule_mode mode) {
         output.emplace_back(std::move(str));
     });
 
-    aq([&]() { strout("a1                      ( 1)"); });
+    aq([&]() noexcept { strout("a1                      ( 1)"); });
 
-    bq([&]() { strout("   b1                   ( 2)"); });
+    bq([&]() noexcept { strout("   b1                   ( 2)"); });
 
-    dq([&]() { strout("           d1           ( 3)"); });
+    dq([&]() noexcept { strout("           d1           ( 3)"); });
 
     b([&]() { strout("   b2                   ( 4)"); })
         .then(stlab::immediate_executor, [&]() { strout("   b2.1                 ( 4.1)"); })
         .detach();
 
-    cq([&]() { strout("        c1              ( 5)"); });
+    cq([&]() noexcept { strout("        c1              ( 5)"); });
 
-    cq([&]() { strout("        c2              ( 6)"); });
+    cq([&]() noexcept { strout("        c2              ( 6)"); });
 
-    dq([&]() { strout("           d2           ( 7)"); });
+    dq([&]() noexcept { strout("           d2           ( 7)"); });
 
-    cq([&]() { strout("        c3              ( 8)"); });
+    cq([&]() noexcept { strout("        c3              ( 8)"); });
 
-    bq([&]() { strout("   b3                   ( 9)"); });
+    bq([&]() noexcept { strout("   b3                   ( 9)"); });
 
-    aq([&]() { strout("a2                      (10)"); });
+    aq([&]() noexcept { strout("a2                      (10)"); });
 
-    aq([&]() { strout("a3                      (11)"); });
+    aq([&]() noexcept { strout("a3                      (11)"); });
 
-    dq([&]() { strout("           d3           (12)"); });
+    dq([&]() noexcept { strout("           d3           (12)"); });
 
     while (true) {
         {
@@ -132,7 +132,7 @@ struct serial_hash {
         : _q{stlab::default_executor, mode}, _h(std::move(s), e) {}
 
     void operator()(std::string s, std::uint64_t e) {
-        _q.executor()([this, _e = e, _s = std::move(s)]() {
+        _q.executor()([this, _e = e, _s = std::move(s)]() noexcept {
             _h(_s, _e);
             ++_c;
         });

From c4adc111293ff309201c8fe1082769304e85aa42 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 13:12:05 -0700
Subject: [PATCH 03/17] Fixing typeos for CI.

---
 stlab/concurrency/system_timer.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stlab/concurrency/system_timer.hpp b/stlab/concurrency/system_timer.hpp
index 7ee9ac0b..0c4746e4 100755
--- a/stlab/concurrency/system_timer.hpp
+++ b/stlab/concurrency/system_timer.hpp
@@ -111,7 +111,7 @@ class system_timer {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
-        -> std::enable_if_f<noexcept(f())> {
+        -> std::enable_if_t<noexcept(f())> {
         using namespace std::chrono;
         auto timer = CreateThreadpoolTimer(&timer_callback_impl<F>, new F(std::forward<F>(f)),
                                            &_callBackEnvironment);
@@ -229,7 +229,7 @@ class system_timer {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     void operator()(std::chrono::duration<Rep, Per> duration, F&& f)
-        ->std::enable_if_f<noexcept(f())> {
+        ->std::enable_if_t<noexcept(f())> {
         lock_t lock(_timed_queue_mutex);
         _timed_queue.emplace_back(std::chrono::steady_clock::now() + duration, std::forward<F>(f));
         std::push_heap(std::begin(_timed_queue), std::end(_timed_queue), greater_first());

From 1f0c8bcba3d5147c5ab45040e7a4e25bafca84b3 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 13:34:56 -0700
Subject: [PATCH 04/17] Fixing typos and mistakes for CI.

---
 stlab/concurrency/system_timer.hpp | 2 +-
 stlab/concurrency/task.hpp         | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/stlab/concurrency/system_timer.hpp b/stlab/concurrency/system_timer.hpp
index 0c4746e4..1a462100 100755
--- a/stlab/concurrency/system_timer.hpp
+++ b/stlab/concurrency/system_timer.hpp
@@ -228,7 +228,7 @@ class system_timer {
     }
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
-    void operator()(std::chrono::duration<Rep, Per> duration, F&& f)
+    auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
         ->std::enable_if_t<noexcept(f())> {
         lock_t lock(_timed_queue_mutex);
         _timed_queue.emplace_back(std::chrono::steady_clock::now() + duration, std::forward<F>(f));
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index cf515af6..811587f2 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -149,8 +149,11 @@ class task<R(Args...) noexcept(NoExcept)> {
     static void dtor(void*) noexcept {}
     static void move_ctor(void*, void*) noexcept {}
     static auto invoke(void*, Args...) noexcept(NoExcept) -> R {
-        if constexpr (NoExcept) std::terminate();
-        throw std::bad_function_call();
+        if constexpr (NoExcept) {
+            std::terminate();
+        } else {
+            throw std::bad_function_call();
+        }
     }
     static auto target_type_() noexcept -> const std::type_info& { return typeid(void); }
     static auto pointer(void*) noexcept -> void* { return nullptr; }

From f3f339d33173bbea18e762afabb2e2c4e0bf1ee6 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 13:47:47 -0700
Subject: [PATCH 05/17] Updating GCC and fixing future for CI.

---
 .github/matrix.json          | 4 ++--
 stlab/concurrency/future.hpp | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/matrix.json b/.github/matrix.json
index c32dc4d7..da5f6769 100644
--- a/.github/matrix.json
+++ b/.github/matrix.json
@@ -1,9 +1,9 @@
 {
     "config": [
         {
-            "name": "Linux GCC 11",
+            "name": "Linux GCC 12",
             "compiler": "gcc",
-            "version": "11",
+            "version": "12",
             "os": "ubuntu-22.04"
         },
         {
diff --git a/stlab/concurrency/future.hpp b/stlab/concurrency/future.hpp
index 75982f55..ff814cd0 100755
--- a/stlab/concurrency/future.hpp
+++ b/stlab/concurrency/future.hpp
@@ -372,7 +372,7 @@ struct shared_base<T, enable_if_not_copyable<T>> : std::enable_shared_from_this<
 
     explicit shared_base(executor_t s) : _executor(std::move(s)) {}
 
-    void reset() { _then.second = task<void()>{}; }
+    void reset() { _then.second = task<void() noexcept>{}; }
 
     template <typename F>
     auto recover(future<T>&& p, F&& f) {

From 25bec08d4423839cccb41efbd136b79998ccb8c0 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 15:57:16 -0700
Subject: [PATCH 06/17] Removing noexcept() from function signatures for GCC
 prior to 13.2

---
 stlab/concurrency/default_executor.hpp   |  9 ++++--
 stlab/concurrency/immediate_executor.hpp |  6 ++--
 stlab/concurrency/main_executor.hpp      |  8 +++--
 stlab/concurrency/serial_queue.hpp       |  3 +-
 stlab/concurrency/system_timer.hpp       |  8 +++--
 stlab/concurrency/task.hpp               |  7 ++--
 stlab/type_traits.hpp                    | 41 ++++++++++++++++++++++++
 7 files changed, 67 insertions(+), 15 deletions(-)
 create mode 100644 stlab/type_traits.hpp

diff --git a/stlab/concurrency/default_executor.hpp b/stlab/concurrency/default_executor.hpp
index 831ad461..3f60c23a 100644
--- a/stlab/concurrency/default_executor.hpp
+++ b/stlab/concurrency/default_executor.hpp
@@ -9,10 +9,13 @@
 #ifndef STLAB_CONCURRENCY_DEFAULT_EXECUTOR_HPP
 #define STLAB_CONCURRENCY_DEFAULT_EXECUTOR_HPP
 
-#include <stlab/concurrency/set_current_thread_name.hpp>
-#include <stlab/concurrency/task.hpp>
 #include <stlab/config.hpp>
+
 #include <stlab/pre_exit.hpp>
+#include <stlab/type_traits.hpp>
+
+#include <stlab/concurrency/set_current_thread_name.hpp>
+#include <stlab/concurrency/task.hpp>
 
 #include <cassert>
 #include <chrono>
@@ -91,7 +94,7 @@ struct executor_type {
     using result_type = void;
 
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<noexcept(f())> {
+    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>> {
         using f_t = decltype(f);
 
         dispatch_group_async_f(detail::group()._group,
diff --git a/stlab/concurrency/immediate_executor.hpp b/stlab/concurrency/immediate_executor.hpp
index 8f855bb1..31a52bea 100644
--- a/stlab/concurrency/immediate_executor.hpp
+++ b/stlab/concurrency/immediate_executor.hpp
@@ -9,9 +9,9 @@
 #ifndef STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 #define STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 
-#include <chrono>
 #include <type_traits>
-#include <utility>
+
+#include <stlab/type_traits.hpp>
 
 /**************************************************************************************************/
 
@@ -28,7 +28,7 @@ namespace detail {
 
 struct immediate_executor_type {
     template <typename F>
-    auto operator()(F&& f) const -> std::enable_if_t<noexcept(f())> {
+    auto operator()(F&& f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         std::forward<F>(f)();
     }
 };
diff --git a/stlab/concurrency/main_executor.hpp b/stlab/concurrency/main_executor.hpp
index b4067699..d77ffd15 100644
--- a/stlab/concurrency/main_executor.hpp
+++ b/stlab/concurrency/main_executor.hpp
@@ -14,6 +14,8 @@
 
 #include <stlab/config.hpp>
 
+#include <stlab/type_traits.hpp>
+
 #if STLAB_MAIN_EXECUTOR(QT5) || STLAB_MAIN_EXECUTOR(QT6)
 #include <QtGlobal>
 #if (STLAB_MAIN_EXECUTOR(QT5) &&                                                                \
@@ -85,7 +87,7 @@ class main_executor_type {
 
 public:
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<noexcept(f())> {
+    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         auto event = std::make_unique<executor_event>();
         event->set_task(std::move(f));
         auto receiver = event->receiver();
@@ -101,7 +103,7 @@ struct main_executor_type {
     using result_type = void;
 
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<noexcept(f())> {
+    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         using f_t = decltype(f);
 
         dispatch_async_f(dispatch_get_main_queue(), new f_t(std::move(f)), [](void* f_) {
@@ -118,7 +120,7 @@ struct main_executor_type {
     using result_type = void;
 
     template <class F>
-    auto operator()(F&& f) const -> std::enable_if_t<noexcept(f())> {
+    auto operator()(F&& f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         using function_type = typename std::remove_reference<F>::type;
         auto p = new function_type(std::forward<F>(f));
 
diff --git a/stlab/concurrency/serial_queue.hpp b/stlab/concurrency/serial_queue.hpp
index 2ca57a66..1af9de82 100644
--- a/stlab/concurrency/serial_queue.hpp
+++ b/stlab/concurrency/serial_queue.hpp
@@ -18,6 +18,7 @@
 #include <utility>
 
 #include <stlab/scope.hpp>
+#include <stlab/type_traits.hpp>
 
 #ifndef STLAB_DISABLE_FUTURE_COROUTINES
 #define STLAB_DISABLE_FUTURE_COROUTINES()
@@ -150,7 +151,7 @@ class serial_queue_t {
             [_e = std::move(e)](auto&& f) { _e(std::forward<decltype(f)>(f)); }, mode)) {}
 
     auto executor() const {
-        return [_impl = _impl](auto&& f) -> std::enable_if_t<noexcept(f())> {
+        return [_impl = _impl](auto&& f) -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value)> {
             _impl->enqueue(std::forward<decltype(f)>(f));
         };
     }
diff --git a/stlab/concurrency/system_timer.hpp b/stlab/concurrency/system_timer.hpp
index 1a462100..c6efc97a 100755
--- a/stlab/concurrency/system_timer.hpp
+++ b/stlab/concurrency/system_timer.hpp
@@ -31,6 +31,8 @@
 
 #include <stlab/concurrency/task.hpp>
 
+#include <stlab/type_traits.hpp>
+
 /**************************************************************************************************/
 
 namespace stlab {
@@ -59,7 +61,7 @@ struct system_timer_type {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F f) const
-        -> std::enable_if_t<noexcept(f())> {
+        -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         using namespace std::chrono;
 
         using f_t = decltype(f);
@@ -111,7 +113,7 @@ class system_timer {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
-        -> std::enable_if_t<noexcept(f())> {
+        -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         using namespace std::chrono;
         auto timer = CreateThreadpoolTimer(&timer_callback_impl<F>, new F(std::forward<F>(f)),
                                            &_callBackEnvironment);
@@ -229,7 +231,7 @@ class system_timer {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
-        ->std::enable_if_t<noexcept(f())> {
+        -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         lock_t lock(_timed_queue_mutex);
         _timed_queue.emplace_back(std::chrono::steady_clock::now() + duration, std::forward<F>(f));
         std::push_heap(std::begin(_timed_queue), std::end(_timed_queue), greater_first());
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 811587f2..8fcf99d0 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -37,8 +37,11 @@ inline namespace v1 {
 template <class>
 class task;
 
-template <class R, class... Args, bool NoExcept>
-class task<R(Args...) noexcept(NoExcept)> {
+template <class R, class... Args>
+class task<R(Args..)> {};
+
+template <class R, class... Args>
+class task<R(Args...) noexcept> {
     template <class F>
     constexpr static bool maybe_empty =
         std::is_pointer<std::decay_t<F>>::value || std::is_member_pointer<std::decay_t<F>>::value ||
diff --git a/stlab/type_traits.hpp b/stlab/type_traits.hpp
new file mode 100644
index 00000000..5933adb8
--- /dev/null
+++ b/stlab/type_traits.hpp
@@ -0,0 +1,41 @@
+/*
+    Copyright 2015 Adobe
+    Distributed under the Boost Software License, Version 1.0.
+    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/**************************************************************************************************/
+
+#ifndef STLAB_TYPE_TRAITS_HPP
+#define STLAB_TYPE_TRAITS_HPP
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+/**
+    @brief This file contains type traits included in versions of C++ later than 14. Only the
+   minimal items used are included. They are not conditional on the C++ version to avoid ODR
+   violations.
+ */
+
+namespace stlab {
+
+inline namespace v1 {
+
+/**
+    @brief See <a href="http://en.cppreference.com/w/cpp/types/is_invocable">std::is_invocable</a>
+
+    This is necessary for GCC prior to 13.2 which does not implement mangling noexcept_expr.
+ */
+
+template <class F, class... Args>
+struct is_nothrow_invocable {
+    static constexpr bool value = noexcept(std::invoke(std::declval<F>(), std::declval<Args>()...));
+};
+
+} // namespace v1
+
+} // namespace stlab
+
+#endif // STLAB_TYPE_TRAITS_HPP

From d26abdab56c116ff625e1b51484c14b8a1030993 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 16:00:00 -0700
Subject: [PATCH 07/17] Reverting accidental save.

---
 stlab/concurrency/task.hpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 8fcf99d0..811587f2 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -37,11 +37,8 @@ inline namespace v1 {
 template <class>
 class task;
 
-template <class R, class... Args>
-class task<R(Args..)> {};
-
-template <class R, class... Args>
-class task<R(Args...) noexcept> {
+template <class R, class... Args, bool NoExcept>
+class task<R(Args...) noexcept(NoExcept)> {
     template <class F>
     constexpr static bool maybe_empty =
         std::is_pointer<std::decay_t<F>>::value || std::is_member_pointer<std::decay_t<F>>::value ||

From 3e113b2478db7169cec6ef5e15c463d4f8592af6 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 16:35:28 -0700
Subject: [PATCH 08/17] Fixing task for MSVC (can't deduce noexcept).

---
 stlab/concurrency/default_executor.hpp |   2 +-
 stlab/concurrency/serial_queue.hpp     |   3 +-
 stlab/concurrency/task.hpp             | 143 +++++++++++++++++--------
 3 files changed, 104 insertions(+), 44 deletions(-)

diff --git a/stlab/concurrency/default_executor.hpp b/stlab/concurrency/default_executor.hpp
index 3f60c23a..e85f2778 100644
--- a/stlab/concurrency/default_executor.hpp
+++ b/stlab/concurrency/default_executor.hpp
@@ -94,7 +94,7 @@ struct executor_type {
     using result_type = void;
 
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>> {
+    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
         using f_t = decltype(f);
 
         dispatch_group_async_f(detail::group()._group,
diff --git a/stlab/concurrency/serial_queue.hpp b/stlab/concurrency/serial_queue.hpp
index 1af9de82..f580737d 100644
--- a/stlab/concurrency/serial_queue.hpp
+++ b/stlab/concurrency/serial_queue.hpp
@@ -151,7 +151,8 @@ class serial_queue_t {
             [_e = std::move(e)](auto&& f) { _e(std::forward<decltype(f)>(f)); }, mode)) {}
 
     auto executor() const {
-        return [_impl = _impl](auto&& f) -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value)> {
+        return [_impl = _impl](
+                   auto&& f) -> std::enable_if_t<stlab::is_nothrow_invocable<decltype(f)>::value> {
             _impl->enqueue(std::forward<decltype(f)>(f));
         };
     }
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 811587f2..0f2a1c5f 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -30,15 +30,12 @@ inline namespace v1 {
 
 /**************************************************************************************************/
 
-/*
-    tasks are functions with a mutable call operator to support moving items through for single
-    invocations.
-*/
-template <class>
-class task;
+namespace detail {
 
-template <class R, class... Args, bool NoExcept>
-class task<R(Args...) noexcept(NoExcept)> {
+/**************************************************************************************************/
+
+template <bool NoExcept, class R, class... Args>
+class task_base {
     template <class F>
     constexpr static bool maybe_empty =
         std::is_pointer<std::decay_t<F>>::value || std::is_member_pointer<std::decay_t<F>>::value ||
@@ -192,17 +189,17 @@ class task<R(Args...) noexcept(NoExcept)> {
 public:
     using result_type = R;
 
-    constexpr task() noexcept = default;
-    constexpr task(std::nullptr_t) noexcept : task() {}
-    task(const task&) = delete;
-    task(task&& x) noexcept : _vtable_ptr(x._vtable_ptr), _invoke(x._invoke) {
+    constexpr task_base() noexcept = default;
+    constexpr task_base(std::nullptr_t) noexcept : task_base() {}
+    task_base(const task_base&) = delete;
+    task_base(task_base&& x) noexcept : _vtable_ptr(x._vtable_ptr), _invoke(x._invoke) {
         _vtable_ptr->move_ctor(&x._model, &_model);
     }
 
     template <class F,
               std::enable_if_t<!NoExcept || noexcept(std::declval<F>()(std::declval<Args>()...)),
                                bool> = true>
-    task(F&& f) {
+    task_base(F&& f) {
         using small_t = model<std::decay_t<F>, true>;
         using large_t = model<std::decay_t<F>, false>;
         using model_t = std::conditional_t<(sizeof(small_t) <= small_size) &&
@@ -216,11 +213,11 @@ class task<R(Args...) noexcept(NoExcept)> {
         _invoke = &model_t::invoke;
     }
 
-    ~task() { _vtable_ptr->dtor(&_model); };
+    ~task_base() { _vtable_ptr->dtor(&_model); };
 
-    task& operator=(const task&) = delete;
+    task_base& operator=(const task_base&) = delete;
 
-    task& operator=(task&& x) noexcept {
+    task_base& operator=(task_base&& x) noexcept {
         _vtable_ptr->dtor(&_model);
         _vtable_ptr = x._vtable_ptr;
         _invoke = x._invoke;
@@ -228,15 +225,15 @@ class task<R(Args...) noexcept(NoExcept)> {
         return *this;
     }
 
-    task& operator=(std::nullptr_t) noexcept { return *this = task(); }
+    task_base& operator=(std::nullptr_t) noexcept { return *this = task_base(); }
 
     template <class F>
     auto operator=(F&& f)
-        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task&> {
-        return *this = task(std::forward<F>(f));
+        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task_base&> {
+        return *this = task_base(std::forward<F>(f));
     }
 
-    void swap(task& x) noexcept { std::swap(*this, x); }
+    void swap(task_base& x) noexcept { std::swap(*this, x); }
 
     explicit operator bool() const { return _vtable_ptr->const_pointer(&_model) != nullptr; }
 
@@ -260,11 +257,18 @@ class task<R(Args...) noexcept(NoExcept)> {
         return _invoke(&_model, std::forward<Brgs>(brgs)...);
     }
 
-    friend inline void swap(task& x, task& y) { return x.swap(y); }
-    friend inline bool operator==(const task& x, std::nullptr_t) { return !static_cast<bool>(x); }
-    friend inline bool operator==(std::nullptr_t, const task& x) { return !static_cast<bool>(x); }
-    friend inline bool operator!=(const task& x, std::nullptr_t) { return static_cast<bool>(x); }
-    friend inline bool operator!=(std::nullptr_t, const task& x) { return static_cast<bool>(x); }
+    friend inline bool operator==(const task_base& x, std::nullptr_t) {
+        return !static_cast<bool>(x);
+    }
+    friend inline bool operator==(std::nullptr_t, const task_base& x) {
+        return !static_cast<bool>(x);
+    }
+    friend inline bool operator!=(const task_base& x, std::nullptr_t) {
+        return static_cast<bool>(x);
+    }
+    friend inline bool operator!=(std::nullptr_t, const task_base& x) {
+        return static_cast<bool>(x);
+    }
 };
 
 #if STLAB_CPP_VERSION_LESS_THAN(17)
@@ -273,30 +277,30 @@ class task<R(Args...) noexcept(NoExcept)> {
 
 #if defined(__GNUC__) && __GNUC__ < 7 && !defined(__clang__)
 template <class R, class... Args, bool NoExcept>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::_vtable = {dtor, move_ctor, target_type_, pointer,
-                                                    const_pointer};
+const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
+    task_base<R(Args...) noexcept(NoExcept)>::_vtable = {dtor, move_ctor, target_type_, pointer,
+                                                         const_pointer};
 
 template <class R, class... Args, bool NoExcept>
-const typename task<R(Args...) noexcept(NoExcept)>::invoke_t
-    task<R(Args...) noexcept(NoExcept)>::_invoke = _invoke;
+const typename task_base<R(Args...) noexcept(NoExcept)>::invoke_t
+    task_base<R(Args...) noexcept(NoExcept)>::_invoke = _invoke;
 #else
 template <class R, class... Args, bool NoExcept>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::_vtable;
+const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
+    task_base<R(Args...) noexcept(NoExcept)>::_vtable;
 #endif
 
 #ifdef _MSC_VER
 
 template <class R, class... Args, bool NoExcept>
 template <class F>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::model<F, false>::_vtable;
+const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
+    task_base<R(Args...) noexcept(NoExcept)>::model<F, false>::_vtable;
 
 template <class R, class... Args, bool NoExcept>
 template <class F>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::model<F, true>::_vtable;
+const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
+    task_base<R(Args...) noexcept(NoExcept)>::model<F, true>::_vtable;
 
 #else
 
@@ -304,23 +308,25 @@ const typename task<R(Args...) noexcept(NoExcept)>::concept_t
 
 template <class R, class... Args>
 template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::template model<F, false>::_vtable = {
-    dtor, move_ctor, target_type, pointer, const_pointer};
+const typename task_base<R(Args...)>::concept_t
+    task_base<R(Args...)>::template model<F, false>::_vtable = {dtor, move_ctor, target_type,
+                                                                pointer, const_pointer};
 
 template <class R, class... Args>
 template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::template model<F, true>::_vtable = {
-    dtor, move_ctor, target_type, pointer, const_pointer};
+const typename task_base<R(Args...)>::concept_t
+    task_base<R(Args...)>::template model<F, true>::_vtable = {dtor, move_ctor, target_type,
+                                                               pointer, const_pointer};
 
 #else
 
 template <class R, class... Args>
 template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, false>::_vtable;
+const typename task_base<R(Args...)>::concept_t task_base<R(Args...)>::model<F, false>::_vtable;
 
 template <class R, class... Args>
 template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, true>::_vtable;
+const typename task_base<R(Args...)>::concept_t task_base<R(Args...)>::model<F, true>::_vtable;
 
 #endif
 
@@ -330,6 +336,59 @@ const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, true>::_vt
 
 /**************************************************************************************************/
 
+} // namespace detail
+
+/**************************************************************************************************/
+
+template <class F>
+class task;
+
+template <class R, class... Args>
+class task<R(Args...)> : detail::task_base<false, R, Args...> {
+    using base_type = detail::task_base<false, R, Args...>;
+
+public:
+    using base_type::base_type;
+    using base_type::target_type;
+    using typename base_type::result_type;
+    using base_type::operator();
+    using base_type::operator bool;
+    using base_type::swap;
+    using base_type::target;
+
+    friend inline void swap(task& x, task& y) { return x.swap(y); }
+    friend inline bool operator==(const task& x, std::nullptr_t) {
+        return static_cast<const base_type&>(x) == nullptr;
+    }
+    friend inline bool operator==(std::nullptr_t, const task& x) { return x == nullptr; }
+    friend inline bool operator!=(const task& x, std::nullptr_t) { return !(x == nullptr); }
+    friend inline bool operator!=(std::nullptr_t, const task& x) { return !(x == nullptr); }
+};
+
+template <class R, class... Args>
+class task<R(Args...) noexcept> : detail::task_base<true, R, Args...> {
+    using base_type = detail::task_base<true, R, Args...>;
+
+public:
+    using base_type::base_type;
+    using base_type::target_type;
+    using typename base_type::result_type;
+    using base_type::operator();
+    using base_type::operator bool;
+    using base_type::swap;
+    using base_type::target;
+
+    friend inline void swap(task& x, task& y) { return x.swap(y); }
+    friend inline bool operator==(const task& x, std::nullptr_t) {
+        return static_cast<const base_type&>(x) == nullptr;
+    }
+    friend inline bool operator==(std::nullptr_t, const task& x) { return x == nullptr; }
+    friend inline bool operator!=(const task& x, std::nullptr_t) { return !(x == nullptr); }
+    friend inline bool operator!=(std::nullptr_t, const task& x) { return !(x == nullptr); }
+};
+
+/**************************************************************************************************/
+
 } // namespace v1
 
 /**************************************************************************************************/

From 949c359b82dfe3f227056d94eea4abb83de2a9ee Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Wed, 16 Aug 2023 17:07:46 -0700
Subject: [PATCH 09/17] Fixing range based for loop issue with GCC.

---
 test/forest_test.cpp | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/test/forest_test.cpp b/test/forest_test.cpp
index cb3f5a12..32487aed 100644
--- a/test/forest_test.cpp
+++ b/test/forest_test.cpp
@@ -31,7 +31,8 @@ void print(const forest<T>& f) {
             --depth;
         }
 
-        for (std::size_t i{0}; i < depth; ++i) std::cout << "    ";
+        for (std::size_t i{0}; i < depth; ++i)
+            std::cout << "    ";
 
         if (is_leading(first)) {
             std::cout << "<";
@@ -174,8 +175,7 @@ auto test_edge_traversal(Forest& f, Iterator fi, Iterator li) {
         Iterator first{fi};
         Iterator last{li};
         while (first != last) {
-            if (first.edge() == Edge)
-                expected += *first;
+            if (first.edge() == Edge) expected += *first;
             ++first;
         }
         BOOST_CHECK(expected.size() == f.size());
@@ -250,13 +250,15 @@ BOOST_AUTO_TEST_CASE(reverse_traversal) {
 
     /*preorder*/ {
         auto a = test_edge_traversal<reverse_iterator_t, forest_edge::leading>(f, rfirst, rlast);
-        auto b = test_edge_traversal<const_reverse_iterator_t, forest_edge::leading>(f, rfirst, rlast);
+        auto b =
+            test_edge_traversal<const_reverse_iterator_t, forest_edge::leading>(f, rfirst, rlast);
         BOOST_CHECK(a == b);
     }
 
     /*postorder*/ {
         auto a = test_edge_traversal<reverse_iterator_t, forest_edge::trailing>(f, rfirst, rlast);
-        auto b = test_edge_traversal<const_reverse_iterator_t, forest_edge::trailing>(f, rfirst, rlast);
+        auto b =
+            test_edge_traversal<const_reverse_iterator_t, forest_edge::trailing>(f, rfirst, rlast);
         BOOST_CHECK(a == b);
     }
 }
@@ -265,7 +267,7 @@ BOOST_AUTO_TEST_CASE(reverse_traversal) {
 
 template <typename Forest, typename T>
 auto find_node(Forest& f, const T& x) {
-    return std::find_if(f.begin(), f.end(), [&](const auto& v){ return v == x; });
+    return std::find_if(f.begin(), f.end(), [&](const auto& v) { return v == x; });
 }
 
 /**************************************************************************************************/
@@ -285,13 +287,13 @@ BOOST_AUTO_TEST_CASE(child_traversal) {
 
     BOOST_CHECK(to_string(child_range(parent)) == expected);
 
-    #if 0
+#if 0
         // I'm not sure reverse_child_iterator ever worked.
         forest<std::string>::reverse_child_iterator first{child_begin(parent)};
         forest<std::string>::reverse_child_iterator last{child_end(parent)};
         std::string result{to_string(first, last)};
         BOOST_CHECK(result == expected);
-    #endif
+#endif
 }
 
 /**************************************************************************************************/
@@ -432,8 +434,9 @@ BOOST_AUTO_TEST_CASE(swap) {
 BOOST_AUTO_TEST_CASE(test_equal_shape) {
     auto f1{big_test_forest()};
     auto f2{f1};
-    
-    for (auto& x : preorder_range(f2)) {
+
+    auto r{preorder_range(f2)};
+    for (auto& x : r) {
         x = "X";
     }
 
@@ -448,7 +451,7 @@ BOOST_AUTO_TEST_CASE(test_transcribe_forest) {
     auto f1{big_test_forest()};
     stlab::forest<std::size_t> f2;
 
-    forests::transcribe(f1, forests::transcriber(f2), [](const std::string& x){
+    forests::transcribe(f1, forests::transcriber(f2), [](const std::string& x) {
         assert(!x.empty());
         return static_cast<std::size_t>(x.front());
     });

From 7162c07cb22cf4b46ddb6e96453872fee05acec2 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 08:32:45 -0700
Subject: [PATCH 10/17] Formatting forest.hpp

---
 stlab/forest.hpp | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/stlab/forest.hpp b/stlab/forest.hpp
index 3c749474..f4ec69f9 100755
--- a/stlab/forest.hpp
+++ b/stlab/forest.hpp
@@ -60,18 +60,14 @@ auto trailing_of(I i) {
 
 /**************************************************************************************************/
 
-constexpr auto is_leading(forest_edge e) {
-    return e == forest_edge::leading;
-}
+constexpr auto is_leading(forest_edge e) { return e == forest_edge::leading; }
 
 template <class I> // I models a FullorderIterator
 auto is_leading(const I& i) {
     return is_leading(i.edge());
 }
 
-constexpr auto is_trailing(forest_edge e) {
-    return e == forest_edge::trailing;
-}
+constexpr auto is_trailing(forest_edge e) { return e == forest_edge::trailing; }
 
 template <class I> // I models a FullorderIterator
 auto is_trailing(const I& i) {
@@ -779,12 +775,10 @@ class forest {
         insert(end(), const_child_iterator(x.begin()), const_child_iterator(x.end()));
     }
     forest(forest&& x) noexcept : forest() { splice(end(), x); }
-    forest& operator=(const forest& x) {
-    return *this = forest(x);
-    }
+    forest& operator=(const forest& x) { return *this = forest(x); }
     forest& operator=(forest&& x) noexcept {
         auto tmp{std::move(x)}; // this is `release()`
-        clear(); // these two lines are `reset()`
+        clear();                // these two lines are `reset()`
         splice(end(), tmp);
         return *this;
     }

From 2a56104a37326501d4a4a59a4ad93b7cc2d2a3e6 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 10:26:06 -0700
Subject: [PATCH 11/17] Revert "Fixing task for MSVC (can't deduce noexcept)."

This reverts commit 3e113b2478db7169cec6ef5e15c463d4f8592af6.
---
 stlab/concurrency/task.hpp | 143 +++++++++++--------------------------
 1 file changed, 42 insertions(+), 101 deletions(-)

diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 0f2a1c5f..811587f2 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -30,12 +30,15 @@ inline namespace v1 {
 
 /**************************************************************************************************/
 
-namespace detail {
-
-/**************************************************************************************************/
+/*
+    tasks are functions with a mutable call operator to support moving items through for single
+    invocations.
+*/
+template <class>
+class task;
 
-template <bool NoExcept, class R, class... Args>
-class task_base {
+template <class R, class... Args, bool NoExcept>
+class task<R(Args...) noexcept(NoExcept)> {
     template <class F>
     constexpr static bool maybe_empty =
         std::is_pointer<std::decay_t<F>>::value || std::is_member_pointer<std::decay_t<F>>::value ||
@@ -189,17 +192,17 @@ class task_base {
 public:
     using result_type = R;
 
-    constexpr task_base() noexcept = default;
-    constexpr task_base(std::nullptr_t) noexcept : task_base() {}
-    task_base(const task_base&) = delete;
-    task_base(task_base&& x) noexcept : _vtable_ptr(x._vtable_ptr), _invoke(x._invoke) {
+    constexpr task() noexcept = default;
+    constexpr task(std::nullptr_t) noexcept : task() {}
+    task(const task&) = delete;
+    task(task&& x) noexcept : _vtable_ptr(x._vtable_ptr), _invoke(x._invoke) {
         _vtable_ptr->move_ctor(&x._model, &_model);
     }
 
     template <class F,
               std::enable_if_t<!NoExcept || noexcept(std::declval<F>()(std::declval<Args>()...)),
                                bool> = true>
-    task_base(F&& f) {
+    task(F&& f) {
         using small_t = model<std::decay_t<F>, true>;
         using large_t = model<std::decay_t<F>, false>;
         using model_t = std::conditional_t<(sizeof(small_t) <= small_size) &&
@@ -213,11 +216,11 @@ class task_base {
         _invoke = &model_t::invoke;
     }
 
-    ~task_base() { _vtable_ptr->dtor(&_model); };
+    ~task() { _vtable_ptr->dtor(&_model); };
 
-    task_base& operator=(const task_base&) = delete;
+    task& operator=(const task&) = delete;
 
-    task_base& operator=(task_base&& x) noexcept {
+    task& operator=(task&& x) noexcept {
         _vtable_ptr->dtor(&_model);
         _vtable_ptr = x._vtable_ptr;
         _invoke = x._invoke;
@@ -225,15 +228,15 @@ class task_base {
         return *this;
     }
 
-    task_base& operator=(std::nullptr_t) noexcept { return *this = task_base(); }
+    task& operator=(std::nullptr_t) noexcept { return *this = task(); }
 
     template <class F>
     auto operator=(F&& f)
-        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task_base&> {
-        return *this = task_base(std::forward<F>(f));
+        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task&> {
+        return *this = task(std::forward<F>(f));
     }
 
-    void swap(task_base& x) noexcept { std::swap(*this, x); }
+    void swap(task& x) noexcept { std::swap(*this, x); }
 
     explicit operator bool() const { return _vtable_ptr->const_pointer(&_model) != nullptr; }
 
@@ -257,18 +260,11 @@ class task_base {
         return _invoke(&_model, std::forward<Brgs>(brgs)...);
     }
 
-    friend inline bool operator==(const task_base& x, std::nullptr_t) {
-        return !static_cast<bool>(x);
-    }
-    friend inline bool operator==(std::nullptr_t, const task_base& x) {
-        return !static_cast<bool>(x);
-    }
-    friend inline bool operator!=(const task_base& x, std::nullptr_t) {
-        return static_cast<bool>(x);
-    }
-    friend inline bool operator!=(std::nullptr_t, const task_base& x) {
-        return static_cast<bool>(x);
-    }
+    friend inline void swap(task& x, task& y) { return x.swap(y); }
+    friend inline bool operator==(const task& x, std::nullptr_t) { return !static_cast<bool>(x); }
+    friend inline bool operator==(std::nullptr_t, const task& x) { return !static_cast<bool>(x); }
+    friend inline bool operator!=(const task& x, std::nullptr_t) { return static_cast<bool>(x); }
+    friend inline bool operator!=(std::nullptr_t, const task& x) { return static_cast<bool>(x); }
 };
 
 #if STLAB_CPP_VERSION_LESS_THAN(17)
@@ -277,30 +273,30 @@ class task_base {
 
 #if defined(__GNUC__) && __GNUC__ < 7 && !defined(__clang__)
 template <class R, class... Args, bool NoExcept>
-const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
-    task_base<R(Args...) noexcept(NoExcept)>::_vtable = {dtor, move_ctor, target_type_, pointer,
-                                                         const_pointer};
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::_vtable = {dtor, move_ctor, target_type_, pointer,
+                                                    const_pointer};
 
 template <class R, class... Args, bool NoExcept>
-const typename task_base<R(Args...) noexcept(NoExcept)>::invoke_t
-    task_base<R(Args...) noexcept(NoExcept)>::_invoke = _invoke;
+const typename task<R(Args...) noexcept(NoExcept)>::invoke_t
+    task<R(Args...) noexcept(NoExcept)>::_invoke = _invoke;
 #else
 template <class R, class... Args, bool NoExcept>
-const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
-    task_base<R(Args...) noexcept(NoExcept)>::_vtable;
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::_vtable;
 #endif
 
 #ifdef _MSC_VER
 
 template <class R, class... Args, bool NoExcept>
 template <class F>
-const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
-    task_base<R(Args...) noexcept(NoExcept)>::model<F, false>::_vtable;
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::model<F, false>::_vtable;
 
 template <class R, class... Args, bool NoExcept>
 template <class F>
-const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
-    task_base<R(Args...) noexcept(NoExcept)>::model<F, true>::_vtable;
+const typename task<R(Args...) noexcept(NoExcept)>::concept_t
+    task<R(Args...) noexcept(NoExcept)>::model<F, true>::_vtable;
 
 #else
 
@@ -308,25 +304,23 @@ const typename task_base<R(Args...) noexcept(NoExcept)>::concept_t
 
 template <class R, class... Args>
 template <class F>
-const typename task_base<R(Args...)>::concept_t
-    task_base<R(Args...)>::template model<F, false>::_vtable = {dtor, move_ctor, target_type,
-                                                                pointer, const_pointer};
+const typename task<R(Args...)>::concept_t task<R(Args...)>::template model<F, false>::_vtable = {
+    dtor, move_ctor, target_type, pointer, const_pointer};
 
 template <class R, class... Args>
 template <class F>
-const typename task_base<R(Args...)>::concept_t
-    task_base<R(Args...)>::template model<F, true>::_vtable = {dtor, move_ctor, target_type,
-                                                               pointer, const_pointer};
+const typename task<R(Args...)>::concept_t task<R(Args...)>::template model<F, true>::_vtable = {
+    dtor, move_ctor, target_type, pointer, const_pointer};
 
 #else
 
 template <class R, class... Args>
 template <class F>
-const typename task_base<R(Args...)>::concept_t task_base<R(Args...)>::model<F, false>::_vtable;
+const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, false>::_vtable;
 
 template <class R, class... Args>
 template <class F>
-const typename task_base<R(Args...)>::concept_t task_base<R(Args...)>::model<F, true>::_vtable;
+const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, true>::_vtable;
 
 #endif
 
@@ -336,59 +330,6 @@ const typename task_base<R(Args...)>::concept_t task_base<R(Args...)>::model<F,
 
 /**************************************************************************************************/
 
-} // namespace detail
-
-/**************************************************************************************************/
-
-template <class F>
-class task;
-
-template <class R, class... Args>
-class task<R(Args...)> : detail::task_base<false, R, Args...> {
-    using base_type = detail::task_base<false, R, Args...>;
-
-public:
-    using base_type::base_type;
-    using base_type::target_type;
-    using typename base_type::result_type;
-    using base_type::operator();
-    using base_type::operator bool;
-    using base_type::swap;
-    using base_type::target;
-
-    friend inline void swap(task& x, task& y) { return x.swap(y); }
-    friend inline bool operator==(const task& x, std::nullptr_t) {
-        return static_cast<const base_type&>(x) == nullptr;
-    }
-    friend inline bool operator==(std::nullptr_t, const task& x) { return x == nullptr; }
-    friend inline bool operator!=(const task& x, std::nullptr_t) { return !(x == nullptr); }
-    friend inline bool operator!=(std::nullptr_t, const task& x) { return !(x == nullptr); }
-};
-
-template <class R, class... Args>
-class task<R(Args...) noexcept> : detail::task_base<true, R, Args...> {
-    using base_type = detail::task_base<true, R, Args...>;
-
-public:
-    using base_type::base_type;
-    using base_type::target_type;
-    using typename base_type::result_type;
-    using base_type::operator();
-    using base_type::operator bool;
-    using base_type::swap;
-    using base_type::target;
-
-    friend inline void swap(task& x, task& y) { return x.swap(y); }
-    friend inline bool operator==(const task& x, std::nullptr_t) {
-        return static_cast<const base_type&>(x) == nullptr;
-    }
-    friend inline bool operator==(std::nullptr_t, const task& x) { return x == nullptr; }
-    friend inline bool operator!=(const task& x, std::nullptr_t) { return !(x == nullptr); }
-    friend inline bool operator!=(std::nullptr_t, const task& x) { return !(x == nullptr); }
-};
-
-/**************************************************************************************************/
-
 } // namespace v1
 
 /**************************************************************************************************/

From 0fdb98d55da607fbcadc5ba10b9c52c118e6dc96 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 10:50:35 -0700
Subject: [PATCH 12/17] Another approach to deduce noexcept.

---
 .github/workflows/stlab.yml |  6 ++--
 stlab/concurrency/task.hpp  | 60 ++++++++++++++++++++++++-------------
 test/forest_test.cpp        |  3 +-
 3 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/stlab.yml b/.github/workflows/stlab.yml
index 7f7712ca..26d31c95 100644
--- a/.github/workflows/stlab.yml
+++ b/.github/workflows/stlab.yml
@@ -4,7 +4,7 @@ on:
   pull_request:
   push:
     branches:
-    - main
+      - main
 
 jobs:
   generate-matrix:
@@ -67,7 +67,7 @@ jobs:
           ./emsdk install latest
           ./emsdk activate latest
           echo 'source "$HOME/emsdk/emsdk_env.sh"' >> $HOME/.bash_profile
-          
+
           # Override Emsdk's bundled node (14.18.2) to the GH Actions system installation (>= 16.16.0)
           sed -i "/^NODE_JS = .*/c\NODE_JS = '`which node`'" .emscripten
           echo "Overwrote .emscripten config file to:"
@@ -122,7 +122,7 @@ jobs:
         run: |
           call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
           mkdir ..\build
-          cmake -S. -B../build -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=23 -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake
+          cmake -S. -B../build -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=20 -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake
 
       - name: Build // Unix
         if: ${{ startsWith(matrix.config.os, 'ubuntu') || startsWith(matrix.config.os, 'macos') }}
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 811587f2..a546a0df 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -34,11 +34,9 @@ inline namespace v1 {
     tasks are functions with a mutable call operator to support moving items through for single
     invocations.
 */
-template <class>
-class task;
 
-template <class R, class... Args, bool NoExcept>
-class task<R(Args...) noexcept(NoExcept)> {
+template <bool NoExcept, class R, class... Args>
+class task_ {
     template <class F>
     constexpr static bool maybe_empty =
         std::is_pointer<std::decay_t<F>>::value || std::is_member_pointer<std::decay_t<F>>::value ||
@@ -192,17 +190,17 @@ class task<R(Args...) noexcept(NoExcept)> {
 public:
     using result_type = R;
 
-    constexpr task() noexcept = default;
-    constexpr task(std::nullptr_t) noexcept : task() {}
-    task(const task&) = delete;
-    task(task&& x) noexcept : _vtable_ptr(x._vtable_ptr), _invoke(x._invoke) {
+    constexpr task_() noexcept = default;
+    constexpr task_(std::nullptr_t) noexcept : task_() {}
+    task_(const task_&) = delete;
+    task_(task_&& x) noexcept : _vtable_ptr(x._vtable_ptr), _invoke(x._invoke) {
         _vtable_ptr->move_ctor(&x._model, &_model);
     }
 
     template <class F,
               std::enable_if_t<!NoExcept || noexcept(std::declval<F>()(std::declval<Args>()...)),
                                bool> = true>
-    task(F&& f) {
+    task_(F&& f) {
         using small_t = model<std::decay_t<F>, true>;
         using large_t = model<std::decay_t<F>, false>;
         using model_t = std::conditional_t<(sizeof(small_t) <= small_size) &&
@@ -216,11 +214,11 @@ class task<R(Args...) noexcept(NoExcept)> {
         _invoke = &model_t::invoke;
     }
 
-    ~task() { _vtable_ptr->dtor(&_model); };
+    ~task_() { _vtable_ptr->dtor(&_model); };
 
-    task& operator=(const task&) = delete;
+    task_& operator=(const task_&) = delete;
 
-    task& operator=(task&& x) noexcept {
+    task_& operator=(task_&& x) noexcept {
         _vtable_ptr->dtor(&_model);
         _vtable_ptr = x._vtable_ptr;
         _invoke = x._invoke;
@@ -228,15 +226,15 @@ class task<R(Args...) noexcept(NoExcept)> {
         return *this;
     }
 
-    task& operator=(std::nullptr_t) noexcept { return *this = task(); }
+    task_& operator=(std::nullptr_t) noexcept { return *this = task_(); }
 
     template <class F>
     auto operator=(F&& f)
-        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task&> {
-        return *this = task(std::forward<F>(f));
+        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task_&> {
+        return *this = task_(std::forward<F>(f));
     }
 
-    void swap(task& x) noexcept { std::swap(*this, x); }
+    void swap(task_& x) noexcept { std::swap(*this, x); }
 
     explicit operator bool() const { return _vtable_ptr->const_pointer(&_model) != nullptr; }
 
@@ -260,13 +258,33 @@ class task<R(Args...) noexcept(NoExcept)> {
         return _invoke(&_model, std::forward<Brgs>(brgs)...);
     }
 
-    friend inline void swap(task& x, task& y) { return x.swap(y); }
-    friend inline bool operator==(const task& x, std::nullptr_t) { return !static_cast<bool>(x); }
-    friend inline bool operator==(std::nullptr_t, const task& x) { return !static_cast<bool>(x); }
-    friend inline bool operator!=(const task& x, std::nullptr_t) { return static_cast<bool>(x); }
-    friend inline bool operator!=(std::nullptr_t, const task& x) { return static_cast<bool>(x); }
+    friend inline void swap(task_& x, task_& y) { return x.swap(y); }
+    friend inline bool operator==(const task_& x, std::nullptr_t) { return !static_cast<bool>(x); }
+    friend inline bool operator==(std::nullptr_t, const task_& x) { return !static_cast<bool>(x); }
+    friend inline bool operator!=(const task_& x, std::nullptr_t) { return static_cast<bool>(x); }
+    friend inline bool operator!=(std::nullptr_t, const task_& x) { return static_cast<bool>(x); }
+};
+
+/**************************************************************************************************/
+
+template <template <bool, class, class...> class T, class F>
+struct noexcept_deducer;
+
+template <template <bool, class, class...> class T, class R, class... Args>
+struct noexcept_deducer<T, R(Args...)> {
+    using type = T<false, R, Args...>;
 };
 
+template <template <bool, class, class...> class T, class R, class... Args>
+struct noexcept_deducer<T, R(Args...) noexcept> {
+    using type = T<true, R, Args...>;
+};
+
+template <class F>
+using task = typename noexcept_deducer<task_, F>::type;
+
+/**************************************************************************************************/
+
 #if STLAB_CPP_VERSION_LESS_THAN(17)
 
 // In C++17 constexpr implies inline and these definitions are deprecated
diff --git a/test/forest_test.cpp b/test/forest_test.cpp
index 32487aed..b3026842 100644
--- a/test/forest_test.cpp
+++ b/test/forest_test.cpp
@@ -435,8 +435,7 @@ BOOST_AUTO_TEST_CASE(test_equal_shape) {
     auto f1{big_test_forest()};
     auto f2{f1};
 
-    auto r{preorder_range(f2)};
-    for (auto& x : r) {
+    for (auto& x : preorder_range(f2)) {
         x = "X";
     }
 

From c58d21557ca6cc44d331e2e25eda8ae7018bb03f Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 11:08:02 -0700
Subject: [PATCH 13/17] Removing noexcept mangling for GCC.

---
 stlab/concurrency/task.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index a546a0df..2e357ebd 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -197,9 +197,9 @@ class task_ {
         _vtable_ptr->move_ctor(&x._model, &_model);
     }
 
-    template <class F,
-              std::enable_if_t<!NoExcept || noexcept(std::declval<F>()(std::declval<Args>()...)),
-                               bool> = true>
+    template <
+        class F,
+        std::enable_if_t<!NoExcept || stlab::is_nothrow_invocable<F, Args...>::value, bool> = true>
     task_(F&& f) {
         using small_t = model<std::decay_t<F>, true>;
         using large_t = model<std::decay_t<F>, false>;
@@ -230,7 +230,8 @@ class task_ {
 
     template <class F>
     auto operator=(F&& f)
-        -> std::enable_if_t<!NoExcept || noexcept(f(std::declval<Args>()...)), task_&> {
+        -> std::enable_if_t<!NoExcept || stlab::is_nothrow_invocable<decltype(f), Args...>::value,
+                            task_&> {
         return *this = task_(std::forward<F>(f));
     }
 

From 888cb4aa9cf057cf406239ff206542092c9b9f56 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 11:50:05 -0700
Subject: [PATCH 14/17] Improving nothrow invocable test.

---
 stlab/concurrency/task.hpp | 2 ++
 stlab/type_traits.hpp      | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 2e357ebd..eecc3870 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -20,6 +20,8 @@
 
 #include <stlab/config.hpp>
 
+#include <stlab/type_traits.hpp>
+
 /**************************************************************************************************/
 
 namespace stlab {
diff --git a/stlab/type_traits.hpp b/stlab/type_traits.hpp
index 5933adb8..9ec1383a 100644
--- a/stlab/type_traits.hpp
+++ b/stlab/type_traits.hpp
@@ -9,6 +9,7 @@
 #ifndef STLAB_TYPE_TRAITS_HPP
 #define STLAB_TYPE_TRAITS_HPP
 
+#include <cstddef>
 #include <functional>
 #include <type_traits>
 #include <utility>
@@ -34,6 +35,11 @@ struct is_nothrow_invocable {
     static constexpr bool value = noexcept(std::invoke(std::declval<F>(), std::declval<Args>()...));
 };
 
+template <class F>
+struct is_nothrow_invocable<std::nullptr_t> {
+    static constexpr bool value = false; // Not invocable
+};
+
 } // namespace v1
 
 } // namespace stlab

From b48bcbea621a4f8e81530701f768e01985b01e8f Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 12:24:48 -0700
Subject: [PATCH 15/17] Fixing implementation to handle non-invocable types.

---
 stlab/type_traits.hpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/stlab/type_traits.hpp b/stlab/type_traits.hpp
index 9ec1383a..47fdd3b9 100644
--- a/stlab/type_traits.hpp
+++ b/stlab/type_traits.hpp
@@ -9,8 +9,6 @@
 #ifndef STLAB_TYPE_TRAITS_HPP
 #define STLAB_TYPE_TRAITS_HPP
 
-#include <cstddef>
-#include <functional>
 #include <type_traits>
 #include <utility>
 
@@ -30,14 +28,15 @@ inline namespace v1 {
     This is necessary for GCC prior to 13.2 which does not implement mangling noexcept_expr.
  */
 
-template <class F, class... Args>
+template <typename F, typename... Args>
 struct is_nothrow_invocable {
-    static constexpr bool value = noexcept(std::invoke(std::declval<F>(), std::declval<Args>()...));
-};
+    template <typename U>
+    static auto test(int)
+        -> decltype(noexcept(std::declval<U>()(std::declval<Args>()...)), void(), std::true_type());
+    template <typename U>
+    static auto test(...) -> std::false_type;
 
-template <class F>
-struct is_nothrow_invocable<std::nullptr_t> {
-    static constexpr bool value = false; // Not invocable
+    static constexpr bool value = decltype(test<F>(0))::value;
 };
 
 } // namespace v1

From 13315f3efcb7b145e2e7dbdac9e4b225e78df0e5 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 12:37:29 -0700
Subject: [PATCH 16/17] Reverting GCC version

Hit a weird issue with version 12 in forest.
---
 .github/matrix.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/matrix.json b/.github/matrix.json
index da5f6769..c32dc4d7 100644
--- a/.github/matrix.json
+++ b/.github/matrix.json
@@ -1,9 +1,9 @@
 {
     "config": [
         {
-            "name": "Linux GCC 12",
+            "name": "Linux GCC 11",
             "compiler": "gcc",
-            "version": "12",
+            "version": "11",
             "os": "ubuntu-22.04"
         },
         {

From 8acdc1389e11dcc830c590ea08aa7609b6065598 Mon Sep 17 00:00:00 2001
From: Sean Parent <sparent@adobe.com>
Date: Sat, 19 Aug 2023 14:50:44 -0700
Subject: [PATCH 17/17] Giving up on C++14 support.

---
 stlab/concurrency/default_executor.hpp   |  4 +-
 stlab/concurrency/immediate_executor.hpp |  4 +-
 stlab/concurrency/main_executor.hpp      |  8 +--
 stlab/concurrency/serial_queue.hpp       |  5 +-
 stlab/concurrency/system_timer.hpp       |  8 +--
 stlab/concurrency/task.hpp               | 72 +-----------------------
 stlab/type_traits.hpp                    | 46 ---------------
 7 files changed, 14 insertions(+), 133 deletions(-)
 delete mode 100644 stlab/type_traits.hpp

diff --git a/stlab/concurrency/default_executor.hpp b/stlab/concurrency/default_executor.hpp
index e85f2778..506aa471 100644
--- a/stlab/concurrency/default_executor.hpp
+++ b/stlab/concurrency/default_executor.hpp
@@ -12,7 +12,6 @@
 #include <stlab/config.hpp>
 
 #include <stlab/pre_exit.hpp>
-#include <stlab/type_traits.hpp>
 
 #include <stlab/concurrency/set_current_thread_name.hpp>
 #include <stlab/concurrency/task.hpp>
@@ -20,6 +19,7 @@
 #include <cassert>
 #include <chrono>
 #include <functional>
+#include <type_traits>
 
 #if STLAB_TASK_SYSTEM(LIBDISPATCH)
 #include <dispatch/dispatch.h>
@@ -94,7 +94,7 @@ struct executor_type {
     using result_type = void;
 
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+    auto operator()(F f) const -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         using f_t = decltype(f);
 
         dispatch_group_async_f(detail::group()._group,
diff --git a/stlab/concurrency/immediate_executor.hpp b/stlab/concurrency/immediate_executor.hpp
index 31a52bea..7c733dcc 100644
--- a/stlab/concurrency/immediate_executor.hpp
+++ b/stlab/concurrency/immediate_executor.hpp
@@ -11,8 +11,6 @@
 
 #include <type_traits>
 
-#include <stlab/type_traits.hpp>
-
 /**************************************************************************************************/
 
 namespace stlab {
@@ -28,7 +26,7 @@ namespace detail {
 
 struct immediate_executor_type {
     template <typename F>
-    auto operator()(F&& f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+    auto operator()(F&& f) const -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         std::forward<F>(f)();
     }
 };
diff --git a/stlab/concurrency/main_executor.hpp b/stlab/concurrency/main_executor.hpp
index d77ffd15..adc0b7be 100644
--- a/stlab/concurrency/main_executor.hpp
+++ b/stlab/concurrency/main_executor.hpp
@@ -14,8 +14,6 @@
 
 #include <stlab/config.hpp>
 
-#include <stlab/type_traits.hpp>
-
 #if STLAB_MAIN_EXECUTOR(QT5) || STLAB_MAIN_EXECUTOR(QT6)
 #include <QtGlobal>
 #if (STLAB_MAIN_EXECUTOR(QT5) &&                                                                \
@@ -87,7 +85,7 @@ class main_executor_type {
 
 public:
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+    auto operator()(F f) const -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         auto event = std::make_unique<executor_event>();
         event->set_task(std::move(f));
         auto receiver = event->receiver();
@@ -103,7 +101,7 @@ struct main_executor_type {
     using result_type = void;
 
     template <typename F>
-    auto operator()(F f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+    auto operator()(F f) const -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         using f_t = decltype(f);
 
         dispatch_async_f(dispatch_get_main_queue(), new f_t(std::move(f)), [](void* f_) {
@@ -120,7 +118,7 @@ struct main_executor_type {
     using result_type = void;
 
     template <class F>
-    auto operator()(F&& f) const -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+    auto operator()(F&& f) const -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         using function_type = typename std::remove_reference<F>::type;
         auto p = new function_type(std::forward<F>(f));
 
diff --git a/stlab/concurrency/serial_queue.hpp b/stlab/concurrency/serial_queue.hpp
index f580737d..97ed6577 100644
--- a/stlab/concurrency/serial_queue.hpp
+++ b/stlab/concurrency/serial_queue.hpp
@@ -18,7 +18,6 @@
 #include <utility>
 
 #include <stlab/scope.hpp>
-#include <stlab/type_traits.hpp>
 
 #ifndef STLAB_DISABLE_FUTURE_COROUTINES
 #define STLAB_DISABLE_FUTURE_COROUTINES()
@@ -151,8 +150,8 @@ class serial_queue_t {
             [_e = std::move(e)](auto&& f) { _e(std::forward<decltype(f)>(f)); }, mode)) {}
 
     auto executor() const {
-        return [_impl = _impl](
-                   auto&& f) -> std::enable_if_t<stlab::is_nothrow_invocable<decltype(f)>::value> {
+        return [_impl =
+                    _impl](auto&& f) -> std::enable_if_t<std::is_nothrow_invocable_v<decltype(f)>> {
             _impl->enqueue(std::forward<decltype(f)>(f));
         };
     }
diff --git a/stlab/concurrency/system_timer.hpp b/stlab/concurrency/system_timer.hpp
index c6efc97a..1c85da9c 100755
--- a/stlab/concurrency/system_timer.hpp
+++ b/stlab/concurrency/system_timer.hpp
@@ -31,8 +31,6 @@
 
 #include <stlab/concurrency/task.hpp>
 
-#include <stlab/type_traits.hpp>
-
 /**************************************************************************************************/
 
 namespace stlab {
@@ -61,7 +59,7 @@ struct system_timer_type {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F f) const
-        -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+        -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         using namespace std::chrono;
 
         using f_t = decltype(f);
@@ -113,7 +111,7 @@ class system_timer {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
-        -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+        -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         using namespace std::chrono;
         auto timer = CreateThreadpoolTimer(&timer_callback_impl<F>, new F(std::forward<F>(f)),
                                            &_callBackEnvironment);
@@ -231,7 +229,7 @@ class system_timer {
 
     template <typename F, typename Rep, typename Per = std::ratio<1>>
     auto operator()(std::chrono::duration<Rep, Per> duration, F&& f)
-        -> std::enable_if_t<stlab::is_nothrow_invocable<F>::value> {
+        -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         lock_t lock(_timed_queue_mutex);
         _timed_queue.emplace_back(std::chrono::steady_clock::now() + duration, std::forward<F>(f));
         std::push_heap(std::begin(_timed_queue), std::end(_timed_queue), greater_first());
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index eecc3870..b29b5c1e 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -20,8 +20,6 @@
 
 #include <stlab/config.hpp>
 
-#include <stlab/type_traits.hpp>
-
 /**************************************************************************************************/
 
 namespace stlab {
@@ -199,9 +197,8 @@ class task_ {
         _vtable_ptr->move_ctor(&x._model, &_model);
     }
 
-    template <
-        class F,
-        std::enable_if_t<!NoExcept || stlab::is_nothrow_invocable<F, Args...>::value, bool> = true>
+    template <class F,
+              std::enable_if_t<!NoExcept || std::is_nothrow_invocable_v<F, Args...>, bool> = true>
     task_(F&& f) {
         using small_t = model<std::decay_t<F>, true>;
         using large_t = model<std::decay_t<F>, false>;
@@ -232,7 +229,7 @@ class task_ {
 
     template <class F>
     auto operator=(F&& f)
-        -> std::enable_if_t<!NoExcept || stlab::is_nothrow_invocable<decltype(f), Args...>::value,
+        -> std::enable_if_t<!NoExcept || std::is_nothrow_invocable_v<decltype(f), Args...>,
                             task_&> {
         return *this = task_(std::forward<F>(f));
     }
@@ -288,69 +285,6 @@ using task = typename noexcept_deducer<task_, F>::type;
 
 /**************************************************************************************************/
 
-#if STLAB_CPP_VERSION_LESS_THAN(17)
-
-// In C++17 constexpr implies inline and these definitions are deprecated
-
-#if defined(__GNUC__) && __GNUC__ < 7 && !defined(__clang__)
-template <class R, class... Args, bool NoExcept>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::_vtable = {dtor, move_ctor, target_type_, pointer,
-                                                    const_pointer};
-
-template <class R, class... Args, bool NoExcept>
-const typename task<R(Args...) noexcept(NoExcept)>::invoke_t
-    task<R(Args...) noexcept(NoExcept)>::_invoke = _invoke;
-#else
-template <class R, class... Args, bool NoExcept>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::_vtable;
-#endif
-
-#ifdef _MSC_VER
-
-template <class R, class... Args, bool NoExcept>
-template <class F>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::model<F, false>::_vtable;
-
-template <class R, class... Args, bool NoExcept>
-template <class F>
-const typename task<R(Args...) noexcept(NoExcept)>::concept_t
-    task<R(Args...) noexcept(NoExcept)>::model<F, true>::_vtable;
-
-#else
-
-#if defined(__GNUC__) && __GNUC__ < 7 && !defined(__clang__)
-
-template <class R, class... Args>
-template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::template model<F, false>::_vtable = {
-    dtor, move_ctor, target_type, pointer, const_pointer};
-
-template <class R, class... Args>
-template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::template model<F, true>::_vtable = {
-    dtor, move_ctor, target_type, pointer, const_pointer};
-
-#else
-
-template <class R, class... Args>
-template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, false>::_vtable;
-
-template <class R, class... Args>
-template <class F>
-const typename task<R(Args...)>::concept_t task<R(Args...)>::model<F, true>::_vtable;
-
-#endif
-
-#endif
-
-#endif
-
-/**************************************************************************************************/
-
 } // namespace v1
 
 /**************************************************************************************************/
diff --git a/stlab/type_traits.hpp b/stlab/type_traits.hpp
deleted file mode 100644
index 47fdd3b9..00000000
--- a/stlab/type_traits.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-    Copyright 2015 Adobe
-    Distributed under the Boost Software License, Version 1.0.
-    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/**************************************************************************************************/
-
-#ifndef STLAB_TYPE_TRAITS_HPP
-#define STLAB_TYPE_TRAITS_HPP
-
-#include <type_traits>
-#include <utility>
-
-/**
-    @brief This file contains type traits included in versions of C++ later than 14. Only the
-   minimal items used are included. They are not conditional on the C++ version to avoid ODR
-   violations.
- */
-
-namespace stlab {
-
-inline namespace v1 {
-
-/**
-    @brief See <a href="http://en.cppreference.com/w/cpp/types/is_invocable">std::is_invocable</a>
-
-    This is necessary for GCC prior to 13.2 which does not implement mangling noexcept_expr.
- */
-
-template <typename F, typename... Args>
-struct is_nothrow_invocable {
-    template <typename U>
-    static auto test(int)
-        -> decltype(noexcept(std::declval<U>()(std::declval<Args>()...)), void(), std::true_type());
-    template <typename U>
-    static auto test(...) -> std::false_type;
-
-    static constexpr bool value = decltype(test<F>(0))::value;
-};
-
-} // namespace v1
-
-} // namespace stlab
-
-#endif // STLAB_TYPE_TRAITS_HPP