P3833R1

Signed-off-by: Ted Lyngmo <ted@lyncon.se>

Author: TedLyngmo

P3833/P3833.md

@@ -2,35 +2,42 @@
 title: "`std::multi_lock`"
 ---
 
-- **Document number:** P3833R1a
+- **Document number:** P3833R1
 - **Date:** 2026-03-24
 - **Audience:** LEWGI/SG1
 - **Project:** ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
 - **Reply-to:** Ted Lyngmo <ted@lyncon.se>
 
+## Revision History
+
+### R1
+
+- Rewrote postconditions throughout the wording to use prose ("is equal to", "is `true`", "is `false`") instead of `==` notation.
+
 ## Abstract
 
 This paper proposes `std::multi_lock`, a RAII class template that combines the functionality of `std::unique_lock` and `std::scoped_lock`. Unlike `std::scoped_lock`, which provides only basic RAII semantics, `std::multi_lock` offers the full flexibility of `std::unique_lock` (deferred locking, try-lock operations, timed locking, and ownership transfer) while supporting multiple mutexes simultaneously.
 
 ## Contents
 
-1. [Motivation](#motivation)
-2. [Proposed Solution](#proposed-solution)
-3. [Impact on the Standard](#impact-on-the-standard)
-4. [Design Decisions](#design-decisions)
+1. [Revision History](#revision-history)
+2. [Motivation](#motivation)
+3. [Proposed Solution](#proposed-solution)
+4. [Impact on the Standard](#impact-on-the-standard)
+5. [Design Decisions](#design-decisions)
    - [Return value for try-lock operations](#return-value-for-try-lock-operations)
    - [Timed locking with multiple mutexes](#timed-locking-with-multiple-mutexes)
    - [Exception Safety](#exception-safety)
    - [Deadlock Avoidance](#deadlock-avoidance)
-5. [Technical Specification](#technical-specification)
+6. [Technical Specification](#technical-specification)
    - [Header `<mutex>` synopsis](#header-mutex-synopsis)
    - [Class template `multi_lock`](#class-template-multi_lock)
-6. [Alternative Designs Considered](#alternative-designs-considered)
-7. [Implementation Experience](#implementation-experience)
-8. [Wording](#wording)
-9. [References](#references)
+7. [Alternative Designs Considered](#alternative-designs-considered)
+8. [Implementation Experience](#implementation-experience)
+9. [Wording](#wording)
+10. [References](#references)
 
-## 1. Motivation
+## 2. Motivation
 
 The C++ standard library provides several mutex wrapper classes:
 
@@ -58,7 +65,7 @@ The following table illustrates how `multi_lock` completes the family of mutex w
 
 (*) Supports deferred locking, time-constrained attempts at locking, recursive locking, and transfer of lock ownership.
 
-## 2. Proposed Solution
+## 3. Proposed Solution
 
 This paper proposes `std::multi_lock<Ms...>`, a variadic class template that:
 
@@ -123,11 +130,11 @@ for(int rv; (rv = lock.try_lock_for(100ms)) != -1;) {
 // critical section
 ```
 
-## 3. Impact on the Standard
+## 4. Impact on the Standard
 
 This proposal is a pure library extension. It adds a new class template `std::multi_lock` to the `<mutex>` header and updates related sections of the standard to reference it. There are no changes to the core language and no breaking changes to existing code.
 
-## 4. Design Decisions
+## 5. Design Decisions
 
 ### Return value for try-lock operations
 
@@ -159,7 +166,7 @@ When locking multiple mutexes, `std::multi_lock` must avoid deadlock. The implem
 - For `try_lock()`: Attempts to lock mutexes in order and backs off if any lock fails. It can use `std::try_lock(*get<Is>(pm)...)` for this purpose.
 - For `try_lock_until()` and `try_lock_for()`: It can use an algorithm similar to `std::lock()` but with timed operations, as proposed in P3832.
 
-## 5. Technical Specification
+## 6. Technical Specification
 
 ### Header `<mutex>` synopsis
 
@@ -237,7 +244,7 @@ namespace std {
 }
 ```
 
-## 6. Alternative Designs Considered
+## 7. Alternative Designs Considered
 
 ### Container-based Interface
 
@@ -256,11 +263,11 @@ multi_lock(std::span<Mutex*> mutexes);
 
 **Rejected:** Both approaches require all mutexes to be of the same type. While `std::span` avoids ownership concerns and could be non-owning, it still cannot mix different mutex types (e.g., `std::mutex` and `std::timed_mutex` in the same lock). The variadic template approach maintains type safety, allows heterogeneous mutex types, and enables compile-time optimizations that would not be possible with a runtime container. Additionally, it is probably preferable to keep the interface similar to that of `unique_lock` and `scoped_lock` to complete the family of mutex wrapper classes with a consistent design.
 
-## 7. Implementation Experience
+## 8. Implementation Experience
 
 A complete implementation is available at [github.com/bemanproject/timed_lock_alg](https://github.com/bemanproject/timed_lock_alg). The implementation has been tested with multiple mutex types and demonstrates that the design is implementable and practical.
 
-## 8. Wording
+## 9. Wording
 
 The following changes are relative to N5014.
 
@@ -568,7 +575,7 @@ mutex_type mutex() const noexcept;
 
 **3**        *Returns*: `pm`.
 
-## 9. References
+## 10. References
 
 - N5014: Working Draft, Standard for Programming Language C++
 - [P0156R2](https://wg21.link/p0156r2): Variadic `lock_guard` (scoped_lock)