[memory] - C++20 → C++23

Files changed (1) hide show

tmp/tmp53_igoit/{from.md → to.md} +464 -295

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

@@ -10,365 +10,416 @@ and some of the contents of the header `<cstdlib>`.
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, destroy objects, and construct
 objects in uninitialized memory buffers ([[pointer.traits]]–
 [[specialized.addressof]] and [[specialized.algorithms]]). The header
-also defines the templates `unique_ptr`, `shared_ptr`, `weak_ptr`, and
-various function templates that operate on objects of these types
-[[smartptr]].
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
   // [pointer.traits], pointer traits
-  template<class Ptr> struct pointer_traits;
-  template<class T> struct pointer_traits<T*>;
   // [pointer.conversion], pointer conversion
   template<class T>
-    constexpr T* to_address(T* p) noexcept;
   template<class Ptr>
-    constexpr auto to_address(const Ptr& p) noexcept;
-  // [util.dynamic.safety], pointer safety%
-%
-{pointer_safety{pointer_safety{pointer_safety}
-  enum class pointer_safety { relaxed, preferred, strict };
-  void declare_reachable(void* p);
-  template<class T>
-    T* undeclare_reachable(T* p);
-  void declare_no_pointers(char* p, size_t n);
-  void undeclare_no_pointers(char* p, size_t n);
-  pointer_safety get_pointer_safety() noexcept;
   // [ptr.align], pointer alignment
-  void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
   template<size_t N, class T>
-    [[nodiscard]] constexpr T* assume_aligned(T* ptr);
   // [allocator.tag], allocator argument tag
-  struct allocator_arg_t { explicit allocator_arg_t() = default; };
-  inline constexpr allocator_arg_t allocator_arg{};
   // [allocator.uses], uses_allocator
-  template<class T, class Alloc> struct uses_allocator;
   // [allocator.uses.trait], uses_allocator
   template<class T, class Alloc>
- inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
   // [allocator.uses.construction], uses-allocator construction
   template<class T, class Alloc, class... Args>
-    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
-                                                    Args&&... args) noexcept -> see below;
   template<class T, class Alloc, class Tuple1, class Tuple2>
-    constexpr auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t,
- Tuple1&& x, Tuple2&& y)
- noexcept ->  see below;
   template<class T, class Alloc>
-    constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept -> see below;
   template<class T, class Alloc, class U, class V>
-    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
-                                                    U&& u, V&& v) noexcept -> see below;
   template<class T, class Alloc, class U, class V>
-    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
- const pair<U,V>& pr) noexcept -> see below;
   template<class T, class Alloc, class U, class V>
-    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
-                                                    pair<U,V>&& pr) noexcept -> see below;
   template<class T, class Alloc, class... Args>
-    constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
   template<class T, class Alloc, class... Args>
-    constexpr T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc,
-                                                         Args&&... args);
   // [allocator.traits], allocator traits
-  template<class Alloc> struct allocator_traits;
   // [default.allocator], the default allocator
   template<class T> class allocator;
   template<class T, class U>
     constexpr bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
   // [specialized.addressof], addressof
   template<class T>
-    constexpr T* addressof(T& r) noexcept;
   template<class T>
-    const T* addressof(const T&&) = delete;
   // [specialized.algorithms], specialized algorithms
   // [special.mem.concepts], special memory concepts
   template<class I>
-    concept no-throw-input-iterator = see below;    // exposition only
   template<class I>
-    concept no-throw-forward-iterator = see below;  // exposition only
   template<class S, class I>
-    concept no-throw-sentinel = see below; // exposition only
   template<class R>
-    concept no-throw-input-range = see below;       // exposition only
   template<class R>
-    concept no-throw-forward-range = see below;     // exposition only
   template<class NoThrowForwardIterator>
-    void uninitialized_default_construct(NoThrowForwardIterator first,
                                          NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
     void uninitialized_default_construct(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                                          NoThrowForwardIterator first,
                                          NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
-      uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
       uninitialized_default_construct_n(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                                         NoThrowForwardIterator first, Size n);
   namespace ranges {
-    template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
       requires default_initializable<iter_value_t<I>>
-        I uninitialized_default_construct(I first, S last);
-    template<no-throw-forward-range R>
       requires default_initializable<range_value_t<R>>
-        borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
-    template<no-throw-forward-iterator I>
       requires default_initializable<iter_value_t<I>>
-        I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
   }
   template<class NoThrowForwardIterator>
-    void uninitialized_value_construct(NoThrowForwardIterator first,
                                        NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
     void uninitialized_value_construct(ExecutionPolicy&& exec,                      // see [algorithms.parallel.overloads]
                                        NoThrowForwardIterator first,
                                        NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
-      uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
       uninitialized_value_construct_n(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                                       NoThrowForwardIterator first, Size n);
   namespace ranges {
-    template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
       requires default_initializable<iter_value_t<I>>
-        I uninitialized_value_construct(I first, S last);
-    template<no-throw-forward-range R>
       requires default_initializable<range_value_t<R>>
-        borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
-    template<no-throw-forward-iterator I>
       requires default_initializable<iter_value_t<I>>
-        I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
   }
   template<class InputIterator, class NoThrowForwardIterator>
-    NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                               NoThrowForwardIterator result);
-  template<class ExecutionPolicy, class InputIterator, class NoThrowForwardIterator>
     NoThrowForwardIterator uninitialized_copy(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
- InputIterator first, InputIterator last,
                                               NoThrowForwardIterator result);
   template<class InputIterator, class Size, class NoThrowForwardIterator>
-    NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                                 NoThrowForwardIterator result);
-  template<class ExecutionPolicy, class InputIterator, class Size, class NoThrowForwardIterator>
     NoThrowForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec,             // see [algorithms.parallel.overloads]
- InputIterator first, Size n,
                                                 NoThrowForwardIterator result);
   namespace ranges {
     template<class I, class O>
-      using uninitialized_copy_result = in_out_result<I, O>;
     template<input_iterator I, sentinel_for<I> S1,
- no-throw-forward-iterator O, no-throw-sentinel<O> S2>
       requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
         uninitialized_copy_result<I, O>
-          uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
-    template<input_range IR, no-throw-forward-range OR>
       requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
         uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
-          uninitialized_copy(IR&& in_range, OR&& out_range);
     template<class I, class O>
-      using uninitialized_copy_n_result = in_out_result<I, O>;
-    template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel<O> S>
       requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
         uninitialized_copy_n_result<I, O>
-          uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
   }
   template<class InputIterator, class NoThrowForwardIterator>
-    NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
                                               NoThrowForwardIterator result);
-  template<class ExecutionPolicy, class InputIterator, class NoThrowForwardIterator>
     NoThrowForwardIterator uninitialized_move(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
- InputIterator first, InputIterator last,
                                               NoThrowForwardIterator result);
   template<class InputIterator, class Size, class NoThrowForwardIterator>
     pair<InputIterator, NoThrowForwardIterator>
-      uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
-  template<class ExecutionPolicy, class InputIterator, class Size, class NoThrowForwardIterator>
-    pair<InputIterator, NoThrowForwardIterator>
       uninitialized_move_n(ExecutionPolicy&& exec,                                  // see [algorithms.parallel.overloads]
- InputIterator first, Size n, NoThrowForwardIterator result);
   namespace ranges {
     template<class I, class O>
-      using uninitialized_move_result = in_out_result<I, O>;
     template<input_iterator I, sentinel_for<I> S1,
- no-throw-forward-iterator O, no-throw-sentinel<O> S2>
       requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
         uninitialized_move_result<I, O>
-          uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
-    template<input_range IR, no-throw-forward-range OR>
       requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
         uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
-          uninitialized_move(IR&& in_range, OR&& out_range);
     template<class I, class O>
-      using uninitialized_move_n_result = in_out_result<I, O>;
     template<input_iterator I,
- no-throw-forward-iterator O, no-throw-sentinel<O> S>
       requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
         uninitialized_move_n_result<I, O>
-          uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
   }
   template<class NoThrowForwardIterator, class T>
-    void uninitialized_fill(NoThrowForwardIterator first, NoThrowForwardIterator last,
-                            const T& x);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class T>
     void uninitialized_fill(ExecutionPolicy&& exec,                                 // see [algorithms.parallel.overloads]
                             NoThrowForwardIterator first, NoThrowForwardIterator last,
                             const T& x);
   template<class NoThrowForwardIterator, class Size, class T>
     NoThrowForwardIterator
-      uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size, class T>
     NoThrowForwardIterator
       uninitialized_fill_n(ExecutionPolicy&& exec,                                  // see [algorithms.parallel.overloads]
                            NoThrowForwardIterator first, Size n, const T& x);
   namespace ranges {
-    template<no-throw-forward-iterator I, no-throw-sentinel<I> S, class T>
       requires constructible_from<iter_value_t<I>, const T&>
-        I uninitialized_fill(I first, S last, const T& x);
-    template<no-throw-forward-range R, class T>
       requires constructible_from<range_value_t<R>, const T&>
-        borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
-    template<no-throw-forward-iterator I, class T>
       requires constructible_from<iter_value_t<I>, const T&>
-        I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
   }
   // [specialized.construct], construct_at
   template<class T, class... Args>
-    constexpr T* construct_at(T* location, Args&&... args);
   namespace ranges {
     template<class T, class... Args>
-      constexpr T* construct_at(T* location, Args&&... args);
   }
   // [specialized.destroy], destroy
   template<class T>
-    constexpr void destroy_at(T* location);
   template<class NoThrowForwardIterator>
-    constexpr void destroy(NoThrowForwardIterator first, NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
     void destroy(ExecutionPolicy&& exec,                                            // see [algorithms.parallel.overloads]
                  NoThrowForwardIterator first, NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
-    constexpr NoThrowForwardIterator destroy_n(NoThrowForwardIterator first, Size n);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator destroy_n(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                                      NoThrowForwardIterator first, Size n);
   namespace ranges {
     template<destructible T>
-      constexpr void destroy_at(T* location) noexcept;
-    template<no-throw-input-iterator I, no-throw-sentinel<I> S>
       requires destructible<iter_value_t<I>>
-        constexpr I destroy(I first, S last) noexcept;
-    template<no-throw-input-range R>
       requires destructible<range_value_t<R>>
-        constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;
-    template<no-throw-input-iterator I>
       requires destructible<iter_value_t<I>>
-        constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;
   }
   // [unique.ptr], class template unique_ptr
-  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); // T is not array
   template<class T>
-    unique_ptr<T> make_unique(size_t n); // T is U[]
   template<class T, class... Args>
     unspecified make_unique(Args&&...) = delete;                                // T is U[N]
   template<class T>
-    unique_ptr<T> make_unique_for_overwrite(); // T is not array
   template<class T>
-    unique_ptr<T> make_unique_for_overwrite(size_t n); // T is U[]
   template<class T, class... Args>
     unspecified make_unique_for_overwrite(Args&&...) = delete;                  // T is U[N]
   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>
     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);
   template<class T, class D>
-    bool operator==(const unique_ptr<T, D>& x, nullptr_t) 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);
   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);
   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);
   // [util.smartptr.weak.bad], class bad_weak_ptr
@@ -466,36 +517,48 @@ namespace std {
   // [util.smartptr.enab], class template enable_shared_from_this
   template<class T> class enable_shared_from_this;
   // [util.smartptr.hash], hash support
-  template<class T> struct hash;
-  template<class T, class D> struct hash<unique_ptr<T, D>>;
   template<class T> struct hash<shared_ptr<T>>;
   // [util.smartptr.atomic], atomic smart pointers
-  template<class T> struct atomic;
   template<class T> struct atomic<shared_ptr<T>>;
   template<class T> struct atomic<weak_ptr<T>>;
 }
 ```
 ### Pointer traits <a id="pointer.traits">[[pointer.traits]]</a>
 The class template `pointer_traits` supplies a uniform interface to
 certain attributes of pointer-like types.
 ``` cpp
 namespace std {
   template<class Ptr> struct pointer_traits {
- using pointer         = Ptr;
-    using element_type    = see below;
-    using difference_type = see below;
-    template<class U> using rebind = see below;
-    static pointer pointer_to(see below r);
   };
   template<class T> struct pointer_traits<T*> {
     using pointer         = T*;
     using element_type    = T;
@@ -508,19 +571,49 @@ namespace std {
 }
 ```
 #### Member types <a id="pointer.traits.types">[[pointer.traits.types]]</a>
 ``` cpp
 using element_type = see below;
 ```
-*Type:* `Ptr::element_type` if the *qualified-id* `Ptr::element_type` is
-valid and denotes a type [[temp.deduct]]; otherwise, `T` if `Ptr` is a
-class template instantiation of the form `SomePointer<T, Args>`, where
-`Args` is zero or more type arguments; otherwise, the specialization is
-ill-formed.
 ``` cpp
 using difference_type = see below;
 ```
@@ -558,21 +651,23 @@ second member function returns `addressof(r)`.
 unspecified; otherwise, it is `element_type&`.
 #### Optional members <a id="pointer.traits.optmem">[[pointer.traits.optmem]]</a>
 Specializations of `pointer_traits` may define the member declared in
-this subclause to customize the behavior of the standard library.
 ``` cpp
 static element_type* to_address(pointer p) noexcept;
 ```
 *Returns:* A pointer of type `element_type*` that references the same
 location as the argument `p`.
-[*Note 1*: This function should be the inverse of `pointer_to`. If
-defined, it customizes the behavior of the non-member function
 `to_address` [[pointer.conversion]]. — *end note*]
 ### Pointer conversion <a id="pointer.conversion">[[pointer.conversion]]</a>
 ``` cpp
@@ -589,100 +684,10 @@ template<class Ptr> constexpr auto to_address(const Ptr& p) noexcept;
 *Returns:* `pointer_traits<Ptr>::to_address(p)` if that expression is
 well-formed (see [[pointer.traits.optmem]]), otherwise
 `to_address(p.operator->())`.
-### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
-A complete object is *declared reachable* while the number of calls to
-`declare_reachable` with an argument referencing the object exceeds the
-number of calls to `undeclare_reachable` with an argument referencing
-the object.
-``` cpp
-void declare_reachable(void* p);
-```
-*Preconditions:* `p` is a safely-derived
-pointer [[basic.stc.dynamic.safety]] or a null pointer value.
-*Effects:* If `p` is not null, the complete object referenced by `p` is
-subsequently declared reachable [[basic.stc.dynamic.safety]].
-*Throws:* May throw `bad_alloc` if the system cannot allocate additional
-memory that may be required to track objects declared reachable.
-``` cpp
-template<class T> T* undeclare_reachable(T* p);
-```
-*Preconditions:* If `p` is not null, the complete object referenced by
-`p` has been previously declared reachable, and is live [[basic.life]]
-from the time of the call until the last `undeclare_reachable(p)` call
-on the object.
-*Returns:* A safely derived copy of `p` which compares equal to `p`.
-*Throws:* Nothing.
-[*Note 1*: It is expected that calls to `declare_reachable(p)` will
-consume a small amount of memory in addition to that occupied by the
-referenced object until the matching call to `undeclare_reachable(p)` is
-encountered. Long running programs should arrange that calls are
-matched. — *end note*]
-``` cpp
-void declare_no_pointers(char* p, size_t n);
-```
-*Preconditions:* No bytes in the specified range are currently
-registered with `declare_no_pointers()`. If the specified range is in an
-allocated object, then it is entirely within a single allocated object.
-The object is live until the corresponding `undeclare_no_pointers()`
-call.
-[*Note 2*: In a garbage-collecting implementation, the fact that a
-region in an object is registered with `declare_no_pointers()` should
-not prevent the object from being collected. — *end note*]
-*Effects:* The `n` bytes starting at `p` no longer contain traceable
-pointer locations, independent of their type. Hence indirection through
-a pointer located there is undefined if the object it points to was
-created by global `operator new` and not previously declared reachable.
-[*Note 3*: This may be used to inform a garbage collector or leak
-detector that this region of memory need not be traced. — *end note*]
-*Throws:* Nothing.
-[*Note 4*: Under some conditions implementations may need to allocate
-memory. However, the request can be ignored if memory allocation
-fails. — *end note*]
-``` cpp
-void undeclare_no_pointers(char* p, size_t n);
-```
-*Preconditions:* The same range has previously been passed to
-`declare_no_pointers()`.
-*Effects:* Unregisters a range registered with `declare_no_pointers()`
-for destruction. It shall be called before the lifetime of the object
-ends.
-*Throws:* Nothing.
-``` cpp
-pointer_safety get_pointer_safety() noexcept;
-```
-*Returns:* `pointer_safety::strict` if the implementation has strict
-pointer safety [[basic.stc.dynamic.safety]]. It is
-*implementation-defined* whether `get_pointer_safety` returns
-`pointer_safety::relaxed` or `pointer_safety::preferred` if the
-implementation has relaxed pointer safety.[^1]
 ### Pointer alignment <a id="ptr.align">[[ptr.align]]</a>
 ``` cpp
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 ```
@@ -720,17 +725,77 @@ similar [[conv.qual]] to `T`, where `X` has alignment `N`
 *Returns:* `ptr`.
 *Throws:* Nothing.
 [*Note 2*: The alignment assumption on an object `X` expressed by a
-call to `assume_aligned` may result in generation of more efficient
 code. It is up to the program to ensure that the assumption actually
-holds. The call does not cause the compiler to verify or enforce this.
-An implementation might only make the assumption for those operations on
-`X` that access `X` through the pointer returned by
 `assume_aligned`. — *end note*]
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
@@ -740,12 +805,12 @@ namespace std {
 The `allocator_arg_t` struct is an empty class type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
 several types (see `tuple`  [[tuple]]) have constructors with
 `allocator_arg_t` as the first argument, immediately followed by an
-argument of a type that meets the *Cpp17Allocator* requirements (
-[[cpp17.allocator]]).
 ### `uses_allocator` <a id="allocator.uses">[[allocator.uses]]</a>
 #### `uses_allocator` trait <a id="allocator.uses.trait">[[allocator.uses.trait]]</a>
@@ -806,28 +871,28 @@ return value or in-place, respectively.
 be specified explicitly by the caller. — *end note*]
 ``` cpp
 template<class T, class Alloc, class... Args>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
-                                                  Args&&... args) noexcept -> see below;
 ```
-*Constraints:* `T` is not a specialization of `pair`.
 *Returns:* A `tuple` value determined as follows:
-- If `uses_allocator_v<T, Alloc>` is `false` and
   `is_constructible_v<T,Args...>` is `true`, return
   `forward_as_tuple(std::forward<Args>(args)...)`.
-- Otherwise, if `uses_allocator_v<T, Alloc>` is `true` and
   `is_constructible_v<T, allocator_arg_t, const Alloc&, Args...>` is
   `true`, return
   ``` cpp
   tuple<allocator_arg_t, const Alloc&, Args&&...>(
     allocator_arg, alloc, std::forward<Args>(args)...)
   ```
-- Otherwise, if `uses_allocator_v<T, Alloc>` is `true` and
   `is_constructible_v<T, Args..., const Alloc&>` is `true`, return
   `forward_as_tuple(std::forward<Args>(args)..., alloc)`.
 - Otherwise, the program is ill-formed.
 [*Note 1*: This definition prevents a silent failure to pass the
@@ -835,17 +900,18 @@ allocator to a constructor of a type for which
 `uses_allocator_v<T, Alloc>` is `true`. — *end note*]
 ``` cpp
 template<class T, class Alloc, class Tuple1, class Tuple2>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t,
-                                                  Tuple1&& x, Tuple2&& y)
-                                                  noexcept -> see below;
 ```
-*Constraints:* `T` is a specialization of `pair`.
-*Effects:* For `T` specified as `pair<T1, T2>`, equivalent to:
 ``` cpp
 return make_tuple(
   piecewise_construct,
   apply([&alloc](auto&&... args1) {
@@ -858,14 +924,14 @@ return make_tuple(
         }, std::forward<Tuple2>(y)));
 ```
 ``` cpp
 template<class T, class Alloc>
-  constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept -> see below;
 ```
-*Constraints:* `T` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
@@ -873,14 +939,14 @@ return uses_allocator_construction_args<T>(alloc, piecewise_construct,
 ```
 ``` cpp
 template<class T, class Alloc, class U, class V>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
-                                                  U&& u, V&& v) noexcept -> see below;
 ```
-*Constraints:* `T` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
@@ -889,14 +955,17 @@ return uses_allocator_construction_args<T>(alloc, piecewise_construct,
 ```
 ``` cpp
 template<class T, class Alloc, class U, class V>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
- const pair<U,V>& pr) noexcept -> see below;
 ```
-*Constraints:* `T` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
@@ -905,23 +974,88 @@ return uses_allocator_construction_args<T>(alloc, piecewise_construct,
 ```
 ``` cpp
 template<class T, class Alloc, class U, class V>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
-                                                  pair<U,V>&& pr) noexcept -> see below;
 ```
-*Constraints:* `T` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
-                                           forward_as_tuple(std::move(pr).first),
-                                           forward_as_tuple(std::move(pr).second));
 ```
 ``` cpp
 template<class T, class Alloc, class... Args>
   constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
 ```
@@ -945,17 +1079,22 @@ return apply([&]<class... U>(U&&... xs) {
      }, uses_allocator_construction_args<T>(alloc, std::forward<Args>(args)...));
 ```
 ### Allocator traits <a id="allocator.traits">[[allocator.traits]]</a>
 The class template `allocator_traits` supplies a uniform interface to
 all allocator types. An allocator cannot be a non-class type, however,
 even if `allocator_traits` supplies the entire required interface.
 [*Note 1*: Thus, it is always possible to create a derived class from
 an allocator. — *end note*]
 ``` cpp
 namespace std {
   template<class Alloc> struct allocator_traits {
     using allocator_type     = Alloc;
@@ -978,10 +1117,12 @@ namespace std {
     template<class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
     [[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
     [[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n,
                                                     const_void_pointer hint);
     static constexpr void deallocate(Alloc& a, pointer p, size_type n);
     template<class T, class... Args>
       static constexpr void construct(Alloc& a, T* p, Args&&... args);
@@ -1100,10 +1241,18 @@ arguments; otherwise, the instantiation of `rebind_alloc` is ill-formed.
 ```
 *Returns:* `a.allocate(n, hint)` if that expression is well-formed;
 otherwise, `a.allocate(n)`.
 ``` cpp
 static constexpr void deallocate(Alloc& a, pointer p, size_type n);
 ```
 *Effects:* Calls `a.deallocate(p, n)`.
@@ -1139,12 +1288,20 @@ static constexpr Alloc select_on_container_copy_construction(const Alloc& rhs);
 ```
 *Returns:* `rhs.select_on_container_copy_construction()` if that
 expression is well-formed; otherwise, `rhs`.
 ### The default allocator <a id="default.allocator">[[default.allocator]]</a>
 All specializations of the default allocator meet the allocator
 completeness requirements [[allocator.requirements.completeness]].
 ``` cpp
 namespace std {
@@ -1152,24 +1309,28 @@ namespace std {
    public:
     using value_type                             = T;
     using size_type                              = size_t;
     using difference_type                        = ptrdiff_t;
     using propagate_on_container_move_assignment = true_type;
-    using is_always_equal                        = true_type;
     constexpr allocator() noexcept;
     constexpr allocator(const allocator&) noexcept;
     template<class U> constexpr allocator(const allocator<U>&) noexcept;
     constexpr ~allocator();
     constexpr allocator& operator=(const allocator&) = default;
     [[nodiscard]] constexpr T* allocate(size_t n);
     constexpr void deallocate(T* p, size_t n);
   };
 }
 ```
 #### Members <a id="allocator.members">[[allocator.members]]</a>
 Except for the destructor, member functions of the default allocator
 shall not introduce data races [[intro.multithread]] as a result of
 concurrent calls to those member functions from different threads. Calls
@@ -1179,30 +1340,54 @@ call shall happen before the next allocation (if any) in this order.
 ``` cpp
 [[nodiscard]] constexpr T* allocate(size_t n);
 ```
-*Mandates:* `T` is not an incomplete type [[basic.types]].
 *Returns:* A pointer to the initial element of an array of `n` `T`.
 *Remarks:* The storage for the array is obtained by calling
 `::operator new` [[new.delete]], but it is unspecified when or how often
 this function is called. This function starts the lifetime of the array
 object, but not that of any of the array elements.
 *Throws:* `bad_array_new_length` if
-`numeric_limits<size_t>::max() / sizeof(T) < n`, or `bad_alloc` if the
 storage cannot be obtained.
 ``` cpp
 constexpr void deallocate(T* p, size_t n);
 ```
-*Preconditions:* `p` is a pointer value obtained from `allocate()`. `n`
-equals the value passed as the first argument to the invocation of
-allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p`.
 *Remarks:* Uses `::operator delete` [[new.delete]], but it is
 unspecified when this function is called.
@@ -1245,26 +1430,10 @@ void* realloc(void* ptr, size_t size);
 standard library.
 *Remarks:* These functions do not attempt to allocate storage by calling
 `::operator new()` [[new.delete]].
-Storage allocated directly with these functions is implicitly declared
-reachable (see  [[basic.stc.dynamic.safety]]) on allocation, ceases to
-be declared reachable on deallocation, and need not cease to be declared
-reachable as the result of an `undeclare_reachable()` call.
-[*Note 1*: This allows existing C libraries to remain unaffected by
-restrictions on pointers that are not safely derived, at the expense of
-providing far fewer garbage collection and leak detection options for
-`malloc()`-allocated objects. It also allows `malloc()` to be
-implemented with a separate allocation arena, bypassing the normal
-`declare_reachable()` implementation. The above functions should never
-intentionally be used as a replacement for `declare_reachable()`, and
-newly written code is strongly encouraged to treat memory allocated with
-these functions as though it were allocated with
-`operator new`. — *end note*]
 These functions implicitly create objects [[intro.object]] in the
 returned region of storage and return a pointer to a suitable created
 object. In the case of `calloc` and `realloc`, the objects are created
 before the storage is zeroed or copied, respectively.

 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, destroy objects, and construct
 objects in uninitialized memory buffers ([[pointer.traits]]–
 [[specialized.addressof]] and [[specialized.algorithms]]). The header
+also defines the templates `unique_ptr`, `shared_ptr`, `weak_ptr`,
+`out_ptr_t`, `inout_ptr_t`, and various function templates that operate
+on objects of these types [[smartptr]].
+Let `POINTER_OF(T)` denote a type that is
+- `T::pointer` if the *qualified-id* `T::pointer` is valid and denotes a
+  type,
+- otherwise, `T::element_type*` if the *qualified-id* `T::element_type`
+  is valid and denotes a type,
+- otherwise, `pointer_traits<T>::element_type*`.
+Let `POINTER_OF_OR(T, U)` denote a type that is:
+- `POINTER_OF(T)` if `POINTER_OF(T)` is valid and denotes a type,
+- otherwise, `U`.
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
   // [pointer.traits], pointer traits
+  template<class Ptr> struct pointer_traits;                                        // freestanding
+  template<class T> struct pointer_traits<T*>;                                      // freestanding
   // [pointer.conversion], pointer conversion
   template<class T>
+    constexpr T* to_address(T* p) noexcept;                                         // freestanding
   template<class Ptr>
+    constexpr auto to_address(const Ptr& p) noexcept;                               // freestanding
   // [ptr.align], pointer alignment
+  void* align(size_t alignment, size_t size, void*& ptr, size_t& space);            // freestanding
   template<size_t N, class T>
+    [[nodiscard]] constexpr T* assume_aligned(T* ptr);                              // freestanding
+  // [obj.lifetime], explicit lifetime management
+  template<class T>
+    T* start_lifetime_as(void* p) noexcept;                                         // freestanding
+  template<class T>
+    const T* start_lifetime_as(const void* p) noexcept;                             // freestanding
+  template<class T>
+    volatile T* start_lifetime_as(volatile void* p) noexcept;                       // freestanding
+  template<class T>
+    const volatile T* start_lifetime_as(const volatile void* p) noexcept;           // freestanding
+  template<class T>
+    T* start_lifetime_as_array(void* p, size_t n) noexcept;                         // freestanding
+  template<class T>
+    const T* start_lifetime_as_array(const void* p, size_t n) noexcept;             // freestanding
+  template<class T>
+    volatile T* start_lifetime_as_array(volatile void* p, size_t n) noexcept;       // freestanding
+  template<class T>
+    const volatile T* start_lifetime_as_array(const volatile void* p,               // freestanding
+                                          size_t n) noexcept;
   // [allocator.tag], allocator argument tag
+  struct allocator_arg_t {                                                          // freestanding
+      explicit allocator_arg_t() = default;                                         // freestanding
+  };
+  inline constexpr allocator_arg_t allocator_arg{};                                 // freestanding
   // [allocator.uses], uses_allocator
+  template<class T, class Alloc> struct uses_allocator;                             // freestanding
   // [allocator.uses.trait], uses_allocator
   template<class T, class Alloc>
+    constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;              // freestanding
   // [allocator.uses.construction], uses-allocator construction
   template<class T, class Alloc, class... Args>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    Args&&... args) noexcept;
   template<class T, class Alloc, class Tuple1, class Tuple2>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+ piecewise_construct_t,
+ Tuple1&& x, Tuple2&& y) noexcept;
   template<class T, class Alloc>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept;   // freestanding
   template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    U&& u, V&& v) noexcept;
   template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    pair<U, V>& pr) noexcept;
   template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+ const pair<U, V>& pr) noexcept;
+  template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    pair<U, V>&& pr) noexcept;
+  template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    const pair<U, V>&& pr) noexcept;
+  template<class T, class Alloc, pair-like P>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    P&& p) noexcept;
+  template<class T, class Alloc, class U>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // freestanding
+                                                    U&& u) noexcept;
   template<class T, class Alloc, class... Args>
+    constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);       // freestanding
   template<class T, class Alloc, class... Args>
+    constexpr T* uninitialized_construct_using_allocator(T* p,                      // freestanding
+ const Alloc& alloc, Args&&... args);
   // [allocator.traits], allocator traits
+  template<class Alloc> struct allocator_traits;                                    // freestanding
+  template<class Pointer, class SizeType = size_t>
+  struct allocation_result {                                                        // freestanding
+    Pointer ptr;
+    SizeType count;
+  };
   // [default.allocator], the default allocator
   template<class T> class allocator;
   template<class T, class U>
     constexpr bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
   // [specialized.addressof], addressof
   template<class T>
+    constexpr T* addressof(T& r) noexcept;                                          // freestanding
   template<class T>
+    const T* addressof(const T&&) = delete;                                         // freestanding
   // [specialized.algorithms], specialized algorithms
   // [special.mem.concepts], special memory concepts
   template<class I>
+    concept nothrow-input-iterator = see below;    // exposition only
   template<class I>
+    concept nothrow-forward-iterator = see below;  // exposition only
   template<class S, class I>
+    concept nothrow-sentinel-for = see below; // exposition only
   template<class R>
+    concept nothrow-input-range = see below;       // exposition only
   template<class R>
+    concept nothrow-forward-range = see below;     // exposition only
   template<class NoThrowForwardIterator>
+    void uninitialized_default_construct(NoThrowForwardIterator first,              // freestanding
                                          NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
     void uninitialized_default_construct(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                                          NoThrowForwardIterator first,
                                          NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
+      uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);      // freestanding
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
       uninitialized_default_construct_n(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                                         NoThrowForwardIterator first, Size n);
   namespace ranges {
+    template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
       requires default_initializable<iter_value_t<I>>
+        I uninitialized_default_construct(I first, S last);                         // freestanding
+    template<nothrow-forward-range R>
       requires default_initializable<range_value_t<R>>
+        borrowed_iterator_t<R> uninitialized_default_construct(R&& r);              // freestanding
+    template<nothrow-forward-iterator I>
       requires default_initializable<iter_value_t<I>>
+        I uninitialized_default_construct_n(I first, iter_difference_t<I> n);       // freestanding
   }
   template<class NoThrowForwardIterator>
+    void uninitialized_value_construct(NoThrowForwardIterator first,                // freestanding
                                        NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
     void uninitialized_value_construct(ExecutionPolicy&& exec,                      // see [algorithms.parallel.overloads]
                                        NoThrowForwardIterator first,
                                        NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
+      uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);        // freestanding
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
       uninitialized_value_construct_n(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                                       NoThrowForwardIterator first, Size n);
   namespace ranges {
+    template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
       requires default_initializable<iter_value_t<I>>
+        I uninitialized_value_construct(I first, S last);                           // freestanding
+    template<nothrow-forward-range R>
       requires default_initializable<range_value_t<R>>
+        borrowed_iterator_t<R> uninitialized_value_construct(R&& r);                // freestanding
+    template<nothrow-forward-iterator I>
       requires default_initializable<iter_value_t<I>>
+        I uninitialized_value_construct_n(I first, iter_difference_t<I> n);         // freestanding
   }
   template<class InputIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_copy(InputIterator first,                  // freestanding
+                                              InputIterator last,
                                               NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class ForwardIterator, class NoThrowForwardIterator>
     NoThrowForwardIterator uninitialized_copy(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
+ ForwardIterator first, ForwardIterator last,
                                               NoThrowForwardIterator result);
   template<class InputIterator, class Size, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,        // freestanding
                                                 NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class ForwardIterator, class Size,
+           class NoThrowForwardIterator>
     NoThrowForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec,             // see [algorithms.parallel.overloads]
+ ForwardIterator first, Size n,
                                                 NoThrowForwardIterator result);
   namespace ranges {
     template<class I, class O>
+      using uninitialized_copy_result = in_out_result<I, O>;                        // freestanding
     template<input_iterator I, sentinel_for<I> S1,
+ nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
       requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
         uninitialized_copy_result<I, O>
+          uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);               // freestanding
+    template<input_range IR, nothrow-forward-range OR>
       requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
         uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
+          uninitialized_copy(IR&& in_range, OR&& out_range);                        // freestanding
     template<class I, class O>
+      using uninitialized_copy_n_result = in_out_result<I, O>;                      // freestanding
+    template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
       requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
         uninitialized_copy_n_result<I, O>
+          uninitialized_copy_n(I ifirst, iter_difference_t<I> n,                    // freestanding
+                               O ofirst, S olast);
   }
   template<class InputIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_move(InputIterator first,                  // freestanding
+                                              InputIterator last,
                                               NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class ForwardIterator, class NoThrowForwardIterator>
     NoThrowForwardIterator uninitialized_move(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
+ ForwardIterator first, ForwardIterator last,
                                               NoThrowForwardIterator result);
   template<class InputIterator, class Size, class NoThrowForwardIterator>
     pair<InputIterator, NoThrowForwardIterator>
+      uninitialized_move_n(InputIterator first, Size n,                             // freestanding
+ NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class ForwardIterator, class Size,
+           class NoThrowForwardIterator>
+    pair<ForwardIterator, NoThrowForwardIterator>
       uninitialized_move_n(ExecutionPolicy&& exec,                                  // see [algorithms.parallel.overloads]
+ ForwardIterator first, Size n, NoThrowForwardIterator result);
   namespace ranges {
     template<class I, class O>
+      using uninitialized_move_result = in_out_result<I, O>;                        // freestanding
     template<input_iterator I, sentinel_for<I> S1,
+ nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
       requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
         uninitialized_move_result<I, O>
+          uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);               // freestanding
+    template<input_range IR, nothrow-forward-range OR>
       requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
         uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
+          uninitialized_move(IR&& in_range, OR&& out_range);                        // freestanding
     template<class I, class O>
+      using uninitialized_move_n_result = in_out_result<I, O>;                      // freestanding
     template<input_iterator I,
+ nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
       requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
         uninitialized_move_n_result<I, O>
+          uninitialized_move_n(I ifirst, iter_difference_t<I> n,                    // freestanding
+                               O ofirst, S olast);
   }
   template<class NoThrowForwardIterator, class T>
+    void uninitialized_fill(NoThrowForwardIterator first,                           // freestanding
+ NoThrowForwardIterator last, const T& x);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class T>
     void uninitialized_fill(ExecutionPolicy&& exec,                                 // see [algorithms.parallel.overloads]
                             NoThrowForwardIterator first, NoThrowForwardIterator last,
                             const T& x);
   template<class NoThrowForwardIterator, class Size, class T>
     NoThrowForwardIterator
+      uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);       // freestanding
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size, class T>
     NoThrowForwardIterator
       uninitialized_fill_n(ExecutionPolicy&& exec,                                  // see [algorithms.parallel.overloads]
                            NoThrowForwardIterator first, Size n, const T& x);
   namespace ranges {
+    template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S, class T>
       requires constructible_from<iter_value_t<I>, const T&>
+        I uninitialized_fill(I first, S last, const T& x);                          // freestanding
+    template<nothrow-forward-range R, class T>
       requires constructible_from<range_value_t<R>, const T&>
+        borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);               // freestanding
+    template<nothrow-forward-iterator I, class T>
       requires constructible_from<iter_value_t<I>, const T&>
+        I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);        // freestanding
   }
   // [specialized.construct], construct_at
   template<class T, class... Args>
+    constexpr T* construct_at(T* location, Args&&... args);                         // freestanding
   namespace ranges {
     template<class T, class... Args>
+      constexpr T* construct_at(T* location, Args&&... args);                       // freestanding
   }
   // [specialized.destroy], destroy
   template<class T>
+    constexpr void destroy_at(T* location);                                         // freestanding
   template<class NoThrowForwardIterator>
+    constexpr void destroy(NoThrowForwardIterator first,                            // freestanding
+                           NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
     void destroy(ExecutionPolicy&& exec,                                            // see [algorithms.parallel.overloads]
                  NoThrowForwardIterator first, NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
+    constexpr NoThrowForwardIterator destroy_n(NoThrowForwardIterator first,        // freestanding
+                                               Size n);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator destroy_n(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                                      NoThrowForwardIterator first, Size n);
   namespace ranges {
     template<destructible T>
+      constexpr void destroy_at(T* location) noexcept;                              // freestanding
+    template<nothrow-input-iterator I, nothrow-sentinel-for<I> S>
       requires destructible<iter_value_t<I>>
+        constexpr I destroy(I first, S last) noexcept;                              // freestanding
+    template<nothrow-input-range R>
       requires destructible<range_value_t<R>>
+        constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;                   // freestanding
+    template<nothrow-input-iterator I>
       requires destructible<iter_value_t<I>>
+        constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;            // freestanding
   }
   // [unique.ptr], class template unique_ptr
+  template<class T> struct default_delete;                                          // freestanding
+  template<class T> struct default_delete<T[]>;                                     // freestanding
+  template<class T, class D = default_delete<T>> class unique_ptr;                  // freestanding
+  template<class T, class D> class unique_ptr<T[], D>;                              // freestanding
   template<class T, class... Args>
+ constexpr unique_ptr<T> make_unique(Args&&... args); // T is not array
   template<class T>
+ constexpr unique_ptr<T> make_unique(size_t n); // T is U[]
   template<class T, class... Args>
     unspecified make_unique(Args&&...) = delete;                                // T is U[N]
   template<class T>
+ constexpr unique_ptr<T> make_unique_for_overwrite(); // T is not array
   template<class T>
+ constexpr unique_ptr<T> make_unique_for_overwrite(size_t n); // T is U[]
   template<class T, class... Args>
     unspecified make_unique_for_overwrite(Args&&...) = delete;                  // T is U[N]
   template<class T, class D>
+ constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;         // freestanding
   template<class T1, class D1, class T2, class D2>
+ constexpr bool operator==(const unique_ptr<T1, D1>& x,                          // freestanding
+                              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);       // freestanding
   template<class T1, class D1, class T2, class D2>
+    bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);       // freestanding
   template<class T1, class D1, class T2, class D2>
+    bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);      // freestanding
   template<class T1, class D1, class T2, class D2>
+    bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);      // freestanding
   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);        // freestanding
   template<class T, class D>
+ constexpr bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;       // freestanding
   template<class T, class D>
+ constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t);                 // freestanding
   template<class T, class D>
+ constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& y);                 // freestanding
   template<class T, class D>
+ constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t);                 // freestanding
   template<class T, class D>
+ constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& y);                 // freestanding
   template<class T, class D>
+ constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t);                // freestanding
   template<class T, class D>
+ constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& y);                // freestanding
   template<class T, class D>
+ constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t);                // freestanding
   template<class T, class D>
+ constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& y);                // freestanding
   template<class T, class D>
+    requires three_way_comparable<typename unique_ptr<T, D>::pointer>
+ constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
+      operator<=>(const unique_ptr<T, D>& x, nullptr_t);                            // freestanding
   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);
   // [util.smartptr.weak.bad], class bad_weak_ptr
   // [util.smartptr.enab], class template enable_shared_from_this
   template<class T> class enable_shared_from_this;
   // [util.smartptr.hash], hash support
+  template<class T> struct hash;                                                    // freestanding
+  template<class T, class D> struct hash<unique_ptr<T, D>>;                         // freestanding
   template<class T> struct hash<shared_ptr<T>>;
   // [util.smartptr.atomic], atomic smart pointers
+  template<class T> struct atomic;                                                  // freestanding
   template<class T> struct atomic<shared_ptr<T>>;
   template<class T> struct atomic<weak_ptr<T>>;
+  // [out.ptr.t], class template out_ptr_t
+  template<class Smart, class Pointer, class... Args>
+    class out_ptr_t;
+  // [out.ptr], function template out_ptr
+  template<class Pointer = void, class Smart, class... Args>
+    auto out_ptr(Smart& s, Args&&... args);
+  // [inout.ptr.t], class template inout_ptr_t
+  template<class Smart, class Pointer, class... Args>
+    class inout_ptr_t;
+  // [inout.ptr], function template inout_ptr
+  template<class Pointer = void, class Smart, class... Args>
+    auto inout_ptr(Smart& s, Args&&... args);
 }
 ```
 ### Pointer traits <a id="pointer.traits">[[pointer.traits]]</a>
+#### General <a id="pointer.traits.general">[[pointer.traits.general]]</a>
 The class template `pointer_traits` supplies a uniform interface to
 certain attributes of pointer-like types.
 ``` cpp
 namespace std {
   template<class Ptr> struct pointer_traits {
+ see below;
   };
   template<class T> struct pointer_traits<T*> {
     using pointer         = T*;
     using element_type    = T;
 }
 ```
 #### Member types <a id="pointer.traits.types">[[pointer.traits.types]]</a>
+The definitions in this subclause make use of the following
+exposition-only class template and concept:
+``` cpp
+template<class T>
+struct ptr-traits-elem          // exposition only
+{ };
+template<class T> requires requires { typename T::element_type; }
+struct ptr-traits-elem<T>
+{ using type = typename T::element_type; };
+template<template<class...> class SomePointer, class T, class... Args>
+  requires (!requires { typename SomePointer<T, Args...>::element_type; })
+struct ptr-traits-elem<SomePointer<T, Args...>>
+{ using type = T; };
+template<class Ptr>
+  concept has-elem-type =       // exposition only
+    requires { typename ptr-traits-elem<Ptr>::type; }
+```
+If `Ptr` satisfies `has-elem-type`, a specialization
+`pointer_traits<Ptr>` generated from the `pointer_traits` primary
+template has the following members as well as those described in
+[[pointer.traits.functions]]; otherwise, such a specialization has no
+members by any of those names.
+``` cpp
+using pointer = see below;
+```
+*Type:* `Ptr`.
 ``` cpp
 using element_type = see below;
 ```
+*Type:* `typename `*`ptr-traits-elem`*`<Ptr>::type`.
 ``` cpp
 using difference_type = see below;
 ```
 unspecified; otherwise, it is `element_type&`.
 #### Optional members <a id="pointer.traits.optmem">[[pointer.traits.optmem]]</a>
 Specializations of `pointer_traits` may define the member declared in
+this subclause to customize the behavior of the standard library. A
+specialization generated from the `pointer_traits` primary template has
+no member by this name.
 ``` cpp
 static element_type* to_address(pointer p) noexcept;
 ```
 *Returns:* A pointer of type `element_type*` that references the same
 location as the argument `p`.
+[*Note 1*: This function is intended to be the inverse of `pointer_to`.
+If defined, it customizes the behavior of the non-member function
 `to_address` [[pointer.conversion]]. — *end note*]
 ### Pointer conversion <a id="pointer.conversion">[[pointer.conversion]]</a>
 ``` cpp
 *Returns:* `pointer_traits<Ptr>::to_address(p)` if that expression is
 well-formed (see [[pointer.traits.optmem]]), otherwise
 `to_address(p.operator->())`.
 ### Pointer alignment <a id="ptr.align">[[ptr.align]]</a>
 ``` cpp
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 ```
 *Returns:* `ptr`.
 *Throws:* Nothing.
 [*Note 2*: The alignment assumption on an object `X` expressed by a
+call to `assume_aligned` might result in generation of more efficient
 code. It is up to the program to ensure that the assumption actually
+holds. The call does not cause the implementation to verify or enforce
+this. An implementation might only make the assumption for those
+operations on `X` that access `X` through the pointer returned by
 `assume_aligned`. — *end note*]
+### Explicit lifetime management <a id="obj.lifetime">[[obj.lifetime]]</a>
+``` cpp
+template<class T>
+  T* start_lifetime_as(void* p) noexcept;
+template<class T>
+  const T* start_lifetime_as(const void* p) noexcept;
+template<class T>
+  volatile T* start_lifetime_as(volatile void* p) noexcept;
+template<class T>
+  const volatile T* start_lifetime_as(const volatile void* p) noexcept;
+```
+*Mandates:* `T` is an implicit-lifetime type [[basic.types.general]] and
+not an incomplete type [[term.incomplete.type]].
+*Preconditions:* \[`p`, `(char*)p + sizeof(T)`) denotes a region of
+allocated storage that is a subset of the region of storage reachable
+through [[basic.compound]] `p` and suitably aligned for the type `T`.
+*Effects:* Implicitly creates objects [[intro.object]] within the
+denoted region consisting of an object *a* of type `T` whose address is
+`p`, and objects nested within *a*, as follows: The object
+representation of *a* is the contents of the storage prior to the call
+to `start_lifetime_as`. The value of each created object *o* of
+trivially-copyable type `U` is determined in the same manner as for a
+call to `bit_cast<U>(E)` [[bit.cast]], where `E` is an lvalue of type
+`U` denoting *o*, except that the storage is not accessed. The value of
+any other created object is unspecified.
+[*Note 1*: The unspecified value can be indeterminate. — *end note*]
+*Returns:* A pointer to the *a* defined in the *Effects* paragraph.
+``` cpp
+template<class T>
+  T* start_lifetime_as_array(void* p, size_t n) noexcept;
+template<class T>
+  const T* start_lifetime_as_array(const void* p, size_t n) noexcept;
+template<class T>
+  volatile T* start_lifetime_as_array(volatile void* p, size_t n) noexcept;
+template<class T>
+  const volatile T* start_lifetime_as_array(const volatile void* p, size_t n) noexcept;
+```
+*Mandates:* `T` is a complete type.
+*Preconditions:* `p` is suitably aligned for an array of `T` or is null.
+`n <= size_t(-1) / sizeof(T)` is `true`. If `n > 0` is `true`,
+\[`(char*)p`, `(char*)p + (n * sizeof(T))`) denotes a region of
+allocated storage that is a subset of the region of storage reachable
+through [[basic.compound]] `p`.
+*Effects:* If `n > 0` is `true`, equivalent to `start_lifetime_as<U>(p)`
+where `U` is the type “array of `n` `T`”. Otherwise, there are no
+effects.
+*Returns:* A pointer to the first element of the created array, if any;
+otherwise, a pointer that compares equal to `p` [[expr.eq]].
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
 The `allocator_arg_t` struct is an empty class type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
 several types (see `tuple`  [[tuple]]) have constructors with
 `allocator_arg_t` as the first argument, immediately followed by an
+argument of a type that meets the *Cpp17Allocator* requirements
+[[allocator.requirements.general]].
 ### `uses_allocator` <a id="allocator.uses">[[allocator.uses]]</a>
 #### `uses_allocator` trait <a id="allocator.uses.trait">[[allocator.uses.trait]]</a>
 be specified explicitly by the caller. — *end note*]
 ``` cpp
 template<class T, class Alloc, class... Args>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  Args&&... args) noexcept;
 ```
+*Constraints:* `remove_cv_t<T>` is not a specialization of `pair`.
 *Returns:* A `tuple` value determined as follows:
+- If `uses_allocator_v<remove_cv_t<T>, Alloc>` is `false` and
   `is_constructible_v<T,Args...>` is `true`, return
   `forward_as_tuple(std::forward<Args>(args)...)`.
+- Otherwise, if `uses_allocator_v<remove_cv_t<T>, Alloc>` is `true` and
   `is_constructible_v<T, allocator_arg_t, const Alloc&, Args...>` is
   `true`, return
   ``` cpp
   tuple<allocator_arg_t, const Alloc&, Args&&...>(
     allocator_arg, alloc, std::forward<Args>(args)...)
   ```
+- Otherwise, if `uses_allocator_v<remove_cv_t<T>, Alloc>` is `true` and
   `is_constructible_v<T, Args..., const Alloc&>` is `true`, return
   `forward_as_tuple(std::forward<Args>(args)..., alloc)`.
 - Otherwise, the program is ill-formed.
 [*Note 1*: This definition prevents a silent failure to pass the
 `uses_allocator_v<T, Alloc>` is `true`. — *end note*]
 ``` cpp
 template<class T, class Alloc, class Tuple1, class Tuple2>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t,
+                                                  Tuple1&& x, Tuple2&& y) noexcept;
 ```
+Let `T1` be `T::first_type`. Let `T2` be `T::second_type`.
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair`.
+*Effects:* Equivalent to:
 ``` cpp
 return make_tuple(
   piecewise_construct,
   apply([&alloc](auto&&... args1) {
         }, std::forward<Tuple2>(y)));
 ```
 ``` cpp
 template<class T, class Alloc>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept;
 ```
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
 ```
 ``` cpp
 template<class T, class Alloc, class U, class V>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  U&& u, V&& v) noexcept;
 ```
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
 ```
 ``` cpp
 template<class T, class Alloc, class U, class V>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  pair<U, V>& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  const pair<U, V>& pr) noexcept;
 ```
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
 ```
 ``` cpp
 template<class T, class Alloc, class U, class V>
   constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  pair<U, V>&& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  const pair<U, V>&& pr) noexcept;
 ```
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair`.
 *Effects:* Equivalent to:
 ``` cpp
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
+                                           forward_as_tuple(get<0>(std::move(pr))),
+                                           forward_as_tuple(get<1>(std::move(pr))));
 ```
+``` cpp
+template<class T, class Alloc, pair-like P>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc, P&& p) noexcept;
+```
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair` and
+`remove_cvref_t<P>` is not a specialization of `ranges::subrange`.
+*Effects:* Equivalent to:
+``` cpp
+return uses_allocator_construction_args<T>(alloc, piecewise_construct,
+                                           forward_as_tuple(get<0>(std::forward<P>(p))),
+                                           forward_as_tuple(get<1>(std::forward<P>(p))));
+```
+``` cpp
+template<class T, class Alloc, class U>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc, U&& u) noexcept;
+```
+Let *FUN* be the function template:
+``` cpp
+template<class A, class B>
+  void FUN(const pair<A, B>&);
+```
+*Constraints:* `remove_cv_t<T>` is a specialization of `pair`, and
+either:
+- `remove_cvref_t<U>` is a specialization of `ranges::subrange`, or
+- `U` does not satisfy `pair-like` and the expression *`FUN`*`(u)` is
+  not well-formed when considered as an unevaluated operand.
+Let *pair-constructor* be an exposition-only class defined as follows:
+``` cpp
+class pair-constructor {
+  using pair-type = remove_cv_t<T>;                             // exposition only
+  constexpr auto do-construct(const pair-type& p) const {       // exposition only
+    return make_obj_using_allocator<pair-type>(alloc_, p);
+  }
+  constexpr auto do-construct(pair-type&& p) const {            // exposition only
+    return make_obj_using_allocator<pair-type>(alloc_, std::move(p));
+  }
+  const Alloc& alloc_;  // exposition only
+  U& u_;                // exposition only
+public:
+  constexpr operator pair-type() const {
+    return do-construct(std::forward<U>(u_));
+  }
+};
+```
+*Returns:* `make_tuple(pc)`, where `pc` is a *pair-constructor* object
+whose *alloc\_* member is initialized with `alloc` and whose *u\_*
+member is initialized with `u`.
 ``` cpp
 template<class T, class Alloc, class... Args>
   constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
 ```
      }, uses_allocator_construction_args<T>(alloc, std::forward<Args>(args)...));
 ```
 ### Allocator traits <a id="allocator.traits">[[allocator.traits]]</a>
+#### General <a id="allocator.traits.general">[[allocator.traits.general]]</a>
 The class template `allocator_traits` supplies a uniform interface to
 all allocator types. An allocator cannot be a non-class type, however,
 even if `allocator_traits` supplies the entire required interface.
 [*Note 1*: Thus, it is always possible to create a derived class from
 an allocator. — *end note*]
+If a program declares an explicit or partial specialization of
+`allocator_traits`, the program is ill-formed, no diagnostic required.
 ``` cpp
 namespace std {
   template<class Alloc> struct allocator_traits {
     using allocator_type     = Alloc;
     template<class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
     [[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
     [[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n,
                                                     const_void_pointer hint);
+    [[nodiscard]] static constexpr allocation_result<pointer, size_type>
+      allocate_at_least(Alloc& a, size_type n);
     static constexpr void deallocate(Alloc& a, pointer p, size_type n);
     template<class T, class... Args>
       static constexpr void construct(Alloc& a, T* p, Args&&... args);
 ```
 *Returns:* `a.allocate(n, hint)` if that expression is well-formed;
 otherwise, `a.allocate(n)`.
+``` cpp
+[[nodiscard]] static constexpr allocation_result<pointer, size_type>
+  allocate_at_least(Alloc& a, size_type n);
+```
+*Returns:* `a.allocate_at_least(n)` if that expression is well-formed;
+otherwise, `{a.allocate(n), n}`.
 ``` cpp
 static constexpr void deallocate(Alloc& a, pointer p, size_type n);
 ```
 *Effects:* Calls `a.deallocate(p, n)`.
 ```
 *Returns:* `rhs.select_on_container_copy_construction()` if that
 expression is well-formed; otherwise, `rhs`.
+#### Other <a id="allocator.traits.other">[[allocator.traits.other]]</a>
+The class template `allocation_result` has the template parameters, data
+members, and special members specified above. It has no base classes or
+members other than those specified.
 ### The default allocator <a id="default.allocator">[[default.allocator]]</a>
+#### General <a id="default.allocator.general">[[default.allocator.general]]</a>
 All specializations of the default allocator meet the allocator
 completeness requirements [[allocator.requirements.completeness]].
 ``` cpp
 namespace std {
    public:
     using value_type                             = T;
     using size_type                              = size_t;
     using difference_type                        = ptrdiff_t;
     using propagate_on_container_move_assignment = true_type;
     constexpr allocator() noexcept;
     constexpr allocator(const allocator&) noexcept;
     template<class U> constexpr allocator(const allocator<U>&) noexcept;
     constexpr ~allocator();
     constexpr allocator& operator=(const allocator&) = default;
     [[nodiscard]] constexpr T* allocate(size_t n);
+    [[nodiscard]] constexpr allocation_result<T*> allocate_at_least(size_t n);
     constexpr void deallocate(T* p, size_t n);
   };
 }
 ```
+`allocator_traits<allocator<T>>::is_always_equal::value`
+is `true` for any `T`.
 #### Members <a id="allocator.members">[[allocator.members]]</a>
 Except for the destructor, member functions of the default allocator
 shall not introduce data races [[intro.multithread]] as a result of
 concurrent calls to those member functions from different threads. Calls
 ``` cpp
 [[nodiscard]] constexpr T* allocate(size_t n);
 ```
+*Mandates:* `T` is not an incomplete type [[term.incomplete.type]].
 *Returns:* A pointer to the initial element of an array of `n` `T`.
+*Throws:* `bad_array_new_length` if
+`numeric_limits<size_t>::max() / sizeof(T) < n`, or `bad_alloc` if the
+storage cannot be obtained.
 *Remarks:* The storage for the array is obtained by calling
 `::operator new` [[new.delete]], but it is unspecified when or how often
 this function is called. This function starts the lifetime of the array
 object, but not that of any of the array elements.
+``` cpp
+[[nodiscard]] constexpr allocation_result<T*> allocate_at_least(size_t n);
+```
+*Mandates:* `T` is not an incomplete type [[term.incomplete.type]].
+*Returns:* `allocation_result<T*>{ptr, count}`, where `ptr` is a pointer
+to the initial element of an array of `count` `T` and `count` ≥ `n`.
 *Throws:* `bad_array_new_length` if
+`numeric_limits<size_t>::max() / sizeof(T)` < `n`, or `bad_alloc` if the
 storage cannot be obtained.
+*Remarks:* The storage for the array is obtained by calling
+`::operator new`, but it is unspecified when or how often this function
+is called. This function starts the lifetime of the array object, but
+not that of any of the array elements.
 ``` cpp
 constexpr void deallocate(T* p, size_t n);
 ```
+*Preconditions:*
+- If `p` is memory that was obtained by a call to `allocate_at_least`,
+  let `ret` be the value returned and `req` be the value passed as the
+  first argument to that call. `p` is equal to `ret.ptr` and `n` is a
+  value such that `req` ≤ `n` ≤ `ret.count`.
+- Otherwise, `p` is a pointer value obtained from `allocate`. `n` equals
+  the value passed as the first argument to the invocation of `allocate`
+  which returned `p`.
 *Effects:* Deallocates the storage referenced by `p`.
 *Remarks:* Uses `::operator delete` [[new.delete]], but it is
 unspecified when this function is called.
 standard library.
 *Remarks:* These functions do not attempt to allocate storage by calling
 `::operator new()` [[new.delete]].
 These functions implicitly create objects [[intro.object]] in the
 returned region of storage and return a pointer to a suitable created
 object. In the case of `calloc` and `realloc`, the objects are created
 before the storage is zeroed or copied, respectively.

Diff to HTML by rtfpessoa