Add stdexec::scope_association

This diff adds a definition for `concept stdexec::scope_association`
plus tests confirming it accepts and rejects the expected things.

Author: ispeters

include/stdexec/__detail/__concepts.hpp

@@ -253,6 +253,12 @@ namespace stdexec {
   template <class... _Ts>
   concept __nothrow_copy_constructible = (__nothrow_constructible_from<_Ts, const _Ts&> && ...);
 
+  template <class _Ty, class _A>
+  concept __nothrow_assignable_from = STDEXEC_IS_NOTHROW_ASSIGNABLE(_Ty, _A);
+
+  template <class... _Ts>
+  concept __nothrow_move_assignable = (__nothrow_assignable_from<_Ts, _Ts> && ...);
+
   template <class... _Ts>
   concept __decay_copyable = (constructible_from<__decay_t<_Ts>, _Ts> && ...);
 

include/stdexec/__detail/__config.hpp

@@ -356,6 +356,12 @@ namespace __coro = std::experimental;
 #  define STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(...) std::is_trivially_constructible_v<__VA_ARGS__>
 #endif
 
+#if STDEXEC_HAS_BUILTIN(__is_nothrow_assignable) || STDEXEC_MSVC()
+#  define STDEXEC_IS_NOTHROW_ASSIGNABLE(...) __is_nothrow_assignable(__VA_ARGS__)
+#else
+#  define STDEXEC_IS_NOTHROW_ASSIGNABLE(...) std::is_nothrow_assignable_v<__VA_ARGS__>
+#endif
+
 #if STDEXEC_HAS_BUILTIN(__is_empty) || STDEXEC_MSVC()
 #  define STDEXEC_IS_EMPTY(...) __is_empty(__VA_ARGS__)
 #else

include/stdexec/__detail/__scope_concepts.hpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025 Ian Petersen
+ *
+ * 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 "__execution_fwd.hpp"
+
+#include "__concepts.hpp"
+
+namespace stdexec {
+  /////////////////////////////////////////////////////////////////////////////
+  // [exec.scope.concepts]
+  template <class _Assoc>
+  concept scope_association = movable<_Assoc> && __nothrow_move_constructible<_Assoc>
+                           && __nothrow_move_assignable<_Assoc> && default_initializable<_Assoc>
+                           && requires(const _Assoc assoc) {
+                                { static_cast<bool>(assoc) } noexcept;
+                                { assoc.try_associate() } -> same_as<_Assoc>;
+                              };
+} // namespace stdexec

include/stdexec/execution.hpp

@@ -47,6 +47,7 @@
 #include "__detail/__run_loop.hpp"                        // IWYU pragma: export
 #include "__detail/__schedule_from.hpp"                   // IWYU pragma: export
 #include "__detail/__schedulers.hpp"                      // IWYU pragma: export
+#include "__detail/__scope_concepts.hpp"                  // IWYU pragma: export
 #include "__detail/__senders.hpp"                         // IWYU pragma: export
 #include "__detail/__sender_adaptor_closure.hpp"          // IWYU pragma: export
 #include "__detail/__split.hpp"                           // IWYU pragma: export

test/CMakeLists.txt

@@ -29,6 +29,7 @@ set(stdexec_test_sources
     stdexec/concepts/test_concepts_receiver.cpp
     stdexec/concepts/test_concept_operation_state.cpp
     stdexec/concepts/test_concepts_sender.cpp
+    stdexec/concepts/test_concepts_scope_association.cpp
     stdexec/concepts/test_awaitables.cpp
     stdexec/algos/factories/test_just.cpp
     stdexec/algos/factories/test_transfer_just.cpp

test/stdexec/concepts/test_concepts_scope_association.cpp

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2022 Ian Petersen
+ *
+ * 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.
+ */
+
+#include <catch2/catch.hpp>
+#include <stdexec/execution.hpp>
+
+namespace ex = stdexec;
+
+namespace {
+
+  // a "null" association that is always truthy and for which try_associate() always succeeds
+  struct null_association {
+    // this need not be explicit, although it should be
+    constexpr operator bool() const noexcept {
+      return true;
+    }
+
+    // this may throw, although it need not
+    constexpr null_association try_associate() const noexcept {
+      return {};
+    }
+  };
+
+  // a CRTP base that lets us produce variations on null_associaton with the right return type on try_associate
+  template <class Derived>
+  struct crtp_association : null_association {
+    constexpr Derived try_associate() const noexcept {
+      return {};
+    }
+  };
+
+  struct throwing_specials : crtp_association<throwing_specials> {
+    // it's ok for the non-move operators to throw
+    throwing_specials() noexcept(false) = default;
+    throwing_specials(const throwing_specials&) noexcept(false) = default;
+    throwing_specials(throwing_specials&&) noexcept = default;
+    ~throwing_specials() = default;
+
+    throwing_specials& operator=(const throwing_specials&) noexcept(false) = default;
+    throwing_specials& operator=(throwing_specials&&) noexcept = default;
+  };
+
+  struct move_only : crtp_association<move_only> {
+    // copy operations are not required
+    move_only() = default;
+    move_only(move_only&&) = default;
+    ~move_only() = default;
+
+    move_only& operator=(move_only&&) = default;
+  };
+
+  struct explicit_bool : crtp_association<explicit_bool> {
+    // the bool conversion may be explicit
+    constexpr explicit operator bool() const noexcept {
+      return true;
+    }
+  };
+
+  struct throwing_reassociate : crtp_association<throwing_reassociate> {
+    // try_associate may throw
+    constexpr throwing_reassociate try_associate() const noexcept(false) {
+      return {};
+    }
+  };
+
+  TEST_CASE(
+    "Scope association concept accepts basic association types",
+    "[concepts][scope_association]") {
+    // scope_association should accept the basic null_association
+    STATIC_REQUIRE(ex::scope_association<null_association>);
+
+    // the default constructor and copy operations may throw
+    STATIC_REQUIRE(ex::scope_association<throwing_specials>);
+    // double check that we're testing what we think we are
+    STATIC_REQUIRE(!ex::__nothrow_constructible_from<throwing_specials>);
+    STATIC_REQUIRE(!ex::__nothrow_constructible_from<throwing_specials, const throwing_specials&>);
+    STATIC_REQUIRE(!ex::__nothrow_assignable_from<throwing_specials, const throwing_specials&>);
+
+    // copy operations are not required
+    STATIC_REQUIRE(ex::scope_association<move_only>);
+
+    // the bool conversion may be explicit
+    STATIC_REQUIRE(ex::scope_association<explicit_bool>);
+
+    // try_associate may throw
+    STATIC_REQUIRE(ex::scope_association<throwing_reassociate>);
+  }
+
+  // invalid association because of immovability
+  struct immovable : crtp_association<immovable> {
+    immovable(immovable&&) = delete;
+  };
+
+  // conditionally-invalid association because of throwing move operations
+  template <bool ThrowingCtor, bool ThrowingAssign>
+  struct throwing_moves : crtp_association<throwing_moves<ThrowingCtor, ThrowingAssign>> {
+    throwing_moves() = default;
+    throwing_moves(throwing_moves&&) noexcept(ThrowingCtor) = default;
+    ~throwing_moves() = default;
+
+    throwing_moves& operator=(throwing_moves&&) noexcept(ThrowingAssign) = default;
+  };
+
+  // invalid assocation because of a throwing move constructor
+  using throwing_move_ctor = throwing_moves<true, false>;
+  // invalid assocation because of a throwing move assignment operator
+  using throwing_move_assign = throwing_moves<false, true>;
+
+  // invalid assocation because of a missing default constructor
+  struct missing_ctor : crtp_association<missing_ctor> {
+    missing_ctor() = delete;
+  };
+
+  // invalid assocation because of a throwing conversion to bool
+  struct throwing_boolish : crtp_association<throwing_boolish> {
+    constexpr explicit operator bool() const noexcept(false) {
+      return true;
+    }
+  };
+
+  // invalid assocation because try_associate returns the wrong type
+  struct cannot_reassociate : null_association { };
+
+  TEST_CASE(
+    "Scope association concept rejects non-association types",
+    "[concepts][scope_association]") {
+    STATIC_REQUIRE(!ex::scope_association<int>);
+
+    // movability is required
+    STATIC_REQUIRE(!ex::scope_association<immovable>);
+
+    // the move operations must be non-throwing
+    STATIC_REQUIRE(!ex::scope_association<throwing_move_ctor>);
+    STATIC_REQUIRE(!ex::scope_association<throwing_move_assign>);
+
+    // default initialization is required
+    STATIC_REQUIRE(!ex::scope_association<missing_ctor>);
+
+    // conversion to bool must not throw
+    STATIC_REQUIRE(!ex::scope_association<throwing_boolish>);
+
+    // try_associate must return an association
+    STATIC_REQUIRE(!ex::scope_association<cannot_reassociate>);
+  }
+} // namespace