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/exec.tex

@@ -0,0 +1,32 @@
+%!TEX root = std.tex
+\rSec0[thread]{Execution control library}
+
+\rSec1[exec.general]{General}
+
+\pnum
+This Clause describes components
+supporting execution of function objects\iref{function.objects}.
+
+\pnum
+The following subclauses describe
+the requirements, concepts, and components
+for execution control primitives as summarized in Table \tref{exec.summary}.
+
+\begin{libsumtab}{Execution control library summary}{exec.summary}
+\ref{exec.sched}     & Schedulers   & \tcode{<execution>} \\
+\ref{exec.recv}      & Receivers    & \\
+\ref{exec.opstate}   & Operation states & \\
+\ref{exec.snd}       & Senders & \\
+\end{libsumtab}
+
+\pnum
+Table \ref{exec.pos} shows
+the types of customization point objects\iref{customization.point.object}
+used in the execution control library.
+
+\begin{floattable}{Types of customization point objects in the execution control library}{exec.pos}{lx{0.40\hsize}l}
+\topline
+\lhdr{Customization point objec ttype} & \chdr{Purpose} & \rhdr{Examples} \\ \capsep
+core & provide core execution functionality, and connection between core components & e.g., \tcode{connect}, \tcode{start} \\
+completion functions & called by senders to announce the completion of the work (success, error, or cancellation) & \tcode{set_value}, \tcode{set_error}, \tcode{set_stopped} \\
+\end{floattable}

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}