Fix markdown code block wrapping which was causing pdf font issues round 2

Author: MungoG

CLAUDE.md

@@ -96,7 +96,7 @@ Rules for all work on WG21 papers in this repository.
     summarize arithmetic or data
 30. Align trailing comment columns when consecutive lines have
     trailing comments
-31. Fenced code blocks must not exceed 80 characters per
+31. Fenced code blocks must not exceed 90 characters per
     line. This rule does not apply to mermaid blocks -
     never reformat mermaid source. When wrapping is
     needed, follow the conventions for the block's
@@ -114,23 +114,27 @@ Rules for all work on WG21 papers in this repository.
     - Trailing comments: shorten the gap between code and
       comment rather than wrapping the code, but keep
       grouped comments aligned with each other (rule 30)
-    - If shortening the gap is not enough, move the
-      comment to the line above the code it describes
+    - If a trailing comment still exceeds 90 characters
+      after tightening the gap, wrap the comment text to
+      a second line. The continuation `//` must align
+      with the `//` on the first line. Never move a
+      trailing comment above the code line - keep all
+      comments in a contiguous block on the right
 
     **Prose in code fences** (markdown, plain text) -
     wrap at word boundaries with no continuation indent
 
 ## Structure
 
-31. Sections with subsections should have at least one introductory
+32. Sections with subsections should have at least one introductory
     sentence between the section heading and the first subsection
     heading - do not leave an empty section heading
-32. Every paper must contain a `## Revision History` section,
+33. Every paper must contain a `## Revision History` section,
     placed immediately after the Abstract's trailing `---` and
     before Section 1. Each revision is an H3 subheading in the
     form `### R<n>: <Month> <Year> (<pre-Meeting mailing>)`
     followed by a bullet list of changes
-33. References and citations - for readers of printed copies:
+34. References and citations - for readers of printed copies:
     - Every hyperlink in the document body must also appear
       in the References section
     - Every hyperlink in the document body must have a
@@ -156,10 +160,10 @@ Rules for all work on WG21 papers in this repository.
 
 ## Tone
 
-34. Do not present options as predetermined conclusions. When
+35. Do not present options as predetermined conclusions. When
     recommending alternatives to a committee, present them as options
     to contemplate, not dictated outcomes
-35. Avoid politically charged comparisons - do not invoke other
+36. Avoid politically charged comparisons - do not invoke other
     contentious features as analogies unless the comparison is
     structurally precise. If the structures being compared are
     fundamentally different, the analogy will be perceived as

d4003-coroutine-io.html

@@ -158,8 +158,7 @@ struct my_awaitable
 
     // This signature satisfies IoAwaitable
     std::coroutine_handle<>
-    await_suspend( std::coroutine_handle<> cont,
-                   io_env const* env )
+        await_suspend( std::coroutine_handle<> cont, io_env const* env )
     {
         cont_ = cont;
         env_ = env;
@@ -307,8 +306,7 @@ struct task
 
     // Satisfies IoAwaitable
     std::coroutine_handle<>
-    await_suspend( std::coroutine_handle<> cont,
-                   io_env const* env )
+        await_suspend( std::coroutine_handle<> cont, io_env const* env )
     {
         h_.promise().set_continuation( cont );
         h_.promise().set_environment( env );
@@ -438,12 +436,11 @@ A launch function (e.g., `run_async`, `run`) bridges non-coroutine code into the
 
 ```cpp
 template<Executor Ex, class... Args>
-// returns wrapper, caller invokes with task
-unspecified run_async( Ex ex, Args&&... args );
+unspecified run_async( Ex ex, Args&&... args ); // returns wrapper,
+                                                // caller invokes with task
 
 template<Executor Ex, class... Args>
-// returns wrapper for co_await
-unspecified run( Ex ex, Args&&... args );
+unspecified run( Ex ex, Args&&... args );       // returns wrapper for co_await
 ```
 
 **Requirements:**
@@ -600,8 +597,7 @@ concept ExecutionContext =
     requires(X& x) {
         typename X::executor_type;
         requires Executor<typename X::executor_type>;
-        { x.get_executor() } noexcept
-            -> std::same_as<typename X::executor_type>;
+        { x.get_executor() } noexcept -> std::same_as<typename X::executor_type>;
     };
 ```
 
@@ -629,8 +625,7 @@ Coroutine frame allocation has a fundamental timing constraint: `operator new` e
 auto t = my_coro(sock);  // operator new called HERE
 co_await t;              // await_transform kicks in HERE (too late)
 
-// my_coro(sock) evaluated BEFORE calling spawn (too late)
-spawn( my_coro(sock) );
+spawn( my_coro(sock) );  // my_coro(sock) evaluated BEFORE calling spawn (too late)
 ```
 
 ### 5.2 The Awkward Approach
@@ -1270,9 +1265,7 @@ concept io_runnable =
   requires { typename T::promise_type; } &&
   requires(T& t, T const& ct, typename T::promise_type const& cp,
            typename T::promise_type& p) {
-    { ct.handle() } noexcept
-        -> same_as<coroutine_handle<
-            typename T::promise_type>>;
+    { ct.handle() } noexcept -> same_as<coroutine_handle<typename T::promise_type>>;
     { cp.exception() } noexcept -> same_as<exception_ptr>;
     { t.release() } noexcept;
     { p.set_continuation(coroutine_handle<>{}) } noexcept;

d4003-coroutine-io.pdf

@@ -164,9 +164,8 @@ read(tcp::socket& sock)
     char buf[1024];
     for (;;)
     {
-        auto [ec, n] = co_await sock.read_some(buf);    // also a tuple
-        // n bytes arrived regardless of ec
-        result.append(buf, n);
+        auto [ec, n] = co_await sock.read_some(buf);   // also a tuple
+        result.append(buf, n);                         // n bytes arrived regardless of ec
         if (ec)
             co_return {ec, std::move(result)};
     }
@@ -207,14 +206,14 @@ sender_of<dynamic_buffer> auto async_read_array(auto handle) {
            return just(std::as_writeable_bytes(std::span(&buf.size, 1)))
                 | async_read(handle)
                 | then(
-                    [&buf] (std::size_t bytes_read) { // from set_value
+                    [&buf] (std::size_t bytes_read) {           // from set_value
                       assert(bytes_read == sizeof(buf.size));
                       buf.data = std::make_unique<std::byte[]>(buf.size);
                       return std::span(buf.data.get(), buf.size);
                     })
                 | async_read(handle)
                 | then(
-                    [&buf] (std::size_t bytes_read) { // from set_value
+                    [&buf] (std::size_t bytes_read) {           // from set_value
                       assert(bytes_read == buf.size);
                       return std::move(buf);
                     });
@@ -413,7 +412,7 @@ do_read(tcp_socket& s, buffer& buf)
 {
     auto [ec, n] = co_await s.async_read(buf);
     if (ec)
-        co_yield with_error(ec); // unfortunately, terminates the coroutine
+        co_yield with_error(ec);        // unfortunately, terminates the coroutine
     co_return n;
 }
 ```
@@ -527,10 +526,8 @@ recycling_allocator<> alloc;
 auto op = connect(
     write_env(
         ex::on(sch,
-            // operator new allocates here...
-            handle_connection(std::move(conn))),
-        // ...but allocator arrives here
-        prop(get_allocator, alloc)),
+            handle_connection(std::move(conn))),   // operator new allocates here...
+        prop(get_allocator, alloc)),               // ...but allocator arrives here
     rcvr);
 start(op);
 ```
@@ -878,15 +875,10 @@ struct read_op
 {
     struct recv_rcvr {
         read_op* self_;
-        void set_value(std::size_t n) && noexcept {
-            self_->completed({}, n);
-        }
-        void set_error(std::error_code ec) && noexcept {
-            self_->completed(ec, 0);
-        }
+        void set_value(std::size_t n) && noexcept { self_->completed({}, n); }
+        void set_error(std::error_code ec) && noexcept { self_->completed(ec, 0); }
         void set_stopped() && noexcept {
-            execution::set_stopped(
-                std::move(self_->rcvr_));
+            execution::set_stopped(std::move(self_->rcvr_));
         }
     };
 
@@ -912,8 +904,7 @@ struct read_op
             return execution::set_value(std::move(rcvr_), bytes_read_);
         if (!ec)
             return start_recv();
-        // bytes_read_ bytes are lost
-        execution::set_error(std::move(rcvr_), ec);
+        execution::set_error(std::move(rcvr_), ec);   // bytes_read_ bytes are lost
     }
 };
 ```

d4007-senders-and-coros.html

@@ -312,7 +312,7 @@ struct fold_left_fn {
                     I i = first;
                     return (*this)(++i, last, u, f);      // recursive Kleisli composition
                 });
-        return std::move(nxt);                            // inductive case: bind + recurse
+        return std::move(nxt);                           // inductive case: bind + recurse
     }
 };
 ```
@@ -336,16 +336,16 @@ The `any_sender_of` type is provided by the [stdexec](https://github.com/NVIDIA/
 The following example is drawn from [backtrack.cpp](https://github.com/steve-downey/sender-examples/blob/main/src/examples/backtrack.cpp)<sup>[31]</sup> in the sender-examples repository:
 
 ```cpp
-auto search_tree(auto                    test,            // predicate
-                 tree::NodePtr<int>      tree,            // current node
-                 stdexec::scheduler auto sch,             // execution context
-                 any_node_sender&&       fail)            // the continuation (failure recovery)
+auto search_tree(auto                    test,  // predicate
+                 tree::NodePtr<int>      tree,  // current node
+                 stdexec::scheduler auto sch,   // execution context
+                 any_node_sender&&       fail)  // the continuation (failure recovery)
     -> any_node_sender {                                  // type-erased monadic return
     if (tree == nullptr) {
         return std::move(fail);                           // invoke the continuation
     }
     if (test(tree)) {
-        return stdexec::just(tree);                       // pure/return: lift into context
+        return stdexec::just(tree);                      // pure/return: lift into context
     }
     return stdexec::on(sch, stdexec::just())              // schedule on executor
       | stdexec::let_value(                               // monadic bind (>>=)
@@ -361,7 +361,8 @@ auto search_tree(auto                    test,            // predicate
                                     test,
                                     tree->right(),        // with failure continuation
                                     sch,
-                                    std::move(fail));     // continuation-passing failure recovery
+                                    std::move(fail));     // continuation-passing
+                                                          //   failure recovery
                             }));
             });
 }
@@ -387,7 +388,7 @@ The following example is drawn from [retry.hpp](https://github.com/NVIDIA/stdexe
 ```cpp
 // Deferred construction helper - emplaces non-movable types
 // into std::optional via conversion operator
-template <std::invocable Fun>                              // higher-order function wrapper
+template <std::invocable Fun>                             // higher-order function wrapper
     requires std::is_nothrow_move_constructible_v<Fun>
 struct _conv {
     Fun f_;                                               // stored callable
@@ -410,7 +411,7 @@ struct _retry_receiver                                    // receiver adaptor pa
           _retry_receiver<S, R>> {
     _op<S, R>* o_;                                        // pointer to owning op state
 
-    auto base() && noexcept -> R&& {                      // access inner receiver (rvalue)
+    auto base() && noexcept -> R&& {                     // access inner receiver (rvalue)
         return static_cast<R&&>(o_->r_);
     }
     auto base() const& noexcept -> const R& {             // access inner receiver (const)
@@ -429,31 +430,31 @@ struct _retry_receiver                                    // receiver adaptor pa
 // and re-constructed on each retry
 template <class S, class R>
 struct _op {
-    S s_;                                                 // the sender to retry
-    R r_;                                                 // the downstream receiver
-    std::optional<                                        // optional nested op state
-        stdexec::connect_result_t<                        //   type of connect(S, retry_rcvr)
-            S&, _retry_receiver<S, R>>> o_;               //   re-created on each retry
+    S s_;                                              // the sender to retry
+    R r_;                                              // the downstream receiver
+    std::optional<                                     // optional nested op state
+        stdexec::connect_result_t<                     //   type of connect(S, retry_rcvr)
+            S&, _retry_receiver<S, R>>> o_;            //   re-created on each retry
 
-    _op(S s, R r)                                         // construct from sender + receiver
+    _op(S s, R r)                                      // construct from sender + receiver
         : s_(static_cast<S&&>(s))
         , r_(static_cast<R&&>(r))
         , o_{_connect()} {}                               // initial connection
 
     _op(_op&&) = delete;                                  // immovable (stable address)
 
-    auto _connect() noexcept {                            // connect sender to retry receiver
-        return _conv{[this] {                             // deferred construction via _conv
-            return stdexec::connect(                      //   connect sender
-                s_,                                       //   to retry receiver
-                _retry_receiver<S, R>{this});             //   that points back to this op
+    auto _connect() noexcept {                         // connect sender to retry receiver
+        return _conv{[this] {                          // deferred construction via _conv
+            return stdexec::connect(                   //   connect sender
+                s_,                                    //   to retry receiver
+                _retry_receiver<S, R>{this});          //   that points back to this op
         }};
     }
 
     void _retry() noexcept {                              // retry: destroy and reconnect
         STDEXEC_TRY {
-            o_.emplace(_connect());                       // re-emplace the operation state
-            stdexec::start(*o_);                          // restart the operation
+            o_.emplace(_connect());                    // re-emplace the operation state
+            stdexec::start(*o_);                       // restart the operation
         }
         STDEXEC_CATCH_ALL {                               // if reconnection itself throws
             stdexec::set_error(                           //   propagate to downstream
@@ -477,15 +478,15 @@ struct _retry_sender {
     explicit _retry_sender(S s)                           // construct from inner sender
         : s_(static_cast<S&&>(s)) {}
 
-    template <class>                                       // completion signature transform:
-    using _error = stdexec::completion_signatures<>;      //   remove all error signatures
+    template <class>                                    // completion signature transform:
+    using _error = stdexec::completion_signatures<>;   //   remove all error signatures
 
     template <class... Args>
     using _value =                                        // pass through value signatures
         stdexec::completion_signatures<
             stdexec::set_value_t(Args...)>;
 
-    template <class Self, class... Env>                    // compute transformed signatures
+    template <class Self, class... Env>                 // compute transformed signatures
     static consteval auto get_completion_signatures()
         -> stdexec::transform_completion_signatures<      // signature transformation
             stdexec::completion_signatures_of_t<S&, Env...>, // from inner sender's sigs
@@ -569,7 +570,7 @@ auto schedule() const noexcept {
 
 ```cpp
 // From nvexec/stream/common.cuh - CUDA kernel launch syntax
-continuation_kernel<<<1, 1, 0, get_stream()>>>(           // <<<grid, block, smem, stream>>>
+continuation_kernel<<<1, 1, 0, get_stream()>>>(  // <<<grid, block, smem, stream>>>
     static_cast<R&&>(rcvr_), Tag(), static_cast<Args&&>(args)...);
 ```