[mem] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp5x_6zp6f/{from.md → to.md} +1771 -403

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

@@ -9,20 +9,21 @@ smart pointers, memory resources, and scoped allocators, as summarized
 in [[mem.summary]].
 **Table: Memory management library summary** <a id="mem.summary">[mem.summary]</a>
 | Subclause               |                                  | Header                  |
-| --------------------- | ----------------- | ----------------------- |
 | [[memory]]              | Memory                           | `<cstdlib>`, `<memory>` |
 | [[smartptr]]            | Smart pointers                   | `<memory>`              |
 | [[mem.res]]             | Memory resources                 | `<memory_resource>`     |
 | [[allocator.adaptor]]   | Scoped allocators                | `<scoped_allocator>`    |
 ## Memory <a id="memory">[[memory]]</a>
-### In general <a id="memory.general">[[memory.general]]</a>
 Subclause  [[memory]] describes the contents of the header `<memory>`
 and some of the contents of the header `<cstdlib>`.
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
@@ -64,11 +65,13 @@ namespace std {
     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>
@@ -84,15 +87,17 @@ namespace std {
   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
@@ -161,179 +166,287 @@ namespace std {
   // [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
@@ -348,18 +461,19 @@ namespace std {
     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
@@ -371,10 +485,24 @@ namespace std {
         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
@@ -400,21 +528,25 @@ namespace std {
   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
@@ -448,95 +580,103 @@ namespace std {
   // [util.smartptr.shared], class template shared_ptr
   template<class T> class shared_ptr;
   // [util.smartptr.shared.create], shared_ptr creation
   template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args); // T is not array
   template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not array
   template<class T>
-    shared_ptr<T> make_shared(size_t N); // T is U[]
   template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[]
   template<class T>
-    shared_ptr<T> make_shared(); // T is U[N]
   template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a); // T is U[N]
   template<class T>
-    shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[]
   template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, size_t N,
                                             const remove_extent_t<T>& u);           // T is U[]
   template<class T>
-    shared_ptr<T> make_shared(const remove_extent_t<T>& u); // T is U[N]
   template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u);     // T is U[N]
   template<class T>
-    shared_ptr<T> make_shared_for_overwrite(); // T is not U[]
   template<class T, class A>
-    shared_ptr<T> allocate_shared_for_overwrite(const A& a); // T is not U[]
   template<class T>
-    shared_ptr<T> make_shared_for_overwrite(size_t N); // T is U[]
   template<class T, class A>
-    shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N); // T is U[]
   // [util.smartptr.shared.cmp], shared_ptr comparisons
   template<class T, class U>
-    bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T, class U>
-    strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T>
-    bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
   template<class T>
-    strong_ordering operator<=>(const shared_ptr<T>& x, nullptr_t) noexcept;
   // [util.smartptr.shared.spec], shared_ptr specialized algorithms
   template<class T>
-    void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
   // [util.smartptr.shared.cast], shared_ptr casts
   template<class T, class U>
-    shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
     shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
     shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r) noexcept;
   // [util.smartptr.getdeleter], shared_ptr get_deleter
   template<class D, class T>
-    D* get_deleter(const shared_ptr<T>& p) noexcept;
   // [util.smartptr.shared.io], shared_ptr I/O
   template<class E, class T, class Y>
     basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
   // [util.smartptr.weak], class template weak_ptr
   template<class T> class weak_ptr;
   // [util.smartptr.weak.spec], weak_ptr specialized algorithms
-  template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
   // [util.smartptr.ownerless], class template owner_less
   template<class T = void> struct owner_less;
   // [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
@@ -548,23 +688,39 @@ namespace std {
   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>
@@ -601,11 +757,11 @@ 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; };
@@ -731,31 +887,43 @@ into the available space, otherwise the adjusted value of `ptr`.
 it can be called repeatedly with possibly different `alignment` and
 `size` arguments for the same buffer. — *end note*]
 ``` cpp
 template<size_t N, class T>
- [[nodiscard]] constexpr T* assume_aligned(T* ptr);
 ```
 *Mandates:* `N` is a power of two.
-*Preconditions:* `ptr` points to an object `X` of a type
-similar [[conv.qual]] to `T`, where `X` has alignment `N`
-[[basic.align]].
 *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;
@@ -765,26 +933,28 @@ 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.
@@ -812,10 +982,86 @@ 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; };
@@ -1116,11 +1362,11 @@ If a program declares an explicit or partial specialization of
 ``` cpp
 namespace std {
   template<class Alloc> struct allocator_traits {
     using allocator_type     = Alloc;
-    using value_type         = typename Alloc::value_type;
     using pointer            = see below;
     using const_pointer      = see below;
     using void_pointer       = see below;
     using const_void_pointer = see below;
@@ -1134,14 +1380,13 @@ namespace std {
     using is_always_equal                        = see below;
     template<class T> using rebind_alloc = see below;
     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>
@@ -1249,25 +1494,24 @@ of the form `Alloc<U, Args>`, where `Args` is zero or more type
 arguments; otherwise, the instantiation of `rebind_alloc` is ill-formed.
 #### Static member functions <a id="allocator.traits.members">[[allocator.traits.members]]</a>
 ``` cpp
-[[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
 ```
 *Returns:* `a.allocate(n)`.
 ``` cpp
-[[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
 ```
 *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}`.
@@ -1336,12 +1580,12 @@ namespace std {
     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);
   };
 }
 ```
@@ -1357,11 +1601,11 @@ concurrent calls to those member functions from different threads. Calls
 to these functions that allocate or deallocate a particular unit of
 storage shall occur in a single total order, and each such deallocation
 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 [[term.incomplete.type]].
 *Returns:* A pointer to the initial element of an array of `n` `T`.
@@ -1374,11 +1618,11 @@ storage cannot be obtained.
 `::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
@@ -1441,23 +1685,38 @@ this subclause. — *end note*]
 ``` cpp
 void* aligned_alloc(size_t alignment, size_t size);
 void* calloc(size_t nmemb, size_t size);
 void* malloc(size_t size);
-void* realloc(void* ptr, size_t size);
 ```
 *Effects:* These functions have the semantics specified in the C
 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.
 ``` cpp
 void free(void* ptr);
 ```
@@ -1465,11 +1724,11 @@ void free(void* ptr);
 library.
 *Remarks:* This function does not attempt to deallocate storage by
 calling `::operator delete()`.
-See also: ISO C 7.22.3
 ## Smart pointers <a id="smartptr">[[smartptr]]</a>
 ### Unique-ownership pointers <a id="unique.ptr">[[unique.ptr]]</a>
@@ -1504,11 +1763,11 @@ 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
 (destruction policy) for the class template `unique_ptr`.
 The template parameter `T` of `default_delete` may be an incomplete
@@ -1623,10 +1882,16 @@ namespace std {
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 }
 ```
 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)`
@@ -1851,11 +2116,15 @@ constexpr unique_ptr& operator=(nullptr_t) noexcept;
 ``` cpp
 constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
-*Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 constexpr pointer operator->() const noexcept;
@@ -2081,11 +2350,11 @@ constexpr void reset(nullptr_t p = nullptr) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
-constexpr template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
@@ -2158,11 +2427,11 @@ template<class T1, class D1, class T2, class D2>
 *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
@@ -2181,34 +2450,34 @@ 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())`.
@@ -2306,20 +2575,20 @@ template<class E, class T, class Y, class D>
 ``` cpp
 namespace std {
   class bad_weak_ptr : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
 constructor taking a `weak_ptr`.
 ``` cpp
-const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
@@ -2341,68 +2610,73 @@ namespace std {
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
     template<class Y>
-      explicit shared_ptr(Y* p);
     template<class Y, class D>
-      shared_ptr(Y* p, D d);
     template<class Y, class D, class A>
-      shared_ptr(Y* p, D d, A a);
     template<class D>
-      shared_ptr(nullptr_t p, D d);
     template<class D, class A>
-      shared_ptr(nullptr_t p, D d, A a);
     template<class Y>
-      shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
     template<class Y>
-      shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
-    shared_ptr(const shared_ptr& r) noexcept;
     template<class Y>
-      shared_ptr(const shared_ptr<Y>& r) noexcept;
-    shared_ptr(shared_ptr&& r) noexcept;
     template<class Y>
-      shared_ptr(shared_ptr<Y>&& r) noexcept;
     template<class Y>
-      explicit shared_ptr(const weak_ptr<Y>& r);
     template<class Y, class D>
-      shared_ptr(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.dest], destructor
-    ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
-    shared_ptr& operator=(const shared_ptr& r) noexcept;
     template<class Y>
-      shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
-    shared_ptr& operator=(shared_ptr&& r) noexcept;
     template<class Y>
-      shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
     template<class Y, class D>
-      shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
-    void swap(shared_ptr& r) noexcept;
-    void reset() noexcept;
     template<class Y>
-      void reset(Y* p);
     template<class Y, class D>
-      void reset(Y* p, D d);
     template<class Y, class D, class A>
-      void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
-    element_type* get() const noexcept;
-    T& operator*() const noexcept;
-    T* operator->() const noexcept;
-    element_type& operator[](ptrdiff_t i) const;
-    long use_count() const noexcept;
-    explicit operator bool() const noexcept;
     template<class U>
-      bool owner_before(const shared_ptr<U>& b) const noexcept;
     template<class U>
-      bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
   template<class T, class D>
@@ -2434,13 +2708,13 @@ For purposes of determining the presence of a data race, member
 functions shall access and modify only the `shared_ptr` and `weak_ptr`
 objects themselves and not objects they refer to. Changes in
 `use_count()` do not reflect modifications that can introduce data
 races.
-For the purposes of subclause [[smartptr]], a pointer type `Y*` is said
-to be *compatible with* a pointer type `T*` when either `Y*` is
-convertible to `T*` or `Y` is `U[N]` and `T` is cv `U[]`.
 ##### Constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 In the constructor definitions below, enables `shared_from_this` with
 `p`, for a pointer `p` of type `Y*`, means that if `Y` has an
@@ -2448,26 +2722,26 @@ unambiguous and accessible base class that is a specialization of
 `enable_shared_from_this` [[util.smartptr.enab]], then `remove_cv_t<Y>*`
 shall be implicitly convertible to `T*` and the constructor evaluates
 the statement:
 ``` cpp
-if (p != nullptr && p->weak_this.expired())
-  p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
 ```
-The assignment to the `weak_this` member is not atomic and conflicts
 with any potentially concurrent access to the same object
 [[intro.multithread]].
 ``` cpp
 constexpr shared_ptr() noexcept;
 ```
 *Ensures:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
-template<class Y> explicit shared_ptr(Y* p);
 ```
 *Constraints:* When `T` is an array type, the expression `delete[] p` is
 well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
 `T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
@@ -2491,14 +2765,14 @@ not an array type, `delete[] p` otherwise.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory cannot be obtained.
 ``` cpp
-template<class Y, class D> shared_ptr(Y* p, D d);
-template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
-template<class D> shared_ptr(nullptr_t p, D d);
-template<class D, class A> shared_ptr(nullptr_t p, D d, A a);
 ```
 *Constraints:* `is_move_constructible_v<D>` is `true`, and `d(p)` is a
 well-formed expression. For the first two overloads:
@@ -2523,12 +2797,12 @@ use. If an exception is thrown, `d(p)` is called.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory cannot be obtained.
 ``` cpp
-template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
-template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
 ownership with the initial value of `r`.
@@ -2541,12 +2815,12 @@ destroyed. — *end note*]
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
-shared_ptr(const shared_ptr& r) noexcept;
-template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
@@ -2554,23 +2828,23 @@ otherwise, constructs a `shared_ptr` object that shares ownership with
 `r`.
 *Ensures:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
-shared_ptr(shared_ptr&& r) noexcept;
-template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 ```
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
 *Ensures:* `*this` contains the old value of `r`. `r` is empty, and
 `r.get() == nullptr`.
 ``` cpp
-template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 *Constraints:* `Y*` is compatible with `T*`.
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
@@ -2580,11 +2854,11 @@ thrown, the constructor has no effect.
 *Ensures:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
 ``` cpp
-template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 ```
 *Constraints:* `Y*` is compatible with `T*` and
 `unique_ptr<Y, D>::pointer` is convertible to `element_type*`.
@@ -2595,11 +2869,11 @@ equivalent to `shared_ptr(r.release(), ref(r.get_deleter()))`. If an
 exception is thrown, the constructor has no effect.
 ##### Destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
-~shared_ptr();
 ```
 *Effects:*
 - If `*this` is empty or shares ownership with another `shared_ptr`
@@ -2615,12 +2889,12 @@ been destroyed all `shared_ptr` instances that shared ownership with
 value. — *end note*]
 ##### Assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
-shared_ptr& operator=(const shared_ptr& r) noexcept;
-template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
@@ -2642,68 +2916,68 @@ q = p;
 both assignments can be no-ops.
 — *end note*]
 ``` cpp
-shared_ptr& operator=(shared_ptr&& r) noexcept;
-template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ``` cpp
-template<class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
 ```
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ##### Modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
-void swap(shared_ptr& r) noexcept;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
-void reset() noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr().swap(*this)`.
 ``` cpp
-template<class Y> void reset(Y* p);
 ```
 *Effects:* Equivalent to `shared_ptr(p).swap(*this)`.
 ``` cpp
-template<class Y, class D> void reset(Y* p, D d);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d).swap(*this)`.
 ``` cpp
-template<class Y, class D, class A> void reset(Y* p, D d, A a);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
 ##### Observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
-element_type* get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
-T& operator*() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
@@ -2713,11 +2987,11 @@ whether this member function is declared. If it is declared, it is
 unspecified what its return type is, except that the declaration
 (although not necessarily the definition) of the function shall be
 well-formed.
 ``` cpp
-T* operator->() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `get()`.
@@ -2726,15 +3000,16 @@ T* operator->() const noexcept;
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
 necessarily the definition) of the function shall be well-formed.
 ``` cpp
-element_type& operator[](ptrdiff_t i) const;
 ```
-*Preconditions:* `get() != nullptr && i >= 0`. If `T` is `U[N]`,
-`i < N`.
 *Returns:* `get()[i]`.
 *Throws:* Nothing.
@@ -2742,11 +3017,11 @@ element_type& operator[](ptrdiff_t i) const;
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
 necessarily the definition) of the function shall be well-formed.
 ``` cpp
-long use_count() const noexcept;
 ```
 *Synchronization:* None.
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
@@ -2762,45 +3037,62 @@ share ownership with `*this`, or `0` when `*this` is empty.
 `use_count()`, the result is approximate. In particular,
 `use_count() == 1` does not imply that accesses through a previously
 destroyed `shared_ptr` have in any sense completed. — *end note*]
 ``` cpp
-explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
 ``` cpp
-template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
-template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
-- `x.owner_before(y)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
-- under the equivalence relation defined by `owner_before`,
-  `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
-  `weak_ptr` instances are equivalent if and only if they share
-  ownership or are both empty.
 ##### Creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
 The common requirements that apply to all `make_shared`,
 `allocate_shared`, `make_shared_for_overwrite`, and
 `allocate_shared_for_overwrite` overloads, unless specified otherwise,
 are described below.
 ``` cpp
 template<class T, ...>
-  shared_ptr<T> make_shared(args);
 template<class T, class A, ...>
-  shared_ptr<T> allocate_shared(const A& a, args);
 template<class T, ...>
-  shared_ptr<T> make_shared_for_overwrite(args);
 template<class T, class A, ...>
-  shared_ptr<T> allocate_shared_for_overwrite(const A& a, args);
 ```
 *Preconditions:* `A` meets the *Cpp17Allocator*
 requirements [[allocator.requirements.general]].
@@ -2841,56 +3133,58 @@ the initialization of the object.
   suitable to hold an object of type `U`.
 - When a (sub)object of a non-array type `U` is specified to have an
   initial value of `v`, or `U(l...)`, where `l...` is a list of
   constructor arguments, `allocate_shared` shall initialize this
   (sub)object via the expression
-  - `allocator_traits<A2>::construct(a2, pv, v)` or
-  - `allocator_traits<A2>::construct(a2, pv, l...)`
-  respectively, where `pv` points to storage suitable to hold an object
- of type `U` and `a2` of type `A2` is a rebound copy of the allocator
-  `a` passed to `allocate_shared` such that its `value_type` is
-  `remove_cv_t<U>`.
 - When a (sub)object of non-array type `U` is specified to have a
   default initial value, `make_shared` shall initialize this (sub)object
   via the expression `::new(pv) U()`, where `pv` has type `void*` and
   points to storage suitable to hold an object of type `U`.
 - When a (sub)object of non-array type `U` is specified to have a
-  default initial value, `allocate_shared` shall initialize this
- (sub)object via the expression
-  `allocator_traits<A2>::construct(a2, pv)`, where `pv` points to
- storage suitable to hold an object of type `U` and `a2` of type `A2`
-  is a rebound copy of the allocator `a` passed to `allocate_shared`
- such that its `value_type` is `remove_cv_t<U>`.
 - When a (sub)object of non-array type `U` is initialized by
   `make_shared_for_overwrite` or `allocate_shared_for_overwrite`, it is
   initialized via the expression `::new(pv) U`, where `pv` has type
   `void*` and points to storage suitable to hold an object of type `U`.
 - Array elements are initialized in ascending order of their addresses.
 - When the lifetime of the object managed by the return value ends, or
   when the initialization of an array element throws an exception, the
   initialized elements are destroyed in the reverse order of their
   original construction.
 - When a (sub)object of non-array type `U` that was initialized by
-  `make_shared` is to be destroyed, it is destroyed via the expression
-  `pv->~U()` where `pv` points to that object of type `U`.
 - When a (sub)object of non-array type `U` that was initialized by
   `allocate_shared` is to be destroyed, it is destroyed via the
-  expression `allocator_traits<A2>::destroy(a2, pv)` where `pv` points
- to that object of type `remove_cv_t<U>` and `a2` of type `A2` is a
- rebound copy of the allocator `a` passed to `allocate_shared` such
- that its `value_type` is `remove_cv_t<U>`.
 [*Note 7*: These functions will typically allocate more memory than
 `sizeof(T)` to allow for internal bookkeeping structures such as
 reference counts. — *end note*]
 ``` cpp
 template<class T, class... Args>
-  shared_ptr<T> make_shared(Args&&... args);                    // T is not array
 template<class T, class A, class... Args>
-  shared_ptr<T> allocate_shared(const A& a, Args&&... args);    // T is not array
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* A `shared_ptr` to an object of type `T` with an initial value
@@ -2909,14 +3203,14 @@ shared_ptr<vector<int>> q = make_shared<vector<int>>(16, 1);
 ```
 — *end example*]
 ``` cpp
-template<class T> shared_ptr<T>
-  make_shared(size_t N); // T is U[]
 template<class T, class A>
-  shared_ptr<T> allocate_shared(const A& a, size_t N);          // T is U[]
 ```
 *Constraints:* `T` is of the form `U[]`.
 *Returns:* A `shared_ptr` to an object of type `U[N]` with a default
@@ -2933,13 +3227,13 @@ shared_ptr<double[][2][2]> q = make_shared<double[][2][2]>(6);
 — *end example*]
 ``` cpp
 template<class T>
-  shared_ptr<T> make_shared();                                  // T is U[N]
 template<class T, class A>
-  shared_ptr<T> allocate_shared(const A& a);                    // T is U[N]
 ```
 *Constraints:* `T` is of the form `U[N]`.
 *Returns:* A `shared_ptr` to an object of type `T` with a default
@@ -2956,14 +3250,14 @@ shared_ptr<double[6][2][2]> q = make_shared<double[6][2][2]>();
 — *end example*]
 ``` cpp
 template<class T>
-  shared_ptr<T> make_shared(size_t N,
                                       const remove_extent_t<T>& u);     // T is U[]
 template<class T, class A>
-  shared_ptr<T> allocate_shared(const A& a, size_t N,
                                           const remove_extent_t<T>& u); // T is U[]
 ```
 *Constraints:* `T` is of the form `U[]`.
@@ -2983,13 +3277,13 @@ shared_ptr<vector<int>[]> r = make_shared<vector<int>[]>(4, {1, 2});
 — *end example*]
 ``` cpp
 template<class T>
-  shared_ptr<T> make_shared(const remove_extent_t<T>& u);       // T is U[N]
 template<class T, class A>
-  shared_ptr<T> allocate_shared(const A& a,
                                           const remove_extent_t<T>& u);   // T is U[N]
 ```
 *Constraints:* `T` is of the form `U[N]`.
@@ -3009,13 +3303,13 @@ shared_ptr<vector<int>[4]> r = make_shared<vector<int>[4]>({1, 2});
 — *end example*]
 ``` cpp
 template<class T>
-  shared_ptr<T> make_shared_for_overwrite();
 template<class T, class A>
-  shared_ptr<T> allocate_shared_for_overwrite(const A& a);
 ```
 *Constraints:* `T` is not an array of unknown bound.
 *Returns:* A `shared_ptr` to an object of type `T`.
@@ -3033,13 +3327,13 @@ shared_ptr<double[1024]> q = make_shared_for_overwrite<double[1024]>();
 — *end example*]
 ``` cpp
 template<class T>
-  shared_ptr<T> make_shared_for_overwrite(size_t N);
 template<class T, class A>
-  shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);
 ```
 *Constraints:* `T` is an array of unknown bound.
 *Returns:* A `shared_ptr` to an object of type `U[N]`, where `U` is
@@ -3056,59 +3350,59 @@ shared_ptr<double[]> p = make_shared_for_overwrite<double[]>(1024);
 ##### Comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
-  bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
 ``` cpp
 template<class T>
-  bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
 template<class T, class U>
-  strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `compare_three_way()(a.get(), b.get())`.
 [*Note 8*: Defining a comparison operator function allows `shared_ptr`
 objects to be used as keys in associative containers. — *end note*]
 ``` cpp
 template<class T>
-  strong_ordering operator<=>(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:*
 ``` cpp
-compare_three_way()(a.get(), static_cast<typename shared_ptr<T>::element_type*>(nullptr).
 ```
 ##### Specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
 ``` cpp
 template<class T>
-  void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 ##### Casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
 ``` cpp
 template<class T, class U>
-  shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
-  shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `static_cast<T*>((U*)nullptr)` is
 well-formed.
@@ -3120,19 +3414,18 @@ shared_ptr<T>(R, static_cast<typename shared_ptr<T>::element_type*>(r.get()))
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
 [*Note 9*: The seemingly equivalent expression
-`shared_ptr<T>(static_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
 ``` cpp
 template<class T, class U>
-  shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
-  shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `dynamic_cast<T*>((U*)nullptr)` is
 well-formed. The expression
 `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())` is
@@ -3148,19 +3441,18 @@ well-defined behavior.
   returns a non-null value `p`, `shared_ptr<T>(`*`R`*`, p)`, where *`R`*
   is `r` for the first overload, and `std::move(r)` for the second.
 - Otherwise, `shared_ptr<T>()`.
 [*Note 10*: The seemingly equivalent expression
-`shared_ptr<T>(dynamic_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
 ``` cpp
 template<class T, class U>
-  shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
-  shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `const_cast<T*>((U*)nullptr)` is well-formed.
 *Returns:*
@@ -3171,13 +3463,12 @@ shared_ptr<T>(R, const_cast<typename shared_ptr<T>::element_type*>(r.get()))
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
 [*Note 11*: The seemingly equivalent expression
-`shared_ptr<T>(const_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
@@ -3195,19 +3486,18 @@ shared_ptr<T>(R, reinterpret_cast<typename shared_ptr<T>::element_type*>(r.get()
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
 [*Note 12*: The seemingly equivalent expression
-`shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
 ##### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
 ``` cpp
 template<class D, class T>
-  D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
 *Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
 `addressof(d)`; otherwise returns `nullptr`. The returned pointer
 remains valid as long as there exists a `shared_ptr` instance that owns
@@ -3244,43 +3534,48 @@ namespace std {
     using element_type = remove_extent_t<T>;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
     template<class Y>
-      weak_ptr(const shared_ptr<Y>& r) noexcept;
-    weak_ptr(const weak_ptr& r) noexcept;
     template<class Y>
-      weak_ptr(const weak_ptr<Y>& r) noexcept;
-    weak_ptr(weak_ptr&& r) noexcept;
     template<class Y>
-      weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
-    ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
-    weak_ptr& operator=(const weak_ptr& r) noexcept;
     template<class Y>
-      weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
     template<class Y>
-      weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
-    weak_ptr& operator=(weak_ptr&& r) noexcept;
     template<class Y>
-      weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
-    void swap(weak_ptr& r) noexcept;
-    void reset() noexcept;
     // [util.smartptr.weak.obs], observers
-    long use_count() const noexcept;
-    bool expired() const noexcept;
-    shared_ptr<T> lock() const noexcept;
     template<class U>
-      bool owner_before(const shared_ptr<U>& b) const noexcept;
     template<class U>
-      bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
 }
@@ -3300,13 +3595,13 @@ constexpr weak_ptr() noexcept;
 pointer value.
 *Ensures:* `use_count() == 0`.
 ``` cpp
-weak_ptr(const weak_ptr& r) noexcept;
-template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
-template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
 *Constraints:* For the second and third constructors, `Y*` is compatible
 with `T*`.
@@ -3316,12 +3611,12 @@ that shares ownership with `r` and stores a copy of the pointer stored
 in `r`.
 *Ensures:* `use_count() == r.use_count()`.
 ``` cpp
-weak_ptr(weak_ptr&& r) noexcept;
-template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 ```
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `weak_ptr` instance from `r`.
@@ -3330,95 +3625,112 @@ template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 null pointer value, and `r.use_count() == 0`.
 ##### Destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
-~weak_ptr();
 ```
 *Effects:* Destroys this `weak_ptr` object but has no effect on the
 object its stored pointer points to.
 ##### Assignment <a id="util.smartptr.weak.assign">[[util.smartptr.weak.assign]]</a>
 ``` cpp
-weak_ptr& operator=(const weak_ptr& r) noexcept;
-template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
-template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Returns:* `*this`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary object.
 ``` cpp
-weak_ptr& operator=(weak_ptr&& r) noexcept;
-template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ##### Modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
-void swap(weak_ptr& r) noexcept;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
-void reset() noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr().swap(*this)`.
 ##### Observers <a id="util.smartptr.weak.obs">[[util.smartptr.weak.obs]]</a>
 ``` cpp
-long use_count() const noexcept;
 ```
 *Returns:* `0` if `*this` is empty; otherwise, the number of
 `shared_ptr` instances that share ownership with `*this`.
 ``` cpp
-bool expired() const noexcept;
 ```
 *Returns:* `use_count() == 0`.
 ``` cpp
-shared_ptr<T> lock() const noexcept;
 ```
 *Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
 executed atomically.
 ``` cpp
-template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
-template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
-- `x.owner_before(y)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
-- under the equivalence relation defined by `owner_before`,
-  `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
-  `weak_ptr` instances are equivalent if and only if they share
-  ownership or are both empty.
 ##### Specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
 template<class T>
-  void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 #### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
@@ -3429,30 +3741,30 @@ of shared and weak pointers.
 ``` cpp
 namespace std {
   template<class T = void> struct owner_less;
   template<class T> struct owner_less<shared_ptr<T>> {
-    bool operator()(const shared_ptr<T>&, const shared_ptr<T>&) const noexcept;
-    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<class T> struct owner_less<weak_ptr<T>> {
-    bool operator()(const weak_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<> struct owner_less<void> {
     template<class T, class U>
-      bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
-      bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
     template<class T, class U>
-      bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
-      bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
     using is_transparent = unspecified;
   };
 }
 ```
@@ -3463,17 +3775,83 @@ namespace std {
 Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
-- two `shared_ptr` or `weak_ptr` instances are equivalent under the
- equivalence relation defined by `operator()`,
-  `!operator()(a, b) && !operator()(b, a)`, if and only if they share
-  ownership or are both empty.
 — *end note*]
 #### Class template `enable_shared_from_this` <a id="util.smartptr.enab">[[util.smartptr.enab]]</a>
 A class `T` can inherit from `enable_shared_from_this<T>` to inherit the
 `shared_from_this` member functions that obtain a `shared_ptr` instance
 pointing to `*this`.
@@ -3485,68 +3863,68 @@ struct X: public enable_shared_from_this<X> { };
 int main() {
   shared_ptr<X> p(new X);
   shared_ptr<X> q = p->shared_from_this();
   assert(p == q);
-  assert(!p.owner_before(q) && !q.owner_before(p)); // p and q share ownership
 }
 ```
 — *end example*]
 ``` cpp
 namespace std {
   template<class T> class enable_shared_from_this {
   protected:
     constexpr enable_shared_from_this() noexcept;
-    enable_shared_from_this(const enable_shared_from_this&) noexcept;
-    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
-    ~enable_shared_from_this();
   public:
-    shared_ptr<T> shared_from_this();
-    shared_ptr<T const> shared_from_this() const;
-    weak_ptr<T> weak_from_this() noexcept;
-    weak_ptr<T const> weak_from_this() const noexcept;
   private:
-    mutable weak_ptr<T> weak_this;  // exposition only
   };
 }
 ```
 The template parameter `T` of `enable_shared_from_this` may be an
 incomplete type.
 ``` cpp
 constexpr enable_shared_from_this() noexcept;
-enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;
 ```
-*Effects:* Value-initializes `weak_this`.
 ``` cpp
-enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
 ```
 *Returns:* `*this`.
-[*Note 1*: `weak_this` is not changed. — *end note*]
 ``` cpp
-shared_ptr<T>       shared_from_this();
-shared_ptr<T const> shared_from_this() const;
 ```
-*Returns:* `shared_ptr<T>(weak_this)`.
 ``` cpp
-weak_ptr<T>       weak_from_this() noexcept;
-weak_ptr<T const> weak_from_this() const noexcept;
 ```
-*Returns:* `weak_this`.
 ### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
 ``` cpp
 template<class T, class D> struct hash<unique_ptr<T, D>>;
@@ -3607,16 +3985,16 @@ pointer value and manually delete it on error or failure.
 ``` cpp
 namespace std {
   template<class Smart, class Pointer, class... Args>
   class out_ptr_t {
   public:
-    explicit out_ptr_t(Smart&, Args...);
     out_ptr_t(const out_ptr_t&) = delete;
-    ~out_ptr_t();
-    operator Pointer*() const noexcept;
     operator void**() const noexcept;
   private:
     Smart& s;                   // exposition only
     tuple<Args...> a;           // exposition only
@@ -3640,41 +4018,40 @@ template.
 Evaluations of the conversion functions on the same object may conflict
 [[intro.races]].
 ``` cpp
-explicit out_ptr_t(Smart& smart, Args... args);
 ```
 *Effects:* Initializes `s` with `smart`, `a` with
 `std::forward<Args>(args)...`, and value-initializes `p`. Then,
 equivalent to:
-- ``` cpp
   s.reset();
   ```
   if the expression `s.reset()` is well-formed;
 - otherwise,
   ``` cpp
   s = Smart();
   ```
   if `is_constructible_v<Smart>` is `true`;
 - otherwise, the program is ill-formed.
 [*Note 1*: The constructor is not `noexcept` to allow for a variety of
 non-terminating and safe implementation strategies. For example, an
 implementation can allocate a `shared_ptr`’s internal node in the
 constructor and let implementation-defined exceptions escape safely. The
 destructor can then move the allocated control block in directly and
 avoid any other exceptions. — *end note*]
 ``` cpp
-~out_ptr_t();
 ```
 Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
 *Effects:* Equivalent to:
@@ -3700,11 +4077,11 @@ Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
   if `is_constructible_v<Smart, SP, Args...>` is `true`;
 - otherwise, the program is ill-formed.
 ``` cpp
-operator Pointer*() const noexcept;
 ```
 *Preconditions:* `operator void**()` has not been called on `*this`.
 *Returns:* `addressof(const_cast<Pointer&>(p))`.
@@ -3735,18 +4112,18 @@ implementations. — *end note*]
 #### Function template `out_ptr` <a id="out.ptr">[[out.ptr]]</a>
 ``` cpp
 template<class Pointer = void, class Smart, class... Args>
-  auto out_ptr(Smart& s, Args&&... args);
 ```
 Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
 *`POINTER_OF`*`(Smart)`.
 *Returns:*
-`out_ptr_t<Smart, P, Args&&...>(s, std::forward<Args>(args)...)`
 #### Class template `inout_ptr_t` <a id="inout.ptr.t">[[inout.ptr.t]]</a>
 `inout_ptr_t` is a class template used to adapt types such as smart
 pointers [[smartptr]] for functions that use output pointer parameters
@@ -3786,16 +4163,16 @@ place.
 ``` cpp
 namespace std {
   template<class Smart, class Pointer, class... Args>
   class inout_ptr_t {
   public:
-    explicit inout_ptr_t(Smart&, Args...);
     inout_ptr_t(const inout_ptr_t&) = delete;
-    ~inout_ptr_t();
-    operator Pointer*() const noexcept;
     operator void**() const noexcept;
   private:
     Smart& s;                   // exposition only
     tuple<Args...> a;           // exposition only
@@ -3817,11 +4194,11 @@ template.
 Evaluations of the conversion functions on the same object may conflict
 [[intro.races]].
 ``` cpp
-explicit inout_ptr_t(Smart& smart, Args... args);
 ```
 *Effects:* Initializes `s` with `smart`, `a` with
 `std::forward<Args>(args)...`, and `p` to either
@@ -3834,11 +4211,11 @@ explicit inout_ptr_t(Smart& smart, Args... args);
 non-terminating and safe implementation strategies. For example, an
 intrusive pointer implementation with a control block can allocate in
 the constructor and safely fail with an exception. — *end note*]
 ``` cpp
-~inout_ptr_t();
 ```
 Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
 Let *release-statement* be `s.release();` if an implementation does not
@@ -3846,14 +4223,12 @@ call `s.release()` in the constructor. Otherwise, it is empty.
 *Effects:* Equivalent to:
 -
   ``` cpp
-  if (p) {
   apply([&](auto&&... args) {
     s = Smart(static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
-  }
   ```
   if `is_pointer_v<Smart>` is `true`;
 - otherwise,
   ``` cpp
@@ -3878,11 +4253,11 @@ call `s.release()` in the constructor. Otherwise, it is empty.
   if `is_constructible_v<Smart, SP, Args...>` is `true`;
 - otherwise, the program is ill-formed.
 ``` cpp
-operator Pointer*() const noexcept;
 ```
 *Preconditions:* `operator void**()` has not been called on `*this`.
 *Returns:* `addressof(const_cast<Pointer&>(p))`.
@@ -3913,19 +4288,977 @@ implementations. — *end note*]
 #### Function template `inout_ptr` <a id="inout.ptr">[[inout.ptr]]</a>
 ``` cpp
 template<class Pointer = void, class Smart, class... Args>
-  auto inout_ptr(Smart& s, Args&&... args);
 ```
 Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
 *`POINTER_OF`*`(Smart)`.
 *Returns:*
 `inout_ptr_t<Smart, P, Args&&...>(s, std::forward<Args>(args)...)`.
 ## Memory resources <a id="mem.res">[[mem.res]]</a>
 ### Header `<memory_resource>` synopsis <a id="mem.res.syn">[[mem.res.syn]]</a>
 ``` cpp
@@ -3973,11 +5306,11 @@ namespace std::pmr {
     memory_resource(const memory_resource&) = default;
     virtual ~memory_resource();
     memory_resource& operator=(const memory_resource&) = default;
- [[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);
     void deallocate(void* p, size_t bytes, size_t alignment = max_align);
     bool is_equal(const memory_resource& other) const noexcept;
   private:
@@ -3996,11 +5329,11 @@ namespace std::pmr {
 ```
 *Effects:* Destroys this `memory_resource`.
 ``` cpp
-[[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);
 ```
 *Effects:* Allocates storage by calling `do_allocate(bytes, alignment)`
 and implicitly creates objects within the allocated region of storage.
@@ -4053,16 +5386,16 @@ allocated storage.
 ``` cpp
 virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
 ```
 *Returns:* A derived class shall implement this function to return
-`true` if memory allocated from `this` can be deallocated from `other`
 and vice-versa, otherwise `false`.
 [*Note 1*: It is possible that the most-derived type of `other` does
-not match the type of `this`. For a derived class `D`, an implementation
-of this function can immediately return `false` if
 `dynamic_cast<const D*>(&other) == nullptr`. — *end note*]
 #### Equality <a id="mem.res.eq">[[mem.res.eq]]</a>
 ``` cpp
@@ -4108,23 +5441,26 @@ namespace std::pmr {
       polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;
     polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
     // [mem.poly.allocator.mem], member functions
- [[nodiscard]] Tp* allocate(size_t n);
     void deallocate(Tp* p, size_t n);
- [[nodiscard]] void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
     void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_align_t));
-    template<class T> [[nodiscard]] T* allocate_object(size_t n = 1);
     template<class T> void deallocate_object(T* p, size_t n = 1);
-    template<class T, class... CtorArgs> [[nodiscard]] T* new_object(CtorArgs&&... ctor_args);
     template<class T> void delete_object(T* p);
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
     polymorphic_allocator select_on_container_copy_construction() const;
     memory_resource* resource() const;
     // friends
@@ -4164,11 +5500,11 @@ template<class U> polymorphic_allocator(const polymorphic_allocator<U>& other) n
 *Effects:* Sets `memory_rsrc` to `other.resource()`.
 #### Member functions <a id="mem.poly.allocator.mem">[[mem.poly.allocator.mem]]</a>
 ``` cpp
-[[nodiscard]] Tp* allocate(size_t n);
 ```
 *Effects:* If `numeric_limits<size_t>::max() / sizeof(Tp) < n`, throws
 `bad_array_new_length`. Otherwise equivalent to:
@@ -4187,11 +5523,11 @@ void deallocate(Tp* p, size_t n);
 `memory_rsrc->deallocate(p, n * sizeof(Tp), alignof(Tp))`.
 *Throws:* Nothing.
 ``` cpp
-[[nodiscard]] void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
 ```
 *Effects:* Equivalent to:
 `return memory_rsrc->allocate(nbytes, alignment);`
@@ -4207,11 +5543,11 @@ void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_ali
 *Effects:* Equivalent to
 `memory_rsrc->deallocate(p, nbytes, alignment)`.
 ``` cpp
 template<class T>
- [[nodiscard]] T* allocate_object(size_t n = 1);
 ```
 *Effects:* Allocates memory suitable for holding an array of `n` objects
 of type `T`, as follows:
@@ -4232,11 +5568,11 @@ template<class T>
 *Effects:* Equivalent to `deallocate_bytes(p, n*sizeof(T), alignof(T))`.
 ``` cpp
 template<class T, class... CtorArgs>
- [[nodiscard]] T* new_object(CtorArgs&&... ctor_args);
 ```
 *Effects:* Allocates and constructs an object of type `T`, as follows.
 Equivalent to:
@@ -4260,11 +5596,11 @@ template<class T>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-allocator_traits<polymorphic_allocator>::destroy(*this, p);
 deallocate_object(p);
 ```
 ``` cpp
 template<class T, class... Args>
@@ -4273,16 +5609,23 @@ template<class T, class... Args>
 *Mandates:* Uses-allocator construction of `T` with allocator `*this`
 (see  [[allocator.uses.construction]]) and constructor arguments
 `std::forward<Args>(args)...` is well-formed.
-*Effects:* Construct a `T` object in the storage whose address is
 represented by `p` by uses-allocator construction with allocator `*this`
 and constructor arguments `std::forward<Args>(args)...`.
 *Throws:* Nothing unless the constructor for `T` throws.
 ``` cpp
 polymorphic_allocator select_on_container_copy_construction() const;
 ```
 *Returns:* `polymorphic_allocator()`.
@@ -4341,13 +5684,13 @@ resource pointer to `r`, otherwise sets the default memory resource
 pointer to `new_delete_resource()`.
 *Returns:* The previous value of the default memory resource pointer.
 *Remarks:* Calling the `set_default_resource` and `get_default_resource`
-functions shall not incur a data race. A call to the
-`set_default_resource` function shall synchronize with subsequent calls
-to the `set_default_resource` and `get_default_resource` functions.
 ``` cpp
 memory_resource* get_default_resource() noexcept;
 ```
@@ -4464,11 +5807,11 @@ size_t max_blocks_per_chunk;
 The maximum number of blocks that will be allocated at once from the
 upstream memory resource [[mem.res.monotonic.buffer]] to replenish a
 pool. If the value of `max_blocks_per_chunk` is zero or is greater than
 an *implementation-defined* limit, that limit is used instead. The
 implementation may choose to use a smaller value than is specified in
-this field and may use different values for different pools.
 ``` cpp
 size_t largest_required_pool_block;
 ```
@@ -4476,11 +5819,11 @@ The largest allocation size that is required to be fulfilled using the
 pooling mechanism. Attempts to allocate a single block larger than this
 threshold will be allocated directly from the upstream memory resource.
 If `largest_required_pool_block` is zero or is greater than an
 *implementation-defined* limit, that limit is used instead. The
 implementation may choose a pass-through threshold larger than specified
-in this field.
 #### Constructors and destructors <a id="mem.res.pool.ctor">[[mem.res.pool.ctor]]</a>
 ``` cpp
 synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);
@@ -4665,12 +6008,12 @@ void release();
 *Effects:* Calls `upstream_rsrc->deallocate()` as necessary to release
 all allocated memory. Resets `current_buffer` and `next_buffer_size` to
 their initial values at construction.
 [*Note 1*: The memory is released back to `upstream_rsrc` even if some
-blocks that were allocated from `this` have not been deallocated from
-`this`. — *end note*]
 ``` cpp
 memory_resource* upstream_resource() const;
 ```
@@ -4764,17 +6107,17 @@ namespace std {
   public:
     using outer_allocator_type = OuterAlloc;
     using inner_allocator_type = see below;
-    using value_type           = typename OuterTraits::value_type;
-    using size_type            = typename OuterTraits::size_type;
-    using difference_type      = typename OuterTraits::difference_type;
-    using pointer              = typename OuterTraits::pointer;
-    using const_pointer        = typename OuterTraits::const_pointer;
-    using void_pointer         = typename OuterTraits::void_pointer;
-    using const_void_pointer   = typename OuterTraits::const_void_pointer;
     using propagate_on_container_copy_assignment = see below;
     using propagate_on_container_move_assignment = see below;
     using propagate_on_container_swap            = see below;
     using is_always_equal                        = see below;
@@ -4807,12 +6150,12 @@ namespace std {
     inner_allocator_type& inner_allocator() noexcept;
     const inner_allocator_type& inner_allocator() const noexcept;
     outer_allocator_type& outer_allocator() noexcept;
     const outer_allocator_type& outer_allocator() const noexcept;
- [[nodiscard]] pointer allocate(size_type n);
- [[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);
     void deallocate(pointer p, size_type n);
     size_type max_size() const;
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
@@ -4962,18 +6305,18 @@ const outer_allocator_type& outer_allocator() const noexcept;
 ```
 *Returns:* `static_cast<const OuterAlloc&>(*this)`.
 ``` cpp
-[[nodiscard]] pointer allocate(size_type n);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)`.
 ``` cpp
-[[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)`.
@@ -5065,14 +6408,15 @@ a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_all
 [allocator.uses]: #allocator.uses
 [allocator.uses.construction]: #allocator.uses.construction
 [allocator.uses.trait]: #allocator.uses.trait
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
-[basic.types.general]: basic.md#basic.types.general
 [bit.cast]: utilities.md#bit.cast
 [c.malloc]: #c.malloc
 [conv.qual]: expr.md#conv.qual
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
@@ -5080,16 +6424,28 @@ a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_all
 [default.allocator]: #default.allocator
 [default.allocator.general]: #default.allocator.general
 [defns.const.subexpr]: intro.md#defns.const.subexpr
 [expr.eq]: expr.md#expr.eq
 [function.objects]: utilities.md#function.objects
 [inout.ptr]: #inout.ptr
 [inout.ptr.t]: #inout.ptr.t
 [intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
 [intro.races]: basic.md#intro.races
 [mem]: #mem
 [mem.general]: #mem.general
 [mem.poly.allocator.class]: #mem.poly.allocator.class
 [mem.poly.allocator.class.general]: #mem.poly.allocator.class.general
 [mem.poly.allocator.ctor]: #mem.poly.allocator.ctor
 [mem.poly.allocator.eq]: #mem.poly.allocator.eq
@@ -5124,20 +6480,30 @@ a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_all
 [pointer.traits]: #pointer.traits
 [pointer.traits.functions]: #pointer.traits.functions
 [pointer.traits.general]: #pointer.traits.general
 [pointer.traits.optmem]: #pointer.traits.optmem
 [pointer.traits.types]: #pointer.traits.types
 [ptr.align]: #ptr.align
 [scoped.adaptor.operators]: #scoped.adaptor.operators
 [smartptr]: #smartptr
 [smartptr.adapt]: #smartptr.adapt
 [specialized.addressof]: #specialized.addressof
 [specialized.algorithms]: algorithms.md#specialized.algorithms
 [stmt.dcl]: stmt.md#stmt.dcl
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [term.incomplete.type]: basic.md#term.incomplete.type
 [tuple]: utilities.md#tuple
 [unique.ptr]: #unique.ptr
 [unique.ptr.create]: #unique.ptr.create
 [unique.ptr.dltr]: #unique.ptr.dltr
 [unique.ptr.dltr.dflt]: #unique.ptr.dltr.dflt
@@ -5162,10 +6528,12 @@ a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_all
 [unord.hash]: utilities.md#unord.hash
 [util.sharedptr]: #util.sharedptr
 [util.smartptr.enab]: #util.smartptr.enab
 [util.smartptr.getdeleter]: #util.smartptr.getdeleter
 [util.smartptr.hash]: #util.smartptr.hash
 [util.smartptr.ownerless]: #util.smartptr.ownerless
 [util.smartptr.shared]: #util.smartptr.shared
 [util.smartptr.shared.assign]: #util.smartptr.shared.assign
 [util.smartptr.shared.cast]: #util.smartptr.shared.cast
 [util.smartptr.shared.cmp]: #util.smartptr.shared.cmp

 in [[mem.summary]].
 **Table: Memory management library summary** <a id="mem.summary">[mem.summary]</a>
 | Subclause               |                                  | Header                  |
+| ----------------------- | -------------------------------- | ----------------------- |
 | [[memory]]              | Memory                           | `<cstdlib>`, `<memory>` |
 | [[smartptr]]            | Smart pointers                   | `<memory>`              |
+| [[mem.composite.types]] | Types for composite class design | `<memory>`              |
 | [[mem.res]]             | Memory resources                 | `<memory_resource>`     |
 | [[allocator.adaptor]]   | Scoped allocators                | `<scoped_allocator>`    |
 ## Memory <a id="memory">[[memory]]</a>
+### General <a id="memory.general">[[memory.general]]</a>
 Subclause  [[memory]] describes the contents of the header `<memory>`
 and some of the contents of the header `<cstdlib>`.
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
     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>
+    constexpr T* assume_aligned(T* ptr); // freestanding
+  template<size_t Alignment, class T>
+    bool is_sufficiently_aligned(T* ptr);
   // [obj.lifetime], explicit lifetime management
   template<class T>
     T* start_lifetime_as(void* p) noexcept;                                         // freestanding
   template<class T>
   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;
+  template<class T>
+    T* trivially_relocate(T* first, T* last, T* result);                            // freestanding
+  template<class T>
+    constexpr T* relocate(T* first, T* last, T* result);                            // freestanding
   // [allocator.tag], allocator argument tag
+  struct allocator_arg_t { 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
   // [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 I>
+    concept nothrow-bidirectional-iterator = see below;        // exposition only
+  template<class I>
+    concept nothrow-random-access-iterator = see below;        // exposition only
   template<class S, class I>
     concept nothrow-sentinel-for = see below;                  // exposition only
+  template<class S, class I>
+    concept nothrow-sized-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 R>
+    concept nothrow-bidirectional-range = see below;           // exposition only
+  template<class R>
+    concept nothrow-random-access-range = see below;           // exposition only
+  template<class R>
+    concept nothrow-sized-random-access-range = see below;     // exposition only
   template<class NoThrowForwardIterator>
+ constexpr void uninitialized_default_construct(NoThrowForwardIterator first, // freestanding
                                                    NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
+    void uninitialized_default_construct(ExecutionPolicy&& exec, // freestanding-deleted,
+                                         NoThrowForwardIterator first,      // see [algorithms.parallel.overloads]
                                          NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator
       uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);      // freestanding
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
+      uninitialized_default_construct_n(ExecutionPolicy&& exec, // freestanding-deleted,
+                                        NoThrowForwardIterator first,       // see [algorithms.parallel.overloads]
+                                        Size n);
   namespace ranges {
     template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
       requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_default_construct(I first, S last); // freestanding
     template<nothrow-forward-range R>
       requires default_initializable<range_value_t<R>>
+ constexpr borrowed_iterator_t<R> uninitialized_default_construct(R&& r); // freestanding
     template<nothrow-forward-iterator I>
       requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_default_construct_n(I first, // freestanding
+                                                      iter_difference_t<I> n);
+    template<execution-policy Ep, nothrow-random-access-iterator I,
+             nothrow-sized-sentinel-for<I> S>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_default_construct(Ep&& exec, I first, S last);      // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-sized-random-access-range R>
+      requires default_initializable<range_value_t<R>>
+        borrowed_iterator_t<R> uninitialized_default_construct(Ep&& exec,   // freestanding-deleted,
+                                                               R&& r);      // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-random-access-iterator I>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_default_construct_n(Ep&& exec, I first,             // freestanding-deleted,
+                                            iter_difference_t<I> n);        // see [algorithms.parallel.overloads]
   }
   template<class NoThrowForwardIterator>
+ constexpr void uninitialized_value_construct(NoThrowForwardIterator first, // freestanding
                                                  NoThrowForwardIterator last);
   template<class ExecutionPolicy, class NoThrowForwardIterator>
+    void uninitialized_value_construct(ExecutionPolicy&& exec, // freestanding-deleted,
+                                       NoThrowForwardIterator first,        // see [algorithms.parallel.overloads]
                                        NoThrowForwardIterator last);
   template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator
       uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);        // freestanding
   template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
     NoThrowForwardIterator
+      uninitialized_value_construct_n(ExecutionPolicy&& exec, // freestanding-deleted,
+                                      NoThrowForwardIterator first,         // see [algorithms.parallel.overloads]
+                                      Size n);
   namespace ranges {
     template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
       requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_value_construct(I first, S last); // freestanding
     template<nothrow-forward-range R>
       requires default_initializable<range_value_t<R>>
+ constexpr borrowed_iterator_t<R> uninitialized_value_construct(R&& r); // freestanding
     template<nothrow-forward-iterator I>
       requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_value_construct_n(I first, // freestanding
+                                                    iter_difference_t<I> n);
+    template<execution-policy Ep, nothrow-random-access-iterator I,
+             nothrow-sized-sentinel-for<I> S>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_value_construct(Ep&& exec, I first, S last);        // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-sized-random-access-range R>
+      requires default_initializable<range_value_t<R>>
+        borrowed_iterator_t<R> uninitialized_value_construct(Ep&& exec,     // freestanding-deleted,
+                                                             R&& r);        // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-random-access-iterator I>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_value_construct_n(Ep&& exec, I first,               // freestanding-deleted,
+                                          iter_difference_t<I> n);          // see [algorithms.parallel.overloads]
   }
   template<class InputIterator, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_copy(InputIterator first, // freestanding
                                                         InputIterator last,
                                                         NoThrowForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_copy(ExecutionPolicy&& exec, // freestanding-deleted,
+                                              ForwardIterator first,        // see [algorithms.parallel.overloads]
+                                              ForwardIterator last,
                                               NoThrowForwardIterator result);
   template<class InputIterator, class Size, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_copy_n(InputIterator first, // freestanding
+                                                          Size n,
                                                           NoThrowForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator, class Size,
            class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec, // freestanding-deleted,
+                                                ForwardIterator first,      // see [algorithms.parallel.overloads]
+                                                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>>
+ constexpr 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>>
+ constexpr 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>>
+ constexpr uninitialized_copy_n_result<I, O>
           uninitialized_copy_n(I ifirst, iter_difference_t<I> n,                    // freestanding
                                O ofirst, S olast);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S1,
+             nothrow-random-access-iterator O, nothrow-sized-sentinel-for<O> S2>
+      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+        uninitialized_copy_result<I, O>
+          uninitialized_copy(Ep&& exec, I ifirst, S1 ilast,                 // freestanding-deleted,
+                             O ofirst, S2 olast);                           // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, sized-random-access-range IR,
+             nothrow-sized-random-access-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(Ep&& exec, IR&& in_range, OR&& out_range);     // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, random_access_iterator I, nothrow-random-access-iterator O,
+             nothrow-sized-sentinel-for<O> S>
+      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+        uninitialized_copy_n_result<I, O>
+          uninitialized_copy_n(Ep&& exec, I ifirst, iter_difference_t<I> n, // freestanding-deleted,
+                               O ofirst, S olast);                          // see [algorithms.parallel.overloads]
   }
   template<class InputIterator, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_move(InputIterator first, // freestanding
                                                         InputIterator last,
                                                         NoThrowForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_move(ExecutionPolicy&& exec, // freestanding-deleted,
+                                              ForwardIterator first,        // see [algorithms.parallel.overloads]
+                                              ForwardIterator last,
                                               NoThrowForwardIterator result);
   template<class InputIterator, class Size, class NoThrowForwardIterator>
+ constexpr 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, // freestanding-deleted,
+                           ForwardIterator first, Size n,                   // see [algorithms.parallel.overloads]
+                           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>>
+ constexpr 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>>
+ constexpr 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>>
+ constexpr uninitialized_move_n_result<I, O>
           uninitialized_move_n(I ifirst, iter_difference_t<I> n,                    // freestanding
                                O ofirst, S olast);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S1,
+             nothrow-random-access-iterator O, nothrow-sized-sentinel-for<O> S2>
+      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+        uninitialized_move_result<I, O>
+          uninitialized_move(Ep&& exec, I ifirst, S1 ilast,                 // freestanding-deleted,
+                             O ofirst, S2 olast);                           // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, sized-random-access-range IR,
+             nothrow-sized-random-access-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(Ep&& exec, IR&& in_range, OR&& out_range);     // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, random_access_iterator I,
+             nothrow-random-access-iterator O, nothrow-sized-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(Ep&& exec, I ifirst, iter_difference_t<I> n, // freestanding-deleted,
+                               O ofirst, S olast);                          // see [algorithms.parallel.overloads]
   }
   template<class NoThrowForwardIterator, class T>
+ constexpr void uninitialized_fill(NoThrowForwardIterator first, // freestanding
                                       NoThrowForwardIterator last, const T& x);
   template<class ExecutionPolicy, class NoThrowForwardIterator, class T>
+    void uninitialized_fill(ExecutionPolicy&& exec, // freestanding-deleted,
+                            NoThrowForwardIterator first,                   // see [algorithms.parallel.overloads]
+                            NoThrowForwardIterator last,
                             const T& x);
   template<class NoThrowForwardIterator, class Size, class T>
+ constexpr 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, // freestanding-deleted,
+                           NoThrowForwardIterator first,                    // see [algorithms.parallel.overloads]
+                           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&>
+ constexpr 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&>
+ constexpr 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&>
+ constexpr I uninitialized_fill_n(I first, // freestanding
+                                         iter_difference_t<I> n, const T& x);
+    template<execution-policy Ep, nothrow-random-access-iterator I,
+             nothrow-sized-sentinel-for<I> S, class T>
+      requires constructible_from<iter_value_t<I>, const T&>
+        I uninitialized_fill(Ep&& exec, I first, S last, const T& x);       // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-sized-random-access-range R, class T>
+      requires constructible_from<range_value_t<R>, const T&>
+        borrowed_iterator_t<R> uninitialized_fill(Ep&& exec, R&& r,         // freestanding-deleted,
+                                                  const T& x);              // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-random-access-iterator I, class T>
+      requires constructible_from<iter_value_t<I>, const T&>
+        I uninitialized_fill_n(Ep&& exec, I first,                          // freestanding-deleted,
+                               iter_difference_t<I> n, const T& x);         // see [algorithms.parallel.overloads]
   }
   // [specialized.construct], construct_at
   template<class T, class... Args>
     constexpr T* construct_at(T* location, Args&&... args);                         // freestanding
     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, // freestanding-deleted,
+                 NoThrowForwardIterator first,                              // see [algorithms.parallel.overloads]
+                 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, // freestanding-deleted,
+                                     NoThrowForwardIterator first, Size n); // see [algorithms.parallel.overloads]
   namespace ranges {
     template<destructible T>
       constexpr void destroy_at(T* location) noexcept;                              // freestanding
         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
+    template<execution-policy Ep, nothrow-random-access-iterator I,
+             nothrow-sized-sentinel-for<I> S>
+      requires destructible<iter_value_t<I>>
+        I destroy(Ep&& exec, I first, S last) noexcept;                     // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-sized-random-access-range R>
+      requires destructible<range_value_t<R>>
+        borrowed_iterator_t<R> destroy(Ep&& exec, R&& r) noexcept;          // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
+    template<execution-policy Ep, nothrow-random-access-iterator I>
+      requires destructible<iter_value_t<I>>
+        I destroy_n(Ep&& exec, I first, iter_difference_t<I> n) noexcept;   // freestanding-deleted,
+                                                                            // see [algorithms.parallel.overloads]
   }
   // [unique.ptr], class template unique_ptr
   template<class T> struct default_delete;                                          // freestanding
   template<class T> struct default_delete<T[]>;                                     // 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>
+ 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>
+ 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>
+ 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>
+ 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>
     requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
                                        typename unique_ptr<T2, D2>::pointer>
+ constexpr 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
   // [util.smartptr.shared], class template shared_ptr
   template<class T> class shared_ptr;
   // [util.smartptr.shared.create], shared_ptr creation
   template<class T, class... Args>
+ constexpr shared_ptr<T> make_shared(Args&&... args); // T is not array
   template<class T, class A, class... Args>
+ constexpr shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not array
   template<class T>
+ constexpr shared_ptr<T> make_shared(size_t N); // T is U[]
   template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[]
   template<class T>
+ constexpr shared_ptr<T> make_shared(); // T is U[N]
   template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a); // T is U[N]
   template<class T>
+ constexpr shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[]
   template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a, size_t N,
                                             const remove_extent_t<T>& u);           // T is U[]
   template<class T>
+ constexpr shared_ptr<T> make_shared(const remove_extent_t<T>& u); // T is U[N]
   template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a, // T is U[N]
+                                            const remove_extent_t<T>& u);
   template<class T>
+ constexpr shared_ptr<T> make_shared_for_overwrite(); // T is not U[]
   template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a); // T is not U[]
   template<class T>
+ constexpr shared_ptr<T> make_shared_for_overwrite(size_t N); // T is U[]
   template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N); // T is U[]
   // [util.smartptr.shared.cmp], shared_ptr comparisons
   template<class T, class U>
+ constexpr bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T, class U>
+ constexpr strong_ordering operator<=>(const shared_ptr<T>& a,
+                                          const shared_ptr<U>& b) noexcept;
   template<class T>
+ constexpr bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
   template<class T>
+ constexpr strong_ordering operator<=>(const shared_ptr<T>& x, nullptr_t) noexcept;
   // [util.smartptr.shared.spec], shared_ptr specialized algorithms
   template<class T>
+ constexpr void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
   // [util.smartptr.shared.cast], shared_ptr casts
   template<class T, class U>
+ constexpr shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
+ constexpr shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
+ constexpr shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
+ constexpr shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
+ constexpr shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
+ constexpr shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
     shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
     shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r) noexcept;
   // [util.smartptr.getdeleter], shared_ptr get_deleter
   template<class D, class T>
+ constexpr D* get_deleter(const shared_ptr<T>& p) noexcept;
   // [util.smartptr.shared.io], shared_ptr I/O
   template<class E, class T, class Y>
     basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
   // [util.smartptr.weak], class template weak_ptr
   template<class T> class weak_ptr;
   // [util.smartptr.weak.spec], weak_ptr specialized algorithms
+  template<class T> constexpr void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
   // [util.smartptr.ownerless], class template owner_less
   template<class T = void> struct owner_less;
+  // [util.smartptr.owner.hash], struct owner_hash
+  struct owner_hash;
+  // [util.smartptr.owner.equal], struct owner_equal
+  struct owner_equal;
   // [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> 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;                                                                // freestanding
   // [out.ptr], function template out_ptr
   template<class Pointer = void, class Smart, class... Args>
+ constexpr auto out_ptr(Smart& s, Args&&... args);                               // freestanding
   // [inout.ptr.t], class template inout_ptr_t
   template<class Smart, class Pointer, class... Args>
+    class inout_ptr_t;                                                              // freestanding
   // [inout.ptr], function template inout_ptr
   template<class Pointer = void, class Smart, class... Args>
+ constexpr auto inout_ptr(Smart& s, Args&&... args);                             // freestanding
+  // [indirect], class template indirect
+  template<class T, class Allocator = allocator<T>>
+    class indirect;
+  // [indirect.hash], hash support
+  template<class T, class Alloc> struct hash<indirect<T, Alloc>>;
+  // [polymorphic], class template polymorphic
+  template<class T, class Allocator = allocator<T>>
+    class polymorphic;
+  namespace pmr {
+    template<class T> using indirect    = indirect<T, polymorphic_allocator<T>>;
+    template<class T> using polymorphic = polymorphic<T, polymorphic_allocator<T>>;
+  }
 }
 ```
 ### Pointer traits <a id="pointer.traits">[[pointer.traits]]</a>
 struct ptr-traits-elem          // exposition only
 { };
 template<class T> requires requires { typename T::element_type; }
 struct ptr-traits-elem<T>
+{ using type = 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; };
 it can be called repeatedly with possibly different `alignment` and
 `size` arguments for the same buffer. — *end note*]
 ``` cpp
 template<size_t N, class T>
+  constexpr T* assume_aligned(T* ptr);
 ```
 *Mandates:* `N` is a power of two.
+*Preconditions:* `ptr` points to an object X of a type
+similar [[conv.qual]] to `T`, where X has alignment `N` [[basic.align]].
 *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*]
+``` cpp
+template<size_t Alignment, class T>
+  bool is_sufficiently_aligned(T* ptr);
+```
+*Preconditions:* `p` points to an object `X` of a type
+similar [[conv.qual]] to `T`.
+*Returns:* `true` if `X` has alignment at least `Alignment`, otherwise
+`false`.
+*Throws:* Nothing.
 ### Explicit lifetime management <a id="obj.lifetime">[[obj.lifetime]]</a>
 ``` cpp
 template<class T>
   T* start_lifetime_as(void* p) noexcept;
   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 [[term.implicit.lifetime.type]] 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 [[term.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.
 effects.
 *Returns:* A pointer to the first element of the created array, if any;
 otherwise, a pointer that compares equal to `p` [[expr.eq]].
+``` cpp
+template<class T>
+  T* trivially_relocate(T* first, T* last, T* result);
+```
+*Mandates:* `is_trivially_relocatable_v<T> && !is_const_v<T>` is `true`.
+`T` is not an array of unknown bound.
+*Preconditions:*
+- \[`first`, `last`) is a valid range.
+- \[`result`, `result + (last - first)`) denotes a region of storage
+  that is a subset of the region reachable through `result`
+  [[basic.compound]] and suitably aligned for the type `T`.
+- No element in the range \[`first`, `last`) is a
+  potentially-overlapping subobject.
+*Ensures:* No effect if `result == first` is `true`. Otherwise, the
+range denoted by \[`result`, `result + (last - first)`) contains objects
+(including subobjects) whose lifetime has begun and whose object
+representations are the original object representations of the
+corresponding objects in the source range \[`first`, `last`) except for
+any parts of the object representations used by the implementation to
+represent type information [[intro.object]]. If any of the objects has
+union type, its active member is the same as that of the corresponding
+object in the source range. If any of the aforementioned objects has a
+non-static data member of reference type, that reference refers to the
+same entity as does the corresponding reference in the source range. The
+lifetimes of the original objects in the source range have ended.
+*Returns:* `result + (last - first)`.
+*Throws:* Nothing.
+*Complexity:* Linear in the length of the source range.
+*Remarks:* The destination region of storage is considered
+reused [[basic.life]]. No constructors or destructors are invoked.
+[*Note 2*: Overlapping ranges are supported. — *end note*]
+``` cpp
+template<class T>
+  constexpr T* relocate(T* first, T* last, T* result);
+```
+*Mandates:* `is_nothrow_relocatable_v<T> && !is_const_v<T>` is `true`.
+`T` is not an array of unknown bound.
+*Preconditions:*
+- \[`first`, `last`) is a valid range.
+- \[`result`, `result + (last - first)`) denotes a region of storage
+  that is a subset of the region reachable through `result`
+  [[basic.compound]] and suitably aligned for the type `T`.
+- No element in the range \[`first`, `last`) is a
+  potentially-overlapping subobject.
+*Effects:*
+- If `result == first` is `true`, no effect;
+- otherwise, if not called during constant evaluation and
+  `is_trivially_relocatable_v<T>` is `true`, then has effects equivalent
+  to: `trivially_relocate(first, last, result);`
+- otherwise, for each integer `i` in \[`0`, `last - first`),
+  - if `T` is an array type, equivalent to:
+    `relocate(begin(first[i]), end(first[i]), *start_lifetime_as<T>(result + i));`
+  - otherwise, equivalent to:
+    `construct_at(result + i, std::move(first[i])); destroy_at(first + i);`
+*Returns:* `result + (last - first)`.
+*Throws:* Nothing.
+[*Note 3*: Overlapping ranges are supported. — *end note*]
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
 ``` cpp
 namespace std {
   template<class Alloc> struct allocator_traits {
     using allocator_type     = Alloc;
+    using value_type         = Alloc::value_type;
     using pointer            = see below;
     using const_pointer      = see below;
     using void_pointer       = see below;
     using const_void_pointer = see below;
     using is_always_equal                        = see below;
     template<class T> using rebind_alloc = see below;
     template<class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
+    static constexpr pointer allocate(Alloc& a, size_type n);
+    static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
+    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>
 arguments; otherwise, the instantiation of `rebind_alloc` is ill-formed.
 #### Static member functions <a id="allocator.traits.members">[[allocator.traits.members]]</a>
 ``` cpp
+static constexpr pointer allocate(Alloc& a, size_type n);
 ```
 *Returns:* `a.allocate(n)`.
 ``` cpp
+static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
 ```
 *Returns:* `a.allocate(n, hint)` if that expression is well-formed;
 otherwise, `a.allocate(n)`.
 ``` cpp
+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}`.
     constexpr allocator(const allocator&) noexcept;
     template<class U> constexpr allocator(const allocator<U>&) noexcept;
     constexpr ~allocator();
     constexpr allocator& operator=(const allocator&) = default;
+    constexpr T* allocate(size_t n);
+    constexpr allocation_result<T*> allocate_at_least(size_t n);
     constexpr void deallocate(T* p, size_t n);
   };
 }
 ```
 to these functions that allocate or deallocate a particular unit of
 storage shall occur in a single total order, and each such deallocation
 call shall happen before the next allocation (if any) in this order.
 ``` cpp
+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`.
 `::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
+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
 ``` cpp
 void* aligned_alloc(size_t alignment, size_t size);
 void* calloc(size_t nmemb, size_t size);
 void* malloc(size_t size);
 ```
 *Effects:* These functions have the semantics specified in the C
 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`, the objects are created before the
+storage is zeroed.
+``` cpp
+void* realloc(void* ptr, size_t size);
+```
+*Preconditions:* `free(ptr)` has well-defined behavior.
+*Effects:* If `ptr` is not null and `size` is zero, the behavior is
+erroneous and the effects are implementation-defined. Otherwise, this
+function has the semantics specified in the C standard library.
+*Remarks:* This function does not attempt to allocate storage by calling
+`::operator new()` [[new.delete]]. When a non-null pointer is returned,
+this function implicitly creates objects [[intro.object]] in the
+returned region of storage and returns a pointer to a suitable created
+object. The objects are created before the storage is copied.
 ``` cpp
 void free(void* ptr);
 ```
 library.
 *Remarks:* This function does not attempt to deallocate storage by
 calling `::operator delete()`.
+See also: ISO C 7.24.4
 ## Smart pointers <a id="smartptr">[[smartptr]]</a>
 ### Unique-ownership pointers <a id="unique.ptr">[[unique.ptr]]</a>
 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>
+##### General <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
 (destruction policy) for the class template `unique_ptr`.
 The template parameter `T` of `default_delete` may be an incomplete
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 }
 ```
+A program that instantiates the definition of `unique_ptr<T, D>` is
+ill-formed if `T*` is an invalid type.
+[*Note 1*: This prevents the instantiation of specializations such as
+`unique_ptr<T&, D>` and `unique_ptr<int() const, D>`. — *end note*]
 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)`
 ``` cpp
 constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
+*Mandates:*
+`reference_converts_from_temporary_v<add_lvalue_reference_t<T>, decltype(*declval<pointer>())>`
+is `false`.
+*Preconditions:* `get() != nullptr` is `true`.
 *Returns:* `*get()`.
 ``` cpp
 constexpr pointer operator->() const noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
+template<class U> constexpr void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
 *Returns:* `x.get() == y.get()`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
+ constexpr bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 Let `CT` denote
 ``` cpp
 *Returns:* `less<CT>()(x.get(), y.get())`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
+ constexpr 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>
+ constexpr 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>
+ constexpr 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>
+ constexpr 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
 namespace std {
   class bad_weak_ptr : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
 constructor taking a `weak_ptr`.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
     template<class Y>
+ constexpr explicit shared_ptr(Y* p);
     template<class Y, class D>
+ constexpr shared_ptr(Y* p, D d);
     template<class Y, class D, class A>
+ constexpr shared_ptr(Y* p, D d, A a);
     template<class D>
+ constexpr shared_ptr(nullptr_t p, D d);
     template<class D, class A>
+ constexpr shared_ptr(nullptr_t p, D d, A a);
     template<class Y>
+ constexpr shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
     template<class Y>
+ constexpr shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
+ constexpr shared_ptr(const shared_ptr& r) noexcept;
     template<class Y>
+ constexpr shared_ptr(const shared_ptr<Y>& r) noexcept;
+ constexpr shared_ptr(shared_ptr&& r) noexcept;
     template<class Y>
+ constexpr shared_ptr(shared_ptr<Y>&& r) noexcept;
     template<class Y>
+ constexpr explicit shared_ptr(const weak_ptr<Y>& r);
     template<class Y, class D>
+ constexpr shared_ptr(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.dest], destructor
+ constexpr ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
+ constexpr shared_ptr& operator=(const shared_ptr& r) noexcept;
     template<class Y>
+ constexpr shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+ constexpr shared_ptr& operator=(shared_ptr&& r) noexcept;
     template<class Y>
+ constexpr shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
     template<class Y, class D>
+ constexpr shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
+ constexpr void swap(shared_ptr& r) noexcept;
+ constexpr void reset() noexcept;
     template<class Y>
+ constexpr void reset(Y* p);
     template<class Y, class D>
+ constexpr void reset(Y* p, D d);
     template<class Y, class D, class A>
+ constexpr void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
+ constexpr element_type* get() const noexcept;
+ constexpr T& operator*() const noexcept;
+ constexpr T* operator->() const noexcept;
+ constexpr element_type& operator[](ptrdiff_t i) const;
+ constexpr long use_count() const noexcept;
+ constexpr explicit operator bool() const noexcept;
     template<class U>
+ constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
     template<class U>
+ constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
+    size_t owner_hash() const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
   template<class T, class D>
 functions shall access and modify only the `shared_ptr` and `weak_ptr`
 objects themselves and not objects they refer to. Changes in
 `use_count()` do not reflect modifications that can introduce data
 races.
+For the purposes of [[smartptr]], a pointer type `Y*` is said to be
+*compatible with* a pointer type `T*` when either `Y*` is convertible to
+`T*` or `Y` is `U[N]` and `T` is cv `U[]`.
 ##### Constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 In the constructor definitions below, enables `shared_from_this` with
 `p`, for a pointer `p` of type `Y*`, means that if `Y` has an
 `enable_shared_from_this` [[util.smartptr.enab]], then `remove_cv_t<Y>*`
 shall be implicitly convertible to `T*` and the constructor evaluates
 the statement:
 ``` cpp
+if (p != nullptr && p->weak-this.expired())
+  p->weak-this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
 ```
+The assignment to the *`weak-this`* member is not atomic and conflicts
 with any potentially concurrent access to the same object
 [[intro.multithread]].
 ``` cpp
 constexpr shared_ptr() noexcept;
 ```
 *Ensures:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
+template<class Y> constexpr explicit shared_ptr(Y* p);
 ```
 *Constraints:* When `T` is an array type, the expression `delete[] p` is
 well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
 `T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory cannot be obtained.
 ``` cpp
+template<class Y, class D> constexpr shared_ptr(Y* p, D d);
+template<class Y, class D, class A> constexpr shared_ptr(Y* p, D d, A a);
+template<class D> constexpr shared_ptr(nullptr_t p, D d);
+template<class D, class A> constexpr shared_ptr(nullptr_t p, D d, A a);
 ```
 *Constraints:* `is_move_constructible_v<D>` is `true`, and `d(p)` is a
 well-formed expression. For the first two overloads:
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory cannot be obtained.
 ``` cpp
+template<class Y> constexpr shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+template<class Y> constexpr shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
 ownership with the initial value of `r`.
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
+constexpr shared_ptr(const shared_ptr& r) noexcept;
+template<class Y> constexpr shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
 `r`.
 *Ensures:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
+constexpr shared_ptr(shared_ptr&& r) noexcept;
+template<class Y> constexpr shared_ptr(shared_ptr<Y>&& r) noexcept;
 ```
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
 *Ensures:* `*this` contains the old value of `r`. `r` is empty, and
 `r.get() == nullptr`.
 ``` cpp
+template<class Y> constexpr explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 *Constraints:* `Y*` is compatible with `T*`.
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
 *Ensures:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
 ``` cpp
+template<class Y, class D> constexpr shared_ptr(unique_ptr<Y, D>&& r);
 ```
 *Constraints:* `Y*` is compatible with `T*` and
 `unique_ptr<Y, D>::pointer` is convertible to `element_type*`.
 exception is thrown, the constructor has no effect.
 ##### Destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
+constexpr ~shared_ptr();
 ```
 *Effects:*
 - If `*this` is empty or shares ownership with another `shared_ptr`
 value. — *end note*]
 ##### Assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
+constexpr shared_ptr& operator=(const shared_ptr& r) noexcept;
+template<class Y> constexpr shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
 both assignments can be no-ops.
 — *end note*]
 ``` cpp
+constexpr shared_ptr& operator=(shared_ptr&& r) noexcept;
+template<class Y> constexpr shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ``` cpp
+template<class Y, class D> constexpr shared_ptr& operator=(unique_ptr<Y, D>&& r);
 ```
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ##### Modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
+constexpr void swap(shared_ptr& r) noexcept;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
+constexpr void reset() noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr().swap(*this)`.
 ``` cpp
+template<class Y> constexpr void reset(Y* p);
 ```
 *Effects:* Equivalent to `shared_ptr(p).swap(*this)`.
 ``` cpp
+template<class Y, class D> constexpr void reset(Y* p, D d);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d).swap(*this)`.
 ``` cpp
+template<class Y, class D, class A> constexpr void reset(Y* p, D d, A a);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
 ##### Observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
+constexpr element_type* get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
+constexpr T& operator*() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 unspecified what its return type is, except that the declaration
 (although not necessarily the definition) of the function shall be
 well-formed.
 ``` cpp
+constexpr T* operator->() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `get()`.
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
 necessarily the definition) of the function shall be well-formed.
 ``` cpp
+constexpr element_type& operator[](ptrdiff_t i) const;
 ```
+*Preconditions:* `get() != nullptr` is `true`.
+`i` ≥ 0. If `T` is `U[N]`, `i` < `N`.
 *Returns:* `get()[i]`.
 *Throws:* Nothing.
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
 necessarily the definition) of the function shall be well-formed.
 ``` cpp
+constexpr long use_count() const noexcept;
 ```
 *Synchronization:* None.
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 `use_count()`, the result is approximate. In particular,
 `use_count() == 1` does not imply that accesses through a previously
 destroyed `shared_ptr` have in any sense completed. — *end note*]
 ``` cpp
+constexpr explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
 ``` cpp
+template<class U> constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
+- `owner_before(b)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
+- `!owner_before(b) && !b.owner_before(*this)` is `true` if and only if
+  `owner_equal(b)` is `true`.
+``` cpp
+size_t owner_hash() const noexcept;
+```
+*Returns:* An unspecified value such that, for any object `x` where
+`owner_equal(x)` is `true`, `owner_hash() == x.owner_hash()` is `true`.
+``` cpp
+template<class U>
+  constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+template<class U>
+  constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
+```
+*Returns:* `true` if and only if `*this` and `b` share ownership or are
+both empty. Otherwise returns `false`.
+*Remarks:* `owner_equal` is an equivalence relation.
 ##### Creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
 The common requirements that apply to all `make_shared`,
 `allocate_shared`, `make_shared_for_overwrite`, and
 `allocate_shared_for_overwrite` overloads, unless specified otherwise,
 are described below.
 ``` cpp
 template<class T, ...>
+ constexpr shared_ptr<T> make_shared(args);
 template<class T, class A, ...>
+ constexpr shared_ptr<T> allocate_shared(const A& a, args);
 template<class T, ...>
+ constexpr shared_ptr<T> make_shared_for_overwrite(args);
 template<class T, class A, ...>
+ constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a, args);
 ```
 *Preconditions:* `A` meets the *Cpp17Allocator*
 requirements [[allocator.requirements.general]].
   suitable to hold an object of type `U`.
 - When a (sub)object of a non-array type `U` is specified to have an
   initial value of `v`, or `U(l...)`, where `l...` is a list of
   constructor arguments, `allocate_shared` shall initialize this
   (sub)object via the expression
+  - `allocator_traits<A2>::construct(a2, pu, v)` or
+  - `allocator_traits<A2>::construct(a2, pu, l...)`
+  respectively, where `pu` is a pointer of type `remove_cv_t<U>*`
+ pointing to storage suitable to hold an object of type
+  `remove_cv_t<U>` and `a2` of type `A2` is a potentially rebound copy
+ of the allocator `a` passed to `allocate_shared`.
 - When a (sub)object of non-array type `U` is specified to have a
   default initial value, `make_shared` shall initialize this (sub)object
   via the expression `::new(pv) U()`, where `pv` has type `void*` and
   points to storage suitable to hold an object of type `U`.
 - When a (sub)object of non-array type `U` is specified to have a
+  default initial value, `allocate_shared` initializes this (sub)object
+  via the expression `allocator_traits<A2>::construct(a2, pu)`, where
+  `pu` is a pointer of type `remove_cv_t<U>*` pointing to storage
+  suitable to hold an object of type `remove_cv_t<U>` and `a2` of type
+ `A2` is a potentially rebound copy of the allocator `a` passed to
+  `allocate_shared`.
 - When a (sub)object of non-array type `U` is initialized by
   `make_shared_for_overwrite` or `allocate_shared_for_overwrite`, it is
   initialized via the expression `::new(pv) U`, where `pv` has type
   `void*` and points to storage suitable to hold an object of type `U`.
 - Array elements are initialized in ascending order of their addresses.
 - When the lifetime of the object managed by the return value ends, or
   when the initialization of an array element throws an exception, the
   initialized elements are destroyed in the reverse order of their
   original construction.
 - When a (sub)object of non-array type `U` that was initialized by
+  `make_shared`, `make_shared_for_overwrite`, or
+  `allocate_shared_for_overwrite` is to be destroyed, it is destroyed
+  via the expression `pu->~U()` where `pu` points to that object of type
+  `U`.
 - When a (sub)object of non-array type `U` that was initialized by
   `allocate_shared` is to be destroyed, it is destroyed via the
+  expression `allocator_traits<A2>::destroy(a2, pu)` where `pu` is a
+ pointer of type `remove_cv_t<U>*` pointing to that object of type
+ `remove_cv_t<U>` and `a2` of type `A2` is a potentially rebound copy
+ of the allocator `a` passed to `allocate_shared`.
 [*Note 7*: These functions will typically allocate more memory than
 `sizeof(T)` to allow for internal bookkeeping structures such as
 reference counts. — *end note*]
 ``` cpp
 template<class T, class... Args>
+ constexpr shared_ptr<T> make_shared(Args&&... args);                    // T is not array
 template<class T, class A, class... Args>
+ constexpr shared_ptr<T> allocate_shared(const A& a, Args&&... args);    // T is not array
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* A `shared_ptr` to an object of type `T` with an initial value
 ```
 — *end example*]
 ``` cpp
+template<class T>
+ constexpr shared_ptr<T> make_shared(size_t N); // T is U[]
 template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a, size_t N);          // T is U[]
 ```
 *Constraints:* `T` is of the form `U[]`.
 *Returns:* A `shared_ptr` to an object of type `U[N]` with a default
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared();                                  // T is U[N]
 template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a);                    // T is U[N]
 ```
 *Constraints:* `T` is of the form `U[N]`.
 *Returns:* A `shared_ptr` to an object of type `T` with a default
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared(size_t N,
                                       const remove_extent_t<T>& u);     // T is U[]
 template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a, size_t N,
                                           const remove_extent_t<T>& u); // T is U[]
 ```
 *Constraints:* `T` is of the form `U[]`.
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared(const remove_extent_t<T>& u);       // T is U[N]
 template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared(const A& a,
                                           const remove_extent_t<T>& u);   // T is U[N]
 ```
 *Constraints:* `T` is of the form `U[N]`.
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared_for_overwrite();
 template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a);
 ```
 *Constraints:* `T` is not an array of unknown bound.
 *Returns:* A `shared_ptr` to an object of type `T`.
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared_for_overwrite(size_t N);
 template<class T, class A>
+ constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);
 ```
 *Constraints:* `T` is an array of unknown bound.
 *Returns:* A `shared_ptr` to an object of type `U[N]`, where `U` is
 ##### Comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
+ constexpr bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
 ``` cpp
 template<class T>
+ constexpr bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
 template<class T, class U>
+ constexpr strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `compare_three_way()(a.get(), b.get())`.
 [*Note 8*: Defining a comparison operator function allows `shared_ptr`
 objects to be used as keys in associative containers. — *end note*]
 ``` cpp
 template<class T>
+ constexpr strong_ordering operator<=>(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:*
 ``` cpp
+compare_three_way()(a.get(), static_cast<typename shared_ptr<T>::element_type*>(nullptr))
 ```
 ##### Specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
 ``` cpp
 template<class T>
+ constexpr void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 ##### Casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
 ``` cpp
 template<class T, class U>
+ constexpr shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
+ constexpr shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `static_cast<T*>((U*)nullptr)` is
 well-formed.
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
 [*Note 9*: The seemingly equivalent expression
+`shared_ptr<T>(static_cast<T*>(r.get()))` can result in undefined
+behavior, attempting to delete the same object twice. — *end note*]
 ``` cpp
 template<class T, class U>
+ constexpr shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
+ constexpr shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `dynamic_cast<T*>((U*)nullptr)` is
 well-formed. The expression
 `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())` is
   returns a non-null value `p`, `shared_ptr<T>(`*`R`*`, p)`, where *`R`*
   is `r` for the first overload, and `std::move(r)` for the second.
 - Otherwise, `shared_ptr<T>()`.
 [*Note 10*: The seemingly equivalent expression
+`shared_ptr<T>(dynamic_cast<T*>(r.get()))` can result in undefined
+behavior, attempting to delete the same object twice. — *end note*]
 ``` cpp
 template<class T, class U>
+ constexpr shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
+ constexpr shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `const_cast<T*>((U*)nullptr)` is well-formed.
 *Returns:*
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
 [*Note 11*: The seemingly equivalent expression
+`shared_ptr<T>(const_cast<T*>(r.get()))` can result in undefined
+behavior, attempting to delete the same object twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
 [*Note 12*: The seemingly equivalent expression
+`shared_ptr<T>(reinterpret_cast<T*>(r.get()))` can result in undefined
+behavior, attempting to delete the same object twice. — *end note*]
 ##### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
 ``` cpp
 template<class D, class T>
+ constexpr D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
 *Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
 `addressof(d)`; otherwise returns `nullptr`. The returned pointer
 remains valid as long as there exists a `shared_ptr` instance that owns
     using element_type = remove_extent_t<T>;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
     template<class Y>
+ constexpr weak_ptr(const shared_ptr<Y>& r) noexcept;
+ constexpr weak_ptr(const weak_ptr& r) noexcept;
     template<class Y>
+ constexpr weak_ptr(const weak_ptr<Y>& r) noexcept;
+ constexpr weak_ptr(weak_ptr&& r) noexcept;
     template<class Y>
+ constexpr weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
+ constexpr ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
+ constexpr weak_ptr& operator=(const weak_ptr& r) noexcept;
     template<class Y>
+ constexpr weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
     template<class Y>
+ constexpr weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+ constexpr weak_ptr& operator=(weak_ptr&& r) noexcept;
     template<class Y>
+ constexpr weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
+ constexpr void swap(weak_ptr& r) noexcept;
+ constexpr void reset() noexcept;
     // [util.smartptr.weak.obs], observers
+ constexpr long use_count() const noexcept;
+ constexpr bool expired() const noexcept;
+ constexpr shared_ptr<T> lock() const noexcept;
     template<class U>
+ constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
     template<class U>
+ constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
+    size_t owner_hash() const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
 }
 pointer value.
 *Ensures:* `use_count() == 0`.
 ``` cpp
+constexpr weak_ptr(const weak_ptr& r) noexcept;
+template<class Y> constexpr weak_ptr(const weak_ptr<Y>& r) noexcept;
+template<class Y> constexpr weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
 *Constraints:* For the second and third constructors, `Y*` is compatible
 with `T*`.
 in `r`.
 *Ensures:* `use_count() == r.use_count()`.
 ``` cpp
+constexpr weak_ptr(weak_ptr&& r) noexcept;
+template<class Y> constexpr weak_ptr(weak_ptr<Y>&& r) noexcept;
 ```
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `weak_ptr` instance from `r`.
 null pointer value, and `r.use_count() == 0`.
 ##### Destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
+constexpr ~weak_ptr();
 ```
 *Effects:* Destroys this `weak_ptr` object but has no effect on the
 object its stored pointer points to.
 ##### Assignment <a id="util.smartptr.weak.assign">[[util.smartptr.weak.assign]]</a>
 ``` cpp
+constexpr weak_ptr& operator=(const weak_ptr& r) noexcept;
+template<class Y> constexpr weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
+template<class Y> constexpr weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Returns:* `*this`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary object.
 ``` cpp
+constexpr weak_ptr& operator=(weak_ptr&& r) noexcept;
+template<class Y> constexpr weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ##### Modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
+constexpr void swap(weak_ptr& r) noexcept;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
+constexpr void reset() noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr().swap(*this)`.
 ##### Observers <a id="util.smartptr.weak.obs">[[util.smartptr.weak.obs]]</a>
 ``` cpp
+constexpr long use_count() const noexcept;
 ```
 *Returns:* `0` if `*this` is empty; otherwise, the number of
 `shared_ptr` instances that share ownership with `*this`.
 ``` cpp
+constexpr bool expired() const noexcept;
 ```
 *Returns:* `use_count() == 0`.
 ``` cpp
+constexpr shared_ptr<T> lock() const noexcept;
 ```
 *Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
 executed atomically.
 ``` cpp
+template<class U> constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
+- `owner_before(b)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
+- `!owner_before(b) && !b.owner_before(*this)` is `true` if and only if
+  `owner_equal(b)` is `true`.
+``` cpp
+size_t owner_hash() const noexcept;
+```
+*Returns:* An unspecified value such that, for any object `x` where
+`owner_equal(x)` is `true`, `owner_hash() == x.owner_hash()` is `true`.
+``` cpp
+template<class U>
+  constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+template<class U>
+  constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
+```
+*Returns:* `true` if and only if `*this` and `b` share ownership or are
+both empty. Otherwise returns `false`.
+*Remarks:* `owner_equal` is an equivalence relation.
 ##### Specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
 template<class T>
+ constexpr void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 #### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
 ``` cpp
 namespace std {
   template<class T = void> struct owner_less;
   template<class T> struct owner_less<shared_ptr<T>> {
+ constexpr bool operator()(const shared_ptr<T>&, const shared_ptr<T>&) const noexcept;
+ constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
+ constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<class T> struct owner_less<weak_ptr<T>> {
+ constexpr bool operator()(const weak_ptr<T>&, const weak_ptr<T>&) const noexcept;
+ constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
+ constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<> struct owner_less<void> {
     template<class T, class U>
+ constexpr bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
+ constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
     template<class T, class U>
+ constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
+ constexpr bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
     using is_transparent = unspecified;
   };
 }
 ```
 Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
+- `!operator()(a, b) && !operator()(b, a)` is `true` if and only if
+  `a.owner_equal(b)` is `true`.
 — *end note*]
+#### Struct `owner_hash` <a id="util.smartptr.owner.hash">[[util.smartptr.owner.hash]]</a>
+The class `owner_hash` provides ownership-based hashing.
+``` cpp
+namespace std {
+  struct owner_hash {
+    template<class T>
+      size_t operator()(const shared_ptr<T>&) const noexcept;
+    template<class T>
+      size_t operator()(const weak_ptr<T>&) const noexcept;
+    using is_transparent = unspecified;
+  };
+}
+```
+``` cpp
+template<class T>
+  size_t operator()(const shared_ptr<T>& x) const noexcept;
+template<class T>
+  size_t operator()(const weak_ptr<T>& x) const noexcept;
+```
+*Returns:* `x.owner_hash()`.
+[*Note 1*: For any object `y` where `x.owner_equal(y)` is `true`,
+`x.owner_hash() == y.owner_hash()` is `true`. — *end note*]
+#### Struct `owner_equal` <a id="util.smartptr.owner.equal">[[util.smartptr.owner.equal]]</a>
+The class `owner_equal` provides ownership-based mixed equality
+comparisons of shared and weak pointers.
+``` cpp
+namespace std {
+  struct owner_equal {
+    template<class T, class U>
+      constexpr bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
+    template<class T, class U>
+      constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
+    template<class T, class U>
+      constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
+    template<class T, class U>
+      constexpr bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
+    using is_transparent = unspecified;
+  };
+}
+```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(const shared_ptr<T>& x, const shared_ptr<U>& y) const noexcept;
+template<class T, class U>
+  constexpr bool operator()(const shared_ptr<T>& x, const weak_ptr<U>& y) const noexcept;
+template<class T, class U>
+  constexpr bool operator()(const weak_ptr<T>& x, const shared_ptr<U>& y) const noexcept;
+template<class T, class U>
+  constexpr bool operator()(const weak_ptr<T>& x, const weak_ptr<U>& y) const noexcept;
+```
+*Returns:* `x.owner_equal(y)`.
+[*Note 1*: `x.owner_equal(y)` is `true` if and only if `x` and `y`
+share ownership or are both empty. — *end note*]
 #### Class template `enable_shared_from_this` <a id="util.smartptr.enab">[[util.smartptr.enab]]</a>
 A class `T` can inherit from `enable_shared_from_this<T>` to inherit the
 `shared_from_this` member functions that obtain a `shared_ptr` instance
 pointing to `*this`.
 int main() {
   shared_ptr<X> p(new X);
   shared_ptr<X> q = p->shared_from_this();
   assert(p == q);
+  assert(p.owner_equal(q)); // p and q share ownership
 }
 ```
 — *end example*]
 ``` cpp
 namespace std {
   template<class T> class enable_shared_from_this {
   protected:
     constexpr enable_shared_from_this() noexcept;
+ constexpr enable_shared_from_this(const enable_shared_from_this&) noexcept;
+ constexpr enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
+ constexpr ~enable_shared_from_this();
   public:
+ constexpr shared_ptr<T> shared_from_this();
+ constexpr shared_ptr<T const> shared_from_this() const;
+ constexpr weak_ptr<T> weak_from_this() noexcept;
+ constexpr weak_ptr<T const> weak_from_this() const noexcept;
   private:
+    mutable weak_ptr<T> weak-this;  // exposition only
   };
 }
 ```
 The template parameter `T` of `enable_shared_from_this` may be an
 incomplete type.
 ``` cpp
 constexpr enable_shared_from_this() noexcept;
+constexpr enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;
 ```
+*Effects:* Value-initializes *weak-this*.
 ``` cpp
+constexpr enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
 ```
 *Returns:* `*this`.
+[*Note 1*: *weak-this* is not changed. — *end note*]
 ``` cpp
+constexpr shared_ptr<T>       shared_from_this();
+constexpr shared_ptr<T const> shared_from_this() const;
 ```
+*Returns:* `shared_ptr<T>(`*`weak-this`*`)`.
 ``` cpp
+constexpr weak_ptr<T>       weak_from_this() noexcept;
+constexpr weak_ptr<T const> weak_from_this() const noexcept;
 ```
+*Returns:* *weak-this*.
 ### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
 ``` cpp
 template<class T, class D> struct hash<unique_ptr<T, D>>;
 ``` cpp
 namespace std {
   template<class Smart, class Pointer, class... Args>
   class out_ptr_t {
   public:
+ constexpr explicit out_ptr_t(Smart&, Args...);
     out_ptr_t(const out_ptr_t&) = delete;
+ constexpr ~out_ptr_t();
+ constexpr operator Pointer*() const noexcept;
     operator void**() const noexcept;
   private:
     Smart& s;                   // exposition only
     tuple<Args...> a;           // exposition only
 Evaluations of the conversion functions on the same object may conflict
 [[intro.races]].
 ``` cpp
+constexpr explicit out_ptr_t(Smart& smart, Args... args);
 ```
 *Effects:* Initializes `s` with `smart`, `a` with
 `std::forward<Args>(args)...`, and value-initializes `p`. Then,
 equivalent to:
+-
+  ``` cpp
   s.reset();
   ```
   if the expression `s.reset()` is well-formed;
 - otherwise,
   ``` cpp
   s = Smart();
   ```
   if `is_constructible_v<Smart>` is `true`;
 - otherwise, the program is ill-formed.
 [*Note 1*: The constructor is not `noexcept` to allow for a variety of
 non-terminating and safe implementation strategies. For example, an
 implementation can allocate a `shared_ptr`’s internal node in the
 constructor and let implementation-defined exceptions escape safely. The
 destructor can then move the allocated control block in directly and
 avoid any other exceptions. — *end note*]
 ``` cpp
+constexpr ~out_ptr_t();
 ```
 Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
 *Effects:* Equivalent to:
   if `is_constructible_v<Smart, SP, Args...>` is `true`;
 - otherwise, the program is ill-formed.
 ``` cpp
+constexpr operator Pointer*() const noexcept;
 ```
 *Preconditions:* `operator void**()` has not been called on `*this`.
 *Returns:* `addressof(const_cast<Pointer&>(p))`.
 #### Function template `out_ptr` <a id="out.ptr">[[out.ptr]]</a>
 ``` cpp
 template<class Pointer = void, class Smart, class... Args>
+ constexpr auto out_ptr(Smart& s, Args&&... args);
 ```
 Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
 *`POINTER_OF`*`(Smart)`.
 *Returns:*
+`out_ptr_t<Smart, P, Args&&...>(s, std::forward<Args>(args)...)`.
 #### Class template `inout_ptr_t` <a id="inout.ptr.t">[[inout.ptr.t]]</a>
 `inout_ptr_t` is a class template used to adapt types such as smart
 pointers [[smartptr]] for functions that use output pointer parameters
 ``` cpp
 namespace std {
   template<class Smart, class Pointer, class... Args>
   class inout_ptr_t {
   public:
+ constexpr explicit inout_ptr_t(Smart&, Args...);
     inout_ptr_t(const inout_ptr_t&) = delete;
+ constexpr ~inout_ptr_t();
+ constexpr operator Pointer*() const noexcept;
     operator void**() const noexcept;
   private:
     Smart& s;                   // exposition only
     tuple<Args...> a;           // exposition only
 Evaluations of the conversion functions on the same object may conflict
 [[intro.races]].
 ``` cpp
+constexpr explicit inout_ptr_t(Smart& smart, Args... args);
 ```
 *Effects:* Initializes `s` with `smart`, `a` with
 `std::forward<Args>(args)...`, and `p` to either
 non-terminating and safe implementation strategies. For example, an
 intrusive pointer implementation with a control block can allocate in
 the constructor and safely fail with an exception. — *end note*]
 ``` cpp
+constexpr ~inout_ptr_t();
 ```
 Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
 Let *release-statement* be `s.release();` if an implementation does not
 *Effects:* Equivalent to:
 -
   ``` cpp
   apply([&](auto&&... args) {
     s = Smart(static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
   ```
   if `is_pointer_v<Smart>` is `true`;
 - otherwise,
   ``` cpp
   if `is_constructible_v<Smart, SP, Args...>` is `true`;
 - otherwise, the program is ill-formed.
 ``` cpp
+constexpr operator Pointer*() const noexcept;
 ```
 *Preconditions:* `operator void**()` has not been called on `*this`.
 *Returns:* `addressof(const_cast<Pointer&>(p))`.
 #### Function template `inout_ptr` <a id="inout.ptr">[[inout.ptr]]</a>
 ``` cpp
 template<class Pointer = void, class Smart, class... Args>
+ constexpr auto inout_ptr(Smart& s, Args&&... args);
 ```
 Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
 *`POINTER_OF`*`(Smart)`.
 *Returns:*
 `inout_ptr_t<Smart, P, Args&&...>(s, std::forward<Args>(args)...)`.
+## Types for composite class design <a id="mem.composite.types">[[mem.composite.types]]</a>
+### Class template `indirect` <a id="indirect">[[indirect]]</a>
+#### General <a id="indirect.general">[[indirect.general]]</a>
+An indirect object manages the lifetime of an owned object. An indirect
+object is *valueless* if it has no owned object. An indirect object may
+become valueless only after it has been moved from.
+In every specialization `indirect<T, Allocator>`, if the type
+`allocator_traits<Allocator>::value_type` is not the same type as `T`,
+the program is ill-formed. Every object of type `indirect<T, Allocator>`
+uses an object of type `Allocator` to allocate and free storage for the
+owned object as needed.
+Constructing an owned object with `args...` using the allocator `a`
+means calling `allocator_traits<Allocator>::construct(a, p, args...)`
+where `args` is an expression pack, `a` is an allocator, and *`p`* is a
+pointer obtained by calling `allocator_traits<Allocator>::allocate`.
+The member *`alloc`* is used for any memory allocation and element
+construction performed by member functions during the lifetime of each
+indirect object. The allocator *`alloc`* may be replaced only via
+assignment or `swap()`. `Allocator` replacement is performed by copy
+assignment, move assignment, or swapping of the allocator only if
+[[container.reqmts]]:
+- `allocator_traits<Allocator>::propagate_on_container_copy_assignment::value`,
+  or
+- `allocator_traits<Allocator>::propagate_on_container_move_assignment::value`,
+  or
+- `allocator_traits<Allocator>::propagate_on_container_swap::value`
+is `true` within the implementation of the corresponding `indirect`
+operation.
+A program that instantiates the definition of the template
+`indirect<T, Allocator>` with a type for the `T` parameter that is a
+non-object type, an array type, `in_place_t`, a specialization of
+`in_place_type_t`, or a cv-qualified type is ill-formed.
+The template parameter `T` of `indirect` may be an incomplete type.
+The template parameter `Allocator` of `indirect` shall meet the
+*Cpp17Allocator* requirements.
+If a program declares an explicit or partial specialization of
+`indirect`, the behavior is undefined.
+#### Synopsis <a id="indirect.syn">[[indirect.syn]]</a>
+``` cpp
+namespace std {
+  template<class T, class Allocator = allocator<T>>
+  class indirect {
+  public:
+    using value_type = T;
+    using allocator_type = Allocator;
+    using pointer = allocator_traits<Allocator>::pointer;
+    using const_pointer = allocator_traits<Allocator>::const_pointer;
+    // [indirect.ctor], constructors
+    constexpr explicit indirect();
+    constexpr explicit indirect(allocator_arg_t, const Allocator& a);
+    constexpr indirect(const indirect& other);
+    constexpr indirect(allocator_arg_t, const Allocator& a, const indirect& other);
+    constexpr indirect(indirect&& other) noexcept;
+    constexpr indirect(allocator_arg_t, const Allocator& a, indirect&& other)
+      noexcept(see below);
+    template<class U = T>
+      constexpr explicit indirect(U&& u);
+    template<class U = T>
+      constexpr explicit indirect(allocator_arg_t, const Allocator& a, U&& u);
+    template<class... Us>
+      constexpr explicit indirect(in_place_t, Us&&... us);
+    template<class... Us>
+      constexpr explicit indirect(allocator_arg_t, const Allocator& a,
+                                  in_place_t, Us&&... us);
+    template<class I, class... Us>
+      constexpr explicit indirect(in_place_t, initializer_list<I> ilist, Us&&... us);
+    template<class I, class... Us>
+      constexpr explicit indirect(allocator_arg_t, const Allocator& a,
+                                  in_place_t, initializer_list<I> ilist, Us&&... us);
+    // [indirect.dtor], destructor
+    constexpr ~indirect();
+    // [indirect.assign], assignment
+    constexpr indirect& operator=(const indirect& other);
+    constexpr indirect& operator=(indirect&& other) noexcept(see below);
+    template<class U = T>
+      constexpr indirect& operator=(U&& u);
+    // [indirect.obs], observers
+    constexpr const T& operator*() const & noexcept;
+    constexpr T& operator*() & noexcept;
+    constexpr const T&& operator*() const && noexcept;
+    constexpr T&& operator*() && noexcept;
+    constexpr const_pointer operator->() const noexcept;
+    constexpr pointer operator->() noexcept;
+    constexpr bool valueless_after_move() const noexcept;
+    constexpr allocator_type get_allocator() const noexcept;
+    // [indirect.swap], swap
+    constexpr void swap(indirect& other) noexcept(see below);
+    friend constexpr void swap(indirect& lhs, indirect& rhs) noexcept(see below);
+    // [indirect.relops], relational operators
+    template<class U, class AA>
+      friend constexpr bool operator==(const indirect& lhs, const indirect<U, AA>& rhs)
+        noexcept(see below);
+    template<class U, class AA>
+      friend constexpr auto operator<=>(const indirect& lhs, const indirect<U, AA>& rhs)
+        -> synth-three-way-result<T, U>;
+    // [indirect.comp.with.t], comparison with T
+    template<class U>
+      friend constexpr bool operator==(const indirect& lhs, const U& rhs) noexcept(see below);
+    template<class U>
+      friend constexpr auto operator<=>(const indirect& lhs, const U& rhs)
+        -> synth-three-way-result<T, U>;
+  private:
+    pointer p;                          // exposition only
+    Allocator alloc = Allocator();      // exposition only
+  };
+  template<class Value>
+    indirect(Value) -> indirect<Value>;
+  template<class Allocator, class Value>
+    indirect(allocator_arg_t, Allocator, Value)
+      -> indirect<Value, typename allocator_traits<Allocator>::template rebind_alloc<Value>>;
+}
+```
+#### Constructors <a id="indirect.ctor">[[indirect.ctor]]</a>
+The following element applies to all functions in  [[indirect.ctor]]:
+*Throws:* Nothing unless `allocator_traits<Allocator>::allocate` or
+`allocator_traits<Allocator>::construct` throws.
+``` cpp
+constexpr explicit indirect();
+```
+*Constraints:* `is_default_constructible_v<Allocator>` is `true`.
+*Mandates:* `is_default_constructible_v<T>` is `true`.
+*Effects:* Constructs an owned object of type `T` with an empty argument
+list, using the allocator *alloc*.
+``` cpp
+constexpr explicit indirect(allocator_arg_t, const Allocator& a);
+```
+*Mandates:* `is_default_constructible_v<T>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `T` with an empty argument list, using the
+allocator *alloc*.
+``` cpp
+constexpr indirect(const indirect& other);
+```
+*Mandates:* `is_copy_constructible_v<T>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with
+`allocator_traits<Allocator>::select_on_container_copy_construction(other.`*`alloc`*`)`.
+If `other` is valueless, `*this` is valueless. Otherwise, constructs an
+owned object of type `T` with `*other`, using the allocator *alloc*.
+``` cpp
+constexpr indirect(allocator_arg_t, const Allocator& a, const indirect& other);
+```
+*Mandates:* `is_copy_constructible_v<T>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. If `other`
+is valueless, `*this` is valueless. Otherwise, constructs an owned
+object of type `T` with `*other`, using the allocator *alloc*.
+``` cpp
+constexpr indirect(indirect&& other) noexcept;
+```
+*Effects:* *alloc* is direct-non-list-initialized from
+`std::move(other.`*`alloc`*`)`. If `other` is valueless, `*this` is
+valueless. Otherwise `*this` takes ownership of the owned object of
+`other`.
+*Ensures:* `other` is valueless.
+``` cpp
+constexpr indirect(allocator_arg_t, const Allocator& a, indirect&& other)
+  noexcept(allocator_traits<Allocator>::is_always_equal::value);
+```
+*Mandates:* If `allocator_traits<Allocator>::is_always_equal::value` is
+`false` then `T` is a complete type.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. If `other`
+is valueless, `*this` is valueless. Otherwise, if
+*`alloc`*` == other.`*`alloc`* is `true`, constructs an object of type
+`indirect` that takes ownership of the owned object of `other`.
+Otherwise, constructs an owned object of type `T` with
+`*std::move(other)`, using the allocator *alloc*.
+*Ensures:* `other` is valueless.
+``` cpp
+template<class U = T>
+  constexpr explicit indirect(U&& u);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, indirect>` is `false`,
+- `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`,
+- `is_constructible_v<T, U>` is `true`, and
+- `is_default_constructible_v<Allocator>` is `true`.
+*Effects:* Constructs an owned object of type `T` with
+`std::forward<U>(u)`, using the allocator *alloc*.
+``` cpp
+template<class U = T>
+  constexpr explicit indirect(allocator_arg_t, const Allocator& a, U&& u);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, indirect>` is `false`,
+- `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`, and
+- `is_constructible_v<T, U>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `T` with `std::forward<U>(u)`, using the
+allocator *alloc*.
+``` cpp
+template<class... Us>
+  constexpr explicit indirect(in_place_t, Us&&... us);
+```
+*Constraints:*
+- `is_constructible_v<T, Us...>` is `true`, and
+- `is_default_constructible_v<Allocator>` is `true`.
+*Effects:* Constructs an owned object of type `T` with
+`std::forward<Us>(us)...`, using the allocator *alloc*.
+``` cpp
+template<class... Us>
+  constexpr explicit indirect(allocator_arg_t, const Allocator& a,
+                              in_place_t, Us&& ...us);
+```
+*Constraints:* `is_constructible_v<T, Us...>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `T` with `std::forward<Us>(us)...`, using the
+allocator *alloc*.
+``` cpp
+template<class I, class... Us>
+  constexpr explicit indirect(in_place_t, initializer_list<I> ilist, Us&&... us);
+```
+*Constraints:*
+- `is_constructible_v<T, initializer_list<I>&, Us...>` is `true`, and
+- `is_default_constructible_v<Allocator>` is `true`.
+*Effects:* Constructs an owned object of type `T` with the arguments
+`ilist, std::forward<Us>(us)...`, using the allocator *alloc*.
+``` cpp
+template<class I, class... Us>
+  constexpr explicit indirect(allocator_arg_t, const Allocator& a,
+                              in_place_t, initializer_list<I> ilist, Us&&... us);
+```
+*Constraints:* `is_constructible_v<T, initializer_list<I>&, Us...>` is
+`true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `T` with the arguments
+`ilist, std::forward<Us>(us)...`, using the allocator *alloc*.
+#### Destructor <a id="indirect.dtor">[[indirect.dtor]]</a>
+``` cpp
+constexpr ~indirect();
+```
+*Mandates:* `T` is a complete type.
+*Effects:* If `*this` is not valueless, destroys the owned object using
+`allocator_traits<Allocator>::destroy` and then the storage is
+deallocated.
+#### Assignment <a id="indirect.assign">[[indirect.assign]]</a>
+``` cpp
+constexpr indirect& operator=(const indirect& other);
+```
+*Mandates:*
+- `is_copy_assignable_v<T>` is `true`, and
+- `is_copy_constructible_v<T>` is `true`.
+*Effects:* If `addressof(other) == this` is `true`, there are no
+effects. Otherwise:
+- The allocator needs updating if
+  `allocator_traits<Allocator>::propagate_on_container_copy_assignment::value`
+  is `true`.
+- If `other` is valueless, `*this` becomes valueless and the owned
+  object in `*this`, if any, is destroyed using
+  `allocator_traits<Allocator>::destroy` and then the storage is
+  deallocated.
+- Otherwise, if *`alloc`*` == other.`*`alloc`* is `true` and `*this` is
+  not valueless, equivalent to `**this = *other`.
+- Otherwise a new owned object is constructed in `*this` using
+  `allocator_traits<Allocator>::construct` with the owned object from
+  `other` as the argument, using either the allocator in `*this` or the
+  allocator in `other` if the allocator needs updating.
+- The previously owned object in `*this`, if any, is destroyed using
+  `allocator_traits<Allocator>::destroy` and then the storage is
+  deallocated.
+- If the allocator needs updating, the allocator in `*this` is replaced
+  with a copy of the allocator in `other`.
+*Returns:* A reference to `*this`.
+*Remarks:* If any exception is thrown, the result of the expression
+`this->valueless_after_move()` remains unchanged. If an exception is
+thrown during the call to `T`’s selected copy constructor, no effect. If
+an exception is thrown during the call to `T`’s copy assignment, the
+state of its owned object is as defined by the exception safety
+guarantee of `T`’s copy assignment.
+``` cpp
+constexpr indirect& operator=(indirect&& other)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+```
+*Mandates:* `is_copy_constructible_v<T>` is `true`.
+*Effects:* If `addressof(other) == this` is `true`, there are no
+effects. Otherwise:
+- The allocator needs updating if
+  `allocator_traits<Allocator>::propagate_on_container_move_assignment::value`
+  is `true`.
+- If `other` is valueless, `*this` becomes valueless and the owned
+  object in `*this`, if any, is destroyed using
+  `allocator_traits<Allocator>::destroy` and then the storage is
+  deallocated.
+- Otherwise, if *`alloc`*` == other.`*`alloc`* is `true`, swaps the
+  owned objects in `*this` and `other`; the owned object in `other`, if
+  any, is then destroyed using `allocator_traits<Allocator>::destroy`
+  and then the storage is deallocated.
+- Otherwise, constructs a new owned object with the owned object of
+  `other` as the argument as an rvalue, using either the allocator in
+  `*this` or the allocator in `other` if the allocator needs updating.
+- The previously owned object in `*this`, if any, is destroyed using
+  `allocator_traits<Allocator>::destroy` and then the storage is
+  deallocated.
+- If the allocator needs updating, the allocator in `*this` is replaced
+  with a copy of the allocator in `other`.
+*Ensures:* `other` is valueless.
+*Returns:* A reference to `*this`.
+*Remarks:* If any exception is thrown, there are no effects on `*this`
+or `other`.
+``` cpp
+template<class U = T>
+  constexpr indirect& operator=(U&& u);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, indirect>` is `false`,
+- `is_constructible_v<T, U>` is `true`, and
+- `is_assignable_v<T&, U>` is `true`.
+*Effects:* If `*this` is valueless then constructs an owned object of
+type `T` with `std::forward<U>(u)` using the allocator *alloc*.
+Otherwise, equivalent to `**this = std::forward<U>(u)`.
+*Returns:* A reference to `*this`.
+#### Observers <a id="indirect.obs">[[indirect.obs]]</a>
+``` cpp
+constexpr const T& operator*() const & noexcept;
+constexpr T& operator*() & noexcept;
+```
+*Preconditions:* `*this` is not valueless.
+*Returns:* `*`*`p`*.
+``` cpp
+constexpr const T&& operator*() const && noexcept;
+constexpr T&& operator*() && noexcept;
+```
+*Preconditions:* `*this` is not valueless.
+*Returns:* `std::move(*`*`p`*`)`.
+``` cpp
+constexpr const_pointer operator->() const noexcept;
+constexpr pointer operator->() noexcept;
+```
+*Preconditions:* `*this` is not valueless.
+*Returns:* *p*.
+``` cpp
+constexpr bool valueless_after_move() const noexcept;
+```
+*Returns:* `true` if `*this` is valueless, otherwise `false`.
+``` cpp
+constexpr allocator_type get_allocator() const noexcept;
+```
+*Returns:* *alloc*.
+#### Swap <a id="indirect.swap">[[indirect.swap]]</a>
+``` cpp
+constexpr void swap(indirect& other)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+```
+*Preconditions:* If
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true`, then `Allocator` meets the *Cpp17Swappable* requirements.
+Otherwise `get_allocator() == other.get_allocator()` is `true`.
+*Effects:* Swaps the states of `*this` and `other`, exchanging owned
+objects or valueless states. If
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true`, then the allocators of `*this` and `other` are exchanged by
+calling `swap` as described in  [[swappable.requirements]]. Otherwise,
+the allocators are not swapped.
+[*Note 1*: Does not call `swap` on the owned objects
+directly. — *end note*]
+``` cpp
+constexpr void swap(indirect& lhs, indirect& rhs) noexcept(noexcept(lhs.swap(rhs)));
+```
+*Effects:* Equivalent to `lhs.swap(rhs)`.
+#### Relational operators <a id="indirect.relops">[[indirect.relops]]</a>
+``` cpp
+template<class U, class AA>
+  constexpr bool operator==(const indirect& lhs, const indirect<U, AA>& rhs)
+    noexcept(noexcept(*lhs == *rhs));
+```
+*Mandates:* The expression `*lhs == *rhs` is well-formed and its result
+is convertible to `bool`.
+*Returns:* If `lhs` is valueless or `rhs` is valueless,
+`lhs.valueless_after_move() == rhs.valueless_after_move()`; otherwise
+`*lhs == *rhs`.
+``` cpp
+template<class U, class AA>
+  constexpr synth-three-way-result<T, U>
+    operator<=>(const indirect& lhs, const indirect<U, AA>& rhs);
+```
+*Returns:* If `lhs` is valueless or `rhs` is valueless,
+`!lhs.valueless_after_move() <=> !rhs.valueless_after_move()`; otherwise
+*`synth-three-way`*`(*lhs, *rhs)`.
+#### Comparison with `T` <a id="indirect.comp.with.t">[[indirect.comp.with.t]]</a>
+``` cpp
+template<class U>
+  constexpr bool operator==(const indirect& lhs, const U& rhs) noexcept(noexcept(*lhs == rhs));
+```
+*Mandates:* The expression `*lhs == rhs` is well-formed and its result
+is convertible to `bool`.
+*Returns:* If `lhs` is valueless, `false`; otherwise `*lhs == rhs`.
+``` cpp
+template<class U>
+  constexpr synth-three-way-result<T, U>
+    operator<=>(const indirect& lhs, const U& rhs);
+```
+*Returns:* If `lhs` is valueless, `strong_ordering::less`; otherwise
+*`synth-three-way`*`(*lhs, rhs)`.
+#### Hash support <a id="indirect.hash">[[indirect.hash]]</a>
+``` cpp
+template<class T, class Allocator>
+struct hash<indirect<T, Allocator>>;
+```
+The specialization `hash<indirect<T, Allocator>>` is
+enabled [[unord.hash]] if and only if `hash<T>` is enabled. When enabled
+for an object `i` of type `indirect<T, Allocator>`,
+`hash<indirect<T, Allocator>>()(i)` evaluates to either the same value
+as `hash<T>()(*i)`, if `i` is not valueless; otherwise to an
+*implementation-defined* value. The member functions are not guaranteed
+to be `noexcept`.
+### Class template `polymorphic` <a id="polymorphic">[[polymorphic]]</a>
+#### General <a id="polymorphic.general">[[polymorphic.general]]</a>
+A polymorphic object manages the lifetime of an owned object. A
+polymorphic object may own objects of different types at different
+points in its lifetime. A polymorphic object is *valueless* if it has no
+owned object. A polymorphic object may become valueless only after it
+has been moved from.
+In every specialization `polymorphic<T, Allocator>`, if the type
+`allocator_traits<Allocator>::value_type` is not the same type as `T`,
+the program is ill-formed. Every object of type
+`polymorphic<T, Allocator>` uses an object of type `Allocator` to
+allocate and free storage for the owned object as needed.
+Constructing an owned object of type `U` with `args...` using the
+allocator `a` means calling
+`allocator_traits<Allocator>::construct(a, p, args...)` where `args` is
+an expression pack, `a` is an allocator, and *`p`* points to storage
+suitable for an owned object of type `U`.
+The member *`alloc`* is used for any memory allocation and element
+construction performed by member functions during the lifetime of each
+polymorphic value object, or until the allocator is replaced. The
+allocator may be replaced only via assignment or `swap()`. `Allocator`
+replacement is performed by copy assignment, move assignment, or
+swapping of the allocator only if [[container.reqmts]]:
+- `allocator_traits<Allocator>::propagate_on_container_copy_assignment::value`,
+  or
+- `allocator_traits<Allocator>::propagate_on_container_move_assignment::value`,
+  or
+- `allocator_traits<Allocator>::propagate_on_container_swap::value`
+is `true` within the implementation of the corresponding `polymorphic`
+operation.
+A program that instantiates the definition of `polymorphic` for a
+non-object type, an array type, `in_place_t`, a specialization of
+`in_place_type_t`, or a cv-qualified type is ill-formed.
+The template parameter `T` of `polymorphic` may be an incomplete type.
+The template parameter `Allocator` of `polymorphic` shall meet the
+requirements of *Cpp17Allocator*.
+If a program declares an explicit or partial specialization of
+`polymorphic`, the behavior is undefined.
+#### Synopsis <a id="polymorphic.syn">[[polymorphic.syn]]</a>
+``` cpp
+namespace std {
+  template<class T, class Allocator = allocator<T>>
+  class polymorphic {
+  public:
+    using value_type = T;
+    using allocator_type = Allocator;
+    using pointer = allocator_traits<Allocator>::pointer;
+    using const_pointer = allocator_traits<Allocator>::const_pointer;
+    // [polymorphic.ctor], constructors
+    constexpr explicit polymorphic();
+    constexpr explicit polymorphic(allocator_arg_t, const Allocator& a);
+    constexpr polymorphic(const polymorphic& other);
+    constexpr polymorphic(allocator_arg_t, const Allocator& a, const polymorphic& other);
+    constexpr polymorphic(polymorphic&& other) noexcept;
+    constexpr polymorphic(allocator_arg_t, const Allocator& a, polymorphic&& other)
+      noexcept(see below);
+    template<class U = T>
+      constexpr explicit polymorphic(U&& u);
+    template<class U = T>
+      constexpr explicit polymorphic(allocator_arg_t, const Allocator& a, U&& u);
+    template<class U, class... Ts>
+      constexpr explicit polymorphic(in_place_type_t<U>, Ts&&... ts);
+    template<class U, class... Ts>
+      constexpr explicit polymorphic(allocator_arg_t, const Allocator& a,
+                                     in_place_type_t<U>, Ts&&... ts);
+    template<class U, class I, class... Us>
+      constexpr explicit polymorphic(in_place_type_t<U>, initializer_list<I> ilist, Us&&... us);
+    template<class U, class I, class... Us>
+      constexpr explicit polymorphic(allocator_arg_t, const Allocator& a,
+                                     in_place_type_t<U>, initializer_list<I> ilist, Us&&... us);
+    // [polymorphic.dtor], destructor
+    constexpr ~polymorphic();
+    // [polymorphic.assign], assignment
+    constexpr polymorphic& operator=(const polymorphic& other);
+    constexpr polymorphic& operator=(polymorphic&& other) noexcept(see below);
+    // [polymorphic.obs], observers
+    constexpr const T& operator*() const noexcept;
+    constexpr T& operator*() noexcept;
+    constexpr const_pointer operator->() const noexcept;
+    constexpr pointer operator->() noexcept;
+    constexpr bool valueless_after_move() const noexcept;
+    constexpr allocator_type get_allocator() const noexcept;
+    // [polymorphic.swap], swap
+    constexpr void swap(polymorphic& other) noexcept(see below);
+    friend constexpr void swap(polymorphic& lhs, polymorphic& rhs) noexcept(see below);
+  private:
+    Allocator alloc = Allocator();      // exposition only
+  };
+}
+```
+#### Constructors <a id="polymorphic.ctor">[[polymorphic.ctor]]</a>
+The following element applies to all functions in  [[polymorphic.ctor]]:
+*Throws:* Nothing unless `allocator_traits<Allocator>::allocate` or
+`allocator_traits<Allocator>::construct` throws.
+``` cpp
+constexpr explicit polymorphic();
+```
+*Constraints:* `is_default_constructible_v<Allocator>` is `true`.
+*Mandates:*
+- `is_default_constructible_v<T>` is `true`, and
+- `is_copy_constructible_v<T>` is `true`.
+*Effects:* Constructs an owned object of type `T` with an empty argument
+list using the allocator *alloc*.
+``` cpp
+constexpr explicit polymorphic(allocator_arg_t, const Allocator& a);
+```
+*Mandates:*
+- `is_default_constructible_v<T>` is `true`, and
+- `is_copy_constructible_v<T>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `T` with an empty argument list using the
+allocator *alloc*.
+``` cpp
+constexpr polymorphic(const polymorphic& other);
+```
+*Effects:* *alloc* is direct-non-list-initialized with
+`allocator_traits<Allocator>::select_on_container_copy_construction(other.`*`alloc`*`)`.
+If `other` is valueless, `*this` is valueless. Otherwise, constructs an
+owned object of type `U`, where `U` is the type of the owned object in
+`other`, with the owned object in `other` using the allocator *alloc*.
+``` cpp
+constexpr polymorphic(allocator_arg_t, const Allocator& a, const polymorphic& other);
+```
+*Effects:* *alloc* is direct-non-list-initialized with `a`. If `other`
+is valueless, `*this` is valueless. Otherwise, constructs an owned
+object of type `U`, where `U` is the type of the owned object in
+`other`, with the owned object in `other` using the allocator *alloc*.
+``` cpp
+constexpr polymorphic(polymorphic&& other) noexcept;
+```
+*Effects:* *alloc* is direct-non-list-initialized with
+`std::move(other.`*`alloc`*`)`. If `other` is valueless, `*this` is
+valueless. Otherwise, either `*this` takes ownership of the owned object
+of `other` or, owns an object of the same type constructed from the
+owned object of `other` considering that owned object as an rvalue,
+using the allocator *alloc*.
+``` cpp
+constexpr polymorphic(allocator_arg_t, const Allocator& a, polymorphic&& other)
+  noexcept(allocator_traits<Allocator>::is_always_equal::value);
+```
+*Effects:* *alloc* is direct-non-list-initialized with `a`. If `other`
+is valueless, `*this` is valueless. Otherwise, if
+*`alloc`*` == other.`*`alloc`* is `true`, either constructs an object of
+type `polymorphic` that owns the owned object of `other`, making `other`
+valueless; or, owns an object of the same type constructed from the
+owned object of `other` considering that owned object as an rvalue.
+Otherwise, if *`alloc`*` != other.`*`alloc`* is `true`, constructs an
+object of type `polymorphic`, considering the owned object in `other` as
+an rvalue, using the allocator *alloc*.
+``` cpp
+template<class U = T>
+  constexpr explicit polymorphic(U&& u);
+```
+*Constraints:* Where `UU` is `remove_cvref_t<U>`,
+- `is_same_v<UU, polymorphic>` is `false`,
+- `derived_from<UU, T>` is `true`,
+- `is_constructible_v<UU, U>` is `true`,
+- `is_copy_constructible_v<UU>` is `true`,
+- `UU` is not a specialization of `in_place_type_t`, and
+- `is_default_constructible_v<Allocator>` is `true`.
+*Effects:* Constructs an owned object of type `UU` with
+`std::forward<U>(u)` using the allocator *alloc*.
+``` cpp
+template<class U = T>
+  constexpr explicit polymorphic(allocator_arg_t, const Allocator& a, U&& u);
+```
+*Constraints:* Where `UU` is `remove_cvref_t<U>`,
+- `is_same_v<UU, polymorphic>` is `false`,
+- `derived_from<UU, T>` is `true`,
+- `is_constructible_v<UU, U>` is `true`,
+- `is_copy_constructible_v<UU>` is `true`, and
+- `UU` is not a specialization of `in_place_type_t`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `UU` with `std::forward<U>(u)` using the
+allocator *alloc*.
+``` cpp
+template<class U, class... Ts>
+  constexpr explicit polymorphic(in_place_type_t<U>, Ts&&... ts);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, U>` is `true`,
+- `derived_from<U, T>` is `true`,
+- `is_constructible_v<U, Ts...>` is `true`,
+- `is_copy_constructible_v<U>` is `true`, and
+- `is_default_constructible_v<Allocator>` is `true`.
+*Effects:* Constructs an owned object of type `U` with
+`std::forward<Ts>(ts)...` using the allocator *alloc*.
+``` cpp
+template<class U, class... Ts>
+  constexpr explicit polymorphic(allocator_arg_t, const Allocator& a,
+                                 in_place_type_t<U>, Ts&&... ts);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, U>` is `true`,
+- `derived_from<U, T>` is `true`,
+- `is_constructible_v<U, Ts...>` is `true`, and
+- `is_copy_constructible_v<U>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `U` with `std::forward<Ts>(ts)...` using the
+allocator *alloc*.
+``` cpp
+template<class U, class I, class... Us>
+  constexpr explicit polymorphic(in_place_type_t<U>, initializer_list<I> ilist, Us&&... us);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, U>` is `true`,
+- `derived_from<U, T>` is `true`,
+- `is_constructible_v<U, initializer_list<I>&, Us...>` is `true`,
+- `is_copy_constructible_v<U>` is `true`, and
+- `is_default_constructible_v<Allocator>` is `true`.
+*Effects:* Constructs an owned object of type `U` with the arguments
+`ilist, std::forward<Us>(us)...` using the allocator *alloc*.
+``` cpp
+template<class U, class I, class... Us>
+  constexpr explicit polymorphic(allocator_arg_t, const Allocator& a,
+                                 in_place_type_t<U>, initializer_list<I> ilist, Us&&... us);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, U>` is `true`,
+- `derived_from<U, T>` is `true`,
+- `is_constructible_v<U, initializer_list<I>&, Us...>` is `true`, and
+- `is_copy_constructible_v<U>` is `true`.
+*Effects:* *alloc* is direct-non-list-initialized with `a`. Constructs
+an owned object of type `U` with the arguments
+`ilist, std::forward<Us>(us)...` using the allocator *alloc*.
+#### Destructor <a id="polymorphic.dtor">[[polymorphic.dtor]]</a>
+``` cpp
+constexpr ~polymorphic();
+```
+*Mandates:* `T` is a complete type.
+*Effects:* If `*this` is not valueless, destroys the owned object using
+`allocator_traits<Allocator>::destroy` and then the storage is
+deallocated.
+#### Assignment <a id="polymorphic.assign">[[polymorphic.assign]]</a>
+``` cpp
+constexpr polymorphic& operator=(const polymorphic& other);
+```
+*Mandates:* `T` is a complete type.
+*Effects:* If `addressof(other) == this` is `true`, there are no
+effects. Otherwise:
+- The allocator needs updating if
+  `allocator_traits<Allocator>::propagate_on_container_copy_assignment::value`
+  is `true`.
+- If `other` is not valueless, a new owned object is constructed in
+  `*this` using `allocator_traits<Allocator>::construct` with the owned
+  object from `other` as the argument, using either the allocator in
+  `*this` or the allocator in `other` if the allocator needs updating.
+- The previously owned object in `*this`, if any, is destroyed using
+  `allocator_traits<Allocator>::destroy` and then the storage is
+  deallocated.
+- If the allocator needs updating, the allocator in `*this` is replaced
+  with a copy of the allocator in `other`.
+*Returns:* A reference to `*this`.
+*Remarks:* If any exception is thrown, there are no effects on `*this`.
+``` cpp
+constexpr polymorphic& operator=(polymorphic&& other)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+```
+*Mandates:* If `allocator_traits<Allocator>::is_always_equal::value` is
+`false`, `T` is a complete type.
+*Effects:* If `addressof(other) == this` is `true`, there are no
+effects. Otherwise:
+- The allocator needs updating if
+  `allocator_traits<Allocator>::propagate_on_container_move_assignment::value`
+  is `true`.
+- If *`alloc`*` == other.`*`alloc`* is `true`, swaps the owned objects
+  in `*this` and `other`; the owned object in `other`, if any, is then
+  destroyed using `allocator_traits<Allocator>::destroy` and then the
+  storage is deallocated.
+- Otherwise, if *`alloc`*` != other.`*`alloc`* is `true`; if `other` is
+  not valueless, a new owned object is constructed in `*this` using
+  `allocator_traits<Allocator>::construct` with the owned object from
+  `other` as the argument as an rvalue, using either the allocator in
+  `*this` or the allocator in `other` if the allocator needs updating.
+- The previously owned object in `*this`, if any, is destroyed using
+  `allocator_traits<Allocator>::destroy` and then the storage is
+  deallocated.
+- If the allocator needs updating, the allocator in `*this` is replaced
+  with a copy of the allocator in `other`.
+*Returns:* A reference to `*this`.
+*Remarks:* If any exception is thrown, there are no effects on `*this`
+or `other`.
+#### Observers <a id="polymorphic.obs">[[polymorphic.obs]]</a>
+``` cpp
+constexpr const T& operator*() const noexcept;
+constexpr T& operator*() noexcept;
+```
+*Preconditions:* `*this` is not valueless.
+*Returns:* A reference to the owned object.
+``` cpp
+constexpr const_pointer operator->() const noexcept;
+constexpr pointer operator->() noexcept;
+```
+*Preconditions:* `*this` is not valueless.
+*Returns:* A pointer to the owned object.
+``` cpp
+constexpr bool valueless_after_move() const noexcept;
+```
+*Returns:* `true` if `*this` is valueless, otherwise `false`.
+``` cpp
+constexpr allocator_type get_allocator() const noexcept;
+```
+*Returns:* *alloc*.
+#### Swap <a id="polymorphic.swap">[[polymorphic.swap]]</a>
+``` cpp
+constexpr void swap(polymorphic& other)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+```
+*Preconditions:* If
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true`, then `Allocator` meets the *Cpp17Swappable* requirements.
+Otherwise `get_allocator() == other.get_allocator()` is `true`.
+*Effects:* Swaps the states of `*this` and `other`, exchanging owned
+objects or valueless states. If
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true`, then the allocators of `*this` and `other` are exchanged by
+calling `swap` as described in  [[swappable.requirements]]. Otherwise,
+the allocators are not swapped.
+[*Note 1*: Does not call `swap` on the owned objects
+directly. — *end note*]
+``` cpp
+constexpr void swap(polymorphic& lhs, polymorphic& rhs) noexcept(noexcept(lhs.swap(rhs)));
+```
+*Effects:* Equivalent to `lhs.swap(rhs)`.
 ## Memory resources <a id="mem.res">[[mem.res]]</a>
 ### Header `<memory_resource>` synopsis <a id="mem.res.syn">[[mem.res.syn]]</a>
 ``` cpp
     memory_resource(const memory_resource&) = default;
     virtual ~memory_resource();
     memory_resource& operator=(const memory_resource&) = default;
+    void* allocate(size_t bytes, size_t alignment = max_align);
     void deallocate(void* p, size_t bytes, size_t alignment = max_align);
     bool is_equal(const memory_resource& other) const noexcept;
   private:
 ```
 *Effects:* Destroys this `memory_resource`.
 ``` cpp
+void* allocate(size_t bytes, size_t alignment = max_align);
 ```
 *Effects:* Allocates storage by calling `do_allocate(bytes, alignment)`
 and implicitly creates objects within the allocated region of storage.
 ``` cpp
 virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
 ```
 *Returns:* A derived class shall implement this function to return
+`true` if memory allocated from `*this` can be deallocated from `other`
 and vice-versa, otherwise `false`.
 [*Note 1*: It is possible that the most-derived type of `other` does
+not match the type of `*this`. For a derived class `D`, an
+implementation of this function can immediately return `false` if
 `dynamic_cast<const D*>(&other) == nullptr`. — *end note*]
 #### Equality <a id="mem.res.eq">[[mem.res.eq]]</a>
 ``` cpp
       polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;
     polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
     // [mem.poly.allocator.mem], member functions
+    Tp* allocate(size_t n);
     void deallocate(Tp* p, size_t n);
+    void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
     void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_align_t));
+    template<class T> T* allocate_object(size_t n = 1);
     template<class T> void deallocate_object(T* p, size_t n = 1);
+    template<class T, class... CtorArgs> T* new_object(CtorArgs&&... ctor_args);
     template<class T> void delete_object(T* p);
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
+    template<class T>
+      void destroy(T* p);
     polymorphic_allocator select_on_container_copy_construction() const;
     memory_resource* resource() const;
     // friends
 *Effects:* Sets `memory_rsrc` to `other.resource()`.
 #### Member functions <a id="mem.poly.allocator.mem">[[mem.poly.allocator.mem]]</a>
 ``` cpp
+Tp* allocate(size_t n);
 ```
 *Effects:* If `numeric_limits<size_t>::max() / sizeof(Tp) < n`, throws
 `bad_array_new_length`. Otherwise equivalent to:
 `memory_rsrc->deallocate(p, n * sizeof(Tp), alignof(Tp))`.
 *Throws:* Nothing.
 ``` cpp
+void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
 ```
 *Effects:* Equivalent to:
 `return memory_rsrc->allocate(nbytes, alignment);`
 *Effects:* Equivalent to
 `memory_rsrc->deallocate(p, nbytes, alignment)`.
 ``` cpp
 template<class T>
+  T* allocate_object(size_t n = 1);
 ```
 *Effects:* Allocates memory suitable for holding an array of `n` objects
 of type `T`, as follows:
 *Effects:* Equivalent to `deallocate_bytes(p, n*sizeof(T), alignof(T))`.
 ``` cpp
 template<class T, class... CtorArgs>
+  T* new_object(CtorArgs&&... ctor_args);
 ```
 *Effects:* Allocates and constructs an object of type `T`, as follows.
 Equivalent to:
 ```
 *Effects:* Equivalent to:
 ``` cpp
+destroy(p);
 deallocate_object(p);
 ```
 ``` cpp
 template<class T, class... Args>
 *Mandates:* Uses-allocator construction of `T` with allocator `*this`
 (see  [[allocator.uses.construction]]) and constructor arguments
 `std::forward<Args>(args)...` is well-formed.
+*Effects:* Constructs a `T` object in the storage whose address is
 represented by `p` by uses-allocator construction with allocator `*this`
 and constructor arguments `std::forward<Args>(args)...`.
 *Throws:* Nothing unless the constructor for `T` throws.
+``` cpp
+template<class T>
+  void destroy(T* p);
+```
+*Effects:* Equivalent to `p->T̃()`.
 ``` cpp
 polymorphic_allocator select_on_container_copy_construction() const;
 ```
 *Returns:* `polymorphic_allocator()`.
 pointer to `new_delete_resource()`.
 *Returns:* The previous value of the default memory resource pointer.
 *Remarks:* Calling the `set_default_resource` and `get_default_resource`
+functions shall not incur a data race [[intro.races]]. A call to the
+`set_default_resource` function synchronizes with subsequent calls to
+the `set_default_resource` and `get_default_resource` functions.
 ``` cpp
 memory_resource* get_default_resource() noexcept;
 ```
 The maximum number of blocks that will be allocated at once from the
 upstream memory resource [[mem.res.monotonic.buffer]] to replenish a
 pool. If the value of `max_blocks_per_chunk` is zero or is greater than
 an *implementation-defined* limit, that limit is used instead. The
 implementation may choose to use a smaller value than is specified in
+this member and may use different values for different pools.
 ``` cpp
 size_t largest_required_pool_block;
 ```
 pooling mechanism. Attempts to allocate a single block larger than this
 threshold will be allocated directly from the upstream memory resource.
 If `largest_required_pool_block` is zero or is greater than an
 *implementation-defined* limit, that limit is used instead. The
 implementation may choose a pass-through threshold larger than specified
+in this member.
 #### Constructors and destructors <a id="mem.res.pool.ctor">[[mem.res.pool.ctor]]</a>
 ``` cpp
 synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);
 *Effects:* Calls `upstream_rsrc->deallocate()` as necessary to release
 all allocated memory. Resets `current_buffer` and `next_buffer_size` to
 their initial values at construction.
 [*Note 1*: The memory is released back to `upstream_rsrc` even if some
+blocks that were allocated from `*this` have not been deallocated from
+`*this`. — *end note*]
 ``` cpp
 memory_resource* upstream_resource() const;
 ```
   public:
     using outer_allocator_type = OuterAlloc;
     using inner_allocator_type = see below;
+    using value_type           = OuterTraits::value_type;
+    using size_type            = OuterTraits::size_type;
+    using difference_type      = OuterTraits::difference_type;
+    using pointer              = OuterTraits::pointer;
+    using const_pointer        = OuterTraits::const_pointer;
+    using void_pointer         = OuterTraits::void_pointer;
+    using const_void_pointer   = OuterTraits::const_void_pointer;
     using propagate_on_container_copy_assignment = see below;
     using propagate_on_container_move_assignment = see below;
     using propagate_on_container_swap            = see below;
     using is_always_equal                        = see below;
     inner_allocator_type& inner_allocator() noexcept;
     const inner_allocator_type& inner_allocator() const noexcept;
     outer_allocator_type& outer_allocator() noexcept;
     const outer_allocator_type& outer_allocator() const noexcept;
+    pointer allocate(size_type n);
+    pointer allocate(size_type n, const_void_pointer hint);
     void deallocate(pointer p, size_type n);
     size_type max_size() const;
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
 ```
 *Returns:* `static_cast<const OuterAlloc&>(*this)`.
 ``` cpp
+pointer allocate(size_type n);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)`.
 ``` cpp
+pointer allocate(size_type n, const_void_pointer hint);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)`.
 [allocator.uses]: #allocator.uses
 [allocator.uses.construction]: #allocator.uses.construction
 [allocator.uses.trait]: #allocator.uses.trait
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
+[basic.life]: basic.md#basic.life
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [bit.cast]: utilities.md#bit.cast
 [c.malloc]: #c.malloc
+[container.reqmts]: containers.md#container.reqmts
 [conv.qual]: expr.md#conv.qual
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [default.allocator]: #default.allocator
 [default.allocator.general]: #default.allocator.general
 [defns.const.subexpr]: intro.md#defns.const.subexpr
 [expr.eq]: expr.md#expr.eq
 [function.objects]: utilities.md#function.objects
+[indirect]: #indirect
+[indirect.assign]: #indirect.assign
+[indirect.comp.with.t]: #indirect.comp.with.t
+[indirect.ctor]: #indirect.ctor
+[indirect.dtor]: #indirect.dtor
+[indirect.general]: #indirect.general
+[indirect.hash]: #indirect.hash
+[indirect.obs]: #indirect.obs
+[indirect.relops]: #indirect.relops
+[indirect.swap]: #indirect.swap
+[indirect.syn]: #indirect.syn
 [inout.ptr]: #inout.ptr
 [inout.ptr.t]: #inout.ptr.t
 [intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
 [intro.races]: basic.md#intro.races
 [mem]: #mem
+[mem.composite.types]: #mem.composite.types
 [mem.general]: #mem.general
 [mem.poly.allocator.class]: #mem.poly.allocator.class
 [mem.poly.allocator.class.general]: #mem.poly.allocator.class.general
 [mem.poly.allocator.ctor]: #mem.poly.allocator.ctor
 [mem.poly.allocator.eq]: #mem.poly.allocator.eq
 [pointer.traits]: #pointer.traits
 [pointer.traits.functions]: #pointer.traits.functions
 [pointer.traits.general]: #pointer.traits.general
 [pointer.traits.optmem]: #pointer.traits.optmem
 [pointer.traits.types]: #pointer.traits.types
+[polymorphic]: #polymorphic
+[polymorphic.assign]: #polymorphic.assign
+[polymorphic.ctor]: #polymorphic.ctor
+[polymorphic.dtor]: #polymorphic.dtor
+[polymorphic.general]: #polymorphic.general
+[polymorphic.obs]: #polymorphic.obs
+[polymorphic.swap]: #polymorphic.swap
+[polymorphic.syn]: #polymorphic.syn
 [ptr.align]: #ptr.align
 [scoped.adaptor.operators]: #scoped.adaptor.operators
 [smartptr]: #smartptr
 [smartptr.adapt]: #smartptr.adapt
 [specialized.addressof]: #specialized.addressof
 [specialized.algorithms]: algorithms.md#specialized.algorithms
 [stmt.dcl]: stmt.md#stmt.dcl
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
+[term.implicit.lifetime.type]: basic.md#term.implicit.lifetime.type
 [term.incomplete.type]: basic.md#term.incomplete.type
+[term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
 [tuple]: utilities.md#tuple
 [unique.ptr]: #unique.ptr
 [unique.ptr.create]: #unique.ptr.create
 [unique.ptr.dltr]: #unique.ptr.dltr
 [unique.ptr.dltr.dflt]: #unique.ptr.dltr.dflt
 [unord.hash]: utilities.md#unord.hash
 [util.sharedptr]: #util.sharedptr
 [util.smartptr.enab]: #util.smartptr.enab
 [util.smartptr.getdeleter]: #util.smartptr.getdeleter
 [util.smartptr.hash]: #util.smartptr.hash
+[util.smartptr.owner.equal]: #util.smartptr.owner.equal
+[util.smartptr.owner.hash]: #util.smartptr.owner.hash
 [util.smartptr.ownerless]: #util.smartptr.ownerless
 [util.smartptr.shared]: #util.smartptr.shared
 [util.smartptr.shared.assign]: #util.smartptr.shared.assign
 [util.smartptr.shared.cast]: #util.smartptr.shared.cast
 [util.smartptr.shared.cmp]: #util.smartptr.shared.cmp

Diff to HTML by rtfpessoa