Turn class templates into a member classes of class templates to further narrow scope of ADL

examples/async_mutex.cpp

@@ -49,8 +49,8 @@ int main() {
   single_thread_context ctx1;
   single_thread_context ctx2;
 
-  sync_wait(when_all(awaitable_sender{makeTask(ctx1.get_scheduler())},
-                     awaitable_sender{makeTask(ctx2.get_scheduler())}));
+  sync_wait(when_all(awaitable_sender(makeTask(ctx1.get_scheduler())),
+                     awaitable_sender(makeTask(ctx2.get_scheduler()))));
 
   if (sharedState != 200'000) {
     std::printf("error: incorrect result %i, expected 2000000\n", sharedState);

examples/async_trace.cpp

@@ -95,12 +95,12 @@ int main() {
                 return time;
               }),
 #if !UNIFEX_NO_COROUTINES
-          awaitable_sender {
+          awaitable_sender(
             []() -> task<int> {
               co_await dump_async_trace("coroutine");
               co_return 42;
             }()
-          }
+          )
 #else
           just(42)
 #endif // UNIFEX_NO_COROUTINES

examples/coroutine_stream_consumer.cpp

@@ -66,7 +66,7 @@ int main() {
     co_return sum;
   };
 
-  sync_wait(awaitable_sender{makeTask()});
+  sync_wait(awaitable_sender(makeTask()));
 
   return 0;
 }

include/unifex/adapt_stream.hpp

@@ -21,66 +21,78 @@
 #include <type_traits>
 
 namespace unifex {
+namespace _adapt_stream {
+template <typename Stream, typename NextAdaptFunc, typename CleanupAdaptFunc>
+struct _adapted {
+  struct type;
+};
+template <typename Stream, typename NextAdaptFunc, typename CleanupAdaptFunc = void>
+using adapted = typename _adapted<
+    std::remove_cvref_t<Stream>,
+    std::decay_t<NextAdaptFunc>,
+    std::decay_t<CleanupAdaptFunc>>::type;
 
-template <
-    typename Stream,
-    typename NextAdaptFunc,
-    typename CleanupAdaptFunc>
-struct adapted_stream {
+template <typename Stream, typename NextAdaptFunc, typename CleanupAdaptFunc>
+struct _adapted<Stream, NextAdaptFunc, CleanupAdaptFunc>::type {
   Stream innerStream_;
   NextAdaptFunc nextAdapter_;
   CleanupAdaptFunc cleanupAdapter_;
 
-  friend auto tag_invoke(tag_t<next>, adapted_stream& s)
-    -> std::invoke_result_t<NextAdaptFunc&, next_sender_t<Stream>> {
+  friend auto tag_invoke(tag_t<next>, type& s)
+      -> std::invoke_result_t<NextAdaptFunc&, next_sender_t<Stream>> {
     return std::invoke(s.nextAdapter_, next(s.innerStream_));
   }
 
-  friend auto tag_invoke(tag_t<cleanup>, adapted_stream& s)
-    -> std::invoke_result_t<CleanupAdaptFunc&, cleanup_sender_t<Stream>> {
+  friend auto tag_invoke(tag_t<cleanup>, type& s)
+      -> std::invoke_result_t<CleanupAdaptFunc&, cleanup_sender_t<Stream>> {
     return std::invoke(s.cleanupAdapter_, cleanup(s.innerStream_));
   }
 };
 
 template <typename Stream, typename AdaptFunc>
-struct both_adapted_stream {
+struct _adapted<Stream, AdaptFunc, void> {
+  struct type;
+};
+template <typename Stream, typename AdaptFunc>
+struct _adapted<Stream, AdaptFunc, void>::type {
   Stream innerStream_;
   AdaptFunc adapter_;
 
-  friend auto tag_invoke(tag_t<next>, both_adapted_stream& s)
-    -> std::invoke_result_t<AdaptFunc&, next_sender_t<Stream>> {
+  friend auto tag_invoke(tag_t<next>, type& s)
+      -> std::invoke_result_t<AdaptFunc&, next_sender_t<Stream>> {
     return std::invoke(s.adapter_, next(s.innerStream_));
   }
 
-  friend auto tag_invoke(tag_t<cleanup>, both_adapted_stream& s)
-    -> std::invoke_result_t<AdaptFunc&, cleanup_sender_t<Stream>> {
+  friend auto tag_invoke(tag_t<cleanup>, type& s)
+      -> std::invoke_result_t<AdaptFunc&, cleanup_sender_t<Stream>> {
     return std::invoke(s.adapter_, cleanup(s.innerStream_));
   }
 };
+} // namespace _adapt_stream
 
-template <typename Stream, typename AdapterFunc>
-auto adapt_stream(Stream&& stream, AdapterFunc&& adapt) {
-  return both_adapted_stream<
-      std::remove_cvref_t<Stream>,
-      std::remove_cvref_t<AdapterFunc>>{(Stream &&) stream,
-                                        (AdapterFunc &&) adapt};
-}
-
-template <
-    typename Stream,
-    typename NextAdapterFunc,
-    typename CleanupAdapterFunc>
-auto adapt_stream(
-    Stream&& stream,
-    NextAdapterFunc&& adaptNext,
-    CleanupAdapterFunc&& adaptCleanup) {
-  return adapted_stream<
-      std::remove_cvref_t<Stream>,
-      std::remove_cvref_t<NextAdapterFunc>,
-      std::remove_cvref_t<CleanupAdapterFunc>>{(Stream &&) stream,
-                                               (NextAdapterFunc &&) adaptNext,
-                                               (CleanupAdapterFunc &&)
-                                                   adaptCleanup};
-}
+namespace _adapt_stream_cpo {
+  inline constexpr struct _fn {
+    template <typename Stream, typename AdapterFunc>
+    auto operator()(Stream&& stream, AdapterFunc&& adapt) const
+        -> _adapt_stream::adapted<Stream, AdapterFunc> {
+      return {(Stream &&) stream, (AdapterFunc &&) adapt};
+    }
 
+    template <
+        typename Stream,
+        typename NextAdapterFunc,
+        typename CleanupAdapterFunc>
+    auto operator()(
+        Stream&& stream,
+        NextAdapterFunc&& adaptNext,
+        CleanupAdapterFunc&& adaptCleanup) const
+        -> _adapt_stream::adapted<Stream, NextAdapterFunc, CleanupAdapterFunc> {
+      return {
+          (Stream &&) stream,
+          (NextAdapterFunc &&) adaptNext,
+          (CleanupAdapterFunc &&) adaptCleanup};
+    }
+  } adapt_stream {};
+} // namespace _adapt_stream_cpo
+using _adapt_stream_cpo::adapt_stream;
 } // namespace unifex

include/unifex/allocate.hpp

@@ -24,16 +24,24 @@
 #include <memory>
 #include <type_traits>
 
-namespace unifex
-{
+namespace unifex {
+namespace _alloc {
   template <typename Operation, typename Allocator>
-  class allocated_operation {
+  struct _op {
+    class type;
+  };
+  template <typename Operation, typename Allocator>
+  using operation = typename _op<Operation, Allocator>::type;
+
+  template <typename Operation, typename Allocator>
+  class _op<Operation, Allocator>::type {
+    using operation = type;
     using allocator_t = typename std::allocator_traits<
         Allocator>::template rebind_alloc<Operation>;
 
   public:
     template <typename Sender, typename Receiver>
-    explicit allocated_operation(Sender&& s, Receiver&& r)
+    explicit type(Sender&& s, Receiver&& r)
       : allocator_(get_allocator(r)) {
       using allocator_traits = std::allocator_traits<allocator_t>;
       Operation* op = allocator_traits::allocate(allocator_, 1);
@@ -48,12 +56,12 @@ namespace unifex
       constructorSucceeded = true;
     }
 
-    ~allocated_operation() {
+    ~type() {
       op_->~Operation();
       std::allocator_traits<allocator_t>::deallocate(allocator_, op_, 1);
     }
 
-    friend void tag_invoke(tag_t<start>, allocated_operation& op) noexcept {
+    friend void tag_invoke(tag_t<start>, operation& op) noexcept {
       start(*op.op_);
     }
 
@@ -63,58 +71,92 @@ namespace unifex
   };
 
   template <typename Sender>
-  class allocate_sender {
+  struct _sender {
+    class type;
+  };
+  template <typename Sender>
+  using sender = typename _sender<std::remove_cvref_t<Sender>>::type;
+
+  template <typename Sender>
+  class _sender<Sender>::type {
+    using sender = type;
   public:
     template <
-        template <typename...>
-        class Variant,
-        template <typename...>
-        class Tuple>
+        template <typename...> class Variant,
+        template <typename...> class Tuple>
     using value_types = typename Sender::template value_types<Variant, Tuple>;
 
     template <template <typename...> class Variant>
     using error_types = typename Sender::template error_types<Variant>;
 
     template <typename Receiver>
-    friend auto tag_invoke(tag_t<connect>, allocate_sender&& s, Receiver&& r)
-        -> allocated_operation<
+    friend auto tag_invoke(tag_t<connect>, sender&& s, Receiver&& r)
+        -> operation<
             operation_t<Sender, Receiver>,
             std::remove_cvref_t<get_allocator_t<Receiver>>> {
-      return allocated_operation<
+      return operation<
           operation_t<Sender, Receiver>,
           std::remove_cvref_t<get_allocator_t<Receiver>>>{
           (Sender &&) s.sender_, (Receiver &&) r};
     }
 
     template <typename Receiver>
-    friend auto tag_invoke(tag_t<connect>, allocate_sender& s, Receiver&& r)
-        -> allocated_operation<
+    friend auto tag_invoke(tag_t<connect>, sender& s, Receiver&& r)
+        -> operation<
             operation_t<Sender&, Receiver>,
             std::remove_cvref_t<get_allocator_t<Receiver>>> {
-      return allocated_operation<
+      return operation<
           operation_t<Sender&, Receiver>,
           std::remove_cvref_t<get_allocator_t<Receiver>>>{
           s.sender_, (Receiver &&) r};
     }
 
     template <typename Receiver>
     friend auto
-    tag_invoke(tag_t<connect>, const allocate_sender& s, Receiver&& r)
-        -> allocated_operation<
+    tag_invoke(tag_t<connect>, const sender& s, Receiver&& r)
+        -> operation<
             operation_t<const Sender&, Receiver>,
             std::remove_cvref_t<get_allocator_t<Receiver>>> {
-      return allocated_operation<
+      return operation<
           operation_t<const Sender&, Receiver>,
           std::remove_cvref_t<get_allocator_t<Receiver>>>{
           std::as_const(s.sender_), (Receiver &&) r};
     }
 
     Sender sender_;
   };
+} // namespace _alloc
 
-  template <typename Sender>
-  auto allocate(Sender&& sender) -> allocate_sender<std::decay_t<Sender>> {
-    return allocate_sender<std::decay_t<Sender>>{(Sender &&) sender};
-  }
+namespace _alloc_cpo {
+  inline constexpr struct _fn {
+  private:
+    template<bool>
+    struct _impl {
+      template <typename Sender>
+      auto operator()(Sender&& predecessor) const
+          noexcept(is_nothrow_tag_invocable_v<_fn, Sender>) {
+        return unifex::tag_invoke(_fn{}, (Sender&&) predecessor);
+      }
+    };
+  public:
+    template <typename Sender>
+    auto operator()(Sender&& predecessor) const
+        noexcept(std::is_nothrow_invocable_v<
+          _impl<is_tag_invocable_v<_fn, Sender>>, Sender>) {
+      return _impl<is_tag_invocable_v<_fn, Sender>>{}((Sender&&) predecessor);
+    }
+  } allocate{};
+
+  template<>
+  struct _fn::_impl<false> {
+    template <typename Sender>
+    auto operator()(Sender&& predecessor) const
+        noexcept(std::is_nothrow_constructible_v<_alloc::sender<Sender>, Sender>)
+        -> _alloc::sender<Sender> {
+      return _alloc::sender<Sender>{(Sender &&) predecessor};
+    }
+  };
+} // namespace _alloc_cpo
+using _alloc_cpo::allocate;
 
-}  // namespace unifex
+} // namespace unifex