[unique.ptr] - C++17 → C++20

Files changed (1) hide show

tmp/tmpz4clb0ex/{from.md → to.md} +250 -298

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

@@ -2,105 +2,35 @@
 A *unique pointer* is an object that owns another object and manages
 that other object through a pointer. More precisely, a unique pointer is
 an object *u* that stores a pointer to a second object *p* and will
 dispose of *p* when *u* is itself destroyed (e.g., when leaving block
-scope ([[stmt.dcl]])). In this context, *u* is said to *own* `p`.
 The mechanism by which *u* disposes of *p* is known as *p*’s associated
 *deleter*, a function object whose correct invocation results in *p*’s
 appropriate disposition (typically its deletion).
 Let the notation *u.p* denote the pointer stored by *u*, and let *u.d*
 denote the associated deleter. Upon request, *u* can *reset* (replace)
-*u.p* and *u.d* with another pointer and deleter, but must properly
-dispose of its owned object via the associated deleter before such
-replacement is considered completed.
-Additionally, *u* can, upon request, *transfer ownership* to another
-unique pointer *u2*. Upon completion of such a transfer, the following
-postconditions hold:
-- *u2.p* is equal to the pre-transfer *u.p*,
-- *u.p* is equal to `nullptr`, and
-- if the pre-transfer *u.d* maintained state, such state has been
-  transferred to *u2.d*.
-As in the case of a reset, *u2* must properly dispose of its
-pre-transfer owned object via the pre-transfer associated deleter before
-the ownership transfer is considered complete.
-[*Note 1*: A deleter’s state need never be copied, only moved or
-swapped as ownership is transferred. — *end note*]
 Each object of a type `U` instantiated from the `unique_ptr` template
 specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
-semantics, each such `U` is `MoveConstructible` and `MoveAssignable`,
-but is not `CopyConstructible` nor `CopyAssignable`. The template
-parameter `T` of `unique_ptr` may be an incomplete type.
-[*Note 2*: The uses of `unique_ptr` include providing exception safety
 for dynamically allocated memory, passing ownership of dynamically
 allocated memory to a function, and returning dynamically allocated
 memory from a function. — *end note*]
-``` cpp
-namespace std {
-  template<class T> struct default_delete;
-  template<class T> struct default_delete<T[]>;
-  template<class T, class D = default_delete<T>> class unique_ptr;
-  template<class T, class D> class unique_ptr<T[], D>;
-  template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
-  template<class T> unique_ptr<T> make_unique(size_t n);
-  template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
-  template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
-  template<class T1, class D1, class T2, class D2>
-    bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template <class T, class D>
-    bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-  template <class T, class D>
-    bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
-  template <class T, class D>
-    bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-  template <class T, class D>
-    bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
-  template <class T, class D>
-    bool operator<(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator<(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator>(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator>(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
-}
-```
 #### Default deleters <a id="unique.ptr.dltr">[[unique.ptr.dltr]]</a>
 ##### In general <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
@@ -123,24 +53,23 @@ namespace std {
 ``` cpp
 template<class U> default_delete(const default_delete<U>& other) noexcept;
 ```
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U>` object.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `U*` is implicitly convertible to `T*`.
 ``` cpp
 void operator()(T* ptr) const;
 ```
 *Effects:* Calls `delete` on `ptr`.
-*Remarks:* If `T` is an incomplete type, the program is ill-formed.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
@@ -153,26 +82,25 @@ namespace std {
 ``` cpp
 template<class U> default_delete(const default_delete<U[]>& other) noexcept;
 ```
-*Effects:* constructs a `default_delete` object from another
 `default_delete<U[]>` object.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `U(*)[]` is convertible to `T(*)[]`.
 ``` cpp
 template<class U> void operator()(U* ptr) const;
 ```
 *Effects:* Calls `delete[]` on `ptr`.
-*Remarks:* If `U` is an incomplete type, the program is ill-formed. This
-function shall not participate in overload resolution unless `U(*)[]` is
-convertible to `T(*)[]`.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
@@ -194,11 +122,12 @@ namespace std {
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
-    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
     add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
@@ -218,126 +147,107 @@ namespace std {
   };
 }
 ```
 The default type for the template parameter `D` is `default_delete`. A
-client-supplied template argument `D` shall be a function object type (
-[[function.objects]]), lvalue reference to function, or lvalue reference
 to function object type for which, given a value `d` of type `D` and a
 value `ptr` of type `unique_ptr<T, D>::pointer`, the expression `d(ptr)`
 is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
-If the deleter’s type `D` is not a reference type, `D` shall satisfy the
-requirements of `Destructible` (Table  [[tab:destructible]]).
 If the *qualified-id* `remove_reference_t<D>::pointer` is valid and
-denotes a type ([[temp.deduct]]), then `unique_ptr<T,
 D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
 Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for
 `element_type*`. The type `unique_ptr<T,
-D>::pointer` shall satisfy the requirements of `NullablePointer` (
-[[nullablepointer.requirements]]).
-[*Example 1*: Given an allocator type `X` ([[allocator.requirements]])
-and letting `A` be a synonym for `allocator_traits<X>`, the types
 `A::pointer`, `A::const_pointer`, `A::void_pointer`, and
 `A::const_void_pointer` may be used as
 `unique_ptr<T, D>::pointer`. — *end example*]
-##### `unique_ptr` constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 constexpr unique_ptr(nullptr_t) noexcept;
 ```
-*Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[tab:defaultconstructible]]), and that construction shall not
-throw an exception.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
-*Postconditions:* `get() == nullptr`. `get_deleter()` returns a
-reference to the stored deleter.
-*Remarks:* If `is_pointer_v<deleter_type>` is `true` or
-`is_default_constructible_v<deleter_type>` is `false`, this constructor
-shall not participate in overload resolution.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
-*Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[tab:defaultconstructible]]), and that construction shall not
-throw an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
-*Postconditions:* `get() == p`. `get_deleter()` returns a reference to
-the stored deleter.
-*Remarks:* If `is_pointer_v<deleter_type>` is `true` or
-`is_default_constructible_v<deleter_type>` is `false`, this constructor
-shall not participate in overload resolution. If class template argument
-deduction ([[over.match.class.deduct]]) would select the function
-template corresponding to this constructor, then the program is
-ill-formed.
-``` cpp
-unique_ptr(pointer p, see below d1) noexcept;
-unique_ptr(pointer p, see below d2) noexcept;
-```
-The signature of these constructors depends upon whether `D` is a
-reference type. If `D` is a non-reference type `A`, then the signatures
-are:
 ``` cpp
-unique_ptr(pointer p, const A& d) noexcept;
-unique_ptr(pointer p, A&& d) noexcept;
 ```
-If `D` is an lvalue reference type `A&`, then the signatures are:
-``` cpp
-unique_ptr(pointer p, A& d) noexcept;
-unique_ptr(pointer p, A&& d) = delete;
-```
-If `D` is an lvalue reference type `const A&`, then the signatures are:
-``` cpp
-unique_ptr(pointer p, const A& d) noexcept;
-unique_ptr(pointer p, const A&& d) = delete;
-```
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
 the stored pointer with `p` and initializing the deleter from
 `std::forward<decltype(d)>(d)`.
-*Remarks:* These constructors shall not participate in overload
-resolution unless `is_constructible_v<D, decltype(d)>` is `true`.
-*Postconditions:* `get() == p`. `get_deleter()` returns a reference to
-the stored deleter. If `D` is a reference type then `get_deleter()`
-returns a reference to the lvalue `d`.
-*Remarks:* If class template argument
-deduction ([[over.match.class.deduct]]) would select a function
-template corresponding to either of these constructors, then the program
-is ill-formed.
 [*Example 1*:
 ``` cpp
 D d;
-unique_ptr<int, D> p1(new int, D());        // D must be MoveConstructible
-unique_ptr<int, D> p2(new int, d);          // D must be CopyConstructible
 unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
 ```
@@ -345,142 +255,144 @@ unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object comb
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
-*Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveConstructible` (Table  [[tab:moveconstructible]]).
-Construction of the deleter from an rvalue of type `D` shall not throw
-an exception.
-*Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
-to `*this`. If `D` is a reference type, this deleter is copy constructed
-from `u`’s deleter; otherwise, this deleter is move constructed from
-`u`’s deleter.
-[*Note 1*: The deleter constructor can be implemented with
 `std::forward<D>`. — *end note*]
-*Postconditions:* `get()` yields the value `u.get()` yielded before the
-construction. `get_deleter()` returns a reference to the stored deleter
-that was constructed from `u.get_deleter()`. If `D` is a reference type
-then `get_deleter()` and `u.get_deleter()` both reference the same
-lvalue deleter.
 ``` cpp
 template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
-*Requires:* If `E` is not a reference type, construction of the deleter
-from an rvalue of type `E` shall be well formed and shall not throw an
 exception. Otherwise, `E` is a reference type and construction of the
-deleter from an lvalue of type `E` shall be well formed and shall not
-throw an exception.
-*Remarks:* This constructor shall not participate in overload resolution
-unless:
-- `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
-- `U` is not an array type, and
-- either `D` is a reference type and `E` is the same type as `D`, or `D`
-  is not a reference type and `E` is implicitly convertible to `D`.
-*Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
-to `*this`. If `E` is a reference type, this deleter is copy constructed
-from `u`’s deleter; otherwise, this deleter is move constructed from
-`u`’s deleter.
 [*Note 2*: The deleter constructor can be implemented with
 `std::forward<E>`. — *end note*]
-*Postconditions:* `get()` yields the value `u.get()` yielded before the
-construction. `get_deleter()` returns a reference to the stored deleter
-that was constructed from `u.get_deleter()`.
-##### `unique_ptr` destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
-*Requires:* The expression `get_deleter()(get())` shall be well formed,
-shall have well-defined behavior, and shall not throw exceptions.
 [*Note 3*: The use of `default_delete` requires `T` to be a complete
 type. — *end note*]
 *Effects:* If `get() == nullptr` there are no effects. Otherwise
 `get_deleter()(get())`.
-##### `unique_ptr` assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
-*Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveAssignable` (Table  [[tab:moveassignable]]) and
-assignment of the deleter from an rvalue of type `D` shall not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
-shall satisfy the `CopyAssignable` requirements and assignment of the
-deleter from an lvalue of type `D` shall not throw an exception.
-*Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by
 `get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
-*Requires:* If `E` is not a reference type, assignment of the deleter
-from an rvalue of type `E` shall be well-formed and shall not throw an
-exception. Otherwise, `E` is a reference type and assignment of the
-deleter from an lvalue of type `E` shall be well-formed and shall not
-throw an exception.
-*Remarks:* This operator shall not participate in overload resolution
-unless:
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
   and
 - `U` is not an array type, and
 - `is_assignable_v<D&, E&&>` is `true`.
-*Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
 *Effects:* As if by `reset()`.
-*Postconditions:* `get() == nullptr`.
 *Returns:* `*this`.
-##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
 add_lvalue_reference_t<T> operator*() const;
 ```
-*Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 pointer operator->() const noexcept;
 ```
-*Requires:* `get() != nullptr`.
 *Returns:* `get()`.
 [*Note 4*: The use of this function typically requires that `T` be a
 complete type. — *end note*]
@@ -502,47 +414,46 @@ const deleter_type& get_deleter() const noexcept;
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
-##### `unique_ptr` modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
 pointer release() noexcept;
 ```
-*Postconditions:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
-*Requires:* The expression `get_deleter()(get())` shall be well formed,
-shall have well-defined behavior, and shall not throw exceptions.
 *Effects:* Assigns `p` to the stored pointer, and then if and only if
 the old value of the stored pointer, `old_p`, was not equal to
 `nullptr`, calls `get_deleter()(old_p)`.
 [*Note 5*: The order of these operations is significant because the
 call to `get_deleter()` may destroy `*this`. — *end note*]
-*Postconditions:* `get() == p`.
 [*Note 6*: The postcondition does not hold if the call to
 `get_deleter()` destroys `*this` since `this->get()` is no longer a
 valid expression. — *end note*]
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
-*Requires:* `get_deleter()` shall be
-swappable ([[swappable.requirements]]) and shall not throw an exception
-under `swap`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.
 #### `unique_ptr` for array objects with a runtime length <a id="unique.ptr.runtime">[[unique.ptr.runtime]]</a>
@@ -610,19 +521,20 @@ interface.
 Descriptions are provided below only for members that differ from the
 primary template.
 The template argument `T` shall be a complete type.
-##### `unique_ptr` constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
 template<class U> explicit unique_ptr(U p) noexcept;
 ```
 This constructor behaves the same as the constructor in the primary
-template that takes a single parameter of type `pointer` except that it
-additionally shall not participate in overload resolution unless
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
@@ -630,70 +542,68 @@ additionally shall not participate in overload resolution unless
 template<class U> unique_ptr(U p, see below d) noexcept;
 template<class U> unique_ptr(U p, see below d) noexcept;
 ```
 These constructors behave the same as the constructors in the primary
-template that take a parameter of type `pointer` and a second parameter
-except that they shall not participate in overload resolution unless
-either
 - `U` is the same type as `pointer`,
 - `U` is `nullptr_t`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
-template <class U, class E>
-  unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
-This constructor behaves the same as in the primary template, except
-that it shall not participate in overload resolution unless all of the
-following conditions hold, where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - either `D` is a reference type and `E` is the same type as `D`, or `D`
   is not a reference type and `E` is implicitly convertible to `D`.
-[*Note 1*: This replaces the overload-resolution specification of the
-primary template — *end note*]
-##### `unique_ptr` assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
-template <class U, class E>
-  unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;
 ```
-This operator behaves the same as in the primary template, except that
-it shall not participate in overload resolution unless all of the
-following conditions hold, where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - `is_assignable_v<D&, E&&>` is `true`.
-[*Note 2*: This replaces the overload-resolution specification of the
-primary template — *end note*]
-##### `unique_ptr` observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
 ```
-*Requires:* `i <` the number of elements in the array to which the
 stored pointer points.
 *Returns:* `get()[i]`.
-##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
 void reset(nullptr_t p = nullptr) noexcept;
 ```
@@ -702,145 +612,165 @@ void reset(nullptr_t p = nullptr) noexcept;
 ``` cpp
 template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
-template, except that it shall not participate in overload resolution
-unless either
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
-#### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `T` is not an array.
 *Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
 ``` cpp
 template<class T> unique_ptr<T> make_unique(size_t n);
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
 ``` cpp
 template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `T` is an array of known bound.
-#### `unique_ptr` specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
-``` cpp
-template <class T1, class D1, class T2, class D2>
-  bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-```
-*Returns:* `x.get() != y.get()`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
-*Requires:* Let *`CT`* denote
 ``` cpp
 common_type_t<typename unique_ptr<T1, D1>::pointer,
               typename unique_ptr<T2, D2>::pointer>
 ```
-Then the specialization `less<`*`CT`*`>` shall be a function object
-type ([[function.objects]]) that induces a strict weak
-ordering ([[alg.sorting]]) on the pointer values.
-*Returns:* `less<`*`CT`*`>()(x.get(), y.get())`.
-*Remarks:* If `unique_ptr<T1, D1>::pointer` is not implicitly
-convertible to *`CT`* or `unique_ptr<T2, D2>::pointer` is not implicitly
-convertible to *`CT`*, the program is ill-formed.
-``` cpp
-template <class T1, class D1, class T2, class D2>
-  bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-```
-*Returns:* `!(y < x)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `y < x`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `!(x < y)`.
 ``` cpp
 template<class T, class D>
   bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-template <class T, class D>
-  bool operator==(nullptr_t, const unique_ptr<T, D>& x) noexcept;
 ```
 *Returns:* `!x`.
-``` cpp
-template <class T, class D>
-  bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-template <class T, class D>
-  bool operator!=(nullptr_t, const unique_ptr<T, D>& x) noexcept;
-```
-*Returns:* `(bool)x`.
 ``` cpp
 template<class T, class D>
   bool operator<(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
   bool operator<(nullptr_t, const unique_ptr<T, D>& x);
 ```
-*Requires:* The specialization `less<unique_ptr<T, D>::pointer>` shall
-be a function object type ([[function.objects]]) that induces a strict
-weak ordering ([[alg.sorting]]) on the pointer values.
 *Returns:* The first function template returns
-`less<unique_ptr<T, D>::pointer>()(x.get(),`
-`nullptr)`. The second function template returns
-`less<unique_ptr<T, D>::pointer>()(nullptr, x.get())`.
 ``` cpp
 template<class T, class D>
   bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
@@ -868,5 +798,27 @@ template <class T, class D>
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.

 A *unique pointer* is an object that owns another object and manages
 that other object through a pointer. More precisely, a unique pointer is
 an object *u* that stores a pointer to a second object *p* and will
 dispose of *p* when *u* is itself destroyed (e.g., when leaving block
+scope [[stmt.dcl]]). In this context, *u* is said to *own* `p`.
 The mechanism by which *u* disposes of *p* is known as *p*’s associated
 *deleter*, a function object whose correct invocation results in *p*’s
 appropriate disposition (typically its deletion).
 Let the notation *u.p* denote the pointer stored by *u*, and let *u.d*
 denote the associated deleter. Upon request, *u* can *reset* (replace)
+*u.p* and *u.d* with another pointer and deleter, but properly disposes
+of its owned object via the associated deleter before such replacement
+is considered completed.
 Each object of a type `U` instantiated from the `unique_ptr` template
 specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
+semantics, each such `U` is *Cpp17MoveConstructible* and
+*Cpp17MoveAssignable*, but is not *Cpp17CopyConstructible* nor
+*Cpp17CopyAssignable*. The template parameter `T` of `unique_ptr` may be
+an incomplete type.
+[*Note 1*: The uses of `unique_ptr` include providing exception safety
 for dynamically allocated memory, passing ownership of dynamically
 allocated memory to a function, and returning dynamically allocated
 memory from a function. — *end note*]
 #### Default deleters <a id="unique.ptr.dltr">[[unique.ptr.dltr]]</a>
 ##### In general <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
 ``` cpp
 template<class U> default_delete(const default_delete<U>& other) noexcept;
 ```
+*Constraints:* `U*` is implicitly convertible to `T*`.
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U>` object.
 ``` cpp
 void operator()(T* ptr) const;
 ```
+*Mandates:* `T` is a complete type.
 *Effects:* Calls `delete` on `ptr`.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
 ``` cpp
 template<class U> default_delete(const default_delete<U[]>& other) noexcept;
 ```
+*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
+*Effects:* Constructs a `default_delete` object from another
 `default_delete<U[]>` object.
 ``` cpp
 template<class U> void operator()(U* ptr) const;
 ```
+*Mandates:* `U` is a complete type.
+*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Effects:* Calls `delete[]` on `ptr`.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
+    template<class U, class E>
+      unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
     add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
   };
 }
 ```
 The default type for the template parameter `D` is `default_delete`. A
+client-supplied template argument `D` shall be a function object type
+[[function.objects]], lvalue reference to function, or lvalue reference
 to function object type for which, given a value `d` of type `D` and a
 value `ptr` of type `unique_ptr<T, D>::pointer`, the expression `d(ptr)`
 is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
+If the deleter’s type `D` is not a reference type, `D` shall meet the
+*Cpp17Destructible* requirements ([[cpp17.destructible]]).
 If the *qualified-id* `remove_reference_t<D>::pointer` is valid and
+denotes a type [[temp.deduct]], then `unique_ptr<T,
 D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
 Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for
 `element_type*`. The type `unique_ptr<T,
+D>::pointer` shall meet the *Cpp17NullablePointer* requirements (
+[[cpp17.nullablepointer]]).
+[*Example 1*: Given an allocator type `X` ([[cpp17.allocator]]) and
+letting `A` be a synonym for `allocator_traits<X>`, the types
 `A::pointer`, `A::const_pointer`, `A::void_pointer`, and
 `A::const_void_pointer` may be used as
 `unique_ptr<T, D>::pointer`. — *end example*]
+##### Constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 constexpr unique_ptr(nullptr_t) noexcept;
 ```
+*Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
+([[cpp17.defaultconstructible]]), and that construction does not throw
+an exception.
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
+*Ensures:* `get() == nullptr`. `get_deleter()` returns a reference to
+the stored deleter.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
+*Mandates:* This constructor is not selected by class template argument
+deduction [[over.match.class.deduct]].
+*Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
+([[cpp17.defaultconstructible]]), and that construction does not throw
+an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
+*Ensures:* `get() == p`. `get_deleter()` returns a reference to the
+stored deleter.
 ``` cpp
+unique_ptr(pointer p, const D& d) noexcept;
+unique_ptr(pointer p, remove_reference_t<D>&& d) noexcept;
 ```
+*Constraints:* `is_constructible_v<D, decltype(d)>` is `true`.
+*Mandates:* These constructors are not selected by class template
+argument deduction [[over.match.class.deduct]].
+*Preconditions:* For the first constructor, if `D` is not a reference
+type, `D` meets the *Cpp17CopyConstructible* requirements and such
+construction does not exit via an exception. For the second constructor,
+if `D` is not a reference type, `D` meets the *Cpp17MoveConstructible*
+requirements and such construction does not exit via an exception.
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
 the stored pointer with `p` and initializing the deleter from
 `std::forward<decltype(d)>(d)`.
+*Ensures:* `get() == p`. `get_deleter()` returns a reference to the
+stored deleter. If `D` is a reference type then `get_deleter()` returns
+a reference to the lvalue `d`.
+*Remarks:* If `D` is a reference type, the second constructor is defined
+as deleted.
 [*Example 1*:
 ``` cpp
 D d;
+unique_ptr<int, D> p1(new int, D());        // D must be Cpp17MoveConstructible
+unique_ptr<int, D> p2(new int, d);          // D must be Cpp17CopyConstructible
 unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
 ```
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
+*Constraints:* `is_move_constructible_v<D>` is `true`.
+*Preconditions:* If `D` is not a reference type, `D` meets the
+*Cpp17MoveConstructible* requirements ([[cpp17.moveconstructible]]).
+Construction of the deleter from an rvalue of type `D` does not throw an
+exception.
+*Effects:* Constructs a `unique_ptr` from `u`. If `D` is a reference
+type, this deleter is copy constructed from `u`’s deleter; otherwise,
+this deleter is move constructed from `u`’s deleter.
+[*Note 1*: The construction of the deleter can be implemented with
 `std::forward<D>`. — *end note*]
+*Ensures:* `get()` yields the value `u.get()` yielded before the
+construction. `u.get() == nullptr`. `get_deleter()` returns a reference
+to the stored deleter that was constructed from `u.get_deleter()`. If
+`D` is a reference type then `get_deleter()` and `u.get_deleter()` both
+reference the same lvalue deleter.
 ``` cpp
 template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
+*Constraints:*
+- `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
+- `U` is not an array type, and
+- either `D` is a reference type and `E` is the same type as `D`, or `D`
+  is not a reference type and `E` is implicitly convertible to `D`.
+*Preconditions:* If `E` is not a reference type, construction of the
+deleter from an rvalue of type `E` is well-formed and does not throw an
 exception. Otherwise, `E` is a reference type and construction of the
+deleter from an lvalue of type `E` is well-formed and does not throw an
+exception.
+*Effects:* Constructs a `unique_ptr` from `u`. If `E` is a reference
+type, this deleter is copy constructed from `u`’s deleter; otherwise,
+this deleter is move constructed from `u`’s deleter.
 [*Note 2*: The deleter constructor can be implemented with
 `std::forward<E>`. — *end note*]
+*Ensures:* `get()` yields the value `u.get()` yielded before the
+construction. `u.get() == nullptr`. `get_deleter()` returns a reference
+to the stored deleter that was constructed from `u.get_deleter()`.
+##### Destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
+*Preconditions:* The expression `get_deleter()(get())` is well-formed,
+has well-defined behavior, and does not throw exceptions.
 [*Note 3*: The use of `default_delete` requires `T` to be a complete
 type. — *end note*]
 *Effects:* If `get() == nullptr` there are no effects. Otherwise
 `get_deleter()(get())`.
+##### Assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
+*Constraints:* `is_move_assignable_v<D>` is `true`.
+*Preconditions:* If `D` is not a reference type, `D` meets the
+*Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]) and
+assignment of the deleter from an rvalue of type `D` does not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
+meets the *Cpp17CopyAssignable* requirements and assignment of the
+deleter from an lvalue of type `D` does not throw an exception.
+*Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
+*Ensures:* `u.get() == nullptr`.
 ``` cpp
 template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
+*Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
   and
 - `U` is not an array type, and
 - `is_assignable_v<D&, E&&>` is `true`.
+*Preconditions:* If `E` is not a reference type, assignment of the
+deleter from an rvalue of type `E` is well-formed and does not throw an
+exception. Otherwise, `E` is a reference type and assignment of the
+deleter from an lvalue of type `E` is well-formed and does not throw an
+exception.
+*Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Returns:* `*this`.
+*Ensures:* `u.get() == nullptr`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
 *Effects:* As if by `reset()`.
+*Ensures:* `get() == nullptr`.
 *Returns:* `*this`.
+##### Observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
 add_lvalue_reference_t<T> operator*() const;
 ```
+*Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 pointer operator->() const noexcept;
 ```
+*Preconditions:* `get() != nullptr`.
 *Returns:* `get()`.
 [*Note 4*: The use of this function typically requires that `T` be a
 complete type. — *end note*]
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
+##### Modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
 pointer release() noexcept;
 ```
+*Ensures:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
+*Preconditions:* The expression `get_deleter()(get())` is well-formed,
+has well-defined behavior, and does not throw exceptions.
 *Effects:* Assigns `p` to the stored pointer, and then if and only if
 the old value of the stored pointer, `old_p`, was not equal to
 `nullptr`, calls `get_deleter()(old_p)`.
 [*Note 5*: The order of these operations is significant because the
 call to `get_deleter()` may destroy `*this`. — *end note*]
+*Ensures:* `get() == p`.
 [*Note 6*: The postcondition does not hold if the call to
 `get_deleter()` destroys `*this` since `this->get()` is no longer a
 valid expression. — *end note*]
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
+*Preconditions:* `get_deleter()` is swappable [[swappable.requirements]]
+and does not throw an exception under `swap`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.
 #### `unique_ptr` for array objects with a runtime length <a id="unique.ptr.runtime">[[unique.ptr.runtime]]</a>
 Descriptions are provided below only for members that differ from the
 primary template.
 The template argument `T` shall be a complete type.
+##### Constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
 template<class U> explicit unique_ptr(U p) noexcept;
 ```
 This constructor behaves the same as the constructor in the primary
+template that takes a single parameter of type `pointer`.
+*Constraints:*
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 template<class U> unique_ptr(U p, see below d) noexcept;
 template<class U> unique_ptr(U p, see below d) noexcept;
 ```
 These constructors behave the same as the constructors in the primary
+template that take a parameter of type `pointer` and a second parameter.
+*Constraints:*
 - `U` is the same type as `pointer`,
 - `U` is `nullptr_t`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
+template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
+This constructor behaves the same as in the primary template.
+*Constraints:* Where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - either `D` is a reference type and `E` is the same type as `D`, or `D`
   is not a reference type and `E` is implicitly convertible to `D`.
+[*Note 1*: This replaces the *Constraints:* specification of the
+primary template. — *end note*]
+##### Assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
+template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;
 ```
+This operator behaves the same as in the primary template.
+*Constraints:* Where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - `is_assignable_v<D&, E&&>` is `true`.
+[*Note 2*: This replaces the *Constraints:* specification of the
+primary template. — *end note*]
+##### Observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
 ```
+*Preconditions:* `i` < the number of elements in the array to which the
 stored pointer points.
 *Returns:* `get()[i]`.
+##### Modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
 void reset(nullptr_t p = nullptr) noexcept;
 ```
 ``` cpp
 template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
+template.
+*Constraints:*
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
+#### Creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
+*Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
 ``` cpp
 template<class T> unique_ptr<T> make_unique(size_t n);
 ```
+*Constraints:* `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
 ``` cpp
 template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
 ```
+*Constraints:* `T` is an array of known bound.
+``` cpp
+template<class T> unique_ptr<T> make_unique_for_overwrite();
+```
+*Constraints:* `T` is not an array type.
+*Returns:* `unique_ptr<T>(new T)`.
+``` cpp
+template<class T> unique_ptr<T> make_unique_for_overwrite(size_t n);
+```
+*Constraints:* `T` is an array of unknown bound.
+*Returns:* `unique_ptr<T>(new remove_extent_t<T>[n])`.
+``` cpp
+template<class T, class... Args> unspecified make_unique_for_overwrite(Args&&...) = delete;
+```
+*Constraints:* `T` is an array of known bound.
+#### Specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
+*Constraints:* `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
+Let `CT` denote
 ``` cpp
 common_type_t<typename unique_ptr<T1, D1>::pointer,
               typename unique_ptr<T2, D2>::pointer>
 ```
+*Mandates:*
+- `unique_ptr<T1, D1>::pointer` is implicitly convertible to `CT` and
+- `unique_ptr<T2, D2>::pointer` is implicitly convertible to `CT`.
+*Preconditions:* The specialization `less<CT>` is a function object
+type [[function.objects]] that induces a strict weak
+ordering [[alg.sorting]] on the pointer values.
+*Returns:* `less<CT>()(x.get(), y.get())`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `y < x`.
+``` cpp
+template<class T1, class D1, class T2, class D2>
+  bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+```
+*Returns:* `!(y < x)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `!(x < y)`.
+``` cpp
+template<class T1, class D1, class T2, class D2>
+  requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
+                                     typename unique_ptr<T2, D2>::pointer>
+  compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
+                             typename unique_ptr<T2, D2>::pointer>
+    operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+```
+*Returns:* `compare_three_way()(x.get(), y.get())`.
 ``` cpp
 template<class T, class D>
   bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 ```
 *Returns:* `!x`.
 ``` cpp
 template<class T, class D>
   bool operator<(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
   bool operator<(nullptr_t, const unique_ptr<T, D>& x);
 ```
+*Preconditions:* The specialization `less<unique_ptr<T, D>::pointer>` is
+a function object type [[function.objects]] that induces a strict weak
+ordering [[alg.sorting]] on the pointer values.
 *Returns:* The first function template returns
+``` cpp
+less<unique_ptr<T, D>::pointer>()(x.get(), nullptr)
+```
+The second function template returns
+``` cpp
+less<unique_ptr<T, D>::pointer>()(nullptr, x.get())
+```
 ``` cpp
 template<class T, class D>
   bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
+``` cpp
+template<class T, class D>
+  requires three_way_comparable_with<typename unique_ptr<T, D>::pointer, nullptr_t>
+  compare_three_way_result_t<typename unique_ptr<T, D>::pointer, nullptr_t>
+    operator<=>(const unique_ptr<T, D>& x, nullptr_t);
+```
+*Returns:* `compare_three_way()(x.get(), nullptr)`.
+#### I/O <a id="unique.ptr.io">[[unique.ptr.io]]</a>
+``` cpp
+template<class E, class T, class Y, class D>
+  basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const unique_ptr<Y, D>& p);
+```
+*Constraints:* `os << p.get()` is a valid expression.
+*Effects:* Equivalent to: `os << p.get();`
+*Returns:* `os`.

Diff to HTML by rtfpessoa