From 2f4037b5454a53f3cfb9c201d8cac8edf7b33655 Mon Sep 17 00:00:00 2001
From: Sean Parent <sean.parent@stlab.cc>
Date: Thu, 14 Mar 2024 17:12:55 -0700
Subject: [PATCH] namespace version bump (#541)

Bumping the inline namespace version to v2 to avoid ODR violations.
The pre_exit code remains at v1 (it must be bumped more carefully).
The portable default executor is moving to v2 - which may lead to more than one thread pool for the portable instance. Pinning the version here is more difficult.
Removed dead reset() operations in future shared_base
Documented (and assert) precondition that future::exception() is only invoked on a ready exception.
Made more of the tuple meta-facilities public to avoid detail:: namespace usage in unit tests.
Restructured unit tests to avoid sleep-wait-loops.
---
 README.md                                |   1 +
 stlab/concurrency/await.hpp              |  15 +-
 stlab/concurrency/channel.hpp            |  26 +-
 stlab/concurrency/default_executor.hpp   |  10 +-
 stlab/concurrency/executor_base.hpp      |  11 +-
 stlab/concurrency/future.hpp             |  36 +--
 stlab/concurrency/immediate_executor.hpp |  11 +-
 stlab/concurrency/main_executor.hpp      |  10 +-
 stlab/concurrency/ready_future.hpp       |  12 +-
 stlab/concurrency/serial_queue.hpp       |   6 +-
 stlab/concurrency/system_timer.hpp       |  20 +-
 stlab/concurrency/task.hpp               |  10 +-
 stlab/concurrency/traits.hpp             |  12 +-
 stlab/concurrency/tuple_algorithm.hpp    |  71 +++---
 stlab/config.hpp.in                      |  64 ++---
 stlab/functional.hpp                     |  11 +-
 stlab/memory.hpp                         |  10 +-
 stlab/pre_exit.hpp                       |   6 +
 stlab/scope.hpp                          |  11 +-
 stlab/test/model.hpp                     |   6 +-
 stlab/utility.hpp                        |  11 +-
 test/executor_test.cpp                   |  61 +++--
 test/future_recover_tests.cpp            |  32 +--
 test/future_test_helper.hpp              |  49 +---
 test/future_tests.cpp                    |   7 +-
 test/future_then_tests.cpp               | 305 +++++++++++------------
 test/future_when_all_arguments_tests.cpp |   8 +-
 test/future_when_all_range_tests.cpp     |   4 +-
 test/future_when_any_arguments_tests.cpp |   4 +-
 test/future_when_any_range_tests.cpp     |   5 +-
 test/tuple_test.cpp                      |  22 +-
 31 files changed, 405 insertions(+), 462 deletions(-)

diff --git a/README.md b/README.md
index d513ea0ce..ba070de97 100644
--- a/README.md
+++ b/README.md
@@ -74,6 +74,7 @@ cmake -S . -B ../BUILD -GNinja -DCMAKE_CXX_STANDARD=17 -DCMAKE_BUILD_TYPE=Releas
 If you organize the build directory into subdirectories you can support multiple configurations.
 
 ```
+rm -rf ../builds/portable
 cmake -S . -B ../builds/portable -GXcode -DCMAKE_CXX_STANDARD=17 -DBUILD_TESTING=ON -DSTLAB_TASK_SYSTEM=portable -DCMAKE_OSX_DEPLOYMENT_TARGET=14.4  -DCMAKE_OSX_DEPLOYMENT_TARGET=macosx14.4
 ```
 
diff --git a/stlab/concurrency/await.hpp b/stlab/concurrency/await.hpp
index 97bb58f6e..0d2885e6a 100644
--- a/stlab/concurrency/await.hpp
+++ b/stlab/concurrency/await.hpp
@@ -31,10 +31,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -203,18 +200,16 @@ template <class T>
 }
 
 template <class T>
-[[deprecated("Use await_for instead.")]] auto blocking_get(future<T> x,
-                                                           const std::chrono::nanoseconds& timeout)
-    -> decltype(x.get_try()) {
+[[deprecated("Use await_for instead.")]] auto blocking_get(
+    future<T> x, const std::chrono::nanoseconds& timeout) -> decltype(x.get_try()) {
     return blocking_get_for(std::move(x), timeout).get_try();
 }
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
+} // namespace stlab
 
 /**************************************************************************************************/
 
-} // namespace stlab
-
 #endif // STLAB_CONCURRENCY_AWAIT_HPP
diff --git a/stlab/concurrency/channel.hpp b/stlab/concurrency/channel.hpp
index ab778bbbe..d7d07ceae 100755
--- a/stlab/concurrency/channel.hpp
+++ b/stlab/concurrency/channel.hpp
@@ -9,6 +9,8 @@
 #ifndef STLAB_CONCURRENCY_CHANNEL_HPP
 #define STLAB_CONCURRENCY_CHANNEL_HPP
 
+#include <stlab/config.hpp>
+
 #include <algorithm>
 #include <array>
 #include <atomic>
@@ -33,10 +35,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -192,7 +191,9 @@ using avoid = std::conditional_t<std::is_same<void, T>::value, avoid_, T>;
 /**************************************************************************************************/
 
 template <typename F, std::size_t... I, typename... T>
-auto invoke_(F&& f, std::tuple<std::variant<T, std::exception_ptr>...>& t, std::index_sequence<I...>) {
+auto invoke_(F&& f,
+             std::tuple<std::variant<T, std::exception_ptr>...>& t,
+             std::index_sequence<I...>) {
     return std::forward<F>(f)(std::move(std::get<I>(t))...);
 }
 
@@ -484,14 +485,12 @@ struct round_robin_queue_strategy {
     queue_t _queue;
 
     bool empty() const {
-        return get_i(
-            _queue, _index, [](const auto& c) { return c.empty(); }, true);
+        return get_i(_queue, _index, [](const auto& c) { return c.empty(); }, true);
     }
 
     auto front() {
         assert(!empty() && "front on an empty container is a very bad idea!");
-        return std::make_tuple(get_i(
-            _queue, _index, [](auto& c) { return c.front(); }, item_t{}));
+        return std::make_tuple(get_i(_queue, _index, [](auto& c) { return c.front(); }, item_t{}));
     }
 
     void pop_front() {
@@ -546,8 +545,8 @@ struct unordered_queue_strategy {
     auto front() {
         assert(!empty() && "front on an empty container is a very bad idea!");
         _index = tuple_find(_queue, [](const auto& c) { return !c.empty(); });
-        return std::make_tuple(get_i(
-            _queue, _index, [](auto& c) { return std::move(c.front()); }, item_t{}));
+        return std::make_tuple(
+            get_i(_queue, _index, [](auto& c) { return std::move(c.front()); }, item_t{}));
     }
 
     void pop_front() {
@@ -1705,10 +1704,7 @@ struct function_process<R(Args...)> {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/default_executor.hpp b/stlab/concurrency/default_executor.hpp
index be370f0cf..eb26673db 100644
--- a/stlab/concurrency/default_executor.hpp
+++ b/stlab/concurrency/default_executor.hpp
@@ -40,10 +40,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -500,10 +497,7 @@ constexpr auto high_executor = detail::executor_type<detail::executor_priority::
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/executor_base.hpp b/stlab/concurrency/executor_base.hpp
index 693a9cf74..a5fec42a5 100644
--- a/stlab/concurrency/executor_base.hpp
+++ b/stlab/concurrency/executor_base.hpp
@@ -9,6 +9,8 @@
 #ifndef STLAB_CONCURRENCY_EXECUTOR_BASE_HPP
 #define STLAB_CONCURRENCY_EXECUTOR_BASE_HPP
 
+#include <stlab/config.hpp>
+
 #include <chrono>
 #include <functional>
 
@@ -18,12 +20,10 @@
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 using executor_t = std::function<void(stlab::task<void() noexcept>)>;
 
 /*
@@ -82,10 +82,7 @@ executor_task_pair<F> operator&(F&& f, executor e) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/future.hpp b/stlab/concurrency/future.hpp
index 9a2911136..e4aac893a 100644
--- a/stlab/concurrency/future.hpp
+++ b/stlab/concurrency/future.hpp
@@ -38,10 +38,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -274,8 +271,6 @@ struct shared_base<T, enable_if_copyable<T>> : std::enable_shared_from_this<shar
 
     explicit shared_base(executor_t s) : _executor(std::move(s)) {}
 
-    void reset() { _then.clear(); } // NEEDS MUTEX
-
     template <typename F>
     auto recover(future<T>&& p, F&& f) {
         return recover(std::move(p), _executor, std::forward<F>(f));
@@ -389,8 +384,6 @@ 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() noexcept>{}; }
-
     template <typename F>
     auto recover(future<T>&& p, F&& f) {
         return recover(std::move(p), _executor, std::forward<F>(f));
@@ -474,8 +467,6 @@ struct shared_base<void> : std::enable_shared_from_this<shared_base<void>> {
 
     explicit shared_base(executor_t s) : _executor(std::move(s)) {}
 
-    void reset() { _then.clear(); }
-
     template <typename F>
     auto recover(future<result_type>&& p, F&& f) {
         return recover(std::move(p), _executor, std::forward<F>(f));
@@ -750,7 +741,11 @@ class STLAB_NODISCARD() future<T, enable_if_copyable<T>> {
         return _p->_exception ? std::optional<std::exception_ptr>{_p->_exception} : std::nullopt;
     }
 
-    std::exception_ptr exception() const& { return _p->_exception; }
+    // Precondition: is_ready()
+    std::exception_ptr exception() const& {
+        assert(is_ready());
+        return _p->_exception;
+    }
 };
 
 /**************************************************************************************************/
@@ -897,7 +892,11 @@ class STLAB_NODISCARD() future<void, void> {
         return _p->_exception ? std::optional<std::exception_ptr>{_p->_exception} : std::nullopt;
     }
 
-    std::exception_ptr exception() const& { return _p->_exception; }
+    // Precondition: is_ready()
+    std::exception_ptr exception() const& {
+        assert(is_ready());
+        return _p->_exception;
+    }
 };
 
 /**************************************************************************************************/
@@ -1001,7 +1000,11 @@ class STLAB_NODISCARD() future<T, enable_if_not_copyable<T>> {
         return _p->_exception ? std::optional<std::exception_ptr>{_p->_exception} : std::nullopt;
     }
 
-    std::exception_ptr exception() const& { return _p->_exception; }
+    // Precondition: is_ready()
+    std::exception_ptr exception() const& {
+        assert(is_ready());
+        return _p->_exception;
+    }
 };
 
 template <typename Sig, typename E, typename F>
@@ -1233,7 +1236,7 @@ template <typename E, typename F, typename... Ts>
 auto when_all(E executor, F f, future<Ts>... args) {
     using vt_t = voidless_tuple<Ts...>;
     using opt_t = optional_placeholder_tuple<Ts...>;
-    using result_t = decltype(detail::apply_tuple(std::declval<F>(), std::declval<vt_t>()));
+    using result_t = decltype(apply_ignore_placeholders(std::declval<F>(), std::declval<vt_t>()));
 
     auto shared = std::make_shared<detail::when_all_shared<F, opt_t>>();
     auto p = package<result_t()>(
@@ -1816,10 +1819,7 @@ auto shared_base<void>::recover(future<result_type>&& p, E executor, F&& f) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/immediate_executor.hpp b/stlab/concurrency/immediate_executor.hpp
index 7c733dcc9..015b2d435 100644
--- a/stlab/concurrency/immediate_executor.hpp
+++ b/stlab/concurrency/immediate_executor.hpp
@@ -9,17 +9,17 @@
 #ifndef STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 #define STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 
+#include <stlab/config.hpp>
+
 #include <type_traits>
 
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 namespace detail {
 
 /**************************************************************************************************/
@@ -41,10 +41,7 @@ constexpr auto immediate_executor = detail::immediate_executor_type{};
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/main_executor.hpp b/stlab/concurrency/main_executor.hpp
index adc0b7bef..c7ad8d3d8 100644
--- a/stlab/concurrency/main_executor.hpp
+++ b/stlab/concurrency/main_executor.hpp
@@ -35,10 +35,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -170,8 +167,11 @@ struct main_executor_type {
 
 constexpr auto main_executor = detail::main_executor_type{};
 
-} // namespace v1
+/**************************************************************************************************/
 
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
+/**************************************************************************************************/
+
 #endif // STLAB_CONCURRENCY_MAIN_EXECUTOR_HPP
diff --git a/stlab/concurrency/ready_future.hpp b/stlab/concurrency/ready_future.hpp
index 4e637c1cb..f68a619ef 100644
--- a/stlab/concurrency/ready_future.hpp
+++ b/stlab/concurrency/ready_future.hpp
@@ -9,6 +9,8 @@
 #ifndef STLAB_CONCURRENCY_READY_FUTURE_HPP
 #define STLAB_CONCURRENCY_READY_FUTURE_HPP
 
+#include <stlab/config.hpp>
+
 #include <exception>
 #include <type_traits>
 #include <utility>
@@ -18,10 +20,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -72,10 +71,9 @@ future<T> make_exceptional_future(std::exception_ptr error, E executor) {
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
+} // namespace stlab
 
 /**************************************************************************************************/
 
-} // namespace stlab
-
 #endif // STLAB_CONCURRENCY_READY_FUTURE_HPP
diff --git a/stlab/concurrency/serial_queue.hpp b/stlab/concurrency/serial_queue.hpp
index 97ed65775..21d80cbaa 100644
--- a/stlab/concurrency/serial_queue.hpp
+++ b/stlab/concurrency/serial_queue.hpp
@@ -11,6 +11,8 @@
 
 /**************************************************************************************************/
 
+#include <stlab/config.hpp>
+
 #include <deque>
 #include <mutex>
 #include <tuple>
@@ -29,7 +31,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -164,7 +166,7 @@ class serial_queue_t {
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/system_timer.hpp b/stlab/concurrency/system_timer.hpp
index 467114695..60cf71f53 100755
--- a/stlab/concurrency/system_timer.hpp
+++ b/stlab/concurrency/system_timer.hpp
@@ -34,10 +34,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -58,8 +55,8 @@ 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<std::is_nothrow_invocable_v<F>> {
+    auto operator()(std::chrono::duration<Rep, Per> duration,
+                    F f) const -> std::enable_if_t<std::is_nothrow_invocable_v<F>> {
         using namespace std::chrono;
 
         using f_t = decltype(f);
@@ -110,8 +107,8 @@ 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<std::is_nothrow_invocable_v<F>> {
+    auto operator()(std::chrono::duration<Rep, Per> duration,
+                    F&& f) -> 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);
@@ -228,8 +225,8 @@ 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<std::is_nothrow_invocable_v<F>> {
+    auto operator()(std::chrono::duration<Rep, Per> duration,
+                    F&& f) -> 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());
@@ -272,10 +269,9 @@ struct system_timer_type {
 
 constexpr auto system_timer = detail::system_timer_type{};
 
-} // namespace v1
-
 /**************************************************************************************************/
 
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/task.hpp b/stlab/concurrency/task.hpp
index 93fafa0de..9cfff2ae7 100644
--- a/stlab/concurrency/task.hpp
+++ b/stlab/concurrency/task.hpp
@@ -23,10 +23,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -285,10 +282,7 @@ using task = typename noexcept_deducer<task_, F>::type;
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/concurrency/traits.hpp b/stlab/concurrency/traits.hpp
index 67159e701..1aed3d71a 100644
--- a/stlab/concurrency/traits.hpp
+++ b/stlab/concurrency/traits.hpp
@@ -9,17 +9,17 @@
 #ifndef STLAB_CONCURRENCY_TRAITS_HPP
 #define STLAB_CONCURRENCY_TRAITS_HPP
 
+#include <stlab/config.hpp>
+
 #include <type_traits>
 
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 template <bool...>
 struct bool_pack;
 template <bool... v>
@@ -27,10 +27,10 @@ using all_true = std::is_same<bool_pack<true, v...>, bool_pack<v..., true>>;
 
 /**************************************************************************************************/
 
-template<template<typename> class test, typename T>
+template <template <typename> class test, typename T>
 struct smart_test : test<T> {};
 
-template<typename T>
+template <typename T>
 using smart_is_copy_constructible = smart_test<std::is_copy_constructible, T>;
 
 template <typename T>
@@ -92,7 +92,7 @@ using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
 
 /**************************************************************************************************/
 
diff --git a/stlab/concurrency/tuple_algorithm.hpp b/stlab/concurrency/tuple_algorithm.hpp
index 327d42f44..c0afe8524 100644
--- a/stlab/concurrency/tuple_algorithm.hpp
+++ b/stlab/concurrency/tuple_algorithm.hpp
@@ -10,6 +10,8 @@
 #ifndef STLAB_CONCURRENCY_TUPLE_ALGORITHM_HPP
 #define STLAB_CONCURRENCY_TUPLE_ALGORITHM_HPP
 
+#include <stlab/config.hpp>
+
 // stdc++
 #include <optional>
 #include <tuple>
@@ -17,10 +19,12 @@
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
+class placeholder {};
+
 /**************************************************************************************************/
 
 namespace detail {
@@ -124,7 +128,8 @@ void tuple_for_each(T& t, Op op) {
  */
 template <typename T, typename F, typename D>
 auto get_i(T& t, std::size_t index, F f, D&& default_v) {
-    return detail::get_i_impl<0, std::tuple_size<T>::value>::go(t, index, std::move(f), std::forward<D>(default_v));
+    return detail::get_i_impl<0, std::tuple_size<T>::value>::go(t, index, std::move(f),
+                                                                std::forward<D>(default_v));
 }
 
 /*
@@ -153,17 +158,6 @@ constexpr decltype(auto) apply_optional_indexed_impl(F&& f, Tuple&& t, std::inde
 
 /**************************************************************************************************/
 
-template <class Seq, class F, class Tuple>
-constexpr decltype(auto) apply_indexed(F&& f, Tuple&& t) {
-    return detail::apply_impl(std::forward<F>(f), std::forward<Tuple>(t), Seq());
-}
-
-template <class F, class Tuple>
-constexpr decltype(auto) apply_tuple(F&& f, Tuple&& t) {
-    return detail::apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
-                              std::make_index_sequence<std::tuple_size<Tuple>::value>());
-}
-
 template <class Seq, class F, class Tuple>
 constexpr decltype(auto) apply_optional_indexed(F&& f, Tuple&& t) {
     return detail::apply_optional_indexed_impl(std::forward<F>(f), std::forward<Tuple>(t), Seq());
@@ -171,8 +165,6 @@ constexpr decltype(auto) apply_optional_indexed(F&& f, Tuple&& t) {
 
 /**************************************************************************************************/
 
-class placeholder {};
-
 template <class T, std::size_t N>
 struct map_placeholder {
     using type = std::index_sequence<N>;
@@ -188,14 +180,6 @@ struct map_placeholder<std::optional<placeholder>, N> {
     using type = std::index_sequence<>;
 };
 
-template <class Tuple>
-struct remove_placeholder {
-    template <std::size_t Index>
-    struct function {
-        using type = typename map_placeholder<std::tuple_element_t<Index, Tuple>, Index>::type;
-    };
-};
-
 /**************************************************************************************************/
 
 } // namespace detail
@@ -207,7 +191,7 @@ using tuple_cat_t = decltype(std::tuple_cat(std::declval<Ts>()...));
 
 /**************************************************************************************************/
 // type-function that takes a parameter pack and returns a std::tuple<Ts...>
-// where all T[i] = void have been removed.
+// where all T[i] == void have been removed.
 template <typename... Ts>
 using voidless_tuple = tuple_cat_t<typename std::conditional<std::is_same<void, Ts>::value,
                                                              std::tuple<>,
@@ -215,24 +199,49 @@ using voidless_tuple = tuple_cat_t<typename std::conditional<std::is_same<void,
 
 /**************************************************************************************************/
 // type-function that takes a parameter pack and returns a std::tuple<Ts...>
-// where all T[i] = void have been replaced with stlab::placeholder.
+// where all T[i] == void have been replaced with stlab::placeholder.
 template <typename... Ts>
-using placeholder_tuple = std::tuple<
-    typename std::conditional<std::is_same<void, Ts>::value, detail::placeholder, Ts>::type...>;
+using placeholder_tuple =
+    std::tuple<typename std::conditional<std::is_same<void, Ts>::value, placeholder, Ts>::type...>;
 
 /**************************************************************************************************/
-// type-function that takes a parameter pack and returns a std::tuple<Ts...>
-// where all T[i] = void have been replaced with stlab::placeholder.
+// type-function that takes a parameter pack and returns a std::tuple<std::optional<Ts>...>
+// where all T[i] == void have been replaced with stlab::placeholder.
 template <typename... Ts>
 using optional_placeholder_tuple = std::tuple<std::optional<
-    typename std::conditional<std::is_same<void, Ts>::value, detail::placeholder, Ts>::type>...>;
+    typename std::conditional<std::is_same<void, Ts>::value, placeholder, Ts>::type>...>;
+
+/**************************************************************************************************/
+// apply the tuple `t`as arguments to the function `f`. Placeholders are ignored.
+template <class F, class Tuple>
+constexpr decltype(auto) apply_ignore_placeholders(F&& f, Tuple&& t) {
+    return detail::apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
+                              std::make_index_sequence<std::tuple_size<Tuple>::value>());
+}
 
 /**************************************************************************************************/
+// remove_placeholder::function<Index>::type returns a std::index_sequence<Index> if the type at
+// Index is not a placeholder, otherwise it returns an empty std::index_sequence.
+template <class Tuple>
+struct remove_placeholder {
+    template <std::size_t Index>
+    struct function {
+        using type =
+            typename detail::map_placeholder<std::tuple_element_t<Index, Tuple>, Index>::type;
+    };
+};
 
-} // namespace v1
+/**************************************************************************************************/
+// apply_indexed applies the tuple `t` as arguments to the function `f` using the index sequence
+// `Seq` to select the arguments.
+template <class Seq, class F, class Tuple>
+constexpr decltype(auto) apply_indexed(F&& f, Tuple&& t) {
+    return detail::apply_impl(std::forward<F>(f), std::forward<Tuple>(t), Seq());
+}
 
 /**************************************************************************************************/
 
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/config.hpp.in b/stlab/config.hpp.in
index 5b4b85a3d..09b398432 100644
--- a/stlab/config.hpp.in
+++ b/stlab/config.hpp.in
@@ -7,6 +7,9 @@
 #ifndef STLAB_CONFIG_HPP
 #define STLAB_CONFIG_HPP
 
+// Release version macro - used for inline namespace increment on each release
+#define STLAB_VERSION_NAMESPACE() v2
+
 // Configuration generated from CMake
 
 #cmakedefine STLAB_NO_STD_COROUTINES
@@ -42,44 +45,43 @@
 
 #if __APPLE__
 
-    #if defined(__has_feature)
-        #if __has_feature(objc_arc)
-            #undef STLAB_FEATURE_PRIVATE_OBJC_ARC
-            #define STLAB_FEATURE_PRIVATE_OBJC_ARC() 1
-        #endif
-    #endif
-
+#if defined(__has_feature)
+#if __has_feature(objc_arc)
+#undef STLAB_FEATURE_PRIVATE_OBJC_ARC
+#define STLAB_FEATURE_PRIVATE_OBJC_ARC() 1
+#endif
+#endif
 
 #elif _MSC_VER
 
-    #if _MSVC_LANG == 201103L
-        #define STLAB_CPP_VERSION_PRIVATE() 11
-    #elif _MSVC_LANG == 201402L
-        #define STLAB_CPP_VERSION_PRIVATE() 14
-    #elif _MSC_FULL_VER >= 191225830 && _MSVC_LANG == 201703L
-        #define STLAB_CPP_VERSION_PRIVATE() 17
-    #elif _MSVC_LANG == 202002L
-        #define STLAB_CPP_VERSION_PRIVATE() 20
-    #else
-        #pragma message("Unknown version of C++, assuming C++20.")
-        #define STLAB_CPP_VERSION_PRIVATE() 20
-    #endif
+#if _MSVC_LANG == 201103L
+#define STLAB_CPP_VERSION_PRIVATE() 11
+#elif _MSVC_LANG == 201402L
+#define STLAB_CPP_VERSION_PRIVATE() 14
+#elif _MSC_FULL_VER >= 191225830 && _MSVC_LANG == 201703L
+#define STLAB_CPP_VERSION_PRIVATE() 17
+#elif _MSVC_LANG == 202002L
+#define STLAB_CPP_VERSION_PRIVATE() 20
+#else
+#pragma message("Unknown version of C++, assuming C++20.")
+#define STLAB_CPP_VERSION_PRIVATE() 20
+#endif
 
 #endif
 
 #if !defined(STLAB_CPP_VERSION_PRIVATE)
-    #if __cplusplus == 201103L
-        #define STLAB_CPP_VERSION_PRIVATE() 11
-    #elif __cplusplus == 201402L
-        #define STLAB_CPP_VERSION_PRIVATE() 14
-    #elif __cplusplus == 201703L
-        #define STLAB_CPP_VERSION_PRIVATE() 17
-    #elif __cplusplus == 202002L
-        #define STLAB_CPP_VERSION_PRIVATE() 20
-    #else
-        //#warning Unknown version of C++, assuming C++23.
-        #define STLAB_CPP_VERSION_PRIVATE() 23
-    #endif
+#if __cplusplus == 201103L
+#define STLAB_CPP_VERSION_PRIVATE() 11
+#elif __cplusplus == 201402L
+#define STLAB_CPP_VERSION_PRIVATE() 14
+#elif __cplusplus == 201703L
+#define STLAB_CPP_VERSION_PRIVATE() 17
+#elif __cplusplus == 202002L
+#define STLAB_CPP_VERSION_PRIVATE() 20
+#else
+// #warning Unknown version of C++, assuming C++23.
+#define STLAB_CPP_VERSION_PRIVATE() 23
+#endif
 #endif
 
 // STLAB_NODISCARD macro
diff --git a/stlab/functional.hpp b/stlab/functional.hpp
index 778574286..c7999c9f9 100755
--- a/stlab/functional.hpp
+++ b/stlab/functional.hpp
@@ -11,18 +11,18 @@
 
 /**************************************************************************************************/
 
+#include <stlab/config.hpp>
+
 #include <functional>
 #include <type_traits>
 
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 template <class T>
 struct unwrap_reference {
     using type = T;
@@ -70,10 +70,7 @@ const T& unwrap(const std::reference_wrapper<T>& val) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/memory.hpp b/stlab/memory.hpp
index b8e02d9e1..f0a9ed60b 100644
--- a/stlab/memory.hpp
+++ b/stlab/memory.hpp
@@ -12,16 +12,15 @@
 /**************************************************************************************************/
 
 #include <memory>
+#include <stlab/config.hpp>
 
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 template <typename T>
 auto make_weak_ptr(const std::shared_ptr<T>& x) {
     return std::weak_ptr<T>(x);
@@ -29,10 +28,7 @@ auto make_weak_ptr(const std::shared_ptr<T>& x) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/pre_exit.hpp b/stlab/pre_exit.hpp
index bdb9ac414..6fbc1c29a 100644
--- a/stlab/pre_exit.hpp
+++ b/stlab/pre_exit.hpp
@@ -16,9 +16,13 @@
 
 /**************************************************************************************************/
 
+// The namespace for pre_exit cannot be changed without an ABI break. If making an ABI breaking
+// change in this file it needs to be done in a way supporting this version as well.
 namespace stlab {
 inline namespace v1 {
 
+/**************************************************************************************************/
+
 /// Pre-exit handler type.
 #if __cpp_noexcept_function_type >= 201510L
 using pre_exit_handler = void (*)() noexcept;
@@ -85,6 +89,8 @@ inline void pre_exit() {
 /// is required to be `noexcept`.
 inline void at_pre_exit(pre_exit_handler f) { detail::_pre_exit_stack().push(f); }
 
+/**************************************************************************************************/
+
 } // namespace v1
 } // namespace stlab
 
diff --git a/stlab/scope.hpp b/stlab/scope.hpp
index 1580cf69a..1d33b0c0c 100644
--- a/stlab/scope.hpp
+++ b/stlab/scope.hpp
@@ -11,6 +11,8 @@
 
 /**************************************************************************************************/
 
+#include <stlab/config.hpp>
+
 #include <mutex>
 #include <tuple>
 #include <utility>
@@ -18,12 +20,10 @@
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 namespace detail {
 
 template <typename T, typename Tuple, size_t... S>
@@ -55,10 +55,7 @@ inline auto scope(std::mutex& m, F&& f) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/test/model.hpp b/stlab/test/model.hpp
index 21a5aaaa4..21e9eb0b8 100644
--- a/stlab/test/model.hpp
+++ b/stlab/test/model.hpp
@@ -11,6 +11,8 @@
 
 /**************************************************************************************************/
 
+#include <stlab/config.hpp>
+
 #include <atomic>
 #include <condition_variable>
 #include <iostream>
@@ -19,7 +21,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -161,7 +163,7 @@ class move_only {
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/stlab/utility.hpp b/stlab/utility.hpp
index e25703a5b..714d48c6c 100644
--- a/stlab/utility.hpp
+++ b/stlab/utility.hpp
@@ -11,18 +11,18 @@
 
 /**************************************************************************************************/
 
+#include <stlab/config.hpp>
+
 #include <array>
 #include <type_traits>
 
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 namespace detail {
 
 /**************************************************************************************************/
@@ -126,10 +126,7 @@ constexpr std::decay_t<T> copy(T&& value) noexcept(noexcept(std::decay_t<T>{
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/
diff --git a/test/executor_test.cpp b/test/executor_test.cpp
index 8e0bc8885..0af8273a4 100644
--- a/test/executor_test.cpp
+++ b/test/executor_test.cpp
@@ -79,7 +79,7 @@ BOOST_AUTO_TEST_CASE(all_low_prio_tasks_are_executed) {
             results.push_back(_i);
         });
     }
-    queue.executor()([&done] () noexcept { 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] () noexcept {
+        queue.executor()([_i = i, &m, &results]() noexcept {
             unique_lock<mutex> block{m};
             results.push_back(_i);
         });
     }
-    queue.executor()([&done] () noexcept { 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] () noexcept {
+        queue.executor()([_i = i, &m, &results]() noexcept {
             unique_lock<mutex> block{m};
             results.push_back(_i);
         });
     }
-    queue.executor()([&done] () noexcept { 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([&] () noexcept {
+    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([&] () noexcept {
+    default_executor([&]() noexcept {
         rest();
         {
             unique_lock<mutex> block{m};
@@ -199,7 +199,9 @@ atomic_int correctLow{0};
 atomic_int correctDefault{0};
 atomic_int correctHigh{0};
 
-template <stlab::detail::executor_priority P>
+enum class executor_priority { high, medium, low };
+
+template <executor_priority P>
 struct check_task {
     atomic_int& _correctScheduleCount;
     atomic_int& _currentPrioCount;
@@ -209,20 +211,18 @@ struct check_task {
         ++_currentPrioCount;
     }
 
-    template <stlab::detail::executor_priority Q>
-    auto schedule_increment() -> std::enable_if_t<Q == stlab::detail::executor_priority::low, int> {
+    template <executor_priority Q>
+    auto schedule_increment() -> std::enable_if_t<Q == executor_priority::low, int> {
         return static_cast<int>(highCount <= taskRunning && defaultCount <= taskRunning);
     }
 
-    template <stlab::detail::executor_priority Q>
-    auto schedule_increment()
-        -> std::enable_if_t<Q == stlab::detail::executor_priority::medium, int> {
+    template <executor_priority Q>
+    auto schedule_increment() -> std::enable_if_t<Q == executor_priority::medium, int> {
         return static_cast<int>(highCount <= taskRunning);
     }
 
-    template <stlab::detail::executor_priority Q>
-    auto schedule_increment()
-        -> std::enable_if_t<Q == stlab::detail::executor_priority::high, int> {
+    template <executor_priority Q>
+    auto schedule_increment() -> std::enable_if_t<Q == executor_priority::high, int> {
         return 0;
     }
 
@@ -237,18 +237,16 @@ struct check_task {
 
         switch (workToDo % 3) {
             case 0:
-                default_executor(check_task<stlab::detail::executor_priority::medium>{
-                    correctDefault, defaultCount});
+                default_executor(
+                    check_task<executor_priority::medium>{correctDefault, defaultCount});
                 break;
 
             case 1:
-                high_executor(
-                    check_task<stlab::detail::executor_priority::high>{correctHigh, highCount});
+                high_executor(check_task<executor_priority::high>{correctHigh, highCount});
                 break;
 
             case 2:
-                low_executor(
-                    check_task<stlab::detail::executor_priority::low>{correctLow, lowCount});
+                low_executor(check_task<executor_priority::low>{correctLow, lowCount});
                 break;
         }
         --workToDo;
@@ -265,10 +263,9 @@ BOOST_AUTO_TEST_CASE(all_tasks_will_be_executed_according_to_their_prio) {
     auto start = chrono::high_resolution_clock::now();
 
     for (auto i = 0; i < startCount; ++i) {
-        low_executor(check_task<stlab::detail::executor_priority::low>{correctLow, lowCount});
-        high_executor(check_task<stlab::detail::executor_priority::high>{correctHigh, highCount});
-        default_executor(
-            check_task<stlab::detail::executor_priority::medium>{correctDefault, defaultCount});
+        low_executor(check_task<executor_priority::low>{correctLow, lowCount});
+        high_executor(check_task<executor_priority::high>{correctHigh, highCount});
+        default_executor(check_task<executor_priority::medium>{correctDefault, defaultCount});
     }
     while (done < expectedWork) {
         rest();
@@ -278,7 +275,8 @@ BOOST_AUTO_TEST_CASE(all_tasks_will_be_executed_according_to_their_prio) {
     std::cout << "\nPerformance measuring: " << std::chrono::duration<double>(stop - start).count()
               << "s\n";
 
-    // REVISIT (sean-parent) - I don't believe that this is measuring the probability of a task executing in order.stl
+    // REVISIT (sean-parent) - I don't believe that this is measuring the probability of a task
+    // executing in order.stl
     cout << "Correct low ordering:     "
          << static_cast<double>(correctLow.load()) / iterations * 100.0 << "%\n";
     cout << "Correct default ordering: "
@@ -298,17 +296,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] () noexcept  {
+        low_executor([_i = i, &results, &counter]() noexcept {
             results[_i] = 1;
             fibonacci<mpre::cpp_int>(fiboN);
             ++counter;
         });
-        default_executor([_i = i + iterations, &results, &counter] () noexcept {
+        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] () noexcept  {
+        high_executor([_i = i + iterations * 2, &results, &counter]() noexcept {
             results[_i] = 3;
             fibonacci<mpre::cpp_int>(fiboN);
             ++counter;
@@ -316,7 +314,7 @@ BOOST_AUTO_TEST_CASE(MeasureTiming) {
     }
 
     mutex block;
-    low_executor([&] () noexcept  {
+    low_executor([&]() noexcept {
         {
             unique_lock<mutex> lock{block};
             done = true;
@@ -336,5 +334,4 @@ BOOST_AUTO_TEST_CASE(MeasureTiming) {
     auto stop = std::chrono::high_resolution_clock::now();
     std::cout << "\nPerformance measuring: " << std::chrono::duration<double>(stop - start).count()
               << "s\n";
-
 }
diff --git a/test/future_recover_tests.cpp b/test/future_recover_tests.cpp
index bd3b94ff0..6b5104778 100644
--- a/test/future_recover_tests.cpp
+++ b/test/future_recover_tests.cpp
@@ -960,9 +960,9 @@ BOOST_AUTO_TEST_CASE(
                 return move_only(42);
             });
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
     }
     {
@@ -979,9 +979,9 @@ BOOST_AUTO_TEST_CASE(
             return move_only(42);
         };
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
     }
 }
@@ -1008,9 +1008,9 @@ BOOST_AUTO_TEST_CASE(future_recover_move_only_types_recover_failure_after_recove
                 });
         }
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
     }
     {
@@ -1032,9 +1032,9 @@ BOOST_AUTO_TEST_CASE(future_recover_move_only_types_recover_failure_after_recove
             };
         }
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
     }
 }
@@ -1057,9 +1057,9 @@ BOOST_AUTO_TEST_CASE(
                 return move_only(42);
             });
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_GE(1, custom_scheduler<1>::usage_counter());
@@ -1081,9 +1081,9 @@ BOOST_AUTO_TEST_CASE(
                 return move_only(42);
             });
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_GE(1, custom_scheduler<1>::usage_counter());
@@ -1112,9 +1112,9 @@ BOOST_AUTO_TEST_CASE(
                 });
         }
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_GE(1, custom_scheduler<1>::usage_counter());
@@ -1140,9 +1140,9 @@ BOOST_AUTO_TEST_CASE(
                 });
         }
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE(error);
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_GE(1, custom_scheduler<1>::usage_counter());
diff --git a/test/future_test_helper.hpp b/test/future_test_helper.hpp
index 2a2b1179f..aa42001b6 100644
--- a/test/future_test_helper.hpp
+++ b/test/future_test_helper.hpp
@@ -9,6 +9,7 @@
 #ifndef FUTURE_TEST_HELPER_HPP_
 #define FUTURE_TEST_HELPER_HPP_
 
+#include <stlab/concurrency/await.hpp>
 #include <stlab/concurrency/default_executor.hpp>
 #include <stlab/concurrency/future.hpp>
 
@@ -30,15 +31,7 @@ struct custom_scheduler {
 
     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
-#if defined(WIN32) || defined(__APPLE__)
         stlab::default_executor(std::move(f));
-#else
-        // The default scheduler under Linux allows only as many tasks as there are physical cores.
-        // But this can lead to a dead lock in some of the tests
-        std::thread(std::move(f)).detach();
-#endif
     }
 
     static int usage_counter() { return counter().load(); }
@@ -100,31 +93,17 @@ struct test_fixture {
     stlab::future<T> sut;
 
     template <typename... F>
-    void wait_until_future_completed(F&... f) {
-        (void)std::initializer_list<int>{(wait_until_future_is_ready(f), 0)...};
-    }
-
-    template <typename F>
-    auto wait_until_future_r_completed(F& f) {
-        auto result = f.get_try();
-        while (!result) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-            result = f.get_try();
-        }
-        return result;
+    void wait_until_future_completed(F&&... f) {
+        (void)std::initializer_list<int>{(wait_until_future_is_ready(std::forward<F>(f)), 0)...};
     }
 
     void check_valid_future() {}
 
-    void check_valid_future(const stlab::future<T>& f) {
-        BOOST_REQUIRE(f.valid() == true);
-        BOOST_REQUIRE(!f.exception());
-    }
+    void check_valid_future(const stlab::future<T>& f) { BOOST_REQUIRE(f.valid() == true); }
 
     template <typename F, typename... FS>
     void check_valid_future(const F& f, const FS&... fs) {
         BOOST_REQUIRE(f.valid() == true);
-        BOOST_REQUIRE(!f.exception());
         check_valid_future(fs...);
     }
 
@@ -136,13 +115,15 @@ struct test_fixture {
     }
 
     template <typename E, typename... F>
-    void wait_until_future_fails(F&... f) {
-        (void)std::initializer_list<int>{(wait_until_this_future_fails<E>(f), 0)...};
+    void wait_until_future_fails(F&&... f) {
+        (void)std::initializer_list<int>{
+            (wait_until_this_future_fails<E>(std::forward<F>(f)), 0)...};
     }
 
     void wait_until_all_tasks_completed() {
         while (_task_counter.load() != 0) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            stlab::invoke_waiting(
+                [] { std::this_thread::sleep_for(std::chrono::milliseconds(1)); });
         }
     }
 
@@ -150,18 +131,14 @@ struct test_fixture {
 
 private:
     template <typename F>
-    void wait_until_future_is_ready(F& f) {
-        while (!f.get_try()) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        }
+    void wait_until_future_is_ready(F&& f) {
+        (void)stlab::await(std::forward<F>(f));
     }
 
     template <typename E, typename F>
-    void wait_until_this_future_fails(F& f) {
+    void wait_until_this_future_fails(F&& f) {
         try {
-            while (!f.get_try()) {
-                std::this_thread::sleep_for(std::chrono::milliseconds(1));
-            }
+            (void)stlab::await(std::forward<F>(f));
         } catch (const E&) {
         }
     }
diff --git a/test/future_tests.cpp b/test/future_tests.cpp
index 50411a472..30dd39ca1 100644
--- a/test/future_tests.cpp
+++ b/test/future_tests.cpp
@@ -230,7 +230,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(future_constructed_minimal_fn, T, copyable_test_ty
     {
         auto sut = async(make_executor<0>(), []() -> T { return T(0); });
         BOOST_REQUIRE(sut.valid() == true);
-        BOOST_REQUIRE(!sut.exception());
 
         sut.reset();
         BOOST_REQUIRE(sut.valid() == false);
@@ -249,12 +248,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(future_constructed_minimal_fn_with_parameters,
     {
         auto sut = async(make_executor<0>(), [](auto x) -> T { return x + T(0); }, T(42));
         BOOST_REQUIRE(sut.valid() == true);
-        BOOST_REQUIRE(!sut.exception());
 
         while (!sut.get_try()) {
             std::this_thread::sleep_for(std::chrono::milliseconds(1));
         }
 
+        BOOST_REQUIRE(!sut.exception());
         BOOST_WARN_EQUAL(T(42) + T(0), *sut.get_try());
     }
     BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
@@ -265,14 +264,14 @@ BOOST_AUTO_TEST_CASE(future_constructed_minimal_fn_moveonly) {
 
     test_setup setup;
     {
-        auto sut = async(make_executor<0>(), []() -> v1::move_only { return v1::move_only{42}; });
+        auto sut = async(make_executor<0>(), []() -> stlab::move_only { return stlab::move_only{42}; });
         BOOST_REQUIRE(sut.valid() == true);
-        BOOST_REQUIRE(!sut.exception());
 
         while (!sut.get_try()) {
             std::this_thread::sleep_for(std::chrono::milliseconds(1));
         }
 
+        BOOST_REQUIRE(!sut.exception());
         BOOST_REQUIRE_EQUAL(42, sut.get_try()->member());
     }
     BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
diff --git a/test/future_then_tests.cpp b/test/future_then_tests.cpp
index 7c987d778..88df30b7b 100755
--- a/test/future_then_tests.cpp
+++ b/test/future_then_tests.cpp
@@ -27,7 +27,7 @@ BOOST_AUTO_TEST_CASE(future_void_single_task) {
 
     int p = 0;
 
-    sut = async(make_executor<0>(), [& _p = p] { _p = 42; });
+    sut = async(make_executor<0>(), [&_p = p] { _p = 42; });
 
     check_valid_future(sut);
     wait_until_future_completed(sut);
@@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE(future_void_single_task_detached) {
 
     atomic_int p{0};
     {
-        auto detached = async(make_executor<0>(), [& _p = p] { _p = 42; });
+        auto detached = async(make_executor<0>(), [&_p = p] { _p = 42; });
         detached.detach();
     }
     while (p.load() != 42) {
@@ -63,7 +63,7 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_with_same_scheduler_then_on_rvalue) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }).then([& _p = p] { _p += 42; });
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }).then([&_p = p] { _p += 42; });
 
         check_valid_future(sut);
         wait_until_future_completed(sut);
@@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_with_same_scheduler_then_on_rvalue) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }) | [& _p = p] { _p += 42; };
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }) | [&_p = p] { _p += 42; };
 
         check_valid_future(sut);
         wait_until_future_completed(sut);
@@ -89,9 +89,9 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_with_same_scheduler_then_on_lvalue) {
 
     {
         atomic_int p{0};
-        auto interim = async(make_executor<0>(), [& _p = p] { _p = 42; });
+        auto interim = async(make_executor<0>(), [&_p = p] { _p = 42; });
 
-        sut = interim.then([& _p = p] { _p += 42; });
+        sut = interim.then([&_p = p] { _p += 42; });
 
         check_valid_future(sut);
         wait_until_future_completed(sut);
@@ -101,9 +101,9 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_with_same_scheduler_then_on_lvalue) {
     }
     {
         atomic_int p{0};
-        auto interim = async(make_executor<0>(), [& _p = p] { _p = 42; });
+        auto interim = async(make_executor<0>(), [&_p = p] { _p = 42; });
 
-        sut = interim | [& _p = p] { _p += 42; };
+        sut = interim | [&_p = p] { _p += 42; };
 
         check_valid_future(sut);
         wait_until_future_completed(sut);
@@ -119,8 +119,7 @@ BOOST_AUTO_TEST_CASE(future_int_void_two_tasks_with_same_scheduler) {
     {
         atomic_int p{0};
 
-        sut =
-            async(make_executor<0>(), [] { return 42; }).then([& _p = p](auto x) { _p = x + 42; });
+        sut = async(make_executor<0>(), [] { return 42; }).then([&_p = p](auto x) { _p = x + 42; });
         check_valid_future(sut);
 
         wait_until_future_completed(sut);
@@ -131,7 +130,7 @@ BOOST_AUTO_TEST_CASE(future_int_void_two_tasks_with_same_scheduler) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [] { return 42; }) | [& _p = p](auto x) { _p = x + 42; };
+        sut = async(make_executor<0>(), [] { return 42; }) | [&_p = p](auto x) { _p = x + 42; };
         check_valid_future(sut);
 
         wait_until_future_completed(sut);
@@ -149,7 +148,7 @@ BOOST_AUTO_TEST_CASE(future_int_void_two_tasks_with_different_scheduler) {
 
         sut = async(make_executor<0>(), [] {
                   return 42;
-              }).then(make_executor<1>(), [& _p = p](auto x) { _p = x + 42; });
+              }).then(make_executor<1>(), [&_p = p](auto x) { _p = x + 42; });
         check_valid_future(sut);
 
         wait_until_future_completed(sut);
@@ -162,7 +161,7 @@ BOOST_AUTO_TEST_CASE(future_int_void_two_tasks_with_different_scheduler) {
         atomic_int p{0};
 
         sut = async(make_executor<0>(), [] { return 42; }) |
-              (executor{make_executor<1>()} & [& _p = p](auto x) { _p = x + 42; });
+              (executor{make_executor<1>()} & [&_p = p](auto x) { _p = x + 42; });
 
         check_valid_future(sut);
 
@@ -180,9 +179,9 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_with_different_scheduler) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] {
-                  _p = 42;
-              }).then(make_executor<1>(), [& _p = p] { _p += 42; });
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }).then(make_executor<1>(), [&_p = p] {
+            _p += 42;
+        });
         check_valid_future(sut);
 
         wait_until_future_completed(sut);
@@ -198,8 +197,8 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_with_different_scheduler) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }) |
-              (executor{make_executor<1>()} & [& _p = p] { _p += 42; });
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }) |
+              (executor{make_executor<1>()} & [&_p = p] { _p += 42; });
 
         check_valid_future(sut);
 
@@ -226,9 +225,9 @@ BOOST_AUTO_TEST_CASE(future_void_Y_formation_tasks_with_same_scheduler) {
         int r1 = 0;
         int r2 = 0;
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; });
-        auto f1 = sut.then([& _p = p, &_r = r1] { _r = 42 + _p; });
-        auto f2 = sut.then([& _p = p, &_r = r2] { _r = 4711 + _p; });
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; });
+        auto f1 = sut.then([&_p = p, &_r = r1] { _r = 42 + _p; });
+        auto f2 = sut.then([&_p = p, &_r = r2] { _r = 4711 + _p; });
 
         check_valid_future(sut, f1, f2);
         wait_until_future_completed(f1, f2);
@@ -242,9 +241,9 @@ BOOST_AUTO_TEST_CASE(future_void_Y_formation_tasks_with_same_scheduler) {
         int r1 = 0;
         int r2 = 0;
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; });
-        auto f1 = sut | [& _p = p, &_r = r1] { _r = 42 + _p; };
-        auto f2 = sut | [& _p = p, &_r = r2] { _r = 4711 + _p; };
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; });
+        auto f1 = sut | [&_p = p, &_r = r1] { _r = 42 + _p; };
+        auto f2 = sut | [&_p = p, &_r = r2] { _r = 4711 + _p; };
 
         check_valid_future(sut, f1, f2);
         wait_until_future_completed(f1, f2);
@@ -293,10 +292,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_int_to_void) {
         atomic_bool second{false};
         atomic_int result{0};
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return 42;
-              }).then([& _flag = second, &_result = result](auto x) {
+              }).then([&_flag = second, &_result = result](auto x) {
             return async(
                 default_executor,
                 [&_flag, &_result](auto x) {
@@ -318,11 +317,11 @@ BOOST_AUTO_TEST_CASE(reduction_future_int_to_void) {
         atomic_int result{0};
 
         sut = async(default_executor,
-                    [& _flag = first] {
+                    [&_flag = first] {
                         _flag = true;
                         return 42;
                     }) |
-              [& _flag = second, &_result = result](auto x) {
+              [&_flag = second, &_result = result](auto x) {
                   return async(
                       default_executor,
                       [&_flag, &_result](auto x) {
@@ -346,10 +345,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_void) {
         atomic_bool first{false};
         move_only result;
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _result = result](auto&& x) {
+              }).then([&_result = result](auto&& x) {
             return async(
                 default_executor, [&_result](auto&& x) { _result = std::move(x); },
                 std::forward<move_only>(x));
@@ -364,10 +363,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_void) {
         bool first{false};
         move_only result;
 
-        sut = async(immediate_executor, [& _flag = first] {
+        sut = async(immediate_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _result = result](auto&& x) {
+              }).then([&_result = result](auto&& x) {
             return async(
                 immediate_executor, [&_result](auto&& x) { _result = std::move(x); },
                 std::forward<move_only>(x));
@@ -389,9 +388,9 @@ BOOST_AUTO_TEST_CASE(future_non_copyable_single_task) {
     sut = async(make_executor<0>(), [] { return move_only(42); });
 
     check_valid_future(sut);
-    auto result = wait_until_future_r_completed(sut);
+    auto result = await(std::move(sut));
 
-    BOOST_REQUIRE_EQUAL(42, result->member());
+    BOOST_REQUIRE_EQUAL(42, result.member());
     BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
 }
 
@@ -399,7 +398,7 @@ BOOST_AUTO_TEST_CASE(future_then_non_copyable_detach) {
     BOOST_TEST_MESSAGE("running future non copyable, detached");
     atomic_bool check{false};
     {
-        async(make_executor<0>(), [& _check = check] {
+        async(make_executor<0>(), [&_check = check] {
             _check = true;
             return move_only(42);
         }).detach();
@@ -414,12 +413,12 @@ BOOST_AUTO_TEST_CASE(future_non_copyable_capture) {
 
     move_only m{42};
 
-    sut = async(make_executor<0>(), [& _m = m] { return move_only(_m.member()); });
+    sut = async(make_executor<0>(), [&_m = m] { return move_only(_m.member()); });
 
     check_valid_future(sut);
-    auto result = wait_until_future_r_completed(sut);
+    auto result = await(std::move(sut));
 
-    BOOST_REQUIRE_EQUAL(42, result->member());
+    BOOST_REQUIRE_EQUAL(42, result.member());
     BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
 }
 
@@ -433,18 +432,18 @@ BOOST_AUTO_TEST_CASE(
             async(make_executor<0>(), [] { return 42; }).then([](auto x) { return move_only(x); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
     {
         sut = async(make_executor<0>(), [] { return 42; }) | [](auto x) { return move_only(x); };
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
 }
@@ -460,9 +459,9 @@ BOOST_AUTO_TEST_CASE(
         });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<1>::usage_counter());
     }
@@ -475,9 +474,9 @@ BOOST_AUTO_TEST_CASE(
               (executor{make_executor<1>()} & [](auto x) { return move_only(x); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<1>::usage_counter());
     }
@@ -494,9 +493,9 @@ BOOST_AUTO_TEST_CASE(
         sut = interim.then([](auto x) { return move_only(x); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
     {
@@ -505,9 +504,9 @@ BOOST_AUTO_TEST_CASE(
         sut = interim | [](auto x) { return move_only(x); };
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
 }
@@ -522,9 +521,9 @@ BOOST_AUTO_TEST_CASE(
         sut = interim.then(make_executor<1>(), [](auto x) { return move_only(x); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<1>::usage_counter());
     }
@@ -536,9 +535,9 @@ BOOST_AUTO_TEST_CASE(
         sut = interim | (executor{make_executor<1>()} & [](auto x) { return move_only(x); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<1>::usage_counter());
     }
@@ -554,9 +553,9 @@ BOOST_AUTO_TEST_CASE(future_non_copyable_as_continuation_with_same_scheduler_the
         });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42 * 2, result->member());
+        BOOST_REQUIRE_EQUAL(42 * 2, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
     {
@@ -564,9 +563,9 @@ BOOST_AUTO_TEST_CASE(future_non_copyable_as_continuation_with_same_scheduler_the
               [](auto&& x) { return move_only(x.member() * 2); };
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42 * 2, result->member());
+        BOOST_REQUIRE_EQUAL(42 * 2, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
 }
@@ -580,9 +579,9 @@ BOOST_AUTO_TEST_CASE(future_non_copyable_as_continuation_with_different_schedule
               }).then(make_executor<1>(), [](auto x) { return move_only(x.member() * 2); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42 * 2, result->member());
+        BOOST_REQUIRE_EQUAL(42 * 2, result.member());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<1>::usage_counter());
     }
@@ -595,9 +594,9 @@ BOOST_AUTO_TEST_CASE(future_non_copyable_as_continuation_with_different_schedule
               (executor{make_executor<1>()} & [](auto x) { return move_only(x.member() * 2); });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42 * 2, result->member());
+        BOOST_REQUIRE_EQUAL(42 * 2, result.member());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<0>::usage_counter());
         BOOST_REQUIRE_EQUAL(1, custom_scheduler<1>::usage_counter());
     }
@@ -611,24 +610,22 @@ BOOST_AUTO_TEST_CASE(future_async_move_only_move_captured_to_result) {
     BOOST_TEST_MESSAGE("running future move only move to result");
 
     {
-        sut = async(make_executor<0>(), [] { return move_only{42}; }).then([](auto x) {
-            return x;
-        });
+        sut =
+            async(make_executor<0>(), [] { return move_only{42}; }).then([](auto x) { return x; });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
     {
-        sut = async(make_executor<0>(), [] { return move_only{42}; }) |
-              [](auto x) { return x; };
+        sut = async(make_executor<0>(), [] { return move_only{42}; }) | [](auto x) { return x; };
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
 }
@@ -638,12 +635,12 @@ BOOST_AUTO_TEST_CASE(future_async_moving_move_only_capture_to_result) {
 
     move_only m{42};
 
-    sut = async(make_executor<0>(), [& _m = m] { return std::move(_m); });
+    sut = async(make_executor<0>(), [&_m = m] { return std::move(_m); });
 
     check_valid_future(sut);
-    auto result = wait_until_future_r_completed(sut);
+    auto result = await(std::move(sut));
 
-    BOOST_REQUIRE_EQUAL(42, result->member());
+    BOOST_REQUIRE_EQUAL(42, result.member());
     BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
 }
 
@@ -652,12 +649,12 @@ BOOST_AUTO_TEST_CASE(future_async_mutable_move_move_only_capture_to_result) {
 
     move_only m{42};
 
-    sut = async(make_executor<0>(), [& _m = m]() { return std::move(_m); });
+    sut = async(make_executor<0>(), [&_m = m]() { return std::move(_m); });
 
     check_valid_future(sut);
-    auto result = wait_until_future_r_completed(sut);
+    auto result = await(std::move(sut));
 
-    BOOST_REQUIRE_EQUAL(42, result->member());
+    BOOST_REQUIRE_EQUAL(42, result.member());
     BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
 }
 
@@ -666,14 +663,14 @@ BOOST_AUTO_TEST_CASE(future_continuation_moving_move_only_capture_to_result) {
 
     move_only m{42};
 
-    sut = async(make_executor<0>(), [] { return move_only{10}; }).then([& _m = m](auto) {
+    sut = async(make_executor<0>(), [] { return move_only{10}; }).then([&_m = m](auto) {
         return std::move(_m);
     });
 
     check_valid_future(sut);
-    auto result = wait_until_future_r_completed(sut);
+    auto result = await(std::move(sut));
 
-    BOOST_REQUIRE_EQUAL(42, result->member());
+    BOOST_REQUIRE_EQUAL(42, result.member());
     BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
 }
 
@@ -683,26 +680,26 @@ BOOST_AUTO_TEST_CASE(future_continuation_async_mutable_move_move_only_capture_to
     {
         move_only m{42};
 
-        sut = async(make_executor<0>(), []() {
-                  return move_only{10};
-              }).then([& _m = m](auto) { return std::move(_m); });
+        sut = async(make_executor<0>(), []() { return move_only{10}; }).then([&_m = m](auto) {
+            return std::move(_m);
+        });
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
     {
         move_only m{42};
 
         sut = async(make_executor<0>(), []() { return move_only{10}; }) |
-              [& _m = m](auto) { return std::move(_m); };
+              [&_m = m](auto) { return std::move(_m); };
 
         check_valid_future(sut);
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
-        BOOST_REQUIRE_EQUAL(42, result->member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
 }
@@ -713,10 +710,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _flag = second](auto&& x) {
+              }).then([&_flag = second](auto&& x) {
             return async(
                 default_executor,
                 [&_flag](auto&& x) {
@@ -726,20 +723,20 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only) {
                 std::forward<move_only>(x));
         });
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
         BOOST_REQUIRE(first);
         BOOST_REQUIRE(second);
-        BOOST_REQUIRE_EQUAL(42, (*result).member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
     }
     {
         bool first{false};
         bool second{false};
 
-        sut = async(immediate_executor, [& _flag = first] {
+        sut = async(immediate_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _flag = second](auto&& x) {
+              }).then([&_flag = second](auto&& x) {
             return async(
                 immediate_executor,
                 [&_flag](auto&& x) {
@@ -749,26 +746,24 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only) {
                 std::forward<move_only>(x));
         });
 
-        auto result = wait_until_future_r_completed(sut);
+        auto result = await(std::move(sut));
 
         BOOST_REQUIRE(first);
         BOOST_REQUIRE(second);
-        BOOST_REQUIRE_EQUAL(42, (*result).member());
+        BOOST_REQUIRE_EQUAL(42, result.member());
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
 
-
-namespace stlab
-{
+namespace stlab {
 
 // specializing std::vector, so that the framework can detect correctly
 // if std::vector<move_only> is copyable or only moveable
-template<template<typename> class test, typename T, typename A>
+template <template <typename> class test, typename T, typename A>
 struct smart_test<test, std::vector<T, A>> : test<T> {};
 
-}
+} // namespace stlab
 
 BOOST_FIXTURE_TEST_SUITE(future_then_move_only_container, test_fixture<std::vector<move_only>>)
 
@@ -777,12 +772,12 @@ BOOST_AUTO_TEST_CASE(future_continuation_async_move_only_container) {
 
     {
         sut = async(make_executor<0>(), []() {
-            std::vector<move_only> result;
-            result.emplace_back(10);
-            result.emplace_back(42);
+                  std::vector<move_only> result;
+                  result.emplace_back(10);
+                  result.emplace_back(42);
 
-            return result;
-        }).then([](auto x) {
+                  return result;
+              }).then([](auto x) {
             x.emplace_back(50);
             return x;
         });
@@ -797,16 +792,18 @@ BOOST_AUTO_TEST_CASE(future_continuation_async_move_only_container) {
         BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
     }
     {
-        sut = async(make_executor<0>(), []() {
-            std::vector<move_only> result;
-            result.emplace_back(10);
-            result.emplace_back(42);
+        sut = async(make_executor<0>(),
+                    []() {
+                        std::vector<move_only> result;
+                        result.emplace_back(10);
+                        result.emplace_back(42);
 
-            return result;
-        }) | [](auto x) {
-            x.emplace_back(50);
-            return x;
-        };
+                        return result;
+                    }) |
+              [](auto x) {
+                  x.emplace_back(50);
+                  return x;
+              };
 
         check_valid_future(sut);
         auto result = stlab::await(std::move(sut));
@@ -821,8 +818,6 @@ BOOST_AUTO_TEST_CASE(future_continuation_async_move_only_container) {
 
 BOOST_AUTO_TEST_SUITE_END()
 
-
-
 BOOST_FIXTURE_TEST_SUITE(future_then_int, test_fixture<int>)
 
 BOOST_AUTO_TEST_CASE(future_int_single_task) {
@@ -856,7 +851,7 @@ BOOST_AUTO_TEST_CASE(future_int_single_task_detached) {
     BOOST_TEST_MESSAGE("running future int single tasks, detached");
     atomic_bool check{false};
     {
-        auto detached = async(make_executor<0>(), [& _check = check] {
+        auto detached = async(make_executor<0>(), [&_check = check] {
             _check = true;
             return 42;
         });
@@ -938,7 +933,7 @@ BOOST_AUTO_TEST_CASE(future_void_int_two_tasks_with_same_scheduler) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }).then([& _p = p] {
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }).then([&_p = p] {
             _p += 42;
             return _p.load();
         });
@@ -952,7 +947,7 @@ BOOST_AUTO_TEST_CASE(future_void_int_two_tasks_with_same_scheduler) {
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }) | [& _p = p] {
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }) | [&_p = p] {
             _p += 42;
             return _p.load();
         };
@@ -970,7 +965,7 @@ BOOST_AUTO_TEST_CASE(future_void_int_two_tasks_with_different_scheduler) {
 
     atomic_int p{0};
 
-    sut = async(make_executor<0>(), [& _p = p] { _p = 42; }).then(make_executor<1>(), [& _p = p] {
+    sut = async(make_executor<0>(), [&_p = p] { _p = 42; }).then(make_executor<1>(), [&_p = p] {
         _p += 42;
         return _p.load();
     });
@@ -1057,7 +1052,7 @@ BOOST_AUTO_TEST_CASE(reduction_future_void_to_int) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] { _flag = true; }).then([& _flag = second] {
+        sut = async(default_executor, [&_flag = first] { _flag = true; }).then([&_flag = second] {
             return async(default_executor, [&_flag] {
                 _flag = true;
                 return 42;
@@ -1074,7 +1069,7 @@ BOOST_AUTO_TEST_CASE(reduction_future_void_to_int) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] { _flag = true; }) | [& _flag = second] {
+        sut = async(default_executor, [&_flag = first] { _flag = true; }) | [&_flag = second] {
             return async(default_executor, [&_flag] {
                 _flag = true;
                 return 42;
@@ -1096,10 +1091,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_int_to_int) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return 42;
-              }).then([& _flag = second](auto x) {
+              }).then([&_flag = second](auto x) {
             return async(
                 default_executor,
                 [&_flag](auto x) {
@@ -1120,11 +1115,11 @@ BOOST_AUTO_TEST_CASE(reduction_future_int_to_int) {
         atomic_bool second{false};
 
         sut = async(default_executor,
-                    [& _flag = first] {
+                    [&_flag = first] {
                         _flag = true;
                         return 42;
                     }) |
-              [& _flag = second](auto x) {
+              [&_flag = second](auto x) {
                   return async(
                       default_executor,
                       [&_flag](auto x) {
@@ -1165,7 +1160,7 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_error_in_1st_task_with_same_scheduler
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [] { throw test_exception("failure"); }).then([& _p = p] {
+        sut = async(make_executor<0>(), [] { throw test_exception("failure"); }).then([&_p = p] {
             _p = 42;
         });
 
@@ -1178,7 +1173,7 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_error_in_1st_task_with_same_scheduler
         atomic_int p{0};
 
         sut = async(make_executor<0>(), [] { throw test_exception("failure"); }) |
-              [& _p = p] { _p = 42; };
+              [&_p = p] { _p = 42; };
 
         wait_until_future_fails<test_exception>(sut);
         check_failure<test_exception>(sut, "failure");
@@ -1193,7 +1188,7 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_error_in_2nd_task_with_same_scheduler
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }).then([& _p = p] {
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }).then([&_p = p] {
             (void)_p;
             throw test_exception("failure");
         });
@@ -1207,7 +1202,7 @@ BOOST_AUTO_TEST_CASE(future_void_two_tasks_error_in_2nd_task_with_same_scheduler
     {
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }) | [& _p = p] {
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }) | [&_p = p] {
             (void)_p;
             throw test_exception("failure");
         };
@@ -1227,7 +1222,7 @@ BOOST_AUTO_TEST_CASE(reduction_future_void_to_void_error) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] { _flag = true; }).then([& _flag = second] {
+        sut = async(default_executor, [&_flag = first] { _flag = true; }).then([&_flag = second] {
             return async(default_executor, [&_flag] {
                 _flag = true;
                 throw test_exception("failure");
@@ -1243,7 +1238,7 @@ BOOST_AUTO_TEST_CASE(reduction_future_void_to_void_error) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] { _flag = true; }) | [& _flag = second] {
+        sut = async(default_executor, [&_flag = first] { _flag = true; }) | [&_flag = second] {
             return async(default_executor, [&_flag] {
                 _flag = true;
                 throw test_exception("failure");
@@ -1263,10 +1258,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_void_when_inner_future_fails)
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _check = second](auto&& x) {
+              }).then([&_check = second](auto&& x) {
             return async(
                 default_executor,
                 [&_check](auto&&) {
@@ -1285,10 +1280,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_void_when_inner_future_fails)
         bool first{false};
         bool second{false};
 
-        sut = async(immediate_executor, [& _flag = first] {
+        sut = async(immediate_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _check = second](auto&& x) {
+              }).then([&_check = second](auto&& x) {
             return async(
                 immediate_executor,
                 [&_check](auto&&) {
@@ -1328,7 +1323,7 @@ BOOST_AUTO_TEST_CASE(future_int_two_tasks_error_in_1st_task_with_same_scheduler)
 
         sut = async(make_executor<0>(), [] {
                   throw test_exception("failure");
-              }).then([& _p = p]() -> int {
+              }).then([&_p = p]() -> int {
             _p = 42;
             return _p;
         });
@@ -1344,7 +1339,7 @@ BOOST_AUTO_TEST_CASE(future_int_two_tasks_error_in_1st_task_with_same_scheduler)
         int p = 0;
 
         sut = async(make_executor<0>(), [] { throw test_exception("failure"); }) |
-              [& _p = p]() -> int {
+              [&_p = p]() -> int {
             _p = 42;
             return _p;
         };
@@ -1364,7 +1359,7 @@ BOOST_AUTO_TEST_CASE(future_int_two_tasks_error_in_2nd_task_with_same_scheduler)
         custom_scheduler<0>::reset();
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }).then([]() -> int {
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }).then([]() -> int {
             throw test_exception("failure");
         });
 
@@ -1378,7 +1373,7 @@ BOOST_AUTO_TEST_CASE(future_int_two_tasks_error_in_2nd_task_with_same_scheduler)
         custom_scheduler<0>::reset();
         atomic_int p{0};
 
-        sut = async(make_executor<0>(), [& _p = p] { _p = 42; }) |
+        sut = async(make_executor<0>(), [&_p = p] { _p = 42; }) |
               []() -> int { throw test_exception("failure"); };
 
         wait_until_future_fails<test_exception>(sut);
@@ -1395,11 +1390,11 @@ BOOST_AUTO_TEST_CASE(future_int_Y_formation_tasks_with_failing_1st_task) {
     atomic_int p{0};
 
     sut = async(make_executor<0>(), []() -> int { throw test_exception("failure"); });
-    auto f1 = sut.then(make_executor<0>(), [& _p = p](auto x) -> int {
+    auto f1 = sut.then(make_executor<0>(), [&_p = p](auto x) -> int {
         _p += 1;
         return x + 42;
     });
-    auto f2 = sut.then(make_executor<0>(), [& _p = p](auto x) -> int {
+    auto f2 = sut.then(make_executor<0>(), [&_p = p](auto x) -> int {
         _p += 1;
         return x + 4177;
     });
@@ -1446,9 +1441,9 @@ BOOST_AUTO_TEST_CASE(reduction_future_void_to_int_error) {
     atomic_bool first{false};
     atomic_bool second{false};
 
-    sut = async(default_executor, [& _flag = first] {
+    sut = async(default_executor, [&_flag = first] {
               _flag = true;
-          }).then([& _flag = second]() -> future<int> {
+          }).then([&_flag = second]() -> future<int> {
         (void)_flag;
         throw test_exception("failure");
     });
@@ -1466,10 +1461,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_int_to_int_error) {
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return 42;
-              }).then([& _flag = second](auto x) {
+              }).then([&_flag = second](auto x) {
             return async(
                 default_executor,
                 [&_flag](auto) -> int {
@@ -1489,11 +1484,11 @@ BOOST_AUTO_TEST_CASE(reduction_future_int_to_int_error) {
         atomic_bool second{false};
 
         sut = async(default_executor,
-                    [& _flag = first] {
+                    [&_flag = first] {
                         _flag = true;
                         return 42;
                     }) |
-              [& _flag = second](auto x) {
+              [&_flag = second](auto x) {
                   return async(
                       default_executor,
                       [&_flag](auto) -> int {
@@ -1520,10 +1515,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only_when_inner_future_f
         atomic_bool first{false};
         atomic_bool second{false};
 
-        sut = async(default_executor, [& _flag = first] {
+        sut = async(default_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _flag = second](auto&& x) {
+              }).then([&_flag = second](auto&& x) {
             return async(
                 default_executor,
                 [&_flag](auto&&) -> move_only {
@@ -1533,7 +1528,7 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only_when_inner_future_f
                 std::forward<move_only>(x));
         });
 
-        wait_until_future_fails<test_exception>(sut);
+        wait_until_future_fails<test_exception>(std::move(sut));
 
         BOOST_REQUIRE(first);
         BOOST_REQUIRE(second);
@@ -1542,10 +1537,10 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only_when_inner_future_f
         bool first{false};
         bool second{false};
 
-        sut = async(immediate_executor, [& _flag = first] {
+        sut = async(immediate_executor, [&_flag = first] {
                   _flag = true;
                   return move_only(42);
-              }).then([& _flag = second](auto&& x) {
+              }).then([&_flag = second](auto&& x) {
             return async(
                 immediate_executor,
                 [&_flag](auto&&) -> move_only {
@@ -1555,7 +1550,7 @@ BOOST_AUTO_TEST_CASE(reduction_future_move_only_to_move_only_when_inner_future_f
                 std::forward<move_only>(x));
         });
 
-        wait_until_future_fails<test_exception>(sut);
+        wait_until_future_fails<test_exception>(std::move(sut));
 
         BOOST_REQUIRE(first);
         BOOST_REQUIRE(second);
diff --git a/test/future_when_all_arguments_tests.cpp b/test/future_when_all_arguments_tests.cpp
index 91600636d..b753908e6 100644
--- a/test/future_when_all_arguments_tests.cpp
+++ b/test/future_when_all_arguments_tests.cpp
@@ -172,9 +172,9 @@ BOOST_AUTO_TEST_CASE(future_when_all_args_move_only_with_one_element) {
   sut = when_all(make_executor<1>(), [](auto x) { return move_only(x.member() + x.member()); }, std::move(f1));
 
   check_valid_future(sut);
-  wait_until_future_completed(sut);
+  auto result = await(std::move(sut));
 
-  BOOST_REQUIRE_EQUAL(42 + 42, (*sut.get_try()).member());
+  BOOST_REQUIRE_EQUAL(42 + 42, result.member());
   BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
   BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
 }
@@ -193,9 +193,9 @@ BOOST_AUTO_TEST_CASE(future_when_all_args_move_only_with_many_elements) {
     std::move(f1), std::move(f2), std::move(f3), std::move(f4));
 
   check_valid_future(sut);
-  wait_until_future_completed(sut);
+  auto result = await(std::move(sut));
 
-  BOOST_REQUIRE_EQUAL(1 * 7 + 2 * 11 + 3 * 13 + 5 * 17, (*sut.get_try()).member());
+  BOOST_REQUIRE_EQUAL(1 * 7 + 2 * 11 + 3 * 13 + 5 * 17, result.member());
   BOOST_REQUIRE_LE(4, custom_scheduler<0>::usage_counter());
   BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
 }
diff --git a/test/future_when_all_range_tests.cpp b/test/future_when_all_range_tests.cpp
index 53e1297e6..647db8776 100644
--- a/test/future_when_all_range_tests.cpp
+++ b/test/future_when_all_range_tests.cpp
@@ -326,10 +326,10 @@ BOOST_AUTO_TEST_CASE(future_when_all_move_range_with_many_elements) {
                    std::make_pair(futures.begin(), futures.end()));
 
     check_valid_future(sut);
-    wait_until_future_completed(sut);
+    auto result = await(std::move(sut));
 
     BOOST_REQUIRE_EQUAL(size_t(4), p);
-    BOOST_REQUIRE_EQUAL(1 + 2 + 3 + 5, (*sut.get_try()).member() );
+    BOOST_REQUIRE_EQUAL(1 + 2 + 3 + 5, result.member() );
     BOOST_REQUIRE_LE(4, custom_scheduler<0>::usage_counter());
     BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
 }
diff --git a/test/future_when_any_arguments_tests.cpp b/test/future_when_any_arguments_tests.cpp
index 92a0aeb2b..9861b5b9d 100644
--- a/test/future_when_any_arguments_tests.cpp
+++ b/test/future_when_any_arguments_tests.cpp
@@ -440,10 +440,10 @@ BOOST_AUTO_TEST_CASE(future_when_any_move_only_argument_with_one_argument) {
 
   check_valid_future(sut);
 
-  wait_until_future_completed(sut);
+  auto result = await(std::move(sut));
 
   BOOST_REQUIRE_EQUAL(size_t(0), index);
-  BOOST_REQUIRE_EQUAL(4711, (*sut.get_try()).member());
+  BOOST_REQUIRE_EQUAL(4711, result.member());
   BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter());
   BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
 }
diff --git a/test/future_when_any_range_tests.cpp b/test/future_when_any_range_tests.cpp
index 8e27a7668..9bb9e9741 100644
--- a/test/future_when_any_range_tests.cpp
+++ b/test/future_when_any_range_tests.cpp
@@ -601,6 +601,7 @@ BOOST_AUTO_TEST_CASE(future_when_any_move_only_range_with_diamond_formation_elem
   thread_block_context block_context;
 
   size_t index = 0;
+  std::optional<move_only> result;
   {
     lock_t lock(*block_context._mutex);
     auto start = async(make_executor<0>(), [] { return 4711; });
@@ -630,7 +631,7 @@ BOOST_AUTO_TEST_CASE(future_when_any_move_only_range_with_diamond_formation_elem
       std::make_pair(futures.begin(), futures.end()));
 
     check_valid_future(sut);
-    wait_until_future_completed(sut);
+    result = await(std::move(sut));
     block_context._go = true;
   }
 
@@ -638,7 +639,7 @@ BOOST_AUTO_TEST_CASE(future_when_any_move_only_range_with_diamond_formation_elem
   wait_until_all_tasks_completed();
 
   BOOST_REQUIRE_EQUAL(size_t(1), index);
-  BOOST_REQUIRE_EQUAL(4711 + 2, (*sut.get_try()).member());
+  BOOST_REQUIRE_EQUAL(4711 + 2, result->member());
   BOOST_REQUIRE_LE(2, custom_scheduler<0>::usage_counter());
   BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
 }
diff --git a/test/tuple_test.cpp b/test/tuple_test.cpp
index d017ff7e8..562dc6905 100644
--- a/test/tuple_test.cpp
+++ b/test/tuple_test.cpp
@@ -54,11 +54,10 @@ using namespace stlab;
 /**************************************************************************************************/
 
 BOOST_AUTO_TEST_CASE(remove_placeholder_test) {
-    auto x = std::make_tuple(10, detail::placeholder(), 25.0, detail::placeholder());
+    auto x = std::make_tuple(10, placeholder(), 25.0, placeholder());
 
-    detail::apply_indexed<
-        index_sequence_transform_t<make_index_sequence<tuple_size<decltype(x)>::value>,
-                                   detail::remove_placeholder<decltype(x)>::function>>(
+    apply_indexed<index_sequence_transform_t<make_index_sequence<tuple_size<decltype(x)>::value>,
+                                             remove_placeholder<decltype(x)>::function>>(
         [](auto... args) { for_each_argument([](auto x) { cout << x << endl; }, args...); }, x);
 }
 
@@ -67,11 +66,10 @@ BOOST_AUTO_TEST_CASE(remove_placeholder_test) {
 BOOST_AUTO_TEST_CASE(add_placeholder_test) {
     using interim_t = placeholder_tuple<int, void, int, void>;
 
-    auto x = interim_t(10, detail::placeholder(), 25, detail::placeholder());
+    auto x = interim_t(10, placeholder(), 25, placeholder());
 
-    detail::apply_indexed<
-        index_sequence_transform_t<make_index_sequence<tuple_size<decltype(x)>::value>,
-                                   detail::remove_placeholder<decltype(x)>::function>>(
+    apply_indexed<index_sequence_transform_t<make_index_sequence<tuple_size<decltype(x)>::value>,
+                                             remove_placeholder<decltype(x)>::function>>(
         [](auto... args) { for_each_argument([](auto x) { cout << x << endl; }, args...); }, x);
 }
 
@@ -82,7 +80,7 @@ void when_all_typecheck(F, future<Ts>...) {
     using pt_t = placeholder_tuple<Ts...>;
     using opt_t = optional_placeholder_tuple<Ts...>;
     using vt_t = voidless_tuple<Ts...>;
-    using result_t = decltype(detail::apply_tuple(std::declval<F>(), std::declval<vt_t>()));
+    using result_t = decltype(apply_ignore_placeholders(std::declval<F>(), std::declval<vt_t>()));
 
     cout << "pt: " << demangle<pt_t>() << "\n";
     cout << "opt_t: " << demangle<opt_t>() << "\n";
@@ -192,9 +190,9 @@ BOOST_AUTO_TEST_CASE(future_when_all_int_void_string_void_bool_void) {
 BOOST_AUTO_TEST_CASE(future_when_any_void) {
     auto fv = [] { return stlab::make_ready_future(stlab::default_executor); };
 
-    auto f =
-        when_any(stlab::default_executor, [](size_t index) { std::cout << "f: " << index << '\n'; },
-                 fv(), fv(), fv(), fv(), fv(), fv());
+    auto f = when_any(
+        stlab::default_executor, [](size_t index) { std::cout << "f: " << index << '\n'; }, fv(),
+        fv(), fv(), fv(), fv(), fv());
 
     while (!f.get_try())
         std::this_thread::sleep_for(std::chrono::milliseconds(1));