P2300R10 std::execution

Author: jensmaurer

source/exceptions.tex

@@ -1084,7 +1084,27 @@
 \item%
 when a call to a \tcode{wait()}, \tcode{wait_until()}, or \tcode{wait_for()}
 function on a condition variable\iref{thread.condition.condvar,thread.condition.condvarany}
-fails to meet a postcondition.
+fails to meet a postcondition, or
+
+\item%
+when a callback invocation exits via an exception
+when requesting stop on
+a \tcode{std::stop_source} or
+a \tcode{std::in\-place_stop_source}\iref{stopsource.mem,stopsource.inplace.mem},
+or in the constructor of
+\tcode{std::stop_callback} or
+\tcode{std::inplace_stop_callback}\iref{stopcallback.cons,stopcallback.inplace.cons}
+when a callback invocation exits via an exception, or
+
+\item%
+when a \tcode{run_loop} object is destroyed
+that is still in the \tcode{running} state\iref{exec.run.loop}, or
+
+\item%
+when \tcode{unhandled_stopped} is called on
+a \tcode{with_awaitable_senders<T>} object\iref{exec.with.awaitable.senders}
+whose continuation is not a handle to a coroutine
+whose promise type has an \tcode{unhandled_stopped} member function.
 
 \end{itemize}
 

source/lib-intro.tex

@@ -525,6 +525,14 @@
 }
 \end{codeblock}
 
+\pnum
+An object \tcode{dst} is said to be \defn{decay-copied from}
+a subexpression \tcode{src}
+if the type of \tcode{dst} is
+\begin{codeblock}
+decay_t<decltype((src))>
+\end{codeblock} and \tcode{dst} is copy-initialized from \tcode{src}.
+
 \rSec3[type.descriptions]{Type descriptions}
 
 \rSec4[type.descriptions.general]{General}
@@ -2850,6 +2858,22 @@
 \end{codeblock}
 \end{example}
 
+\pnum
+The following exposition-only concept defines
+the minimal requirements on an Allocator type.
+\begin{codeblock}
+template<class Alloc>
+concept @\defexposconcept{simple-allocator}@ =
+  requires(Alloc alloc, size_t n) {
+    { *alloc.allocate(n) } -> @\libconcept{same_as}@<typename Alloc::value_type&>;
+    { alloc.deallocate(alloc.allocate(n), n) };
+  } &&
+  @\libconcept{copy_constructible}@<Alloc> &&
+  @\libconcept{equality_comparable}@<Alloc>;
+\end{codeblock}
+A type \tcode{Alloc} models \exposconcept{simple-allocator}
+if it meets the requirements of \ref{allocator.requirements.general}.
+
 \rSec4[allocator.requirements.completeness]{Allocator completeness requirements}
 
 \pnum

source/support.tex

@@ -765,6 +765,7 @@
 #define @\defnlibxname{cpp_lib_saturation_arithmetic}@             202311L // also in \libheader{numeric}
 #define @\defnlibxname{cpp_lib_scoped_lock}@                       201703L // also in \libheader{mutex}
 #define @\defnlibxname{cpp_lib_semaphore}@                         201907L // also in \libheader{semaphore}
+#define @\defnlibxname{cpp_lib_senders}@                           202406L // also in \libheader{execution}
 #define @\defnlibxname{cpp_lib_shared_mutex}@                      201505L // also in \libheader{shared_mutex}
 #define @\defnlibxname{cpp_lib_shared_ptr_arrays}@                 201707L // also in \libheader{memory}
 #define @\defnlibxname{cpp_lib_shared_ptr_weak_type}@              201606L // also in \libheader{memory}

source/utilities.tex

@@ -10755,6 +10755,23 @@
     struct greater_equal;                                                           // freestanding
     struct less_equal;                                                              // freestanding
   }
+
+  template<class Fn, class... Args>
+    concept @\defexposconcept{callable}@ =         // \expos
+      requires (Fn&& fn, Args&&... args) {
+        std::forward<Fn>(fn)(std::forward<Args>(args)...);
+      };
+  template<class Fn, class... Args>
+    concept @\defexposconcept{nothrow-callable}@ =   // \expos
+      \exposconcept{callable}<Fn, Args...> &&
+      requires (Fn&& fn, Args&&... args) {
+        { std::forward<Fn>(fn)(std::forward<Args>(args)...) } noexcept;
+      };
+  template<class Fn, class... Args>
+    using @\exposid{call-result-t}@ = decltype(declval<Fn>()(declval<Args>()...));  // \expos
+
+  template<const auto& T>
+    using @\exposid{decayed-typeof}@ = decltype(auto(T));                           // \expos
 }
 \end{codeblock}