initial implementation for std::execution::task (#1820)

Author: ericniebler

include/exec/task.hpp

@@ -477,12 +477,12 @@ namespace exec {
      public:
       // Make this task awaitable within a particular context:
       template <class _ParentPromise>
-      constexpr // requires __std::constructible_from<
-        //   awaiter_context_t<__promise, _ParentPromise>,
-        //   __promise_context_t&,
-        //   _ParentPromise&
-        // >
-        auto as_awaitable(_ParentPromise&) && noexcept { //-> __task_awaitable<_ParentPromise> {
+        requires __std::constructible_from<
+          awaiter_context_t<__promise, _ParentPromise>,
+          __promise_context_t&,
+          _ParentPromise&
+        >
+      constexpr auto as_awaitable(_ParentPromise&) && noexcept -> __task_awaitable<_ParentPromise> {
         return __task_awaitable<_ParentPromise>{std::exchange(__coro_, {})};
       }
 

include/stdexec/__detail/__affine_on.hpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "__sender_concepts.hpp"
+#include "__schedulers.hpp"
+
+namespace STDEXEC {
+  struct affine_on_t {
+    template <sender _Sender, scheduler _Scheduler>
+    constexpr auto operator()(_Sender&& __sndr, _Scheduler&&) const -> auto&& {
+      // BUGBUG TODO: implement me
+      return static_cast<_Sender&&>(__sndr);
+    }
+  };
+
+  inline constexpr affine_on_t affine_on{};
+} // namespace STDEXEC

include/stdexec/__detail/__as_awaitable.hpp

@@ -36,18 +36,18 @@ namespace STDEXEC {
     extern const __q<__decayed_std_tuple> __as_single;
 
     template <>
-    inline const __q<__midentity> __as_single<1>;
+    inline constexpr __q<__midentity> __as_single<1>;
 
     template <>
-    inline const __mconst<void> __as_single<0>;
+    inline constexpr __mconst<void> __as_single<0>;
 
     template <class... _Values>
     using __single_value = __minvoke<decltype(__as_single<sizeof...(_Values)>), _Values...>;
 
     template <class _Sender, class _Promise>
     using __value_t = __decay_t<
       __value_types_of_t<_Sender, env_of_t<_Promise&>, __q<__single_value>, __msingle_or<void>>
-    >;
+      >;
   } // namespace __detail
 
   /////////////////////////////////////////////////////////////////////////////

include/stdexec/__detail/__concepts.hpp

@@ -290,9 +290,9 @@ namespace STDEXEC {
 
   namespace __detail {
     template <class _Alloc>
-    constexpr auto __test_alloc_pointer(int) -> typename _Alloc::pointer;
+    constexpr auto __test_alloc_pointer(int) -> _Alloc::pointer;
     template <class _Alloc>
-    constexpr auto __test_alloc_pointer(long) -> typename _Alloc::value_type*;
+    constexpr auto __test_alloc_pointer(long) -> _Alloc::value_type*;
 
     template <class _Alloc>
     using __alloc_pointer_t = decltype(__detail::__test_alloc_pointer<__decay_t<_Alloc>>(0));

include/stdexec/__detail/__execution_fwd.hpp

@@ -200,42 +200,10 @@ namespace STDEXEC {
 
   namespace __cmplsigs {
     struct get_completion_signatures_t;
-
-#if STDEXEC_NO_STD_CONSTEXPR_EXCEPTIONS()
-    // Without constexpr exceptions, we cannot always produce a valid
-    // completion_signatures type. We must permit get_completion_signatures to return an
-    // error type because we can't throw it.
-    template <class _Completions>
-    concept __well_formed_completions_helper =
-      __valid_completion_signatures<_Completions>
-      || STDEXEC_IS_BASE_OF(STDEXEC::dependent_sender_error, _Completions)
-      || __is_instance_of<_Completions, _ERROR_>;
-#else
-    // When we have constexpr exceptions, we can require that get_completion_signatures
-    // always produces a valid completion_signatures type.
-    template <class _Completions>
-    concept __well_formed_completions_helper = __valid_completion_signatures<_Completions>;
-#endif
   } // namespace __cmplsigs
 
   using __cmplsigs::get_completion_signatures_t;
 
-  // The cast to bool is to hide the disjunction in __well_formed_completions_helper.
-  template <class _Completions>
-  concept __well_formed_completions = bool(
-    __cmplsigs::__well_formed_completions_helper<_Completions>);
-
-  // template <class _Sender>
-  // consteval auto get_completion_signatures();
-
-  // template <class _Sender, class _Env>
-  // consteval auto get_completion_signatures();
-
-  // // Legacy interface:
-  // template <class _Sender, class... _Env>
-  //   requires(sizeof...(_Env) <= 1)
-  // constexpr auto get_completion_signatures(_Sender&&, const _Env&...) noexcept;
-
 #if STDEXEC_NO_STD_CONSTEXPR_EXCEPTIONS()
 
   template <class... _What, class... _Values>

include/stdexec/__detail/__meta.hpp

@@ -812,27 +812,39 @@ namespace STDEXEC {
     using __f = __minvoke<__mzip_with2_<_Cp, _Dp>, _Fn, _Continuation>;
   };
 
+  template <class _Ty, class _Uy>
+  using __msame_as = __mbool<STDEXEC_IS_SAME(_Ty, _Uy)>;
+
+  template <class _Ty, class _Uy>
+  using __mconvertible_to = __mbool<STDEXEC_IS_CONVERTIBLE_TO(_Ty, _Uy)>;
+
   template <bool>
-  struct __mfind_ {
-    template <class _Needle, class _Continuation, class _Head, class... _Tail>
+  struct __mfind_if_ {
+    template <class _Fn, class _Continuation, class _Head, class... _Tail>
     using __f = __minvoke_if_c<
-      __same_as<_Needle, _Head>,
+      __mcall1<_Fn, _Head>::value,
       __mbind_front<_Continuation, _Head>,
-      __mbind_front<__mfind_<(sizeof...(_Tail) != 0)>, _Needle, _Continuation>,
+      __mbind_front<__mfind_if_<(sizeof...(_Tail) != 0)>, _Fn, _Continuation>,
       _Tail...
     >;
   };
 
   template <>
-  struct __mfind_<false> {
-    template <class _Needle, class _Continuation>
+  struct __mfind_if_<false> {
+    template <class _Fn, class _Continuation>
     using __f = __minvoke<_Continuation>;
   };
 
+  template <class _Fn, class _Continuation = __q<__mlist>>
+  struct __mfind_if {
+    template <class... _Args>
+    using __f = __minvoke<__mfind_if_<(sizeof...(_Args) != 0)>, _Fn, _Continuation, _Args...>;
+  };
+
   template <class _Needle, class _Continuation = __q<__mlist>>
   struct __mfind {
     template <class... _Args>
-    using __f = __minvoke<__mfind_<(sizeof...(_Args) != 0)>, _Needle, _Continuation, _Args...>;
+    using __f = __mcall<__mfind_if<__mbind_front_q<__msame_as, _Needle>, _Continuation>, _Args...>;
   };
 
   template <class _Needle>

include/stdexec/__detail/__optional.hpp

@@ -135,7 +135,7 @@ namespace STDEXEC {
         if (!__has_value_) {
           STDEXEC_THROW(__bad_optional_access());
         }
-        return static_cast<_Tp&&>(__value_);
+        return static_cast<_Tp&&>(static_cast<_Tp&>(__value_));
       }
 
       constexpr auto operator*() & noexcept -> _Tp& {
@@ -150,17 +150,17 @@ namespace STDEXEC {
 
       constexpr auto operator*() && noexcept -> _Tp&& {
         STDEXEC_ASSERT(__has_value_);
-        return static_cast<_Tp&&>(__value_);
+        return static_cast<_Tp&&>(static_cast<_Tp&>(__value_));
       }
 
-      constexpr auto operator->() & noexcept -> _Tp* {
+      constexpr auto operator->() & noexcept -> std::add_pointer_t<_Tp> {
         STDEXEC_ASSERT(__has_value_);
-        return &__value_;
+        return std::addressof(static_cast<_Tp&>(__value_));
       }
 
-      constexpr auto operator->() const & noexcept -> const _Tp* {
+      constexpr auto operator->() const & noexcept -> std::add_pointer_t<const _Tp> {
         STDEXEC_ASSERT(__has_value_);
-        return &__value_;
+        return std::addressof(static_cast<const _Tp&>(__value_));
       }
 
       [[nodiscard]]
@@ -175,6 +175,71 @@ namespace STDEXEC {
         }
       }
     };
+
+    // __optional<T&>
+    template <class _Tp>
+    struct __optional<_Tp&> {
+      _Tp* __value_ = nullptr;
+
+      __optional() noexcept = default;
+
+      __optional(__nullopt_t) noexcept {
+      }
+
+      template <__not_decays_to<__optional> _Up>
+        requires __std::constructible_from<_Tp&, _Up>
+      constexpr __optional(_Up&& __val) noexcept(__nothrow_constructible_from<_Tp&, _Up>) {
+        emplace(static_cast<_Up&&>(__val));
+      }
+
+      template <__not_decays_to<__optional> _Up>
+        requires __std::constructible_from<_Tp&, _Up>
+      constexpr __optional(std::in_place_t, _Up&& __val)
+        noexcept(__nothrow_constructible_from<_Tp&, _Up>) {
+        emplace(static_cast<_Up&&>(__val));
+      }
+
+      template <class _Up>
+        requires __std::constructible_from<_Tp&, _Up>
+      constexpr auto emplace(_Up&& __us) noexcept(__nothrow_constructible_from<_Tp&, _Up>) -> _Tp& {
+        __value_ = std::addressof(static_cast<_Up&&>(__us));
+        return *__value_;
+      }
+
+      template <class _Fn, class... _Args>
+        requires __std::same_as<_Tp&, __call_result_t<_Fn, _Args...>>
+      auto __emplace_from(_Fn&& __f, _Args&&... __args) noexcept(__nothrow_callable<_Fn, _Args...>)
+        -> _Tp& {
+        __value_ = std::addressof(static_cast<_Fn&&>(__f)(static_cast<_Args&&>(__args)...));
+        return *__value_;
+      }
+
+      constexpr auto value() const -> _Tp& {
+        if (__value_ == nullptr) {
+          STDEXEC_THROW(__bad_optional_access());
+        }
+        return *__value_;
+      }
+
+      constexpr auto operator*() const -> _Tp& {
+        STDEXEC_ASSERT(__value_ != nullptr);
+        return *__value_;
+      }
+
+      constexpr auto operator->() const -> _Tp* {
+        STDEXEC_ASSERT(__value_ != nullptr);
+        return __value_;
+      }
+
+      [[nodiscard]]
+      constexpr auto has_value() const noexcept -> bool {
+        return __value_ != nullptr;
+      }
+
+      constexpr void reset() noexcept {
+        __value_ = nullptr;
+      }
+    };
   } // namespace __opt
 
   using __opt::__optional;

include/stdexec/__detail/__scope.hpp

@@ -18,7 +18,7 @@
 #include "__config.hpp"
 #include "__utility.hpp"
 
-#include <functional>
+#include <type_traits>
 
 namespace STDEXEC {
   template <class _Fn, class... _Ts>