[specialized.algorithms] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpbfrrbtdz/{from.md → to.md} +130 -46

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

@@ -8,18 +8,31 @@ header `<memory>`.
 Unless otherwise specified, if an exception is thrown in the following
 algorithms, objects constructed by a placement *new-expression*
 [[expr.new]] are destroyed in an unspecified order before allowing the
 exception to propagate.
 Some algorithms specified in [[specialized.algorithms]] make use of the
-exposition-only function `voidify`:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
     return addressof(obj);
   }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
@@ -52,10 +65,25 @@ assignment, or comparisons between valid values of type `I` and `S`.
 [*Note 2*: This concept allows some `sentinel_for`
 [[iterator.concept.sentinel]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-input-range = // exposition only
   range<R> &&
   nothrow-input-iterator<iterator_t<R>> &&
@@ -72,44 +100,97 @@ concept nothrow-forward-iterator = // exposition only
   nothrow-input-iterator<I> &&
   forward_iterator<I> &&
   nothrow-sentinel-for<I, I>;
 ```
-[*Note 3*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-forward-range = // exposition only
   nothrow-input-range<R> &&
   nothrow-forward-iterator<iterator_t<R>>;
 ```
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
-  void uninitialized_default_construct(NoThrowForwardIterator first, NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 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);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
-    borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
@@ -119,27 +200,27 @@ for (; first != last; ++first)
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
- NoThrowForwardIterator uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type;
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
-    I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
@@ -150,29 +231,29 @@ return uninitialized_default_construct(counted_iterator(first, n),
 ### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
-  void uninitialized_value_construct(NoThrowForwardIterator first, NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 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);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
-    borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
@@ -182,27 +263,27 @@ for (; first != last; ++first)
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
- NoThrowForwardIterator uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type();
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
-    I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
@@ -213,37 +294,36 @@ return uninitialized_value_construct(counted_iterator(first, n),
 ### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
-  NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++result, (void)++first)
-  ::new (voidify(*result))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   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);
   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);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
@@ -257,32 +337,31 @@ for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
-  NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                                         NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
-  ::new (voidify(*result))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   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, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
@@ -298,11 +377,11 @@ return {std::move(t.in).base(), t.out};
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
-  NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
@@ -310,24 +389,24 @@ template<class InputIterator, class NoThrowForwardIterator>
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; (void)++result, ++first)
   ::new (voidify(*result))
- typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
 return result;
 ```
 ``` cpp
 namespace ranges {
   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);
   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);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
@@ -346,11 +425,11 @@ return {std::move(ifirst), ofirst};
 \[`ifirst`, `ilast`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
-  pair<InputIterator, NoThrowForwardIterator>
     uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
@@ -358,19 +437,19 @@ template<class InputIterator, class Size, class NoThrowForwardIterator>
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
   ::new (voidify(*result))
- typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
   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, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
@@ -390,29 +469,29 @@ state. — *end note*]
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
 template<class NoThrowForwardIterator, class T>
-  void uninitialized_fill(NoThrowForwardIterator first, NoThrowForwardIterator last, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 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);
   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);
 }
 ```
 *Effects:* Equivalent to:
@@ -422,27 +501,27 @@ for (; first != last; ++first)
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
- NoThrowForwardIterator uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n--; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 return first;
 ```
 ``` cpp
 namespace ranges {
   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);
 }
 ```
 *Effects:* Equivalent to:
@@ -460,17 +539,22 @@ namespace ranges {
   template<class T, class... Args>
     constexpr T* construct_at(T* location, Args&&... args);
 }
 ```
-*Constraints:* The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
 treated as an unevaluated operand [[term.unevaluated.operand]].
 *Effects:* Equivalent to:
 ``` cpp
   return ::new (voidify(*location)) T(std::forward<Args>(args)...);
 ```
 ### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>

 Unless otherwise specified, if an exception is thrown in the following
 algorithms, objects constructed by a placement *new-expression*
 [[expr.new]] are destroyed in an unspecified order before allowing the
 exception to propagate.
+[*Note 1*: When new objects are created by the algorithms specified in
+[[specialized.algorithms]], the lifetime ends for any existing objects
+(including potentially-overlapping subobjects [[intro.object]]) in
+storage that is reused [[basic.life]]. — *end note*]
 Some algorithms specified in [[specialized.algorithms]] make use of the
+following exposition-only function templates:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
     return addressof(obj);
   }
+template<class I>
+  decltype(auto) deref-move(I& it) {
+    if constexpr (is_lvalue_reference_v<decltype(*it)>)
+      return std::move(*it);
+    else
+      return *it;
+  }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
 [*Note 2*: This concept allows some `sentinel_for`
 [[iterator.concept.sentinel]] operations to throw
 exceptions. — *end note*]
+``` cpp
+template<class S, class I>
+concept nothrow-sized-sentinel-for = // exposition only
+  nothrow-sentinel-for<S, I> &&
+  sized_sentinel_for<S, I>;
+```
+Types `S` and `I` model `nothrow-sized-sentinel-for` only if no
+exceptions are thrown from the `-` operator for valid values of type `I`
+and `S`.
+[*Note 3*: This concept allows some `sized_sentinel_for`
+[[iterator.concept.sizedsentinel]] operations to throw
+exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-input-range = // exposition only
   range<R> &&
   nothrow-input-iterator<iterator_t<R>> &&
   nothrow-input-iterator<I> &&
   forward_iterator<I> &&
   nothrow-sentinel-for<I, I>;
 ```
+[*Note 4*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-forward-range = // exposition only
   nothrow-input-range<R> &&
   nothrow-forward-iterator<iterator_t<R>>;
 ```
+``` cpp
+template<class I>
+concept nothrow-bidirectional-iterator = // exposition only
+  nothrow-forward-iterator<I> &&
+  bidirectional_iterator<I>;
+```
+A type `I` models `nothrow-bidirectional-iterator` only if no exceptions
+are thrown from decrementing valid iterators.
+[*Note 5*: This concept allows some `bidirectional_iterator`
+[[iterator.concept.bidir]] operations to throw
+exceptions. — *end note*]
+``` cpp
+template<class R>
+concept nothrow-bidirectional-range = // exposition only
+  nothrow-forward-range<R> &&
+  nothrow-bidirectional-iterator<iterator_t<R>>;
+```
+``` cpp
+template<class I>
+concept nothrow-random-access-iterator = // exposition only
+  nothrow-bidirectional-iterator<I> &&
+  random_access_iterator<I> &&
+  nothrow-sized-sentinel-for<I, I>;
+```
+A type `I` models `nothrow-random-access-iterator` only if no exceptions
+are thrown from comparisons of valid iterators, or the `-`, `+`, `-=`,
+`+=`, `[]` operators on valid values of type `I` and
+`iter_difference_t<I>`.
+[*Note 6*: This concept allows some `random_access_iterator`
+[[iterator.concept.random.access]] operations to throw
+exceptions. — *end note*]
+``` cpp
+template<class R>
+concept nothrow-random-access-range = // exposition only
+  nothrow-bidirectional-range<R> &&
+  nothrow-random-access-iterator<iterator_t<R>>;
+template<class R>
+concept nothrow-sized-random-access-range = // exposition only
+  nothrow-random-access-range<R> && sized_range<R>;
+```
+A type `R` models `nothrow-sized-random-access-range` only if no
+exceptions are thrown from the call to `ranges::size` on an object of
+type `R`.
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
+ constexpr void uninitialized_default_construct(NoThrowForwardIterator first,
+                                                 NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 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);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
+ constexpr borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator
+    uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type;
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
 ### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
+ constexpr void uninitialized_value_construct(NoThrowForwardIterator first,
+                                               NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 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);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
+ constexpr borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator
+    uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type();
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
 ### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++result, (void)++first)
+  ::new (voidify(*result)) iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   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);
   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);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                                         NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
+  ::new (voidify(*result)) iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   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, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; (void)++result, ++first)
   ::new (voidify(*result))
+    iterator_traits<NoThrowForwardIterator>::value_type(deref-move(first));
 return result;
 ```
 ``` cpp
 namespace ranges {
   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);
   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);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
 \[`ifirst`, `ilast`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
+ constexpr pair<InputIterator, NoThrowForwardIterator>
     uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
   ::new (voidify(*result))
+    iterator_traits<NoThrowForwardIterator>::value_type(deref-move(first));
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
   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, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
 template<class NoThrowForwardIterator, class T>
+ constexpr void uninitialized_fill(NoThrowForwardIterator first,
+                                    NoThrowForwardIterator last, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 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);
   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);
 }
 ```
 *Effects:* Equivalent to:
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
+ constexpr NoThrowForwardIterator
+    uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n--; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type(x);
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, class T>
     requires constructible_from<iter_value_t<I>, const T&>
+ constexpr I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
 }
 ```
 *Effects:* Equivalent to:
   template<class T, class... Args>
     constexpr T* construct_at(T* location, Args&&... args);
 }
 ```
+*Constraints:* `is_unbounded_array_v<T>` is `false`. The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
 treated as an unevaluated operand [[term.unevaluated.operand]].
+*Mandates:* If `is_array_v<T>` is `true`, `sizeof...(Args)` is zero.
 *Effects:* Equivalent to:
 ``` cpp
+if constexpr (is_array_v<T>)
+  return ::new (voidify(*location)) T[1]();
+else
   return ::new (voidify(*location)) T(std::forward<Args>(args)...);
 ```
 ### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>

Diff to HTML by rtfpessoa