[thread.lock] - C++20 → C++23

Files changed (1) hide show

tmp/tmp72ygan_h/{from.md → to.md} +69 -71

tmp/tmp72ygan_h/{from.md → to.md} RENAMED Viewed

@@ -1,7 +1,9 @@
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
 managing ownership of a lockable object in an exception safe manner. A
 lock is said to *own* a lockable object if it is currently managing the
@@ -61,39 +63,36 @@ object referenced by `pm` does not exist for the entire lifetime of the
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex, the calling
-thread does not own the mutex `m`.
 *Effects:* Initializes `pm` with `m`. Calls `m.lock()`.
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
-*Preconditions:* The calling thread owns the mutex `m`.
 *Effects:* Initializes `pm` with `m`.
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
 ```
-*Effects:* As if by `pm.unlock()`.
 #### Class template `scoped_lock` <a id="thread.lock.scoped">[[thread.lock.scoped]]</a>
 ``` cpp
 namespace std {
   template<class... MutexTypes>
   class scoped_lock {
   public:
-    using mutex_type = Mutex; // If MutexTypes... consists of the single type Mutex
     explicit scoped_lock(MutexTypes&... m);
     explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
     ~scoped_lock();
@@ -109,32 +108,35 @@ namespace std {
 An object of type `scoped_lock` controls the ownership of lockable
 objects within a scope. A `scoped_lock` object maintains ownership of
 lockable objects throughout the `scoped_lock` object’s lifetime
 [[basic.life]]. The behavior of a program is undefined if the lockable
 objects referenced by `pm` do not exist for the entire lifetime of the
-`scoped_lock` object. When `sizeof...(MutexTypes)` is `1`, the supplied
-`Mutex` type shall meet the *Cpp17BasicLockable* requirements
-[[thread.req.lockable.basic]]. Otherwise, each of the mutex types shall
-meet the *Cpp17Lockable* requirements [[thread.req.lockable.req]].
 ``` cpp
 explicit scoped_lock(MutexTypes&... m);
 ```
-*Preconditions:* If a `MutexTypes` type is not a recursive mutex, the
-calling thread does not own the corresponding mutex element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`. Then if
 `sizeof...(MutexTypes)` is `0`, no effects. Otherwise if
 `sizeof...(MutexTypes)` is `1`, then `m.lock()`. Otherwise,
 `lock(m...)`.
 ``` cpp
 explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 ```
-*Preconditions:* The calling thread owns all the mutexes in `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
@@ -145,10 +147,12 @@ explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 *Effects:* For all `i` in \[`0`, `sizeof...(MutexTypes)`),
 `get<i>(pm).unlock()`.
 #### Class template `unique_lock` <a id="thread.lock.unique">[[thread.lock.unique]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class unique_lock {
   public:
@@ -194,13 +198,10 @@ namespace std {
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
-  template<class Mutex>
-    void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
 An object of type `unique_lock` controls the ownership of a lockable
 object within a scope. Ownership of the lockable object may be acquired
@@ -224,19 +225,16 @@ meets the *Cpp17TimedLockable* requirements. — *end note*]
 ``` cpp
 unique_lock() noexcept;
 ```
-*Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex the calling
-thread does not own the mutex.
 *Effects:* Calls `m.lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
@@ -248,35 +246,33 @@ unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
 *Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
-requirements [[thread.req.lockable.req]]. If `mutex_type` is not a
-recursive mutex the calling thread does not own the mutex.
 *Effects:* Calls `m.try_lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
-*Preconditions:* The calling thread owns the mutex.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template<class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex the calling
-thread does not own the mutex. The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
@@ -285,12 +281,11 @@ value returned by the call to `m.try_lock_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex the calling
-thread does not own the mutex. The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
@@ -351,14 +346,14 @@ bool try_lock();
 *Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
 requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
-*Returns:* The value returned by the call to `try_lock()`.
-*Ensures:* `owns == res`, where `res` is the value returned by the call
-to `try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
 an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -374,17 +369,17 @@ template<class Clock, class Duration>
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
-*Returns:* The value returned by the call to `try_lock_until(abs_time)`.
-*Ensures:* `owns == res`, where `res` is the value returned by the call
-to `try_lock_until(abs_time)`.
-*Throws:* Any exception thrown by `pm->try_lock_until()`. `system_error`
-when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -397,17 +392,17 @@ template<class Rep, class Period>
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
-*Returns:* The value returned by the call to `try_lock_for(rel_time)`.
-*Ensures:* `owns == res`, where `res` is the value returned by the call
-to `try_lock_for(rel_time)`.
-*Throws:* Any exception thrown by `pm->try_lock_for()`. `system_error`
-when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -437,14 +432,14 @@ void swap(unique_lock& u) noexcept;
 ``` cpp
 mutex_type* release() noexcept;
 ```
-*Returns:* The previous value of `pm`.
 *Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
@@ -470,10 +465,12 @@ mutex_type *mutex() const noexcept;
 *Returns:* `pm`.
 #### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class shared_lock {
   public:
@@ -517,13 +514,10 @@ namespace std {
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
-  template<class Mutex>
-    void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
@@ -531,15 +525,19 @@ may be acquired at construction or after construction, and may be
 transferred, after acquisition, to another `shared_lock` object. Objects
 of type `shared_lock` are not copyable but are movable. The behavior of
 a program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
 remaining lifetime [[basic.life]] of the `shared_lock` object. The
-supplied `Mutex` type shall meet the shared mutex requirements
-[[thread.sharedtimedmutex.requirements]].
-[*Note 1*: `shared_lock<Mutex>` meets the *Cpp17TimedLockable*
-requirements [[thread.req.lockable.timed]]. — *end note*]
 ##### Constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
@@ -549,13 +547,10 @@ shared_lock() noexcept;
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
@@ -566,34 +561,31 @@ shared_lock(mutex_type& m, defer_lock_t) noexcept;
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.try_lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared()`.
 ``` cpp
 shared_lock(mutex_type& m, adopt_lock_t);
 ```
-*Preconditions:* The calling thread has shared ownership of the mutex.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 template<class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.try_lock_shared_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_until(abs_time)`.
@@ -602,12 +594,12 @@ value returned by the call to `m.try_lock_shared_until(abs_time)`.
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.try_lock_shared_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_for(rel_time)`.
@@ -658,15 +650,15 @@ when an exception is required [[thread.req.exception]].
 bool try_lock();
 ```
 *Effects:* As if by `pm->try_lock_shared()`.
-*Returns:* The value returned by the call to `pm->try_lock_shared()`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared()`.
 *Throws:* Any exception thrown by `pm->try_lock_shared()`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -676,18 +668,21 @@ to `pm->try_lock_shared()`.
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *Effects:* As if by `pm->try_lock_shared_until(abs_time)`.
-*Returns:* The value returned by the call to
-`pm->try_lock_shared_until(abs_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -697,18 +692,21 @@ to `pm->try_lock_shared_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
 *Effects:* As if by `pm->try_lock_shared_for(rel_time)`.
-*Returns:* The value returned by the call to
-`pm->try_lock_shared_for(rel_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -740,14 +738,14 @@ void swap(shared_lock& sl) noexcept;
 ``` cpp
 mutex_type* release() noexcept;
 ```
-*Returns:* The previous value of `pm`.
 *Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```

 ### Locks <a id="thread.lock">[[thread.lock]]</a>
+#### General <a id="thread.lock.general">[[thread.lock.general]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
 managing ownership of a lockable object in an exception safe manner. A
 lock is said to *own* a lockable object if it is currently managing the
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
 *Effects:* Initializes `pm` with `m`. Calls `m.lock()`.
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on `m`.
 *Effects:* Initializes `pm` with `m`.
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
 ```
+*Effects:* Equivalent to: `pm.unlock()`
 #### Class template `scoped_lock` <a id="thread.lock.scoped">[[thread.lock.scoped]]</a>
 ``` cpp
 namespace std {
   template<class... MutexTypes>
   class scoped_lock {
   public:
+    using mutex_type = see below; // Only if sizeof...(MutexTypes) == 1 is true
     explicit scoped_lock(MutexTypes&... m);
     explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
     ~scoped_lock();
 An object of type `scoped_lock` controls the ownership of lockable
 objects within a scope. A `scoped_lock` object maintains ownership of
 lockable objects throughout the `scoped_lock` object’s lifetime
 [[basic.life]]. The behavior of a program is undefined if the lockable
 objects referenced by `pm` do not exist for the entire lifetime of the
+`scoped_lock` object.
+- If `sizeof...(MutexTypes)` is one, let `Mutex` denote the sole type
+  constituting the pack `MutexTypes`. `Mutex` shall meet the
+  *Cpp17BasicLockable* requirements [[thread.req.lockable.basic]]. The
+  member *typedef-name* `mutex_type` denotes the same type as `Mutex`.
+- Otherwise, all types in the template parameter pack `MutexTypes` shall
+  meet the *Cpp17Lockable* requirements [[thread.req.lockable.req]] and
+  there is no member `mutex_type`.
 ``` cpp
 explicit scoped_lock(MutexTypes&... m);
 ```
 *Effects:* Initializes `pm` with `tie(m...)`. Then if
 `sizeof...(MutexTypes)` is `0`, no effects. Otherwise if
 `sizeof...(MutexTypes)` is `1`, then `m.lock()`. Otherwise,
 `lock(m...)`.
 ``` cpp
 explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on each
+element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
 *Effects:* For all `i` in \[`0`, `sizeof...(MutexTypes)`),
 `get<i>(pm).unlock()`.
 #### Class template `unique_lock` <a id="thread.lock.unique">[[thread.lock.unique]]</a>
+##### General <a id="thread.lock.unique.general">[[thread.lock.unique.general]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class unique_lock {
   public:
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
 }
 ```
 An object of type `unique_lock` controls the ownership of a lockable
 object within a scope. Ownership of the lockable object may be acquired
 ``` cpp
 unique_lock() noexcept;
 ```
+*Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
 *Effects:* Calls `m.lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
 *Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]].
 *Effects:* Calls `m.try_lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on `m`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template<class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 *Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
 requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock()`.
+*Returns:* The value returned by `pm->try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
 an exception is required [[thread.req.exception]].
 *Error conditions:*
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock_until(abs_time)`.
+*Returns:* The value returned by `pm->try_lock_until(abs_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_until(abstime)`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock_for(rel_time)`.
+*Returns:* The value returned by `pm->try_lock_for(rel_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_for(rel_time)`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 mutex_type* release() noexcept;
 ```
 *Ensures:* `pm == 0` and `owns == false`.
+*Returns:* The previous value of `pm`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
 *Returns:* `pm`.
 #### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
+##### General <a id="thread.lock.shared.general">[[thread.lock.shared.general]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class shared_lock {
   public:
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
 }
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
 transferred, after acquisition, to another `shared_lock` object. Objects
 of type `shared_lock` are not copyable but are movable. The behavior of
 a program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
 remaining lifetime [[basic.life]] of the `shared_lock` object. The
+supplied `Mutex` type shall meet the *Cpp17SharedLockable* requirements
+[[thread.req.lockable.shared]].
+[*Note 1*: `shared_lock<Mutex>` meets the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]]. If `Mutex` meets the
+*Cpp17SharedTimedLockable* requirements
+[[thread.req.lockable.shared.timed]], `shared_lock<Mutex>` also meets
+the *Cpp17TimedLockable* requirements
+[[thread.req.lockable.timed]]. — *end note*]
 ##### Constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
 *Effects:* Calls `m.lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
 *Effects:* Calls `m.try_lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared()`.
 ``` cpp
 shared_lock(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a shared lock on `m`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 template<class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* Calls `m.try_lock_shared_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_until(abs_time)`.
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* Calls `m.try_lock_shared_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_for(rel_time)`.
 bool try_lock();
 ```
 *Effects:* As if by `pm->try_lock_shared()`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared()`.
+*Returns:* The value returned by the call to `pm->try_lock_shared()`.
 *Throws:* Any exception thrown by `pm->try_lock_shared()`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* As if by `pm->try_lock_shared_until(abs_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_until(abs_time)`.
+*Returns:* The value returned by the call to
+`pm->try_lock_shared_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* As if by `pm->try_lock_shared_for(rel_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_for(rel_time)`.
+*Returns:* The value returned by the call to
+`pm->try_lock_shared_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 ``` cpp
 mutex_type* release() noexcept;
 ```
 *Ensures:* `pm == nullptr` and `owns == false`.
+*Returns:* The previous value of `pm`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```

Diff to HTML by rtfpessoa