From 9a87982f05822ce2fc62ed88be720d299486857d Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Thu, 25 Jul 2019 08:45:21 -0700
Subject: [PATCH 01/10] Fix inconsistencies in the Latex used for concept names
 throughout the library.

---
 source/algorithms.tex |   2 +-
 source/concepts.tex   |   6 +--
 source/iterators.tex  | 108 +++++++++++++++++++++---------------------
 source/ranges.tex     |  38 +++++++--------
 source/utilities.tex  |   6 +--
 5 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index f68441ae72..f21bef7c0e 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -3740,7 +3740,7 @@
   \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
   for the overloads in namespace \tcode{std}, or
 \item
-  pairwise model \tcode{SizedSentinel}\iref{iterator.concept.sizedsentinel}
+  pairwise model \libconcept{SizedSentinel}\iref{iterator.concept.sizedsentinel}
   for the overloads in namespace \tcode{ranges},
 \end{itemize}
 and \tcode{last1 - first1 != last2 - first2},
diff --git a/source/concepts.tex b/source/concepts.tex
index a2969a1163..d235330af3 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -561,7 +561,7 @@
   is that \tcode{t1} equals \tcode{u2} and \tcode{u1} equals \tcode{t2}.
 
 \item If \tcode{T} and \tcode{U} are different types that model
-  \libconcept{CommonReference<const T\&, const U\&>},
+  \tcode{\libconcept{CommonReference}<const T\&, const U\&>},
   the result of the operation is that
   \tcode{C(t1)} equals \tcode{C(u2)}
   and
@@ -605,8 +605,8 @@
 
 \item
   Otherwise, if \tcode{E1} and \tcode{E2} are lvalues of the
-  same type \tcode{T} that models \libconcept{MoveConstructible<T>} and
-  \libconcept{Assignable<T\&, T>},
+  same type \tcode{T} that models \tcode{\libconcept{MoveConstructible}<T>} and
+  \tcode{\libconcept{Assignable}<T\&, T>},
   \tcode{S} is an expression that exchanges the denoted values.
   \tcode{S} is a constant expression if
   \begin{itemize}
diff --git a/source/iterators.tex b/source/iterators.tex
index a1e55fe57d..625394b367 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -81,7 +81,7 @@
     = decltype(ranges::iter_move(declval<T&>()));
 
   // \ref{iterator.concepts}, iterator concepts
-  // \ref{iterator.concept.readable}, concept \tcode{Readable}
+  // \ref{iterator.concept.readable}, concept \libconcept{Readable}
   template<class In>
     concept Readable = @\seebelow@;
 
@@ -89,54 +89,54 @@
     using iter_common_reference_t =
       common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
 
-  // \ref{iterator.concept.writable}, concept \tcode{Writable}
+  // \ref{iterator.concept.writable}, concept \libconcept{Writable}
   template<class Out, class T>
     concept Writable = @\seebelow@;
 
-  // \ref{iterator.concept.winc}, concept \tcode{WeaklyIncrementable}
+  // \ref{iterator.concept.winc}, concept \libconcept{WeaklyIncrementable}
   template<class I>
     concept WeaklyIncrementable = @\seebelow@;
 
-  // \ref{iterator.concept.inc}, concept \tcode{Incrementable}
+  // \ref{iterator.concept.inc}, concept \libconcept{Incrementable}
   template<class I>
     concept Incrementable = @\seebelow@;
 
-  // \ref{iterator.concept.iterator}, concept \tcode{Iterator}
+  // \ref{iterator.concept.iterator}, concept \libconcept{Iterator}
   template<class I>
     concept Iterator = @\seebelow@;
 
-  // \ref{iterator.concept.sentinel}, concept \tcode{Sentinel}
+  // \ref{iterator.concept.sentinel}, concept \libconcept{Sentinel}
   template<class S, class I>
     concept Sentinel = @\seebelow@;
 
-  // \ref{iterator.concept.sizedsentinel}, concept \tcode{SizedSentinel}
+  // \ref{iterator.concept.sizedsentinel}, concept \libconcept{SizedSentinel}
   template<class S, class I>
     inline constexpr bool disable_sized_sentinel = false;
 
   template<class S, class I>
     concept SizedSentinel = @\seebelow@;
 
-  // \ref{iterator.concept.input}, concept \tcode{InputIterator}
+  // \ref{iterator.concept.input}, concept \libconcept{InputIterator}
   template<class I>
     concept InputIterator = @\seebelow@;
 
-  // \ref{iterator.concept.output}, concept \tcode{OutputIterator}
+  // \ref{iterator.concept.output}, concept \libconcept{OutputIterator}
   template<class I, class T>
     concept OutputIterator = @\seebelow@;
 
-  // \ref{iterator.concept.forward}, concept \tcode{ForwardIterator}
+  // \ref{iterator.concept.forward}, concept \libconcept{ForwardIterator}
   template<class I>
     concept ForwardIterator = @\seebelow@;
 
-  // \ref{iterator.concept.bidir}, concept \tcode{BidirectionalIterator}
+  // \ref{iterator.concept.bidir}, concept \libconcept{BidirectionalIterator}
   template<class I>
     concept BidirectionalIterator = @\seebelow@;
 
-  // \ref{iterator.concept.random.access}, concept \tcode{RandomAccessIterator}
+  // \ref{iterator.concept.random.access}, concept \libconcept{RandomAccessIterator}
   template<class I>
     concept RandomAccessIterator = @\seebelow@;
 
-  // \ref{iterator.concept.contiguous}, concept \tcode{ContiguousIterator}
+  // \ref{iterator.concept.contiguous}, concept \libconcept{ContiguousIterator}
   template<class I>
     concept ContiguousIterator = @\seebelow@;
 
@@ -169,38 +169,38 @@
     struct incrementable_traits<projected<I, Proj>>;
 
   // \ref{alg.req}, common algorithm requirements
-  // \ref{alg.req.ind.move}, concept \tcode{IndirectlyMovable}
+  // \ref{alg.req.ind.move}, concept \libconcept{IndirectlyMovable}
   template<class In, class Out>
     concept IndirectlyMovable = @\seebelow@;
 
   template<class In, class Out>
     concept IndirectlyMovableStorable = @\seebelow@;
 
-  // \ref{alg.req.ind.copy}, concept \tcode{IndirectlyCopyable}
+  // \ref{alg.req.ind.copy}, concept \libconcept{IndirectlyCopyable}
   template<class In, class Out>
     concept IndirectlyCopyable = @\seebelow@;
 
   template<class In, class Out>
     concept IndirectlyCopyableStorable = @\seebelow@;
 
-  // \ref{alg.req.ind.swap}, concept \tcode{IndirectlySwappable}
+  // \ref{alg.req.ind.swap}, concept \libconcept{IndirectlySwappable}
   template<class I1, class I2 = I1>
     concept IndirectlySwappable = @\seebelow@;
 
-  // \ref{alg.req.ind.cmp}, concept \tcode{IndirectlyComparable}
+  // \ref{alg.req.ind.cmp}, concept \libconcept{IndirectlyComparable}
   template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
     concept IndirectlyComparable = @\seebelow@;
 
-  // \ref{alg.req.permutable}, concept \tcode{Permutable}
+  // \ref{alg.req.permutable}, concept \libconcept{Permutable}
   template<class I>
     concept Permutable = @\seebelow@;
 
-  // \ref{alg.req.mergeable}, concept \tcode{Mergeable}
+  // \ref{alg.req.mergeable}, concept \libconcept{Mergeable}
   template<class I1, class I2, class Out,
       class R = ranges::less, class P1 = identity, class P2 = identity>
     concept Mergeable = @\seebelow@;
 
-  // \ref{alg.req.sortable}, concept \tcode{Sortable}
+  // \ref{alg.req.sortable}, concept \libconcept{Sortable}
   template<class I, class R = ranges::less, class P = identity>
     concept Sortable = @\seebelow@;
 
@@ -669,7 +669,7 @@
 it is often necessary to determine the difference type that
 corresponds to a particular incrementable type. Accordingly,
 it is required that if \tcode{WI} is the name of a type that models the
-\tcode{WeaklyIncrementable} concept\iref{iterator.concept.winc},
+\libconcept{WeaklyIncrementable} concept\iref{iterator.concept.winc},
 the type
 \begin{codeblock}
 iter_difference_t<WI>
@@ -731,7 +731,7 @@
 To implement algorithms only in terms of readable types, it is often necessary
 to determine the value type that corresponds to a particular readable type.
 Accordingly, it is required that if \tcode{R} is the name of a type that
-models the \tcode{Readable} concept\iref{iterator.concept.readable},
+models the \libconcept{Readable} concept\iref{iterator.concept.readable},
 the type
 \begin{codeblock}
 iter_value_t<R>
@@ -1126,7 +1126,7 @@
 then \tcode{ranges::swap(*E1, *E2)}.
 
 \item Otherwise, if the types \tcode{T1} and \tcode{T2} of \tcode{E1} and
-\tcode{E2} model \tcode{IndirectlyMovableStorable<T1, T2>} and
+\tcode{E2} model \tcode{\libconcept{IndirectlyMovableStorable}<T1, T2>} and
 \tcode{IndirectlyMovableStorable<T2, T1>}, then
 \tcode{(void)(*E1 = \placeholdernc{iter-exchange-move}(E2, E1))},
 except that \tcode{E1} is evaluated only once.
@@ -1217,10 +1217,10 @@
 exposition-only \placeholder{dereferenceable} concept\iref{iterator.synopsis}.
 \end{note}
 
-\rSec3[iterator.concept.writable]{Concept \tcode{Writable}}
+\rSec3[iterator.concept.writable]{Concept \libconcept{Writable}}
 
 \pnum
-The \tcode{Writable} concept specifies the requirements for writing a value
+The \libconcept{Writable} concept specifies the requirements for writing a value
 into an iterator's referenced object.
 
 \indexlibrary{\idxcode{Writable}}%
@@ -1240,7 +1240,7 @@
 \pnum
 Let \tcode{E} be an an expression such that \tcode{decltype((E))} is \tcode{T},
 and let \tcode{o} be a dereferenceable object of type \tcode{Out}.
-\tcode{Out} and \tcode{T} model \tcode{Writable<Out, T>} only if
+\tcode{Out} and \tcode{T} model \tcode{\libconcept{Writable}<Out, T>} only if
 
 \begin{itemize}
 \item If \tcode{Out} and \tcode{T} model
@@ -1268,13 +1268,13 @@
 iterators with prvalue non-proxy reference types that permit rvalue
 assignment but do not also permit \tcode{const} rvalue assignment.
 Consequently, an iterator type \tcode{I} that returns \tcode{std::string}
-by value does not model \libconcept{Writable<I, std::string>}.
+by value does not model \tcode{\libconcept{Writable}<I, std::string>}.
 \end{note}
 
-\rSec3[iterator.concept.winc]{Concept \tcode{WeaklyIncrementable}}
+\rSec3[iterator.concept.winc]{Concept \libconcept{WeaklyIncrementable}}
 
 \pnum
-The \tcode{WeaklyIncrementable} concept specifies the requirements on
+The \libconcept{WeaklyIncrementable} concept specifies the requirements on
 types that can be incremented with the pre- and post-increment operators.
 The increment operations are not required to be equality-preserving,
 nor is the type required to be \libconcept{EqualityComparable}.
@@ -1316,10 +1316,10 @@
 template.
 \end{note}
 
-\rSec3[iterator.concept.inc]{Concept \tcode{Incrementable}}
+\rSec3[iterator.concept.inc]{Concept \libconcept{Incrementable}}
 
 \pnum
-The \tcode{Incrementable} concept specifies requirements on types that can be incremented with the pre-
+The \libconcept{Incrementable} concept specifies requirements on types that can be incremented with the pre-
 and post-increment operators. The increment operations are required to be equality-preserving,
 and the type is required to be \libconcept{EqualityComparable}.
 \begin{note}
@@ -1358,7 +1358,7 @@
 algorithms with types that model \libconcept{Increment\-able}.
 \end{note}
 
-\rSec3[iterator.concept.iterator]{Concept \tcode{Iterator}}
+\rSec3[iterator.concept.iterator]{Concept \libconcept{Iterator}}
 
 \pnum
 The \libconcept{Iterator} concept forms the basis
@@ -1380,7 +1380,7 @@
     WeaklyIncrementable<I>;
 \end{codeblock}
 
-\rSec3[iterator.concept.sentinel]{Concept \tcode{Sentinel}}
+\rSec3[iterator.concept.sentinel]{Concept \libconcept{Sentinel}}
 
 \pnum
 The \libconcept{Sentinel} concept specifies the relationship
@@ -1400,7 +1400,7 @@
 \pnum
 Let \tcode{s} and \tcode{i} be values of type \tcode{S} and
 \tcode{I} such that \range{i}{s} denotes a range. Types
-\tcode{S} and \tcode{I} model \tcode{Sentinel<S, I>} only if
+\tcode{S} and \tcode{I} model \tcode{\libconcept{Sentinel}<S, I>} only if
 
 \begin{itemize}
 \item \tcode{i == s} is well-defined.
@@ -1418,7 +1418,7 @@
 to \tcode{i}. Consequently, \tcode{i == s} is no longer required to be
 well-defined.
 
-\rSec3[iterator.concept.sizedsentinel]{Concept \tcode{SizedSentinel}}
+\rSec3[iterator.concept.sizedsentinel]{Concept \libconcept{SizedSentinel}}
 
 \pnum
 The \libconcept{SizedSentinel} concept specifies
@@ -1445,7 +1445,7 @@
 a sentinel of type \tcode{S} such that \range{i}{s} denotes a range.
 Let $N$ be the smallest number of applications of \tcode{++i}
 necessary to make \tcode{bool(i == s)} be \tcode{true}.
-\tcode{S} and \tcode{I} model \tcode{SizedSentinel<S, I>} only if
+\tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>} only if
 
 \begin{itemize}
 \item If $N$ is representable by \tcode{iter_difference_t<I>},
@@ -1469,12 +1469,12 @@
 counted iterators and their sentinels\iref{counted.iterator}.
 \end{example}
 
-\rSec3[iterator.concept.input]{Concept \tcode{InputIterator}}
+\rSec3[iterator.concept.input]{Concept \libconcept{InputIterator}}
 
 \pnum
-The \tcode{InputIterator} concept defines requirements for a type
+The \libconcept{InputIterator} concept defines requirements for a type
 whose referenced values can be read (from the requirement for
-\tcode{Readable}\iref{iterator.concept.readable}) and which can be both pre- and
+\libconcept{Readable}\iref{iterator.concept.readable}) and which can be both pre- and
 post-incremented.
 \begin{note}
 Unlike the \oldconcept{InputIterator} requirements\iref{input.iterators},
@@ -1492,12 +1492,12 @@
     DerivedFrom<@\placeholdernc{ITER_CONCEPT}@(I), input_iterator_tag>;
 \end{codeblock}
 
-\rSec3[iterator.concept.output]{Concept \tcode{OutputIterator}}
+\rSec3[iterator.concept.output]{Concept \libconcept{OutputIterator}}
 
 \pnum
-The \tcode{OutputIterator} concept defines requirements for a type that
+The \libconcept{OutputIterator} concept defines requirements for a type that
 can be used to write values (from the requirement for
-\tcode{Writable}\iref{iterator.concept.writable}) and which can be both pre- and post-incremented.
+\libconcept{Writable}\iref{iterator.concept.writable}) and which can be both pre- and post-incremented.
 \begin{note}
 Output iterators are not required to model \libconcept{EqualityComparable}.
 \end{note}
@@ -1515,7 +1515,7 @@
 
 \pnum
 Let \tcode{E} be an expression such that \tcode{decltype((E))} is \tcode{T}, and let \tcode{i} be a
-dereferenceable object of type \tcode{I}. \tcode{I} and \tcode{T} model \tcode{OutputIterator<I, T>} only if
+dereferenceable object of type \tcode{I}. \tcode{I} and \tcode{T} model \tcode{\libconcept{OutputIterator}<I, T>} only if
 \tcode{*i++ = E;} has effects equivalent to:
 \begin{codeblock}
   *i = E;
@@ -1528,7 +1528,7 @@
 They should be single-pass algorithms.
 \end{note}
 
-\rSec3[iterator.concept.forward]{Concept \tcode{ForwardIterator}}
+\rSec3[iterator.concept.forward]{Concept \libconcept{ForwardIterator}}
 
 \pnum
 The \libconcept{ForwardIterator} concept adds equality comparison and
@@ -2318,7 +2318,7 @@
 
 \pnum
 Let \tcode{i} be a dereferenceable value of type \tcode{In}.
-\tcode{In} and \tcode{Out} model \tcode{IndirectlyMovableStorable<In, Out>}
+\tcode{In} and \tcode{Out} model \tcode{\libconcept{IndirectlyMovableStorable}<In, Out>}
 only if after the initialization of the object \tcode{obj} in
 \begin{codeblock}
 iter_value_t<In> obj(ranges::iter_move(i));
@@ -2363,7 +2363,7 @@
 
 \pnum
 Let \tcode{i} be a dereferenceable value of type \tcode{In}.
-\tcode{In} and \tcode{Out} model \tcode{IndirectlyCopyableStorable<In, Out>}
+\tcode{In} and \tcode{Out} model \tcode{\libconcept{IndirectlyCopyableStorable}<In, Out>}
 only if after the initialization of the object \tcode{obj} in
 \begin{codeblock}
 iter_value_t<In> obj(*i);
@@ -2731,9 +2731,9 @@
 \pnum
 \effects
 \begin{itemize}
-\item If \tcode{I} and \tcode{S} model \tcode{Assignable<I\&, S>},
+\item If \tcode{I} and \tcode{S} model \tcode{\libconcept{Assignable}<I\&, S>},
   equivalent to \tcode{i = std::move(bound)}.
-\item Otherwise, if \tcode{S} and \tcode{I} model \tcode{SizedSentinel<S, I>},
+\item Otherwise, if \tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>},
   equivalent to \tcode{ranges::advance(i, bound - i)}.
 \item Otherwise, while \tcode{bool(i != bound)} is \tcode{true},
   increments \tcode{i}.
@@ -2753,12 +2753,12 @@
 If \tcode{n == 0}, \range{i}{bound} or \range{bound}{i} denotes a range.
 If \tcode{n < 0}, \range{bound}{i} denotes a range,
 \tcode{I} models \libconcept{BidirectionalIterator}, and
-\tcode{I} and \tcode{S} model \tcode{Same<I, S>}.
+\tcode{I} and \tcode{S} model \tcode{\libconcept{Same}<I, S>}.
 
 \pnum
 \effects
 \begin{itemize}
-\item If \tcode{S} and \tcode{I} model \tcode{SizedSentinel<S, I>}:
+\item If \tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>}:
   \begin{itemize}
   \item If \brk{}$|\tcode{n}| \ge |\tcode{bound - i}|$,
     equivalent to \tcode{ranges::advance(i, bound)}.
@@ -2798,7 +2798,7 @@
 
 \pnum
 \effects
-If \tcode{S} and \tcode{I} model \tcode{SizedSentinel<S, I>},
+If \tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>},
 returns \tcode{(last - first)};
 otherwise, returns the number of increments needed to get from
 \tcode{first}
@@ -2978,7 +2978,7 @@
 \tcode{random_access_iterator_tag} if
 the type
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} models
-\libconcept{DerivedFrom<random_access_iterator_tag>}, and
+\tcode{\libconcept{DerivedFrom}<random_access_iterator_tag>}, and
 \item
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} otherwise.
 \end{itemize}
@@ -3962,7 +3962,7 @@
 \tcode{random_access_iterator_tag} if
 the type
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} models
-\libconcept{DerivedFrom<\tcode{random_access_iterator_tag}>}, and
+\tcode{\libconcept{DerivedFrom}<random_access_iterator_tag>}, and
 \item
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} otherwise.
 \end{itemize}
@@ -4370,7 +4370,7 @@
 \pnum
 Class template \tcode{move_sentinel} is a sentinel adaptor useful for denoting
 ranges together with \tcode{move_iterator}. When an input iterator type
-\tcode{I} and sentinel type \tcode{S} model \tcode{Sentinel<S, I>},
+\tcode{I} and sentinel type \tcode{S} model \tcode{\libconcept{Sentinel}<S, I>},
 \tcode{move_sentinel<S>} and \tcode{move_iterator<I>} model
 \tcode{Sentinel<move_sentinel<S>, move_iterator<I>{>}} as well.
 
diff --git a/source/ranges.tex b/source/ranges.tex
index 5872a5dac8..671c82b245 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -320,7 +320,7 @@
 Whenever \tcode{ranges::end(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::end(E)} and \tcode{ranges::begin(E)}
-model \libconcept{Sentinel<S, I>}.
+model \tcode{\libconcept{Sentinel}<S, I>}.
 \end{note}
 
 \rSec2[range.access.cbegin]{\tcode{ranges::cbegin}}
@@ -357,7 +357,7 @@
 Whenever \tcode{ranges::cend(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::cend(E)} and \tcode{ranges::cbegin(E)}
-model \libconcept{Sentinel<S, I>}.
+model \tcode{\libconcept{Sentinel}<S, I>}.
 \end{note}
 
 \rSec2[range.access.rbegin]{\tcode{ranges::rbegin}}
@@ -430,7 +430,7 @@
   Otherwise, \tcode{make_reverse_iterator(ranges::begin(E))} if both
   \tcode{ranges::begin(E)} and \tcode{ranges::\brk{}end(E)} are valid
   expressions of the same type \tcode{I} which models
-  \tcode{BidirectionalIterator}\iref{iterator.concept.bidir}.
+  \libconcept{BidirectionalIterator}\iref{iterator.concept.bidir}.
 
 \item
   Otherwise, \tcode{ranges::rend(E)} is ill-formed.
@@ -445,7 +445,7 @@
 Whenever \tcode{ranges::rend(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::rend(E)} and \tcode{ranges::rbegin(E)}
-model \libconcept{Sentinel<S, I>}.
+model \tcode{\libconcept{Sentinel}<S, I>}.
 \end{note}
 
 \rSec2[range.access.crbegin]{\tcode{ranges::crbegin}}
@@ -483,7 +483,7 @@
 Whenever \tcode{ranges::crend(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::crend(E)} and \tcode{ranges::crbegin(E)}
-model \libconcept{Sentinel<S, I>}.
+model \tcode{\libconcept{Sentinel}<S, I>}.
 \end{note}
 
 \rSec2[range.prim.size]{\tcode{ranges::size}}
@@ -526,8 +526,8 @@
   if it is a valid expression and
   the types \tcode{I} and \tcode{S} of \tcode{ranges::begin(E)} and
   \tcode{ranges::end(E)} (respectively) model both
-  \tcode{SizedSentinel<S, I>}\iref{iterator.concept.sizedsentinel} and
-  \tcode{Forward\-Iterator<I>}.
+  \tcode{\libconcept{SizedSentinel}<S, I>}\iref{iterator.concept.sizedsentinel} and
+  \tcode{\libconcept{Forward\-Iterator}<I>}.
   However, \tcode{E} is evaluated only once.
 
 \item
@@ -643,7 +643,7 @@
 whose type models \libconcept{Iterator}\iref{iterator.concept.iterator}.
 Calling \tcode{ranges::end} on a range returns an object whose type \tcode{S},
 together with the type \tcode{I} of the object returned by \tcode{ranges::begin},
-models \libconcept{Sentinel<S, I>}.
+models \tcode{\libconcept{Sentinel}<S, I>}.
 The library formalizes the interfaces, semantics, and complexity of ranges
 to enable algorithms and range adaptors that work efficiently
 on different types of sequences.
@@ -655,7 +655,7 @@
 The \libconcept{SizedRange} concept refines \libconcept{Range} with
 the requirement that the number of elements in the range can be determined
 in constant time using the \tcode{ranges::size} function.
-The \tcode{View} concept specifies requirements on a \libconcept{Range} type
+The \libconcept{View} concept specifies requirements on a \libconcept{Range} type
 with constant-time copy and assign operations.
 
 \pnum
@@ -809,7 +809,7 @@
 \begin{note}
 The complexity requirement for the evaluation of \tcode{ranges::size}
 is non-amortized, unlike the case for the complexity of the evaluations of
-\tcode{ranges::begin} and \tcode{ranges::end} in the \tcode{Range} concept.
+\tcode{ranges::begin} and \tcode{ranges::end} in the \libconcept{Range} concept.
 \end{note}
 
 \pnum
@@ -822,7 +822,7 @@
 \rSec2[range.view]{Views}
 
 \pnum
-The \tcode{View} concept specifies the requirements of a \libconcept{Range} type
+The \libconcept{View} concept specifies the requirements of a \libconcept{Range} type
 that has constant time copy, move, and assignment operators; that is, the cost of
 these operations is not proportional to the number of elements in the
 \tcode{View}.
@@ -893,11 +893,11 @@
 \rSec2[range.refinements]{Other range refinements}
 
 \pnum
-The \tcode{OutputRange} concept specifies requirements of a
+The \libconcept{OutputRange} concept specifies requirements of a
 \libconcept{Range} type for which \tcode{ranges::begin} returns
-a model of \tcode{OutputIterator}\iref{iterator.concept.output}.
-\tcode{InputRange}, \tcode{ForwardRange}, \tcode{BidirectionalRange},
-and \tcode{RandomAccessRange} are defined similarly.
+a model of \libconcept{OutputIterator}\iref{iterator.concept.output}.
+\libconcept{InputRange}, \libconcept{ForwardRange}, \libconcept{BidirectionalRange},
+and \libconcept{RandomAccessRange} are defined similarly.
 
 \indexlibrary{\idxcode{OutputRange}}%
 \indexlibrary{\idxcode{InputRange}}%
@@ -942,11 +942,11 @@
 \end{itemdecl}
 
 \pnum
-The \tcode{CommonRange} concept specifies requirements of
+The \libconcept{CommonRange} concept specifies requirements of
 a \libconcept{Range} type for which \tcode{ranges::begin} and
 \tcode{ranges::end} return objects of the same type.
 \begin{example}
-The standard containers\iref{containers} model \tcode{CommonRange}.
+The standard containers\iref{containers} model \libconcept{CommonRange}.
 \end{example}
 
 \indexlibrary{\idxcode{CommonRange}}%
@@ -1073,7 +1073,7 @@
 incomplete type. Before any member of the resulting specialization of
 \tcode{view_interface} other than special member functions
 is referenced, \tcode{D} shall be complete, and
-model both \libconcept{DerivedFrom<view_interface<D>>} and \libconcept{View}.
+model both \tcode{\libconcept{DerivedFrom}<view_interface<D>>} and \libconcept{View}.
 
 \rSec3[view.interface.members]{Members}
 
@@ -4870,7 +4870,7 @@
 
 \begin{itemize}
 \item If \tcode{T} models \libconcept{Iterator} and
-  \tcode{decltype((F))} models \libconcept{ConvertibleTo<iter_difference_t<T>>},
+  \tcode{decltype((F))} models \tcode{\libconcept{ConvertibleTo}<iter_difference_t<T>>},
   \begin{itemize}
   \item \tcode{subrange\{E, E + static_cast<iter_difference_t<T>>(F)\}}
     if \tcode{T} models \libconcept{RandomAccessItera\-tor}.
diff --git a/source/utilities.tex b/source/utilities.tex
index 977e5b5b39..f273fe2c8a 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -8118,7 +8118,7 @@
 
 \pnum
 \begin{note}
-This concept allows some \tcode{InputIterator}\iref{iterator.concept.input}
+This concept allows some \libconcept{InputIterator}\iref{iterator.concept.input}
 operations to throw exceptions.
 \end{note}
 \end{itemdescr}
@@ -8137,7 +8137,7 @@
 
 \pnum
 \begin{note}
-This concept allows some \tcode{Sentinel}\iref{iterator.concept.sentinel}
+This concept allows some \libconcept{Sentinel}\iref{iterator.concept.sentinel}
 operations to throw exceptions.
 \end{note}
 \end{itemdescr}
@@ -8168,7 +8168,7 @@
 \begin{itemdescr}
 \pnum
 \begin{note}
-This concept allows some \tcode{ForwardIterator}\iref{iterator.concept.forward}
+This concept allows some \libconcept{ForwardIterator}\iref{iterator.concept.forward}
 operations to throw exceptions.
 \end{note}
 \end{itemdescr}

From cbc84ade41fa5c807e0d23b664411854bf0789be Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Fri, 26 Jul 2019 01:45:16 -0700
Subject: [PATCH 02/10] P1754R1 Rename concepts to standard_case for C++20,
 while we still can

Fixed whitespace issues seen during review.
Fixed additional inconsistencies in the Latex used for concept names.
[concept.strictweakorder] Fix \indexlibrary for strict_weak_order.
[ranges] Change ranges::view to ranges::views.

Fixes #3015.
---
 source/algorithms.tex  | 1590 ++++++++++++++++++++--------------------
 source/concepts.tex    |  446 +++++------
 source/containers.tex  |    4 +-
 source/expressions.tex |    4 +-
 source/iterators.tex   |  984 ++++++++++++-------------
 source/lib-intro.tex   |    8 +-
 source/numerics.tex    |   18 +-
 source/ranges.tex      | 1030 +++++++++++++-------------
 source/strings.tex     |    2 +-
 source/utilities.tex   |  187 ++---
 10 files changed, 2141 insertions(+), 2132 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index f21bef7c0e..789bd25b7b 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -242,9 +242,9 @@
 \tcode{ranges::next(i, s)}.
 
 \pnum
-Overloads of algorithms that take \libconcept{Range} arguments\iref{range.range}
+Overloads of algorithms that take \libconcept{range} arguments\iref{range.range}
 behave as if they are implemented by calling \tcode{ranges::begin} and
-\tcode{ranges::end} on the \libconcept{Range}(s) and
+\tcode{ranges::end} on the \libconcept{range}(s) and
 dispatching to the overload in namespace \tcode{ranges}
 that takes separate iterator and sentinel arguments.
 
@@ -617,11 +617,11 @@
                 ForwardIterator first, ForwardIterator last, Predicate pred);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
   }
 
@@ -633,11 +633,11 @@
                 ForwardIterator first, ForwardIterator last, Predicate pred);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
   }
 
@@ -649,11 +649,11 @@
                  ForwardIterator first, ForwardIterator last, Predicate pred);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
   }
 
@@ -671,24 +671,24 @@
       [[no_unique_address]] F fun;
 
       template<class I2, class F2>
-        requires ConvertibleTo<const I&, I2> && ConvertibleTo<const F&, F2>
+        requires convertible_to<const I&, I2> && convertible_to<const F&, F2>
         operator for_each_result<I2, F2>() const & {
           return {in, fun};
         }
 
       template<class I2, class F2>
-        requires ConvertibleTo<I, I2> && ConvertibleTo<F, F2>
+        requires convertible_to<I, I2> && convertible_to<F, F2>
         operator for_each_result<I2, F2>() && {
           return {std::move(in), std::move(fun)};
         }
     };
 
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryInvocable<projected<I, Proj>> Fun>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirectly_unary_invocable<projected<I, Proj>> Fun>
       constexpr for_each_result<I, Fun>
         for_each(I first, S last, Fun f, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryInvocable<projected<iterator_t<R>, Proj>> Fun>
+    template<input_range R, class Proj = identity,
+             indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
       constexpr for_each_result<safe_iterator_t<R>, Fun>
         for_each(R&& r, Fun f, Proj proj = {});
   }
@@ -723,25 +723,25 @@
                                 Predicate pred);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class T, class Proj = identity>
-      requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+      requires indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr I find(I first, S last, const T& value, Proj proj = {});
-    template<InputRange R, class T, class Proj = identity>
-      requires IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    template<input_range R, class T, class Proj = identity>
+      requires indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr safe_iterator_t<R>
         find(R&& r, const T& value, Proj proj = {});
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr safe_iterator_t<R>
         find_if(R&& r, Pred pred, Proj proj = {});
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr safe_iterator_t<R>
         find_if_not(R&& r, Pred pred, Proj proj = {});
   }
@@ -770,15 +770,15 @@
                BinaryPredicate pred);
 
   namespace ranges {
-    template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2,
+    template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
       constexpr subrange<I1>
         find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<ForwardRange R1, ForwardRange R2,
+    template<forward_range R1, forward_range R2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr safe_subrange_t<R1>
         find_end(R1&& r1, R2&& r2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -808,16 +808,16 @@
                     BinaryPredicate pred);
 
   namespace ranges {
-    template<InputIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
              class Proj1 = identity, class Proj2 = identity,
-             IndirectRelation<projected<I1, Proj1>,
-                              projected<I2, Proj2>> Pred = ranges::equal_to>
+             indirect_relation<projected<I1, Proj1>,
+                                projected<I2, Proj2>> Pred = ranges::equal_to>
       constexpr I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
                                  Pred pred = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, ForwardRange R2, class Proj1 = identity, class Proj2 = identity,
-             IndirectRelation<projected<iterator_t<R1>, Proj1>,
-                              projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
+    template<input_range R1, forward_range R2, class Proj1 = identity, class Proj2 = identity,
+             indirect_relation<projected<iterator_t<R1>, Proj1>,
+                                projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
       constexpr safe_iterator_t<R1>
         find_first_of(R1&& r1, R2&& r2,
                       Pred pred = {},
@@ -843,12 +843,12 @@
                     BinaryPredicate pred);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectRelation<projected<I, Proj>> Pred = ranges::equal_to>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_relation<projected<I, Proj>> Pred = ranges::equal_to>
       constexpr I adjacent_find(I first, S last, Pred pred = {},
                                 Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectRelation<projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
+    template<forward_range R, class Proj = identity,
+             indirect_relation<projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
       constexpr safe_iterator_t<R>
         adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
   }
@@ -870,20 +870,20 @@
                ForwardIterator first, ForwardIterator last, Predicate pred);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class T, class Proj = identity>
-      requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+      requires indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr iter_difference_t<I>
         count(I first, S last, const T& value, Proj proj = {});
-    template<InputRange R, class T, class Proj = identity>
-      requires IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    template<input_range R, class T, class Proj = identity>
+      requires indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr iter_difference_t<iterator_t<R>>
         count(R&& r, const T& value, Proj proj = {});
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr iter_difference_t<I>
         count_if(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr iter_difference_t<iterator_t<R>>
         count_if(R&& r, Pred pred, Proj proj = {});
   }
@@ -937,29 +937,29 @@
       [[no_unique_address]] I2 in2;
 
       template<class II1, class II2>
-        requires ConvertibleTo<const I1&, II1> && ConvertibleTo<const I2&, II2>
+        requires convertible_to<const I1&, II1> && convertible_to<const I2&, II2>
         operator mismatch_result<II1, II2>() const & {
           return {in1, in2};
         }
 
       template<class II1, class II2>
-        requires ConvertibleTo<I1, II1> && ConvertibleTo<I2, II2>
+        requires convertible_to<I1, II1> && convertible_to<I2, II2>
         operator mismatch_result<II1, II2>() && {
           return {std::move(in1), std::move(in2)};
         }
     };
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              class Proj1 = identity, class Proj2 = identity,
-             IndirectRelation<projected<I1, Proj1>,
-                              projected<I2, Proj2>> Pred = ranges::equal_to>
+             indirect_relation<projected<I1, Proj1>,
+                               projected<I2, Proj2>> Pred = ranges::equal_to>
       constexpr mismatch_result<I1, I2>
         mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2,
+    template<input_range R1, input_range R2,
              class Proj1 = identity, class Proj2 = identity,
-             IndirectRelation<projected<iterator_t<R1>, Proj1>,
-                              projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
+             indirect_relation<projected<iterator_t<R1>, Proj1>,
+                               projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
       constexpr mismatch_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
         mismatch(R1&& r1, R2&& r2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -1000,15 +1000,15 @@
                BinaryPredicate pred);
 
   namespace ranges {
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
       constexpr bool equal(I1 first1, S1 last1, I2 first2, S2 last2,
                            Pred pred = {},
                            Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, class Pred = ranges::equal_to,
+    template<input_range R1, input_range R2, class Pred = ranges::equal_to,
              class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
                            Proj1 proj1 = {}, Proj2 proj2 = {});
   }
@@ -1029,16 +1029,16 @@
                                   BinaryPredicate pred);
 
   namespace ranges {
-    template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2,
-             Sentinel<I2> S2, class Pred = ranges::equal_to, class Proj1 = identity,
+    template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
+             sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = identity,
              class Proj2 = identity>
-      requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
       constexpr bool is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
                                     Pred pred = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<ForwardRange R1, ForwardRange R2, class Pred = ranges::equal_to,
+    template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
              class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool is_permutation(R1&& r1, R2&& r2, Pred pred = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
   }
@@ -1067,16 +1067,16 @@
              BinaryPredicate pred);
 
   namespace ranges {
-    template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2,
-             Sentinel<I2> S2, class Pred = ranges::equal_to,
+    template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
+             sentinel_for<I2> S2, class Pred = ranges::equal_to,
              class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
       constexpr subrange<I1>
         search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<ForwardRange R1, ForwardRange R2, class Pred = ranges::equal_to,
+    template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
              class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr safe_subrange_t<R1>
         search(R1&& r1, R2&& r2, Pred pred = {},
                Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -1105,15 +1105,15 @@
                BinaryPredicate pred);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class T,
+    template<forward_iterator I, sentinel_for<I> S, class T,
              class Pred = ranges::equal_to, class Proj = identity>
-      requires IndirectlyComparable<I, const T*, Pred, Proj>
+      requires indirectly_comparable<I, const T*, Pred, Proj>
       constexpr subrange<I>
         search_n(I first, S last, iter_difference_t<I> count,
                  const T& value, Pred pred = {}, Proj proj = {});
-    template<ForwardRange R, class T, class Pred = ranges::equal_to,
+    template<forward_range R, class T, class Pred = ranges::equal_to,
              class Proj = identity>
-      requires IndirectlyComparable<iterator_t<R>, const T*, Pred, Proj>
+      requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
       constexpr safe_subrange_t<R>
         search_n(R&& r, iter_difference_t<iterator_t<R>> count,
                  const T& value, Pred pred = {}, Proj proj = {});
@@ -1140,24 +1140,24 @@
       [[no_unique_address]] O out;
 
       template<class I2, class O2>
-        requires ConvertibleTo<const I&, I2> && ConvertibleTo<const O&, O2>
+        requires convertible_to<const I&, I2> && convertible_to<const O&, O2>
         operator copy_result<I2, O2>() const & {
           return {in, out};
         }
 
       template<class I2, class O2>
-        requires ConvertibleTo<I, I2> && ConvertibleTo<O, O2>
+        requires convertible_to<I, I2> && convertible_to<O, O2>
         operator copy_result<I2, O2>() && {
           return {std::move(in), std::move(out)};
         }
     };
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
-      requires IndirectlyCopyable<I, O>
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+      requires indirectly_copyable<I, O>
       constexpr copy_result<I, O>
         copy(I first, S last, O result);
-    template<InputRange R, WeaklyIncrementable O>
-      requires IndirectlyCopyable<iterator_t<R>, O>
+    template<input_range R, weakly_incrementable O>
+      requires indirectly_copyable<iterator_t<R>, O>
       constexpr copy_result<safe_iterator_t<R>, O>
         copy(R&& r, O result);
   }
@@ -1175,8 +1175,8 @@
     template<class I, class O>
     using copy_n_result = copy_result<I, O>;
 
-    template<InputIterator I, WeaklyIncrementable O>
-      requires IndirectlyCopyable<I, O>
+    template<input_iterator I, weakly_incrementable O>
+      requires indirectly_copyable<I, O>
       constexpr copy_n_result<I, O>
         copy_n(I first, iter_difference_t<I> n, O result);
   }
@@ -1194,14 +1194,14 @@
     template<class I, class O>
     using copy_if_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
-      requires IndirectlyCopyable<I, O>
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O>
       constexpr copy_if_result<I, O>
         copy_if(I first, S last, O result, Pred pred, Proj proj = {});
-    template<InputRange R, WeaklyIncrementable O, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires IndirectlyCopyable<iterator_t<R>, O>
+    template<input_range R, weakly_incrementable O, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, O>
       constexpr copy_if_result<safe_iterator_t<R>, O>
         copy_if(R&& r, O result, Pred pred, Proj proj = {});
   }
@@ -1215,12 +1215,12 @@
     template<class I1, class I2>
     using copy_backward_result = copy_result<I1, I2>;
 
-    template<BidirectionalIterator I1, Sentinel<I1> S1, BidirectionalIterator I2>
-      requires IndirectlyCopyable<I1, I2>
+    template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+      requires indirectly_copyable<I1, I2>
       constexpr copy_backward_result<I1, I2>
         copy_backward(I1 first, S1 last, I2 result);
-    template<BidirectionalRange R, BidirectionalIterator I>
-      requires IndirectlyCopyable<iterator_t<R>, I>
+    template<bidirectional_range R, bidirectional_iterator I>
+      requires indirectly_copyable<iterator_t<R>, I>
       constexpr copy_backward_result<safe_iterator_t<R>, I>
         copy_backward(R&& r, I result);
   }
@@ -1239,12 +1239,12 @@
     template<class I, class O>
     using move_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
-      requires IndirectlyMovable<I, O>
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+      requires indirectly_movable<I, O>
       constexpr move_result<I, O>
         move(I first, S last, O result);
-    template<InputRange R, WeaklyIncrementable O>
-      requires IndirectlyMovable<iterator_t<R>, O>
+    template<input_range R, weakly_incrementable O>
+      requires indirectly_movable<iterator_t<R>, O>
       constexpr move_result<safe_iterator_t<R>, O>
         move(R&& r, O result);
   }
@@ -1258,12 +1258,12 @@
     template<class I1, class I2>
     using move_backward_result = copy_result<I1, I2>;
 
-    template<BidirectionalIterator I1, Sentinel<I1> S1, BidirectionalIterator I2>
-      requires IndirectlyMovable<I1, I2>
+    template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+      requires indirectly_movable<I1, I2>
       constexpr move_backward_result<I1, I2>
         move_backward(I1 first, S1 last, I2 result);
-    template<BidirectionalRange R, BidirectionalIterator I>
-      requires IndirectlyMovable<iterator_t<R>, I>
+    template<bidirectional_range R, bidirectional_iterator I>
+      requires indirectly_movable<iterator_t<R>, I>
       constexpr move_backward_result<safe_iterator_t<R>, I>
         move_backward(R&& r, I result);
   }
@@ -1281,12 +1281,12 @@
     template<class I1, class I2>
     using swap_ranges_result = mismatch_result<I1, I2>;
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2>
-      requires IndirectlySwappable<I1, I2>
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
+      requires indirectly_swappable<I1, I2>
       constexpr swap_ranges_result<I1, I2>
         swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
-    template<InputRange R1, InputRange R2>
-      requires IndirectlySwappable<iterator_t<R1>, iterator_t<R2>>
+    template<input_range R1, input_range R2>
+      requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
       constexpr swap_ranges_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
         swap_ranges(R1&& r1, R2&& r2);
   }
@@ -1323,14 +1323,14 @@
     template<class I, class O>
     using unary_transform_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-             CopyConstructible F, class Proj = identity>
-      requires Writable<O, indirect_result_t<F&, projected<I, Proj>>>
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+             copy_constructible F, class Proj = identity>
+      requires writable<O, indirect_result_t<F&, projected<I, Proj>>>
       constexpr unary_transform_result<I, O>
         transform(I first1, S last1, O result, F op, Proj proj = {});
-    template<InputRange R, WeaklyIncrementable O, CopyConstructible F,
+    template<input_range R, weakly_incrementable O, copy_constructible F,
              class Proj = identity>
-      requires Writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
+      requires writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
       constexpr unary_transform_result<safe_iterator_t<R>, O>
         transform(R&& r, O result, F op, Proj proj = {});
 
@@ -1341,31 +1341,31 @@
       [[no_unique_address]] O  out;
 
       template<class II1, class II2, class OO>
-        requires ConvertibleTo<const I1&, II1> &&
-          ConvertibleTo<const I2&, II2> && ConvertibleTo<const O&, OO>
+        requires convertible_to<const I1&, II1> &&
+          convertible_to<const I2&, II2> && convertible_to<const O&, OO>
         operator binary_transform_result<II1, II2, OO>() const & {
           return {in1, in2, out};
         }
 
       template<class II1, class II2, class OO>
-        requires ConvertibleTo<I1, II1> &&
-          ConvertibleTo<I2, II2> && ConvertibleTo<O, OO>
+        requires convertible_to<I1, II1> &&
+          convertible_to<I2, II2> && convertible_to<O, OO>
         operator binary_transform_result<II1, II2, OO>() && {
           return {std::move(in1), std::move(in2), std::move(out)};
         }
     };
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-             WeaklyIncrementable O, CopyConstructible F, class Proj1 = identity,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+             weakly_incrementable O, copy_constructible F, class Proj1 = identity,
              class Proj2 = identity>
-      requires Writable<O, indirect_result_t<F&, projected<I1, Proj1>,
+      requires writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                              projected<I2, Proj2>>>
       constexpr binary_transform_result<I1, I2, O>
         transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, WeaklyIncrementable O,
-             CopyConstructible F, class Proj1 = identity, class Proj2 = identity>
-      requires Writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
+    template<input_range R1, input_range R2, weakly_incrementable O,
+             copy_constructible F, class Proj1 = identity, class Proj2 = identity>
+      requires writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                              projected<iterator_t<R2>, Proj2>>>
       constexpr binary_transform_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
         transform(R1&& r1, R2&& r2, O result,
@@ -1389,23 +1389,23 @@
                     Predicate pred, const T& new_value);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class T1, class T2, class Proj = identity>
-      requires Writable<I, const T2&> &&
-               IndirectRelation<ranges::equal_to, projected<I, Proj>, const T1*>
+    template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
+      requires writable<I, const T2&> &&
+               indirect_relation<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr I
         replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
-    template<InputRange R, class T1, class T2, class Proj = identity>
-      requires Writable<iterator_t<R>, const T2&> &&
-               IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+    template<input_range R, class T1, class T2, class Proj = identity>
+      requires writable<iterator_t<R>, const T2&> &&
+               indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
       constexpr safe_iterator_t<R>
         replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
-    template<InputIterator I, Sentinel<I> S, class T, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
-      requires Writable<I, const T&>
+    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires writable<I, const T&>
       constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-    template<InputRange R, class T, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires Writable<iterator_t<R>, const T&>
+    template<input_range R, class T, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires writable<iterator_t<R>, const T&>
       constexpr safe_iterator_t<R>
         replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
   }
@@ -1434,17 +1434,18 @@
     template<class I, class O>
     using replace_copy_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, class T1, class T2, OutputIterator<const T2&> O,
+    template<input_iterator I, sentinel_for<I> S,
+             class T1, class T2, output_iterator<const T2&> O,
              class Proj = identity>
-      requires IndirectlyCopyable<I, O> &&
-               IndirectRelation<ranges::equal_to, projected<I, Proj>, const T1*>
+      requires indirectly_copyable<I, O> &&
+               indirect_relation<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr replace_copy_result<I, O>
         replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                      Proj proj = {});
-    template<InputRange R, class T1, class T2, OutputIterator<const T2&> O,
+    template<input_range R, class T1, class T2, output_iterator<const T2&> O,
              class Proj = identity>
-      requires IndirectlyCopyable<iterator_t<R>, O> &&
-               IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+      requires indirectly_copyable<iterator_t<R>, O> &&
+               indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
       constexpr replace_copy_result<safe_iterator_t<R>, O>
         replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                      Proj proj = {});
@@ -1452,15 +1453,16 @@
     template<class I, class O>
     using replace_copy_if_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, class T, OutputIterator<const T&> O,
-             class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
-      requires IndirectlyCopyable<I, O>
+    template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O>
       constexpr replace_copy_if_result<I, O>
         replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                         Proj proj = {});
-    template<InputRange R, class T, OutputIterator<const T&> O, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires IndirectlyCopyable<iterator_t<R>, O>
+    template<input_range R, class T, output_iterator<const T&> O,
+             class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, O>
       constexpr replace_copy_if_result<safe_iterator_t<R>, O>
         replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                         Proj proj = {});
@@ -1480,11 +1482,11 @@
                            ForwardIterator first, Size n, const T& value);
 
   namespace ranges {
-    template<class T, OutputIterator<const T&> O, Sentinel<O> S>
+    template<class T, output_iterator<const T&> O, sentinel_for<O> S>
       constexpr O fill(O first, S last, const T& value);
-    template<class T, OutputRange<const T&> R>
+    template<class T, output_range<const T&> R>
       constexpr safe_iterator_t<R> fill(R&& r, const T& value);
-    template<class T, OutputIterator<const T&> O>
+    template<class T, output_iterator<const T&> O>
       constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
   }
 
@@ -1503,14 +1505,14 @@
                                ForwardIterator first, Size n, Generator gen);
 
   namespace ranges {
-    template<Iterator O, Sentinel<O> S, CopyConstructible F>
-      requires Invocable<F&> && Writable<O, invoke_result_t<F&>>
+    template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
+      requires invocable<F&> && writable<O, invoke_result_t<F&>>
       constexpr O generate(O first, S last, F gen);
-    template<class R, CopyConstructible F>
-      requires Invocable<F&> && OutputRange<R, invoke_result_t<F&>>
+    template<class R, copy_constructible F>
+      requires invocable<F&> && output_range<R, invoke_result_t<F&>>
       constexpr safe_iterator_t<R> generate(R&& r, F gen);
-    template<Iterator O, CopyConstructible F>
-      requires Invocable<F&> && Writable<O, invoke_result_t<F&>>
+    template<input_or_output_iterator O, copy_constructible F>
+      requires invocable<F&> && writable<O, invoke_result_t<F&>>
       constexpr O generate_n(O first, iter_difference_t<O> n, F gen);
   }
 
@@ -1531,20 +1533,20 @@
                               Predicate pred);
 
   namespace ranges {
-    template<Permutable I, Sentinel<I> S, class T, class Proj = identity>
-      requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+    template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
+      requires indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr I remove(I first, S last, const T& value, Proj proj = {});
-    template<ForwardRange R, class T, class Proj = identity>
-      requires Permutable<iterator_t<R>> &&
-               IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    template<forward_range R, class T, class Proj = identity>
+      requires permutable<iterator_t<R>> &&
+               indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr safe_iterator_t<R>
         remove(R&& r, const T& value, Proj proj = {});
-    template<Permutable I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<permutable I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I remove_if(I first, S last, Pred pred, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires Permutable<iterator_t<R>>
+    template<forward_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires permutable<iterator_t<R>>
       constexpr safe_iterator_t<R>
         remove_if(R&& r, Pred pred, Proj proj = {});
   }
@@ -1574,29 +1576,29 @@
     template<class I, class O>
     using remove_copy_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class T,
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
              class Proj = identity>
-      requires IndirectlyCopyable<I, O> &&
-               IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+      requires indirectly_copyable<I, O> &&
+               indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr remove_copy_result<I, O>
         remove_copy(I first, S last, O result, const T& value, Proj proj = {});
-    template<InputRange R, WeaklyIncrementable O, class T, class Proj = identity>
-      requires IndirectlyCopyable<iterator_t<R>, O> &&
-               IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    template<input_range R, weakly_incrementable O, class T, class Proj = identity>
+      requires indirectly_copyable<iterator_t<R>, O> &&
+               indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr remove_copy_result<safe_iterator_t<R>, O>
         remove_copy(R&& r, O result, const T& value, Proj proj = {});
 
     template<class I, class O>
     using remove_copy_if_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-             class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
-      requires IndirectlyCopyable<I, O>
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O>
       constexpr remove_copy_if_result<I, O>
         remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
-    template<InputRange R, WeaklyIncrementable O, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires IndirectlyCopyable<iterator_t<R>, O>
+    template<input_range R, weakly_incrementable O, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, O>
       constexpr remove_copy_if_result<safe_iterator_t<R>, O>
         remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
   }
@@ -1616,12 +1618,12 @@
                            BinaryPredicate pred);
 
   namespace ranges {
-    template<Permutable I, Sentinel<I> S, class Proj = identity,
-             IndirectRelation<projected<I, Proj>> C = ranges::equal_to>
+    template<permutable I, sentinel_for<I> S, class Proj = identity,
+             indirect_relation<projected<I, Proj>> C = ranges::equal_to>
       constexpr I unique(I first, S last, C comp = {}, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectRelation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
-      requires Permutable<iterator_t<R>>
+    template<forward_range R, class Proj = identity,
+             indirect_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+      requires permutable<iterator_t<R>>
       constexpr safe_iterator_t<R>
         unique(R&& r, C comp = {}, Proj proj = {});
   }
@@ -1650,20 +1652,20 @@
     template<class I, class O>
     using unique_copy_result = copy_result<I, O>;
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-             class Proj = identity, IndirectRelation<projected<I, Proj>> C = ranges::equal_to>
-      requires IndirectlyCopyable<I, O> &&
-               (ForwardIterator<I> ||
-                (InputIterator<O> && Same<iter_value_t<I>, iter_value_t<O>>) ||
-                IndirectlyCopyableStorable<I, O>)
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+             class Proj = identity, indirect_relation<projected<I, Proj>> C = ranges::equal_to>
+      requires indirectly_copyable<I, O> &&
+               (forward_iterator<I> ||
+                (input_iterator<O> && same_to<iter_value_t<I>, iter_value_t<O>>) ||
+                 indirectly_copyable_storable<I, O>)
       constexpr unique_copy_result<I, O>
         unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
-    template<InputRange R, WeaklyIncrementable O, class Proj = identity,
-             IndirectRelation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
-      requires IndirectlyCopyable<iterator_t<R>, O> &&
-               (ForwardIterator<iterator_t<R>> ||
-                (InputIterator<O> && Same<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
-                IndirectlyCopyableStorable<iterator_t<R>, O>)
+    template<input_range R, weakly_incrementable O, class Proj = identity,
+             indirect_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+      requires indirectly_copyable<iterator_t<R>, O> &&
+               (forward_iterator<iterator_t<R>> ||
+                (input_iterator<O> && same_to<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
+                 indirectly_copyable_storable<iterator_t<R>, O>)
       constexpr unique_copy_result<safe_iterator_t<R>, O>
         unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
   }
@@ -1676,11 +1678,11 @@
                  BidirectionalIterator first, BidirectionalIterator last);
 
   namespace ranges {
-    template<BidirectionalIterator I, Sentinel<I> S>
-      requires Permutable<I>
+    template<bidirectional_iterator I, sentinel_for<I> S>
+      requires permutable<I>
       constexpr I reverse(I first, S last);
-    template<BidirectionalRange R>
-      requires Permutable<iterator_t<R>>
+    template<bidirectional_range R>
+      requires permutable<iterator_t<R>>
       constexpr safe_iterator_t<R> reverse(R&& r);
   }
 
@@ -1698,12 +1700,12 @@
     template<class I, class O>
     using reverse_copy_result = copy_result<I, O>;
 
-    template<BidirectionalIterator I, Sentinel<I> S, WeaklyIncrementable O>
-      requires IndirectlyCopyable<I, O>
+    template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
+      requires indirectly_copyable<I, O>
       constexpr reverse_copy_result<I, O>
         reverse_copy(I first, S last, O result);
-    template<BidirectionalRange R, WeaklyIncrementable O>
-      requires IndirectlyCopyable<iterator_t<R>, O>
+    template<bidirectional_range R, weakly_incrementable O>
+      requires indirectly_copyable<iterator_t<R>, O>
       constexpr reverse_copy_result<safe_iterator_t<R>, O>
         reverse_copy(R&& r, O result);
   }
@@ -1720,10 +1722,10 @@
                            ForwardIterator last);
 
   namespace ranges {
-    template<Permutable I, Sentinel<I> S>
+    template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> rotate(I first, I middle, S last);
-    template<ForwardRange R>
-      requires Permutable<iterator_t<R>>
+    template<forward_range R>
+      requires permutable<iterator_t<R>>
       constexpr safe_subrange_t<R> rotate(R&& r, iterator_t<R> middle);
   }
 
@@ -1741,12 +1743,12 @@
     template<class I, class O>
     using rotate_copy_result = copy_result<I, O>;
 
-    template<ForwardIterator I, Sentinel<I> S, WeaklyIncrementable O>
-      requires IndirectlyCopyable<I, O>
+    template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
+      requires indirectly_copyable<I, O>
       constexpr rotate_copy_result<I, O>
         rotate_copy(I first, I middle, S last, O result);
-    template<ForwardRange R, WeaklyIncrementable O>
-      requires IndirectlyCopyable<iterator_t<R>, O>
+    template<forward_range R, weakly_incrementable O>
+      requires indirectly_copyable<iterator_t<R>, O>
       constexpr rotate_copy_result<safe_iterator_t<R>, O>
         rotate_copy(R&& r, iterator_t<R> middle, O result);
   }
@@ -1765,15 +1767,15 @@
                  UniformRandomBitGenerator&& g);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Gen>
-      requires Permutable<I> &&
-               UniformRandomBitGenerator<remove_reference_t<Gen>> &&
-               ConvertibleTo<invoke_result_t<Gen&>, iter_difference_t<I>>
+    template<random_access_iterator I, sentinel_for<I> S, class Gen>
+      requires permutable<I> &&
+               uniform_random_bit_generator<remove_reference_t<Gen>> &&
+               convertible_to<invoke_result_t<Gen&>, iter_difference_t<I>>
       I shuffle(I first, S last, Gen&& g);
-    template<RandomAccessRange R, class Gen>
-      requires Permutable<iterator_t<R>> &&
-               UniformRandomBitGenerator<remove_reference_t<Gen>> &&
-               ConvertibleTo<invoke_result_t<Gen&>, iter_difference_t<iterator_t<R>>>
+    template<random_access_range R, class Gen>
+      requires permutable<iterator_t<R>> &&
+               uniform_random_bit_generator<remove_reference_t<Gen>> &&
+               convertible_to<invoke_result_t<Gen&>, iter_difference_t<iterator_t<R>>>
       safe_iterator_t<R> shuffle(R&& r, Gen&& g);
   }
 
@@ -1813,13 +1815,13 @@
               Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         sort(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         sort(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -1838,12 +1840,12 @@
                      Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       safe_iterator_t<R>
         stable_sort(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -1868,13 +1870,13 @@
                       RandomAccessIterator last, Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
                      Proj proj = {});
@@ -1907,19 +1909,20 @@
                         Compare comp);
 
   namespace ranges {
-    template<InputIterator I1, Sentinel<I1> S1, RandomAccessIterator I2, Sentinel<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1,
+             random_access_iterator I2, sentinel_for<I2> S2,
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyCopyable<I1, I2> && Sortable<I2, Comp, Proj2> &&
-               IndirectStrictWeakOrder<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
+      requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
+               indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
       constexpr I2
         partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, RandomAccessRange R2, class Comp = ranges::less,
+    template<input_range R1, random_access_range R2, class Comp = ranges::less,
              class Proj1 = identity, class Proj2 = identity>
-      requires IndirectlyCopyable<iterator_t<R1>, iterator_t<R2>> &&
-               Sortable<iterator_t<R2>, Comp, Proj2> &&
-               IndirectStrictWeakOrder<Comp, projected<iterator_t<R1>, Proj1>,
-                                       projected<iterator_t<R2>, Proj2>>
+      requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
+               sortable<iterator_t<R2>, Comp, Proj2> &&
+               indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
+                                          projected<iterator_t<R2>, Proj2>>
       constexpr safe_iterator_t<R2>
         partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -1939,11 +1942,11 @@
                    Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<forward_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
   }
 
@@ -1965,11 +1968,11 @@
                       Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<forward_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr safe_iterator_t<R>
         is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -1991,13 +1994,13 @@
                      RandomAccessIterator last, Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
   }
@@ -2013,12 +2016,12 @@
                   const T& value, Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
                               Proj proj = {});
-    template<ForwardRange R, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+    template<forward_range R, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr safe_iterator_t<R>
         lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
@@ -2034,11 +2037,11 @@
                   const T& value, Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+    template<forward_range R, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr safe_iterator_t<R>
         upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
@@ -2054,12 +2057,12 @@
                   const T& value, Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr subrange<I>
         equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+    template<forward_range R, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr safe_subrange_t<R>
         equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
@@ -2075,12 +2078,12 @@
                     const T& value, Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
                                    Proj proj = {});
-    template<ForwardRange R, class T, class Proj = identity,
-             IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+    template<forward_range R, class T, class Proj = identity,
+             indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
                                    Proj proj = {});
@@ -2094,11 +2097,11 @@
                         ForwardIterator first, ForwardIterator last, Predicate pred);
 
   namespace ranges {
-    template<InputIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<input_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
   }
 
@@ -2113,13 +2116,13 @@
                               Predicate pred);
 
   namespace ranges {
-    template<Permutable I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<permutable I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I
         partition(I first, S last, Pred pred, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires Permutable<iterator_t<R>>
+    template<forward_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires permutable<iterator_t<R>>
       constexpr safe_iterator_t<R>
         partition(R&& r, Pred pred, Proj proj = {});
   }
@@ -2135,13 +2138,13 @@
                                            Predicate pred);
 
   namespace ranges {
-    template<BidirectionalIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
-      requires Permutable<I>
+    template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires permutable<I>
       I stable_partition(I first, S last, Pred pred, Proj proj = {});
-    template<BidirectionalRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires Permutable<iterator_t<R>>
+    template<bidirectional_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires permutable<iterator_t<R>>
       safe_iterator_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
   }
 
@@ -2167,31 +2170,34 @@
       [[no_unique_address]] O2 out2;
 
       template<class II, class OO1, class OO2>
-        requires ConvertibleTo<const I&, II> &&
-          ConvertibleTo<const O1&, OO1> && ConvertibleTo<const O2&, OO2>
+        requires convertible_to<const I&, II> &&
+          convertible_to<const O1&, OO1> && convertible_to<const O2&, OO2>
         operator partition_copy_result<II, OO1, OO2>() const & {
           return {in, out1, out2};
         }
 
       template<class II, class OO1, class OO2>
-        requires ConvertibleTo<I, II> &&
-          ConvertibleTo<O1, OO1> && ConvertibleTo<O2, OO2>
+        requires convertible_to<I, II> &&
+          convertible_to<O1, OO1> && convertible_to<O2, OO2>
         operator partition_copy_result<II, OO1, OO2>() && {
           return {std::move(in), std::move(out1), std::move(out2)};
         }
     };
 
-    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O1, WeaklyIncrementable O2,
-             class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
-      requires IndirectlyCopyable<I, O1> && IndirectlyCopyable<I, O2>
+    template<input_iterator I, sentinel_for<I> S,
+             weakly_incrementable O1, weakly_incrementable O2,
+             class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
       constexpr partition_copy_result<I, O1, O2>
         partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
                        Proj proj = {});
-    template<InputRange R, WeaklyIncrementable O1, WeaklyIncrementable O2,
+    template<input_range R,
+             weakly_incrementable O1, weakly_incrementable O2,
              class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-      requires IndirectlyCopyable<iterator_t<R>, O1> &&
-               IndirectlyCopyable<iterator_t<R>, O2>
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, O1> &&
+               indirectly_copyable<iterator_t<R>, O2>
       constexpr partition_copy_result<safe_iterator_t<R>, O1, O2>
         partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
   }
@@ -2202,11 +2208,11 @@
                       Predicate pred);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectUnaryPredicate<projected<I, Proj>> Pred>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+    template<forward_range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr safe_iterator_t<R>
         partition_point(R&& r, Pred pred, Proj proj = {});
   }
@@ -2242,16 +2248,16 @@
     template<class I1, class I2, class O>
     using merge_result = binary_transform_result<I1, I2, O>;
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-             WeaklyIncrementable O, class Comp = ranges::less, class Proj1 = identity,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+             weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
              class Proj2 = identity>
-      requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
       constexpr merge_result<I1, I2, O>
         merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, WeaklyIncrementable O, class Comp = ranges::less,
+    template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
              class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr merge_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
         merge(R1&& r1, R2&& r2, O result,
               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -2277,12 +2283,12 @@
                        BidirectionalIterator last, Compare comp);
 
   namespace ranges {
-    template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
-    template<BidirectionalRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       safe_iterator_t<R>
         inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
                       Proj proj = {});
@@ -2308,16 +2314,16 @@
                   Compare comp);
 
   namespace ranges {
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              class Proj1 = identity, class Proj2 = identity,
-             IndirectStrictWeakOrder<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
+             indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
                ranges::less>
       constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, class Proj1 = identity,
+    template<input_range R1, input_range R2, class Proj1 = identity,
              class Proj2 = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R1>, Proj1>,
-                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+             indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                        projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
       constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
   }
@@ -2351,16 +2357,16 @@
     template<class I1, class I2, class O>
     using set_union_result = binary_transform_result<I1, I2, O>;
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-             WeaklyIncrementable O, class Comp = ranges::less,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+             weakly_incrementable O, class Comp = ranges::less,
              class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
       constexpr set_union_result<I1, I2, O>
         set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+    template<input_range R1, input_range R2, weakly_incrementable O,
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_union_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
         set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -2395,16 +2401,16 @@
     template<class I1, class I2, class O>
     using set_intersection_result = binary_transform_result<I1, I2, O>;
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-             WeaklyIncrementable O, class Comp = ranges::less,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+             weakly_incrementable O, class Comp = ranges::less,
              class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
       constexpr set_intersection_result<I1, I2, O>
         set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                          Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+    template<input_range R1, input_range R2, weakly_incrementable O,
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_intersection_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
         set_intersection(R1&& r1, R2&& r2, O result,
                          Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -2439,16 +2445,16 @@
     template<class I, class O>
     using set_difference_result = copy_result<I, O>;
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-             WeaklyIncrementable O, class Comp = ranges::less,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+             weakly_incrementable O, class Comp = ranges::less,
              class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
       constexpr set_difference_result<I1, O>
         set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+    template<input_range R1, input_range R2, weakly_incrementable O,
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_difference_result<safe_iterator_t<R1>, O>
         set_difference(R1&& r1, R2&& r2, O result,
                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -2483,17 +2489,17 @@
     template<class I1, class I2, class O>
     using set_symmetric_difference_result = binary_transform_result<I1, I2, O>;
 
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-             WeaklyIncrementable O, class Comp = ranges::less,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+             weakly_incrementable O, class Comp = ranges::less,
              class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
       constexpr set_symmetric_difference_result<I1, I2, O>
         set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                                  Comp comp = {}, Proj1 proj1 = {},
                                  Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+    template<input_range R1, input_range R2, weakly_incrementable O,
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-      requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_symmetric_difference_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
         set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -2507,13 +2513,13 @@
                              Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         push_heap(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         push_heap(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2525,13 +2531,13 @@
                             Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         pop_heap(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2543,13 +2549,13 @@
                              Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         make_heap(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         make_heap(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2561,13 +2567,13 @@
                              Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr I
         sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+    template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr safe_iterator_t<R>
         sort_heap(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2586,11 +2592,11 @@
                  Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<random_access_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
   }
 
@@ -2612,11 +2618,11 @@
                     Compare comp);
 
   namespace ranges {
-    template<RandomAccessIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
-    template<RandomAccessRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<random_access_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr safe_iterator_t<R>
         is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2632,14 +2638,14 @@
 
   namespace ranges {
     template<class T, class Proj = identity,
-             IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+             indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
       constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
-    template<Copyable T, class Proj = identity,
-             IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+    template<copyable T, class Proj = identity,
+             indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
       constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-      requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
+    template<input_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      requires indirectly_copyable_storable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
       constexpr iter_value_t<iterator_t<R>>
         min(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2654,14 +2660,14 @@
 
   namespace ranges {
     template<class T, class Proj = identity,
-             IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+             indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
       constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
-    template<Copyable T, class Proj = identity,
-             IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+    template<copyable T, class Proj = identity,
+             indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
       constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-      requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
+    template<input_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      requires indirectly_copyable_storable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
       constexpr iter_value_t<iterator_t<R>>
         max(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2681,29 +2687,29 @@
       [[no_unique_address]] T max;
 
       template<class T2>
-        requires ConvertibleTo<const T&, T2>
+        requires convertible_to<const T&, T2>
         operator minmax_result<T2>() const & {
           return {min, max};
         }
 
       template<class T2>
-        requires ConvertibleTo<T, T2>
+        requires convertible_to<T, T2>
         operator minmax_result<T2>() && {
           return {std::move(min), std::move(max)};
         }
     };
 
     template<class T, class Proj = identity,
-             IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+             indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
       constexpr minmax_result<const T&>
         minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
-    template<Copyable T, class Proj = identity,
-             IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+    template<copyable T, class Proj = identity,
+             indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
       constexpr minmax_result<T>
         minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
-    template<InputRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-      requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
+    template<input_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      requires indirectly_copyable_storable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
       constexpr minmax_result<iter_value_t<iterator_t<R>>>
         minmax(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2722,11 +2728,11 @@
                                 Compare comp);
 
   namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<forward_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr safe_iterator_t<R>
         min_element(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2745,11 +2751,11 @@
                                 Compare comp);
 
  namespace ranges {
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<forward_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr safe_iterator_t<R>
         max_element(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2773,12 +2779,12 @@
     template<class I>
     using minmax_element_result = minmax_result<I>;
 
-    template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-             IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr minmax_element_result<I>
         minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
-    template<ForwardRange R, class Proj = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    template<forward_range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr minmax_element_result<safe_iterator_t<R>>
         minmax_element(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2813,17 +2819,17 @@
                               Compare comp);
 
   namespace ranges {
-    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              class Proj1 = identity, class Proj2 = identity,
-             IndirectStrictWeakOrder<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
+             indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
                ranges::less>
       constexpr bool
         lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
                                 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-    template<InputRange R1, InputRange R2, class Proj1 = identity,
+    template<input_range R1, input_range R2, class Proj1 = identity,
              class Proj2 = identity,
-             IndirectStrictWeakOrder<projected<iterator_t<R1>, Proj1>,
-                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+             indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                        projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
       constexpr bool
         lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -2852,14 +2858,14 @@
                                     BidirectionalIterator last, Compare comp);
 
   namespace ranges {
-    template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr bool
         next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
-    template<BidirectionalRange R, class Comp = ranges::less,
+    template<bidirectional_range R, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr bool
         next_permutation(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2872,14 +2878,14 @@
                                     BidirectionalIterator last, Compare comp);
 
   namespace ranges {
-    template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
+    template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<I, Comp, Proj>
+      requires sortable<I, Comp, Proj>
       constexpr bool
         prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
-    template<BidirectionalRange R, class Comp = ranges::less,
+    template<bidirectional_range R, class Comp = ranges::less,
              class Proj = identity>
-      requires Sortable<iterator_t<R>, Comp, Proj>
+      requires sortable<iterator_t<R>, Comp, Proj>
       constexpr bool
         prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
   }
@@ -2898,11 +2904,11 @@
   bool all_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
               Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
 
@@ -2932,11 +2938,11 @@
   bool any_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
               Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
 
@@ -2965,11 +2971,11 @@
   bool none_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
 
@@ -3072,12 +3078,12 @@
 
 \indexlibrary{\idxcode{for_each}}%
 \begin{itemdecl}
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryInvocable<projected<I, Proj>> Fun>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirectly_unary_invocable<projected<I, Proj>> Fun>
   constexpr ranges::for_each_result<I, Fun>
     ranges::for_each(I first, S last, Fun f, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryInvocable<projected<iterator_t<R>, Proj>> Fun>
+template<input_range R, class Proj = identity,
+         indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
   constexpr ranges::for_each_result<safe_iterator_t<R>, Fun>
     ranges::for_each(R&& r, Fun f, Proj proj = {});
 \end{itemdecl}
@@ -3108,7 +3114,7 @@
 \pnum
 \begin{note}
 The overloads in namespace \tcode{ranges} require
-\tcode{Fun} to model \libconcept{CopyConstructible}.
+\tcode{Fun} to model \libconcept{copy_constructible}.
 \end{note}
 \end{itemdescr}
 
@@ -3214,25 +3220,25 @@
                               ForwardIterator first, ForwardIterator last,
                               Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, class T, class Proj = identity>
-  requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+  requires indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
-template<InputRange R, class T, class Proj = identity>
-  requires IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+template<input_range R, class T, class Proj = identity>
+  requires indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr safe_iterator_t<R>
     ranges::find(R&& r, const T& value, Proj proj = {});
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr safe_iterator_t<R>
     ranges::find_if(R&& r, Pred pred, Proj proj = {});
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr safe_iterator_t<R>
     ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -3289,18 +3295,18 @@
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 
-template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2,
+template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr subrange<I1>
     ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
-             Proj1 proj1 = {}, Proj2 proj2 = {});
-template<ForwardRange R1, ForwardRange R2,
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<forward_range R1, forward_range R2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr safe_subrange_t<R1>
     ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
-             Proj1 proj1 = {}, Proj2 proj2 = {});
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3374,17 +3380,17 @@
                   ForwardIterator2 first2, ForwardIterator2 last2,
                   BinaryPredicate pred);
 
-template<InputIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2,
+template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
          class Proj1 = identity, class Proj2 = identity,
-         IndirectRelation<projected<I1, Proj1>,
-                          projected<I2, Proj2>> Pred = ranges::equal_to>
+         indirect_relation<projected<I1, Proj1>,
+                           projected<I2, Proj2>> Pred = ranges::equal_to>
   constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
                                      Pred pred = {},
                                      Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, ForwardRange R2, class Proj1 = identity,
+template<input_range R1, forward_range R2, class Proj1 = identity,
          class Proj2 = identity,
-         IndirectRelation<projected<iterator_t<R1>, Proj1>,
-                          projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
+         indirect_relation<projected<iterator_t<R1>, Proj1>,
+                           projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
   constexpr safe_iterator_t<R1>
     ranges::find_first_of(R1&& r1, R2&& r2,
                           Pred pred = {},
@@ -3441,11 +3447,11 @@
                   ForwardIterator first, ForwardIterator last,
                   BinaryPredicate pred);
 
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectRelation<projected<I, Proj>> Pred = ranges::equal_to>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_relation<projected<I, Proj>> Pred = ranges::equal_to>
   constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectRelation<projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
+template<forward_range R, class Proj = identity,
+         indirect_relation<projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
   constexpr safe_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
 \end{itemdecl}
 
@@ -3498,20 +3504,20 @@
     count_if(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last, Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, class T, class Proj = identity>
-  requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+  requires indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr iter_difference_t<I>
     ranges::count(I first, S last, const T& value, Proj proj = {});
-template<InputRange R, class T, class Proj = identity>
-  requires IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+template<input_range R, class T, class Proj = identity>
+  requires indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr iter_difference_t<iterator_t<R>>
     ranges::count(R&& r, const T& value, Proj proj = {});
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr iter_difference_t<I>
     ranges::count_if(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr iter_difference_t<iterator_t<R>>
     ranges::count_if(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -3595,17 +3601,17 @@
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          class Proj1 = identity, class Proj2 = identity,
-         IndirectRelation<projected<I1, Proj1>,
-                          projected<I2, Proj2>> Pred = ranges::equal_to>
+         indirect_relation<projected<I1, Proj1>,
+                           projected<I2, Proj2>> Pred = ranges::equal_to>
   constexpr ranges::mismatch_result<I1, I2>
     ranges::mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2,
+template<input_range R1, input_range R2,
          class Proj1 = identity, class Proj2 = identity,
-         IndirectRelation<projected<iterator_t<R1>, Proj1>,
-                          projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
+         indirect_relation<projected<iterator_t<R1>, Proj1>,
+                           projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
   constexpr ranges::mismatch_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
     ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -3688,15 +3694,15 @@
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
                                Pred pred = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, class Pred = ranges::equal_to,
+template<input_range R1, input_range R2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
 \end{itemdecl}
@@ -3740,7 +3746,7 @@
   \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
   for the overloads in namespace \tcode{std}, or
 \item
-  pairwise model \libconcept{SizedSentinel}\iref{iterator.concept.sizedsentinel}
+  pairwise model \libconcept{sized_sentinel_for}\iref{iterator.concept.sizedsentinel}
   for the overloads in namespace \tcode{ranges},
 \end{itemize}
 and \tcode{last1 - first1 != last2 - first2},
@@ -3819,16 +3825,16 @@
 
 \indexlibrary{\idxcode{is_permutation}}%
 \begin{itemdecl}
-template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2,
-         Sentinel<I2> S2, class Pred = ranges::equal_to, class Proj1 = identity,
+template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
+         sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = identity,
          class Proj2 = identity>
-  requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr bool ranges::is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
                                         Pred pred = {},
                                         Proj1 proj1 = {}, Proj2 proj2 = {});
-template<ForwardRange R1, ForwardRange R2, class Pred = ranges::equal_to,
+template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr bool ranges::is_permutation(R1&& r1, R2&& r2, Pred pred = {},
                                         Proj1 proj1 = {}, Proj2 proj2 = {});
 \end{itemdecl}
@@ -3848,8 +3854,8 @@
 \complexity
 No applications of the corresponding predicate and projections if:
 \begin{itemize}
-\item \tcode{S1} and \tcode{I1} model \libconcept{SizedSentinel},
-\item \tcode{S2} and \tcode{I2} model \libconcept{SizedSentinel}, and
+\item \tcode{S1} and \tcode{I1} model \libconcept{sized_sentinel_for},
+\item \tcode{S2} and \tcode{I2} model \libconcept{sized_sentinel_for}, and
 \item \tcode{last1 - first1 != last2 - first2}.
 \end{itemize}
 Otherwise, exactly \tcode{last1 - first1} applications
@@ -3907,16 +3913,16 @@
 
 \indexlibrary{\idxcode{search}}%
 \begin{itemdecl}
-template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2,
-         Sentinel<I2> S2, class Pred = ranges::equal_to,
+template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
+         sentinel_for<I2> S2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr subrange<I1>
     ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                    Proj1 proj1 = {}, Proj2 proj2 = {});
-template<ForwardRange R1, ForwardRange R2, class Pred = ranges::equal_to,
+template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr safe_subrange_t<R1>
     ranges::search(R1&& r1, R2&& r2, Pred pred = {},
                    Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -3995,15 +4001,15 @@
 
 \indexlibrary{\idxcode{search_n}}%
 \begin{itemdecl}
-template<ForwardIterator I, Sentinel<I> S, class T,
+template<forward_iterator I, sentinel_for<I> S, class T,
          class Pred = ranges::equal_to, class Proj = identity>
-  requires IndirectlyComparable<I, const T*, Pred, Proj>
+  requires indirectly_comparable<I, const T*, Pred, Proj>
   constexpr subrange<I>
     ranges::search_n(I first, S last, iter_difference_t<I> count,
                      const T& value, Pred pred = {}, Proj proj = {});
-template<ForwardRange R, class T, class Pred = ranges::equal_to,
+template<forward_range R, class T, class Pred = ranges::equal_to,
          class Proj = identity>
-  requires IndirectlyComparable<iterator_t<R>, const T*, Pred, Proj>
+  requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
   constexpr safe_subrange_t<R>
     ranges::search_n(R&& r, iter_difference_t<iterator_t<R>> count,
                      const T& value, Pred pred = {}, Proj proj = {});
@@ -4052,11 +4058,11 @@
   constexpr OutputIterator copy(InputIterator first, InputIterator last,
                                 OutputIterator result);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
-  requires IndirectlyCopyable<I, O>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+  requires indirectly_copyable<I, O>
   constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result);
-template<InputRange R, WeaklyIncrementable O>
-  requires IndirectlyCopyable<iterator_t<R>, O>
+template<input_range R, weakly_incrementable O>
+  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::copy_result<safe_iterator_t<R>, O> ranges::copy(R&& r, O result);
 \end{itemdecl}
 
@@ -4130,8 +4136,8 @@
                           ForwardIterator1 first, Size n,
                           ForwardIterator2 result);
 
-template<InputIterator I, WeaklyIncrementable O>
-  requires IndirectlyCopyable<I, O>
+template<input_iterator I, weakly_incrementable O>
+  requires indirectly_copyable<I, O>
   constexpr ranges::copy_n_result<I, O>
     ranges::copy_n(I first, iter_difference_t<I> n, O result);
 \end{itemdecl}
@@ -4172,14 +4178,14 @@
                            ForwardIterator1 first, ForwardIterator1 last,
                            ForwardIterator2 result, Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
-  requires IndirectlyCopyable<I, O>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
   constexpr ranges::copy_if_result<I, O>
     ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {});
-template<InputRange R, WeaklyIncrementable O, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires IndirectlyCopyable<iterator_t<R>, O>
+template<input_range R, weakly_incrementable O, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::copy_if_result<safe_iterator_t<R>, O>
     ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -4244,12 +4250,12 @@
                   BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 
-template<BidirectionalIterator I1, Sentinel<I1> S1, BidirectionalIterator I2>
-  requires IndirectlyCopyable<I1, I2>
+template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+  requires indirectly_copyable<I1, I2>
   constexpr ranges::copy_backward_result<I1, I2>
     ranges::copy_backward(I1 first, S1 last, I2 result);
-template<BidirectionalRange R, BidirectionalIterator I>
-  requires IndirectlyCopyable<iterator_t<R>, I>
+template<bidirectional_range R, bidirectional_iterator I>
+  requires indirectly_copyable<iterator_t<R>, I>
   constexpr ranges::copy_backward_result<safe_iterator_t<R>, I>
     ranges::copy_backward(R&& r, I result);
 \end{itemdecl}
@@ -4296,12 +4302,12 @@
   constexpr OutputIterator move(InputIterator first, InputIterator last,
                                 OutputIterator result);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
-  requires IndirectlyMovable<I, O>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+  requires indirectly_movable<I, O>
   constexpr ranges::move_result<I, O>
     ranges::move(I first, S last, O result);
-template<InputRange R, WeaklyIncrementable O>
-  requires IndirectlyMovable<iterator_t<R>, O>
+template<input_range R, weakly_incrementable O>
+  requires indirectly_movable<iterator_t<R>, O>
   constexpr ranges::move_result<safe_iterator_t<R>, O>
     ranges::move(R&& r, O result);
 \end{itemdecl}
@@ -4386,12 +4392,12 @@
     move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 
-template<BidirectionalIterator I1, Sentinel<I1> S1, BidirectionalIterator I2>
-  requires IndirectlyMovable<I1, I2>
+template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+  requires indirectly_movable<I1, I2>
   constexpr ranges::move_backward_result<I1, I2>
     ranges::move_backward(I1 first, S1 last, I2 result);
-template<BidirectionalRange R, BidirectionalIterator I>
-  requires IndirectlyMovable<iterator_t<R>, I>
+template<bidirectional_range R, bidirectional_iterator I>
+  requires indirectly_movable<iterator_t<R>, I>
   constexpr ranges::move_backward_result<safe_iterator_t<R>, I>
     ranges::move_backward(R&& r, I result);
 \end{itemdecl}
@@ -4453,12 +4459,12 @@
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2>
-  requires IndirectlySwappable<I1, I2>
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
+  requires indirectly_swappable<I1, I2>
   constexpr ranges::swap_ranges_result<I1, I2>
     ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
-template<InputRange R1, InputRange R2>
-  requires IndirectlySwappable<iterator_t<R1>, iterator_t<R2>>
+template<input_range R1, input_range R2>
+  requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
   constexpr ranges::swap_ranges_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
     ranges::swap_ranges(R1&& r1, R2&& r2);
 \end{itemdecl}
@@ -4556,27 +4562,27 @@
               ForwardIterator2 first2, ForwardIterator result,
               BinaryOperation binary_op);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-         CopyConstructible F, class Proj = identity>
-  requires Writable<O, indirect_result_t<F&, projected<I, Proj>>>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         copy_constructible F, class Proj = identity>
+  requires writable<O, indirect_result_t<F&, projected<I, Proj>>>
   constexpr ranges::unary_transform_result<I, O>
     ranges::transform(I first1, S last1, O result, F op, Proj proj = {});
-template<InputRange R, WeaklyIncrementable O, CopyConstructible F,
+template<input_range R, weakly_incrementable O, copy_constructible F,
          class Proj = identity>
-  requires Writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
+  requires writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
   constexpr ranges::unary_transform_result<safe_iterator_t<R>, O>
     ranges::transform(R&& r, O result, F op, Proj proj = {});
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-         WeaklyIncrementable O, CopyConstructible F, class Proj1 = identity,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         weakly_incrementable O, copy_constructible F, class Proj1 = identity,
          class Proj2 = identity>
-  requires Writable<O, indirect_result_t<F&, projected<I1, Proj1>,
+  requires writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                          projected<I2, Proj2>>>
   constexpr ranges::binary_transform_result<I1, I2, O>
     ranges::transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                       F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, WeaklyIncrementable O,
-         CopyConstructible F, class Proj1 = identity, class Proj2 = identity>
-  requires Writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
+template<input_range R1, input_range R2, weakly_incrementable O,
+         copy_constructible F, class Proj1 = identity, class Proj2 = identity>
+  requires writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                          projected<iterator_t<R2>, Proj2>>>
   constexpr ranges::binary_transform_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
     ranges::transform(R1&& r1, R2&& r2, O result,
@@ -4675,23 +4681,23 @@
                   ForwardIterator first, ForwardIterator last,
                   Predicate pred, const T& new_value);
 
-template<InputIterator I, Sentinel<I> S, class T1, class T2, class Proj = identity>
-  requires Writable<I, const T2&> &&
-           IndirectRelation<ranges::equal_to, projected<I, Proj>, const T1*>
+template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
+  requires writable<I, const T2&> &&
+           indirect_relation<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr I
     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
-template<InputRange R, class T1, class T2, class Proj = identity>
-  requires Writable<iterator_t<R>, const T2&> &&
-           IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+template<input_range R, class T1, class T2, class Proj = identity>
+  requires writable<iterator_t<R>, const T2&> &&
+           indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr safe_iterator_t<R>
     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
-template<InputIterator I, Sentinel<I> S, class T, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
-  requires Writable<I, const T&>
+template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires writable<I, const T&>
   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-template<InputRange R, class T, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires Writable<iterator_t<R>, const T&>
+template<input_range R, class T, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires writable<iterator_t<R>, const T&>
   constexpr safe_iterator_t<R>
     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
 \end{itemdecl}
@@ -4754,30 +4760,30 @@
                     ForwardIterator2 result,
                     Predicate pred, const T& new_value);
 
-template<InputIterator I, Sentinel<I> S, class T1, class T2, OutputIterator<const T2&> O,
+template<input_iterator I, sentinel_for<I> S, class T1, class T2, output_iterator<const T2&> O,
          class Proj = identity>
-  requires IndirectlyCopyable<I, O> &&
-           IndirectRelation<ranges::equal_to, projected<I, Proj>, const T1*>
+  requires indirectly_copyable<I, O> &&
+           indirect_relation<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr ranges::replace_copy_result<I, O>
     ranges::replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
-template<InputRange R, class T1, class T2, OutputIterator<const T2&> O,
+template<input_range R, class T1, class T2, output_iterator<const T2&> O,
          class Proj = identity>
-  requires IndirectlyCopyable<iterator_t<R>, O> &&
-           IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+  requires indirectly_copyable<iterator_t<R>, O> &&
+           indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr ranges::replace_copy_result<safe_iterator_t<R>, O>
     ranges::replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
 
-template<InputIterator I, Sentinel<I> S, class T, OutputIterator<const T&> O,
-         class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
-  requires IndirectlyCopyable<I, O>
+template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
   constexpr ranges::replace_copy_if_result<I, O>
     ranges::replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                             Proj proj = {});
-template<InputRange R, class T, OutputIterator<const T&> O, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires IndirectlyCopyable<iterator_t<R>, O>
+template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::replace_copy_if_result<safe_iterator_t<R>, O>
     ranges::replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                             Proj proj = {});
@@ -4848,11 +4854,11 @@
                          ForwardIterator first, Size n, const T& value);
 
 
-template<class T, OutputIterator<const T&> O, Sentinel<O> S>
+template<class T, output_iterator<const T&> O, sentinel_for<O> S>
   constexpr O ranges::fill(O first, S last, const T& value);
-template<class T, OutputRange<const T&> R>
+template<class T, output_range<const T&> R>
   constexpr safe_iterator_t<R> ranges::fill(R&& r, const T& value);
-template<class T, OutputIterator<const T&> O>
+template<class T, output_iterator<const T&> O>
   constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);
 \end{itemdecl}
 
@@ -4901,14 +4907,14 @@
   ForwardIterator generate_n(ExecutionPolicy&& exec,
                              ForwardIterator first, Size n, Generator gen);
 
-template<Iterator O, Sentinel<O> S, CopyConstructible F>
-  requires Invocable<F&> && Writable<O, invoke_result_t<F&>>
+template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
+  requires invocable<F&> && writable<O, invoke_result_t<F&>>
   constexpr O ranges::generate(O first, S last, F gen);
-template<class R, CopyConstructible F>
-  requires Invocable<F&> && OutputRange<R, invoke_result_t<F&>>
+template<class R, copy_constructible F>
+  requires invocable<F&> && output_range<R, invoke_result_t<F&>>
   constexpr safe_iterator_t<R> ranges::generate(R&& r, F gen);
-template<Iterator O, CopyConstructible F>
-  requires Invocable<F&> && Writable<O, invoke_result_t<F&>>
+template<input_or_output_iterator O, copy_constructible F>
+  requires invocable<F&> && writable<O, invoke_result_t<F&>>
   constexpr O ranges::generate_n(O first, iter_difference_t<O> n, F gen);
 \end{itemdecl}
 
@@ -4957,20 +4963,20 @@
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
 
-template<Permutable I, Sentinel<I> S, class T, class Proj = identity>
-  requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
+  requires indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr I ranges::remove(I first, S last, const T& value, Proj proj = {});
-template<ForwardRange R, class T, class Proj = identity>
-  requires Permutable<iterator_t<R>> &&
-           IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+template<forward_range R, class T, class Proj = identity>
+  requires permutable<iterator_t<R>> &&
+           indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr safe_iterator_t<R>
     ranges::remove(R&& r, const T& value, Proj proj = {});
-template<Permutable I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<permutable I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::remove_if(I first, S last, Pred pred, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires Permutable<iterator_t<R>>
+template<forward_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
   constexpr safe_iterator_t<R>
     ranges::remove_if(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -5044,25 +5050,25 @@
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result, Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class T,
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
          class Proj = identity>
-  requires IndirectlyCopyable<I, O> &&
-           IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
+  requires indirectly_copyable<I, O> &&
+           indirect_relation<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr ranges::remove_copy_result<I, O>
     ranges::remove_copy(I first, S last, O result, const T& value, Proj proj = {});
-template<InputRange R, WeaklyIncrementable O, class T, class Proj = identity>
-  requires IndirectlyCopyable<iterator_t<R>, O> &&
-           IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+template<input_range R, weakly_incrementable O, class T, class Proj = identity>
+  requires indirectly_copyable<iterator_t<R>, O> &&
+           indirect_relation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr ranges::remove_copy_result<safe_iterator_t<R>, O>
     ranges::remove_copy(R&& r, O result, const T& value, Proj proj = {});
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-         class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
-  requires IndirectlyCopyable<I, O>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
   constexpr ranges::remove_copy_if_result<I, O>
     ranges::remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
-template<InputRange R, WeaklyIncrementable O, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires IndirectlyCopyable<iterator_t<R>, O>
+template<input_range R, weakly_incrementable O, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::remove_copy_if_result<safe_iterator_t<R>, O>
     ranges::remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -5132,12 +5138,12 @@
                          ForwardIterator first, ForwardIterator last,
                          BinaryPredicate pred);
 
-template<Permutable I, Sentinel<I> S, class Proj = identity,
-         IndirectRelation<projected<I, Proj>> C = ranges::equal_to>
+template<permutable I, sentinel_for<I> S, class Proj = identity,
+         indirect_relation<projected<I, Proj>> C = ranges::equal_to>
   constexpr I ranges::unique(I first, S last, C comp = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectRelation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
-  requires Permutable<iterator_t<R>>
+template<forward_range R, class Proj = identity,
+         indirect_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires permutable<iterator_t<R>>
   constexpr safe_iterator_t<R>
     ranges::unique(R&& r, C comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -5206,20 +5212,20 @@
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, BinaryPredicate pred);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-         class Proj = identity, IndirectRelation<projected<I, Proj>> C = ranges::equal_to>
-  requires IndirectlyCopyable<I, O> &&
-           (ForwardIterator<I> ||
-            (InputIterator<O> && Same<iter_value_t<I>, iter_value_t<O>>) ||
-            IndirectlyCopyableStorable<I, O>)
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         class Proj = identity, indirect_relation<projected<I, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<I, O> &&
+           (forward_iterator<I> ||
+            (input_iterator<O> && same_to<iter_value_t<I>, iter_value_t<O>>) ||
+             indirectly_copyable_storable<I, O>)
   constexpr ranges::unique_copy_result<I, O>
     ranges::unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
-template<InputRange R, WeaklyIncrementable O, class Proj = identity,
-         IndirectRelation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
-  requires IndirectlyCopyable<iterator_t<R>, O> &&
-           (ForwardIterator<iterator_t<R>> ||
-            (InputIterator<O> && Same<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
-            IndirectlyCopyableStorable<iterator_t<R>, O>)
+template<input_range R, weakly_incrementable O, class Proj = identity,
+         indirect_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<iterator_t<R>, O> &&
+           (forward_iterator<iterator_t<R>> ||
+            (input_iterator<O> && same_to<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
+             indirectly_copyable_storable<iterator_t<R>, O>)
   constexpr ranges::unique_copy_result<safe_iterator_t<R>, O>
     ranges::unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -5305,11 +5311,11 @@
   void reverse(ExecutionPolicy&& exec,
                BidirectionalIterator first, BidirectionalIterator last);
 
-template<BidirectionalIterator I, Sentinel<I> S>
-  requires Permutable<I>
+template<bidirectional_iterator I, sentinel_for<I> S>
+  requires permutable<I>
   constexpr I ranges::reverse(I first, S last);
-template<BidirectionalRange R>
-  requires Permutable<iterator_t<R>>
+template<bidirectional_range R>
+  requires permutable<iterator_t<R>>
   constexpr safe_iterator_t<R> ranges::reverse(R&& r);
 \end{itemdecl}
 
@@ -5348,12 +5354,12 @@
                  BidirectionalIterator first, BidirectionalIterator last,
                  ForwardIterator result);
 
-template<BidirectionalIterator I, Sentinel<I> S, WeaklyIncrementable O>
-  requires IndirectlyCopyable<I, O>
+template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
+  requires indirectly_copyable<I, O>
   constexpr ranges::reverse_copy_result<I, O>
     ranges::reverse_copy(I first, S last, O result);
-template<BidirectionalRange R, WeaklyIncrementable O>
-  requires IndirectlyCopyable<iterator_t<R>, O>
+template<bidirectional_range R, weakly_incrementable O>
+  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::reverse_copy_result<safe_iterator_t<R>, O>
     ranges::reverse_copy(R&& r, O result);
 \end{itemdecl}
@@ -5400,7 +5406,7 @@
     rotate(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 
-template<Permutable I, Sentinel<I> S>
+template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::rotate(I first, I middle, S last);
 \end{itemdecl}
 
@@ -5441,8 +5447,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template<ForwardRange R>
-  requires Permutable<iterator_t<R>>
+template<forward_range R>
+  requires permutable<iterator_t<R>>
   constexpr safe_subrange_t<R> ranges::rotate(R&& r, iterator_t<R> middle);
 \end{itemdecl}
 
@@ -5465,8 +5471,8 @@
                 ForwardIterator1 first, ForwardIterator1 middle, ForwardIterator1 last,
                 ForwardIterator2 result);
 
-  template<ForwardIterator I, Sentinel<I> S, WeaklyIncrementable O>
-    requires IndirectlyCopyable<I, O>
+  template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
+    requires indirectly_copyable<I, O>
     constexpr ranges::rotate_copy_result<I, O>
       ranges::rotate_copy(I first, I middle, S last, O result);
 \end{itemdecl}
@@ -5503,8 +5509,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template<ForwardRange R, WeaklyIncrementable O>
-  requires IndirectlyCopyable<iterator_t<R>, O>
+template<forward_range R, weakly_incrementable O>
+  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::rotate_copy_result<safe_iterator_t<R>, O>
     ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
 \end{itemdecl}
@@ -5596,13 +5602,13 @@
                RandomAccessIterator last,
                UniformRandomBitGenerator&& g);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Gen>
-  requires Permutable<I> &&
-           UniformRandomBitGenerator<remove_reference_t<Gen>>
+template<random_access_iterator I, sentinel_for<I> S, class Gen>
+  requires permutable<I> &&
+           uniform_random_bit_generator<remove_reference_t<Gen>>
   I ranges::shuffle(I first, S last, Gen&& g);
-template<RandomAccessRange R, class Gen>
-  requires Permutable<iterator_t<R>> &&
-           UniformRandomBitGenerator<remove_reference_t<Gen>>
+template<random_access_range R, class Gen>
+  requires permutable<iterator_t<R>> &&
+           uniform_random_bit_generator<remove_reference_t<Gen>>
   safe_iterator_t<R> ranges::shuffle(R&& r, Gen&& g);
 \end{itemdecl}
 
@@ -5827,13 +5833,13 @@
             RandomAccessIterator first, RandomAccessIterator last,
             Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -5886,12 +5892,12 @@
                    RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   safe_iterator_t<R>
     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -5958,9 +5964,9 @@
                     RandomAccessIterator last,
                     Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -6002,8 +6008,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -6049,19 +6055,19 @@
                       RandomAccessIterator result_last,
                       Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, RandomAccessIterator I2, Sentinel<I2> S2,
+template<input_iterator I1, sentinel_for<I1> S1, random_access_iterator I2, sentinel_for<I2> S2,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyCopyable<I1, I2> && Sortable<I2, Comp, Proj2> &&
-           IndirectStrictWeakOrder<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
+  requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
+           indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
   constexpr I2
     ranges::partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, RandomAccessRange R2, class Comp = ranges::less,
+template<input_range R1, random_access_range R2, class Comp = ranges::less,
          class Proj1 = identity, class Proj2 = identity>
-  requires IndirectlyCopyable<iterator_t<R1>, iterator_t<R2>> &&
-           Sortable<iterator_t<R2>, Comp, Proj2> &&
-           IndirectStrictWeakOrder<Comp, projected<iterator_t<R1>, Proj1>,
-                                   projected<iterator_t<R2>, Proj2>>
+  requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
+           sortable<iterator_t<R2>, Comp, Proj2> &&
+           indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
+                                      projected<iterator_t<R2>, Proj2>>
   constexpr safe_iterator_t<R2>
     ranges::partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -6181,11 +6187,11 @@
 
 \indexlibrary{\idxcode{is_sorted}}%
 \begin{itemdecl}
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<forward_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
 
@@ -6216,11 +6222,11 @@
                     ForwardIterator first, ForwardIterator last,
                     Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<forward_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr safe_iterator_t<R>
     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -6262,9 +6268,9 @@
                    RandomAccessIterator first, RandomAccessIterator nth,
                    RandomAccessIterator last, Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -6308,8 +6314,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -6351,12 +6357,12 @@
     lower_bound(ForwardIterator first, ForwardIterator last,
                 const T& value, Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::lower_bound(I first, S last, const T& value, Comp comp = {},
                                   Proj proj = {});
-template<ForwardRange R, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+template<forward_range R, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr safe_iterator_t<R>
     ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
@@ -6399,11 +6405,11 @@
     upper_bound(ForwardIterator first, ForwardIterator last,
                 const T& value, Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+template<forward_range R, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr safe_iterator_t<R>
     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
@@ -6447,12 +6453,12 @@
                 ForwardIterator last, const T& value,
                 Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr subrange<I>
     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+template<forward_range R, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr safe_subrange_t<R>
     ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
@@ -6511,12 +6517,12 @@
     binary_search(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr bool ranges::binary_search(I first, S last, const T& value, Comp comp = {},
                                        Proj proj = {});
-template<ForwardRange R, class T, class Proj = identity,
-         IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
+template<forward_range R, class T, class Proj = identity,
+         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
                                        Proj proj = {});
@@ -6561,11 +6567,11 @@
   bool is_partitioned(ExecutionPolicy&& exec,
                       ForwardIterator first, ForwardIterator last, Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
 
@@ -6596,13 +6602,13 @@
     partition(ExecutionPolicy&& exec,
               ForwardIterator first, ForwardIterator last, Predicate pred);
 
-template<Permutable I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<permutable I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I
     ranges::partition(I first, S last, Pred pred, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires Permutable<iterator_t<R>>
+template<forward_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
   constexpr safe_iterator_t<R>
     ranges::partition(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -6639,7 +6645,7 @@
   At most $N / 2$ swaps if the type of \tcode{first} meets
   the \oldconcept{BidirectionalIterator} requirements
   for the overloads in namespace \tcode{std} or
-  models \libconcept{BidirectionalIterator}
+  models \libconcept{bidirectional_iterator}
   for the overloads in namespace \tcode{ranges},
   and at most $N$ swaps otherwise.
 \item
@@ -6659,13 +6665,13 @@
     stable_partition(ExecutionPolicy&& exec,
                      BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
 
-template<BidirectionalIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
-  requires Permutable<I>
+template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires permutable<I>
   I ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
-template<BidirectionalRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires Permutable<iterator_t<R>>
+template<bidirectional_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
   safe_iterator_t<R> ranges::stable_partition(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
 
@@ -6725,17 +6731,17 @@
                    ForwardIterator first, ForwardIterator last,
                    ForwardIterator1 out_true, ForwardIterator2 out_false, Predicate pred);
 
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O1, WeaklyIncrementable O2,
-         class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
-  requires IndirectlyCopyable<I, O1> && IndirectlyCopyable<I, O2>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O1, weakly_incrementable O2,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
   constexpr ranges::partition_copy_result<I, O1, O2>
     ranges::partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
-                   Proj proj = {});
-template<InputRange R, WeaklyIncrementable O1, WeaklyIncrementable O2,
+                           Proj proj = {});
+template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
          class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
-  requires IndirectlyCopyable<iterator_t<R>, O1> &&
-           IndirectlyCopyable<iterator_t<R>, O2>
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, O1> &&
+           indirectly_copyable<iterator_t<R>, O2>
   constexpr ranges::partition_copy_result<safe_iterator_t<R>, O1, O2>
     ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -6787,11 +6793,11 @@
   constexpr ForwardIterator
     partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
 
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectUnaryPredicate<projected<I, Proj>> Pred>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::partition_point(I first, S last, Pred pred, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
+template<forward_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr safe_iterator_t<R>
     ranges::partition_point(R&& r, Pred pred, Proj proj = {});
 \end{itemdecl}
@@ -6852,16 +6858,16 @@
           ForwardIterator2 first2, ForwardIterator2 last2,
           ForwardIterator result, Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-         WeaklyIncrementable O, class Comp = ranges::less, class Proj1 = identity,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
          class Proj2 = identity>
-  requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
   constexpr ranges::merge_result<I1, I2, O>
     ranges::merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, WeaklyIncrementable O, class Comp = ranges::less,
+template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
          class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::merge_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
     ranges::merge(R1&& r1, R2&& r2, O result,
                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -6943,9 +6949,9 @@
                      BidirectionalIterator middle,
                      BidirectionalIterator last, Compare comp);
 
-template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
 
@@ -6995,8 +7001,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template<BidirectionalRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   safe_iterator_t<R>
     ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7043,16 +7049,16 @@
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          class Proj1 = identity, class Proj2 = identity,
-         IndirectStrictWeakOrder<projected<I1, Proj1>,
-                                 projected<I2, Proj2>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<I1, Proj1>,
+                                    projected<I2, Proj2>> Comp = ranges::less>
   constexpr bool ranges::includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
                                   Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, class Proj1 = identity,
+template<input_range R1, input_range R2, class Proj1 = identity,
          class Proj2 = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R1>, Proj1>,
-                                 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                    projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
   constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
                                   Proj1 proj1 = {}, Proj2 proj2 = {});
 \end{itemdecl}
@@ -7117,16 +7123,16 @@
               ForwardIterator2 first2, ForwardIterator2 last2,
               ForwardIterator result, Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-         WeaklyIncrementable O, class Comp = ranges::less,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         weakly_incrementable O, class Comp = ranges::less,
          class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
   constexpr ranges::set_union_result<I1, I2, O>
     ranges::set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_union_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
     ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -7212,16 +7218,16 @@
                      ForwardIterator2 first2, ForwardIterator2 last2,
                      ForwardIterator result, Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-         WeaklyIncrementable O, class Comp = ranges::less,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         weakly_incrementable O, class Comp = ranges::less,
          class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
   constexpr ranges::set_intersection_result<I1, I2, O>
     ranges::set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_intersection_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
     ranges::set_intersection(R1&& r1, R2&& r2, O result,
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -7305,16 +7311,16 @@
                    ForwardIterator2 first2, ForwardIterator2 last2,
                    ForwardIterator result, Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-         WeaklyIncrementable O, class Comp = ranges::less,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         weakly_incrementable O, class Comp = ranges::less,
          class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
   constexpr ranges::set_difference_result<I1, O>
     ranges::set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_difference_result<safe_iterator_t<R1>, O>
     ranges::set_difference(R1&& r1, R2&& r2, O result,
                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -7399,17 +7405,17 @@
                              ForwardIterator2 first2, ForwardIterator2 last2,
                              ForwardIterator result, Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
-         WeaklyIncrementable O, class Comp = ranges::less,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         weakly_incrementable O, class Comp = ranges::less,
          class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
   constexpr ranges::set_symmetric_difference_result<I1, I2, O>
     ranges::set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                                      Comp comp = {}, Proj1 proj1 = {},
                                      Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, WeaklyIncrementable O,
+template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
-  requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_symmetric_difference_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
     ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                      Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -7506,13 +7512,13 @@
   constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                            Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7557,13 +7563,13 @@
   constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                           Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7615,13 +7621,13 @@
   constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                            Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7664,13 +7670,13 @@
   constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
                            Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr I
     ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+template<random_access_range R, class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr safe_iterator_t<R>
     ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7769,11 +7775,11 @@
 
 \indexlibrary{\idxcode{is_heap}}%
 \begin{itemdecl}
-template<RandomAccessIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<random_access_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
 
@@ -7804,11 +7810,11 @@
                   RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp);
 
-template<RandomAccessIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
-template<RandomAccessRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<random_access_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr safe_iterator_t<R>
     ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7841,7 +7847,7 @@
   constexpr const T& min(const T& a, const T& b, Compare comp);
 
 template<class T, class Proj = identity,
-         IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
   constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
 
@@ -7874,12 +7880,12 @@
 template<class T, class Compare>
   constexpr T min(initializer_list<T> r, Compare comp);
 
-template<Copyable T, class Proj = identity,
-         IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+template<copyable T, class Proj = identity,
+         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
   constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-  requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
+template<input_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  requires indirectly_copyable_storable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
   constexpr iter_value_t<iterator_t<R>>
     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7918,7 +7924,7 @@
   constexpr const T& max(const T& a, const T& b, Compare comp);
 
 template<class T, class Proj = identity,
-         IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
   constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
 
@@ -7951,12 +7957,12 @@
 template<class T, class Compare>
   constexpr T max(initializer_list<T> r, Compare comp);
 
-template<Copyable T, class Proj = identity,
-         IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+template<copyable T, class Proj = identity,
+         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
   constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-  requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
+template<input_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  requires indirectly_copyable_storable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
   constexpr iter_value_t<iterator_t<R>>
     ranges::max(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -7995,7 +8001,7 @@
   constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
 
 template<class T, class Proj = identity,
-         IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
   constexpr ranges::minmax_result<const T&>
     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -8030,13 +8036,13 @@
 template<class T, class Compare>
   constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
 
-template<Copyable T, class Proj = identity,
-         IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
+template<copyable T, class Proj = identity,
+         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
   constexpr ranges::minmax_result<T>
     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
-template<InputRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-  requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
+template<input_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  requires indirectly_copyable_storable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
   constexpr ranges::minmax_result<iter_value_t<iterator_t<R>>>
     ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -8087,11 +8093,11 @@
                               ForwardIterator first, ForwardIterator last,
                               Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<forward_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr safe_iterator_t<R>
     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -8134,11 +8140,11 @@
                               ForwardIterator first, ForwardIterator last,
                               Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<forward_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr safe_iterator_t<R>
     ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -8183,12 +8189,12 @@
     minmax_element(ExecutionPolicy&& exec,
                    ForwardIterator first, ForwardIterator last, Compare comp);
 
-template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
-         IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr ranges::minmax_result<I>
     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
-template<ForwardRange R, class Proj = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+template<forward_range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr ranges::minmax_result<safe_iterator_t<R>>
     ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -8271,17 +8277,17 @@
                             ForwardIterator2 first2, ForwardIterator2 last2,
                             Compare comp);
 
-template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          class Proj1 = identity, class Proj2 = identity,
-         IndirectStrictWeakOrder<projected<I1, Proj1>,
-                                 projected<I2, Proj2>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<I1, Proj1>,
+                                    projected<I2, Proj2>> Comp = ranges::less>
   constexpr bool
     ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
-template<InputRange R1, InputRange R2, class Proj1 = identity,
+template<input_range R1, input_range R2, class Proj1 = identity,
          class Proj2 = identity,
-         IndirectStrictWeakOrder<projected<iterator_t<R1>, Proj1>,
-                                 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+         indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                    projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
   constexpr bool
     ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
@@ -8427,14 +8433,14 @@
   constexpr bool next_permutation(BidirectionalIterator first,
                                   BidirectionalIterator last, Compare comp);
 
-template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr bool
     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
-template<BidirectionalRange R, class Comp = ranges::less,
+template<bidirectional_range R, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr bool
     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
@@ -8480,14 +8486,14 @@
   constexpr bool prev_permutation(BidirectionalIterator first,
                                   BidirectionalIterator last, Compare comp);
 
-template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
+template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<I, Comp, Proj>
+  requires sortable<I, Comp, Proj>
   constexpr bool
     ranges::prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
-template<BidirectionalRange R, class Comp = ranges::less,
+template<bidirectional_range R, class Comp = ranges::less,
          class Proj = identity>
-  requires Sortable<iterator_t<R>, Comp, Proj>
+  requires sortable<iterator_t<R>, Comp, Proj>
   constexpr bool
     ranges::prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
 \end{itemdecl}
diff --git a/source/concepts.tex b/source/concepts.tex
index d235330af3..6f3e52d1c3 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -147,116 +147,116 @@
 \begin{codeblock}
 namespace std {
   // \ref{concepts.lang}, language-related concepts
-  // \ref{concept.same}, concept \libconcept{Same}
+  // \ref{concept.same}, concept \libconcept{same_to}
   template<class T, class U>
-    concept Same = @\seebelow@;
+    concept same_to = @\seebelow@;
 
-  // \ref{concept.derivedfrom}, concept \libconcept{DerivedFrom}
+  // \ref{concept.derivedfrom}, concept \libconcept{derived_from}
   template<class Derived, class Base>
-    concept DerivedFrom = @\seebelow@;
+    concept derived_from = @\seebelow@;
 
-  // \ref{concept.convertibleto}, concept \libconcept{ConvertibleTo}
+  // \ref{concept.convertibleto}, concept \libconcept{convertible_to}
   template<class From, class To>
-    concept ConvertibleTo = @\seebelow@;
+    concept convertible_to = @\seebelow@;
 
-  // \ref{concept.commonref}, concept \libconcept{CommonReference}
+  // \ref{concept.commonref}, concept \libconcept{common_reference_with}
   template<class T, class U>
-    concept CommonReference = @\seebelow@;
+    concept common_reference_with = @\seebelow@;
 
-  // \ref{concept.common}, concept \libconcept{Common}
+  // \ref{concept.common}, concept \libconcept{common_with}
   template<class T, class U>
-    concept Common = @\seebelow@;
+    concept common_with = @\seebelow@;
 
   // \ref{concepts.integral}, integral concepts
   template<class T>
-    concept Integral = @\seebelow@;
+    concept integral = @\seebelow@;
   template<class T>
-    concept SignedIntegral = @\seebelow@;
+    concept signed_integral = @\seebelow@;
   template<class T>
-    concept UnsignedIntegral = @\seebelow@;
+    concept unsigned_integral = @\seebelow@;
 
-  // \ref{concept.assignable}, concept \libconcept{Assignable}
+  // \ref{concept.assignable}, concept \libconcept{assignable_from}
   template<class LHS, class RHS>
-    concept Assignable = @\seebelow@;
+    concept assignable_from = @\seebelow@;
 
-  // \ref{concept.swappable}, concept \libconcept{Swappable}
+  // \ref{concept.swappable}, concept \libconcept{swappable}
   namespace ranges {
     inline namespace @\unspec@ {
       inline constexpr @\unspec@ swap = @\unspec@;
     }
   }
   template<class T>
-    concept Swappable = @\seebelow@;
+    concept swappable = @\seebelow@;
   template<class T, class U>
-    concept SwappableWith = @\seebelow@;
+    concept swappable_with = @\seebelow@;
 
-  // \ref{concept.destructible}, concept \libconcept{Destructible}
+  // \ref{concept.destructible}, concept \libconcept{destructible}
   template<class T>
-    concept Destructible = @\seebelow@;
+    concept destructible = @\seebelow@;
 
-  // \ref{concept.constructible}, concept \libconcept{Constructible}
+  // \ref{concept.constructible}, concept \libconcept{constructible_from}
   template<class T, class... Args>
-    concept Constructible = @\seebelow@;
+    concept constructible_from = @\seebelow@;
 
-  // \ref{concept.defaultconstructible}, concept \libconcept{DefaultConstructible}
+  // \ref{concept.defaultconstructible}, concept \libconcept{default_constructible}
   template<class T>
-    concept DefaultConstructible = @\seebelow@;
+    concept default_constructible = @\seebelow@;
 
-  // \ref{concept.moveconstructible}, concept \libconcept{MoveConstructible}
+  // \ref{concept.moveconstructible}, concept \libconcept{move_constructible}
   template<class T>
-    concept MoveConstructible = @\seebelow@;
+    concept move_constructible = @\seebelow@;
 
-  // \ref{concept.copyconstructible}, concept \libconcept{CopyConstructible}
+  // \ref{concept.copyconstructible}, concept \libconcept{copy_constructible}
   template<class T>
-    concept CopyConstructible = @\seebelow@;
+    concept copy_constructible = @\seebelow@;
 
   // \ref{concepts.compare}, comparison concepts
-  // \ref{concept.boolean}, concept \libconcept{Boolean}
+  // \ref{concept.boolean}, concept \libconcept{boolean}
   template<class B>
-    concept Boolean = @\seebelow@;
+    concept boolean = @\seebelow@;
 
-  // \ref{concept.equalitycomparable}, concept \libconcept{EqualityComparable}
+  // \ref{concept.equalitycomparable}, concept \libconcept{equality_comparable}
   template<class T>
-    concept EqualityComparable = @\seebelow@;
+    concept equality_comparable = @\seebelow@;
   template<class T, class U>
-    concept EqualityComparableWith = @\seebelow@;
+    concept equality_comparable_with = @\seebelow@;
 
-  // \ref{concept.stricttotallyordered}, concept \libconcept{StrictTotallyOrdered}
+  // \ref{concept.stricttotallyordered}, concept \libconcept{totally_ordered}
   template<class T>
-    concept StrictTotallyOrdered = @\seebelow@;
+    concept totally_ordered = @\seebelow@;
   template<class T, class U>
-    concept StrictTotallyOrderedWith = @\seebelow@;
+    concept totally_ordered_with = @\seebelow@;
 
   // \ref{concepts.object}, object concepts
   template<class T>
-    concept Movable = @\seebelow@;
+    concept movable = @\seebelow@;
   template<class T>
-    concept Copyable = @\seebelow@;
+    concept copyable = @\seebelow@;
   template<class T>
-    concept Semiregular = @\seebelow@;
+    concept semiregular = @\seebelow@;
   template<class T>
-    concept Regular = @\seebelow@;
+    concept regular = @\seebelow@;
 
   // \ref{concepts.callable}, callable concepts
-  // \ref{concept.invocable}, concept \libconcept{Invocable}
+  // \ref{concept.invocable}, concept \libconcept{invocable}
   template<class F, class... Args>
-    concept Invocable = @\seebelow@;
+    concept invocable = @\seebelow@;
 
-  // \ref{concept.regularinvocable}, concept \libconcept{RegularInvocable}
+  // \ref{concept.regularinvocable}, concept \libconcept{regular_invocable}
   template<class F, class... Args>
-    concept RegularInvocable = @\seebelow@;
+    concept regular_invocable = @\seebelow@;
 
-  // \ref{concept.predicate}, concept \libconcept{Predicate}
+  // \ref{concept.predicate}, concept \libconcept{predicate}
   template<class F, class... Args>
-    concept Predicate = @\seebelow@;
+    concept predicate = @\seebelow@;
 
-  // \ref{concept.relation}, concept \libconcept{Relation}
+  // \ref{concept.relation}, concept \libconcept{relation}
   template<class R, class T, class U>
-    concept Relation = @\seebelow@;
+    concept relation = @\seebelow@;
 
-  // \ref{concept.strictweakorder}, concept \libconcept{StrictWeakOrder}
+  // \ref{concept.strictweakorder}, concept \libconcept{strict_weak_order}
   template<class R, class T, class U>
-    concept StrictWeakOrder = @\seebelow@;
+    concept strict_weak_order = @\seebelow@;
 }
 \end{codeblock}
 
@@ -269,31 +269,31 @@
 features. These concepts express relationships between types, type
 classifications, and fundamental type properties.
 
-\rSec2[concept.same]{Concept \libconcept{Same}}
+\rSec2[concept.same]{Concept \libconcept{same_to}}
 
-\indexlibrary{\idxcode{Same}}%
+\indexlibrary{\idxcode{same_to}}%
 \begin{itemdecl}
 template<class T, class U>
   concept @\placeholdernc{same-impl}@ = is_same_v<T, U>;    // \expos
 
 template<class T, class U>
-  concept Same = @\placeholdernc{same-impl}@<T, U> && @\placeholdernc{same-impl}@<U, T>;
+  concept same_to = @\placeholdernc{same-impl}@<T, U> && @\placeholdernc{same-impl}@<U, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \begin{note}
-\tcode{\libconcept{Same}<T, U>} subsumes \tcode{\libconcept{Same}<U, T>} and
+\tcode{\libconcept{same_to}<T, U>} subsumes \tcode{\libconcept{same_to}<U, T>} and
 vice versa.
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.derivedfrom]{Concept \libconcept{DerivedFrom}}
+\rSec2[concept.derivedfrom]{Concept \libconcept{derived_from}}
 
-\indexlibrary{\idxcode{DerivedFrom}}%
+\indexlibrary{\idxcode{derived_from}}%
 \begin{itemdecl}
 template<class Derived, class Base>
-  concept DerivedFrom =
+  concept derived_from =
     is_base_of_v<Base, Derived> &&
     is_convertible_v<const volatile Derived*, const volatile Base*>;
 \end{itemdecl}
@@ -301,24 +301,24 @@
 \begin{itemdescr}
 \pnum
 \begin{note}
-\tcode{\libconcept{DerivedFrom}<Derived, Base>} is satisfied if and only if
+\tcode{\libconcept{derived_from}<Derived, Base>} is satisfied if and only if
 \tcode{Derived} is publicly and unambiguously derived from \tcode{Base}, or
 \tcode{Derived} and \tcode{Base} are the same class type ignoring cv-qualifiers.
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.convertibleto]{Concept \libconcept{ConvertibleTo}}
+\rSec2[concept.convertibleto]{Concept \libconcept{convertible_to}}
 
 \pnum
-The \libconcept{ConvertibleTo} concept requires an expression of a particular
+The \libconcept{convertible_to} concept requires an expression of a particular
 type and value category to be both implicitly and explicitly convertible to some
 other type. The implicit and explicit conversions are required to produce equal
 results.
 
-\indexlibrary{\idxcode{ConvertibleTo}}%
+\indexlibrary{\idxcode{convertible_to}}%
 \begin{itemdecl}
 template<class From, class To>
-  concept ConvertibleTo =
+  concept convertible_to =
     is_convertible_v<From, To> &&
     requires(From (&f)()) {
       static_cast<To>(f());
@@ -336,7 +336,7 @@
 for some types \tcode{From} and \tcode{To},
 and let \tcode{f} be a function with no arguments and return type \tcode{From}
 such that \tcode{f()} is equality-preserving.
-\tcode{From} and \tcode{To} model \tcode{\libconcept{ConvertibleTo}<From, To>}
+\tcode{From} and \tcode{To} model \tcode{\libconcept{convertible_to}<From, To>}
 only if:
 
 \begin{itemize}
@@ -361,14 +361,14 @@
 \end{itemdescr}
 
 
-\rSec2[concept.commonref]{Concept \libconcept{CommonReference}}
+\rSec2[concept.commonref]{Concept \libconcept{common_reference_with}}
 
 \pnum
 For two types \tcode{T} and \tcode{U}, if \tcode{common_reference_t<T, U>}
 is well-formed and denotes a type \tcode{C} such that both
-\tcode{\libconcept{ConvertibleTo}<T, C>}
+\tcode{\libconcept{convertible_to}<T, C>}
 and
-\tcode{\libconcept{ConvertibleTo}<U, C>}
+\tcode{\libconcept{convertible_to}<U, C>}
 are modeled, then \tcode{T} and \tcode{U} share a
 \term{common reference type}, \tcode{C}.
 \begin{note}
@@ -376,13 +376,13 @@
 different type. \tcode{C} may be a reference type.
 \end{note}
 
-\indexlibrary{\idxcode{CommonReference}}%
+\indexlibrary{\idxcode{common_reference_with}}%
 \begin{itemdecl}
 template<class T, class U>
-  concept CommonReference =
-    Same<common_reference_t<T, U>, common_reference_t<U, T>> &&
-    ConvertibleTo<T, common_reference_t<T, U>> &&
-    ConvertibleTo<U, common_reference_t<T, U>>;
+  concept common_reference_with =
+    same_to<common_reference_t<T, U>, common_reference_t<U, T>> &&
+    convertible_to<T, common_reference_t<T, U>> &&
+    convertible_to<U, common_reference_t<T, U>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -393,7 +393,7 @@
 \tcode{decltype((t1))} and \tcode{decltype((t2))} are each \tcode{T}, and
 let \tcode{u1} and \tcode{u2} be equality-preserving expressions such that
 \tcode{decltype((u1))} and \tcode{decltype((u2))} are each \tcode{U}.
-\tcode{T} and \tcode{U} model \tcode{\libconcept{CommonReference}<T, U>}
+\tcode{T} and \tcode{U} model \tcode{\libconcept{common_reference_with}<T, U>}
 only if:
 \begin{itemize}
 \item \tcode{C(t1)} equals \tcode{C(t2)} if and only if
@@ -404,12 +404,12 @@
 
 \pnum
 \begin{note}
-Users can customize the behavior of \libconcept{CommonReference} by specializing
+Users can customize the behavior of \libconcept{common_reference_with} by specializing
 the \tcode{basic_common_reference} class template\iref{meta.trans.other}.
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.common]{Concept \libconcept{Common}}
+\rSec2[concept.common]{Concept \libconcept{common_with}}
 
 \pnum
 If \tcode{T} and \tcode{U} can both be explicitly converted to some third type,
@@ -420,19 +420,19 @@
 different type. \tcode{C} might not be unique.
 \end{note}
 
-\indexlibrary{\idxcode{Common}}%
+\indexlibrary{\idxcode{common_with}}%
 \begin{itemdecl}
 template<class T, class U>
-  concept Common =
-    Same<common_type_t<T, U>, common_type_t<U, T>> &&
+  concept common_with =
+    same_to<common_type_t<T, U>, common_type_t<U, T>> &&
     requires {
       static_cast<common_type_t<T, U>>(declval<T>());
       static_cast<common_type_t<T, U>>(declval<U>());
     } &&
-    CommonReference<
+    common_reference_with<
       add_lvalue_reference_t<const T>,
       add_lvalue_reference_t<const U>> &&
-    CommonReference<
+    common_reference_with<
       add_lvalue_reference_t<common_type_t<T, U>>,
       common_reference_t<
         add_lvalue_reference_t<const T>,
@@ -447,7 +447,7 @@
 \tcode{decltype((t1))} and \tcode{decltype((t2))} are each \tcode{T}, and
 let \tcode{u1} and \tcode{u2} be equality-preserving expressions such that
 \tcode{decltype((u1))} and \tcode{decltype((u2))} are each \tcode{U}.
-\tcode{T} and \tcode{U} model \tcode{\libconcept{Common}<T, U>}
+\tcode{T} and \tcode{U} model \tcode{\libconcept{common_with}<T, U>}
 only if:
 \begin{itemize}
 \item \tcode{C(t1)} equals \tcode{C(t2)} if and only if
@@ -458,7 +458,7 @@
 
 \pnum
 \begin{note}
-Users can customize the behavior of \libconcept{Common} by specializing the
+Users can customize the behavior of \libconcept{common_with} by specializing the
 \tcode{common_type} class template\iref{meta.trans.other}.
 \end{note}
 
@@ -466,42 +466,42 @@
 
 \rSec2[concepts.integral]{Integral concepts}
 
-\indexlibrary{\idxcode{Integral}}%
-\indexlibrary{\idxcode{SignedIntegral}}%
-\indexlibrary{\idxcode{UnsignedIntegral}}%
+\indexlibrary{\idxcode{integral}}%
+\indexlibrary{\idxcode{signed_integral}}%
+\indexlibrary{\idxcode{unsigned_integral}}%
 \begin{itemdecl}
 template<class T>
-  concept Integral = is_integral_v<T>;
+  concept integral = is_integral_v<T>;
 template<class T>
-  concept SignedIntegral = Integral<T> && is_signed_v<T>;
+  concept signed_integral = integral<T> && is_signed_v<T>;
 template<class T>
-  concept UnsignedIntegral = Integral<T> && !SignedIntegral<T>;
+  concept unsigned_integral = integral<T> && !signed_integral<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \begin{note}
-\libconcept{SignedIntegral} can be modeled even by types that are
+\libconcept{signed_integral} can be modeled even by types that are
 not signed integral types\iref{basic.fundamental}; for example, \tcode{char}.
 \end{note}
 
 \pnum
 \begin{note}
-\libconcept{UnsignedIntegral} can be modeled even by types that are
+\libconcept{unsigned_integral} can be modeled even by types that are
 not unsigned integral types\iref{basic.fundamental}; for example, \tcode{bool}.
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.assignable]{Concept \libconcept{Assignable}}
+\rSec2[concept.assignable]{Concept \libconcept{assignable_from}}
 
-\indexlibrary{\idxcode{Assignable}}%
+\indexlibrary{\idxcode{assignable_from}}%
 \begin{itemdecl}
 template<class LHS, class RHS>
-  concept Assignable =
+  concept assignable_from =
     is_lvalue_reference_v<LHS> &&
-    CommonReference<const remove_reference_t<LHS>&, const remove_reference_t<RHS>&> &&
+    common_reference_with<const remove_reference_t<LHS>&, const remove_reference_t<RHS>&> &&
     requires(LHS lhs, RHS&& rhs) {
-      { lhs = std::forward<RHS>(rhs) } -> Same<LHS>;
+      { lhs = std::forward<RHS>(rhs) } -> same_to<LHS>;
     };
 \end{itemdecl}
 
@@ -516,7 +516,7 @@
 \item \tcode{rcopy} be a distinct object that is equal to \tcode{rhs}.
 \end{itemize}
 \tcode{LHS} and \tcode{RHS} model
-\tcode{\libconcept{Assignable}<LHS, RHS>} only if
+\tcode{\libconcept{assignable_from}<LHS, RHS>} only if
 
 \begin{itemize}
 \item \tcode{addressof(lhs = rhs) == addressof(lcopy)}.
@@ -544,7 +544,7 @@
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.swappable]{Concept \libconcept{Swappable}}
+\rSec2[concept.swappable]{Concept \libconcept{swappable}}
 
 \pnum
 Let \tcode{t1} and \tcode{t2} be equality-preserving expressions that denote
@@ -561,7 +561,7 @@
   is that \tcode{t1} equals \tcode{u2} and \tcode{u1} equals \tcode{t2}.
 
 \item If \tcode{T} and \tcode{U} are different types that model
-  \tcode{\libconcept{CommonReference}<const T\&, const U\&>},
+  \tcode{\libconcept{common_reference_with}<const T\&, const U\&>},
   the result of the operation is that
   \tcode{C(t1)} equals \tcode{C(u2)}
   and
@@ -605,8 +605,8 @@
 
 \item
   Otherwise, if \tcode{E1} and \tcode{E2} are lvalues of the
-  same type \tcode{T} that models \tcode{\libconcept{MoveConstructible}<T>} and
-  \tcode{\libconcept{Assignable}<T\&, T>},
+  same type \tcode{T} that models \tcode{\libconcept{move_constructible}<T>} and
+  \tcode{\libconcept{assignable_from}<T\&, T>},
   \tcode{S} is an expression that exchanges the denoted values.
   \tcode{S} is a constant expression if
   \begin{itemize}
@@ -639,17 +639,17 @@
 \tcode{E1} and \tcode{E2} and has type \tcode{void}.
 \end{note}
 
-\indexlibrary{\idxcode{Swappable}}%
+\indexlibrary{\idxcode{swappable}}%
 \begin{itemdecl}
 template<class T>
-  concept Swappable = requires(T& a, T& b) { ranges::swap(a, b); };
+  concept swappable = requires(T& a, T& b) { ranges::swap(a, b); };
 \end{itemdecl}
 
-\indexlibrary{\idxcode{SwappableWith}}%
+\indexlibrary{\idxcode{swappable_with}}%
 \begin{itemdecl}
 template<class T, class U>
-  concept SwappableWith =
-    CommonReference<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
+  concept swappable_with =
+    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
     requires(T&& t, U&& u) {
       ranges::swap(std::forward<T>(t), std::forward<T>(t));
       ranges::swap(std::forward<U>(u), std::forward<U>(u));
@@ -660,7 +660,7 @@
 
 \pnum
 \begin{note}
-The semantics of the \libconcept{Swappable} and \libconcept{SwappableWith}
+The semantics of the \libconcept{swappable} and \libconcept{swappable_with}
 concepts are fully defined by the \tcode{ranges::swap} customization point.
 \end{note}
 
@@ -675,12 +675,12 @@
 
 namespace ranges = std::ranges;
 
-template<class T, std::SwappableWith<T> U>
+template<class T, std::swappable_with<T> U>
 void value_swap(T&& t, U&& u) {
   ranges::swap(std::forward<T>(t), std::forward<U>(u));
 }
 
-template<std::Swappable T>
+template<std::swappable T>
 void lv_swap(T& t1, T& t2) {
   ranges::swap(t1, t2);
 }
@@ -708,17 +708,17 @@
 \end{codeblock}
 \end{example}
 
-\rSec2[concept.destructible]{Concept \libconcept{Destructible}}
+\rSec2[concept.destructible]{Concept \libconcept{destructible}}
 
 \pnum
-The \libconcept{Destructible} concept specifies properties of all types,
+The \libconcept{destructible} concept specifies properties of all types,
 instances of which can be destroyed at the end of their lifetime, or reference
 types.
 
-\indexlibrary{\idxcode{Destructible}}%
+\indexlibrary{\idxcode{destructible}}%
 \begin{itemdecl}
 template<class T>
-  concept Destructible = is_nothrow_destructible_v<T>;
+  concept destructible = is_nothrow_destructible_v<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -730,39 +730,39 @@
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.constructible]{Concept \libconcept{Constructible}}
+\rSec2[concept.constructible]{Concept \libconcept{constructible_from}}
 
 \pnum
-The \libconcept{Constructible} concept constrains the initialization of a
+The \libconcept{constructible_from} concept constrains the initialization of a
 variable of a given type with a particular set of argument types.
 
-\indexlibrary{\idxcode{Constructible}}%
+\indexlibrary{\idxcode{constructible_from}}%
 \begin{itemdecl}
 template<class T, class... Args>
-  concept Constructible = Destructible<T> && is_constructible_v<T, Args...>;
+  concept constructible_from = destructible<T> && is_constructible_v<T, Args...>;
 \end{itemdecl}
 
-\rSec2[concept.defaultconstructible]{Concept \libconcept{DefaultConstructible}}
+\rSec2[concept.defaultconstructible]{Concept \libconcept{default_constructible}}
 
-\indexlibrary{\idxcode{DefaultConstructible}}%
+\indexlibrary{\idxcode{default_constructible}}%
 \begin{itemdecl}
 template<class T>
-  concept DefaultConstructible = Constructible<T>;
+  concept default_constructible = constructible_from<T>;
 \end{itemdecl}
 
-\rSec2[concept.moveconstructible]{Concept \libconcept{MoveConstructible}}
+\rSec2[concept.moveconstructible]{Concept \libconcept{move_constructible}}
 
-\indexlibrary{\idxcode{MoveConstructible}}%
+\indexlibrary{\idxcode{move_constructible}}%
 \begin{itemdecl}
 template<class T>
-  concept MoveConstructible = Constructible<T, T> && ConvertibleTo<T, T>;
+  concept move_constructible = constructible_from<T, T> && convertible_to<T, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 If \tcode{T} is an object type, then let \tcode{rv} be an rvalue of type
 \tcode{T} and \tcode{u2} a distinct object of type \tcode{T} equal to
-\tcode{rv}. \tcode{T} models \libconcept{MoveConstructible} only if
+\tcode{rv}. \tcode{T} models \libconcept{move_constructible} only if
 
 \begin{itemize}
 \item After the definition \tcode{T u = rv;}, \tcode{u} is equal to \tcode{u2}.
@@ -774,23 +774,23 @@
 \end{itemize}
 \end{itemdescr}
 
-\rSec2[concept.copyconstructible]{Concept \libconcept{CopyConstructible}}
+\rSec2[concept.copyconstructible]{Concept \libconcept{copy_constructible}}
 
-\indexlibrary{\idxcode{CopyConstructible}}%
+\indexlibrary{\idxcode{copy_constructible}}%
 \begin{itemdecl}
 template<class T>
-  concept CopyConstructible =
-    MoveConstructible<T> &&
-    Constructible<T, T&> && ConvertibleTo<T&, T> &&
-    Constructible<T, const T&> && ConvertibleTo<const T&, T> &&
-    Constructible<T, const T> && ConvertibleTo<const T, T>;
+  concept copy_constructible =
+    move_constructible<T> &&
+    constructible_from<T, T&> && convertible_to<T&, T> &&
+    constructible_from<T, const T&> && convertible_to<const T&, T> &&
+    constructible_from<T, const T> && convertible_to<const T, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type
 (possibly \tcode{const}) \tcode{T} or an rvalue of type \tcode{const T}.
-\tcode{T} models \libconcept{CopyConstructible} only if
+\tcode{T} models \libconcept{copy_constructible} only if
 
 \begin{itemize}
 \item After the definition \tcode{T u = v;}, \tcode{u} is equal to \tcode{v}.
@@ -808,40 +808,40 @@
 This subclause describes concepts that establish relationships and orderings
 on values of possibly differing object types.
 
-\rSec2[concept.boolean]{Concept \libconcept{Boolean}}
+\rSec2[concept.boolean]{Concept \libconcept{boolean}}
 
 \pnum
-The \libconcept{Boolean} concept specifies the requirements on a type that is
+The \libconcept{boolean} concept specifies the requirements on a type that is
 usable in Boolean contexts.
 
-\indexlibrary{\idxcode{Boolean}}%
+\indexlibrary{\idxcode{boolean}}%
 \begin{itemdecl}
 template<class B>
-  concept Boolean =
-    Movable<remove_cvref_t<B>> && // (see \ref{concepts.object})
+  concept boolean =
+    movable<remove_cvref_t<B>> && // (see \ref{concepts.object})
     requires(const remove_reference_t<B>& b1,
              const remove_reference_t<B>& b2, const bool a) {
-      { b1 } -> ConvertibleTo<bool>;
-      { !b1 } -> ConvertibleTo<bool>;
-      { b1 &&  a } -> Same<bool>;
-      { b1 ||  a } -> Same<bool>;
-      { b1 && b2 } -> Same<bool>;
-      {  a && b2 } -> Same<bool>;
-      { b1 || b2 } -> Same<bool>;
-      {  a || b2 } -> Same<bool>;
-      { b1 == b2 } -> ConvertibleTo<bool>;
-      { b1 ==  a } -> ConvertibleTo<bool>;
-      {  a == b2 } -> ConvertibleTo<bool>;
-      { b1 != b2 } -> ConvertibleTo<bool>;
-      { b1 !=  a } -> ConvertibleTo<bool>;
-      {  a != b2 } -> ConvertibleTo<bool>;
+      { b1 } -> convertible_to<bool>;
+      { !b1 } -> convertible_to<bool>;
+      { b1 &&  a } -> same_to<bool>;
+      { b1 ||  a } -> same_to<bool>;
+      { b1 && b2 } -> same_to<bool>;
+      {  a && b2 } -> same_to<bool>;
+      { b1 || b2 } -> same_to<bool>;
+      {  a || b2 } -> same_to<bool>;
+      { b1 == b2 } -> convertible_to<bool>;
+      { b1 ==  a } -> convertible_to<bool>;
+      {  a == b2 } -> convertible_to<bool>;
+      { b1 != b2 } -> convertible_to<bool>;
+      { b1 !=  a } -> convertible_to<bool>;
+      {  a != b2 } -> convertible_to<bool>;
     };
 \end{itemdecl}
 
 \pnum
 For some type \tcode{B}, let \tcode{b1} and \tcode{b2} be
 lvalues of type \tcode{const remove_reference_t<B>}.
-\tcode{B} models \libconcept{Boolean} only if
+\tcode{B} models \libconcept{boolean} only if
 
 \begin{itemize}
 \item \tcode{bool(b1) == !bool(!b1)}.
@@ -864,22 +864,22 @@
 \pnum
 \begin{example}
 The types \tcode{bool}, \tcode{true_type}\iref{meta.type.synop}, and
-\tcode{bitset<$N$>::reference}\iref{template.bitset} are \libconcept{Boolean}
+\tcode{bitset<$N$>::reference}\iref{template.bitset} are \libconcept{boolean}
 types. Pointers, smart pointers, and types with only explicit conversions to
-\tcode{bool} are not \libconcept{Boolean} types.
+\tcode{bool} are not \libconcept{boolean} types.
 \end{example}
 
-\rSec2[concept.equalitycomparable]{Concept \libconcept{EqualityComparable}}
+\rSec2[concept.equalitycomparable]{Concept \libconcept{equality_comparable}}
 
 \begin{itemdecl}
 template<class T, class U>
   concept @\placeholder{weakly-equality-comparable-with}@ = // \expos
     requires(const remove_reference_t<T>& t,
              const remove_reference_t<U>& u) {
-      { t == u } -> Boolean;
-      { t != u } -> Boolean;
-      { u == t } -> Boolean;
-      { u != t } -> Boolean;
+      { t == u } -> boolean;
+      { t != u } -> boolean;
+      { u == t } -> boolean;
+      { u != t } -> boolean;
     };
 \end{itemdecl}
 
@@ -900,16 +900,16 @@
 \end{itemize}
 \end{itemdescr}
 
-\indexlibrary{\idxcode{EqualityComparable}}%
+\indexlibrary{\idxcode{equality_comparable}}%
 \begin{itemdecl}
 template<class T>
-  concept EqualityComparable = @\placeholder{weakly-equality-comparable-with}@<T, T>;
+  concept equality_comparable = @\placeholder{weakly-equality-comparable-with}@<T, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 Let \tcode{a} and \tcode{b} be objects of type \tcode{T}.
-\tcode{T} models \libconcept{EqualityComparable} only if
+\tcode{T} models \libconcept{equality_comparable} only if
 \tcode{bool(a == b)} is \tcode{true} when \tcode{a} is equal to
 \tcode{b}\iref{concepts.equality}, and \tcode{false} otherwise.
 
@@ -920,13 +920,13 @@
 \end{note}
 \end{itemdescr}
 
-\indexlibrary{\idxcode{EqualityComparableWith}}%
+\indexlibrary{\idxcode{equality_comparable_with}}%
 \begin{itemdecl}
 template<class T, class U>
-  concept EqualityComparableWith =
-    EqualityComparable<T> && EqualityComparable<U> &&
-    CommonReference<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
-    EqualityComparable<
+  concept equality_comparable_with =
+    equality_comparable<T> && equality_comparable<U> &&
+    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
+    equality_comparable<
       common_reference_t<
         const remove_reference_t<T>&,
         const remove_reference_t<U>&>> &&
@@ -943,23 +943,23 @@
 common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>
 \end{codeblock}
 \tcode{T} and \tcode{U} model
-\tcode{\libconcept{EqualityComparableWith}<T, U>} only if
+\tcode{\libconcept{equality_comparable_with}<T, U>} only if
 \tcode{bool(t == u) == bool(C(t) == C(u))}.
 \end{itemdescr}
 
-\rSec2[concept.stricttotallyordered]{Concept \libconcept{StrictTotallyOrdered}}
+\rSec2[concept.stricttotallyordered]{Concept \libconcept{totally_ordered}}
 
-\indexlibrary{\idxcode{StrictTotallyOrdered}}%
+\indexlibrary{\idxcode{totally_ordered}}%
 \begin{itemdecl}
 template<class T>
-  concept StrictTotallyOrdered =
-    EqualityComparable<T> &&
+  concept totally_ordered =
+    equality_comparable<T> &&
     requires(const remove_reference_t<T>& a,
              const remove_reference_t<T>& b) {
-      { a <  b } -> Boolean;
-      { a >  b } -> Boolean;
-      { a <= b } -> Boolean;
-      { a >= b } -> Boolean;
+      { a <  b } -> boolean;
+      { a >  b } -> boolean;
+      { a <= b } -> boolean;
+      { a >= b } -> boolean;
     };
 \end{itemdecl}
 
@@ -967,7 +967,7 @@
 \pnum
 For some type \tcode{T}, let \tcode{a}, \tcode{b}, and \tcode{c} be
 lvalues of type \tcode{const remove_reference_t<T>}.
-\tcode{T} models \libconcept{StrictTotallyOrdered} only if
+\tcode{T} models \libconcept{totally_ordered} only if
 
 \begin{itemize}
 \item Exactly one of \tcode{bool(a < b)}, \tcode{bool(a > b)}, or
@@ -983,24 +983,24 @@
 
 \begin{itemdecl}
 template<class T, class U>
-  concept StrictTotallyOrderedWith =
-    StrictTotallyOrdered<T> && StrictTotallyOrdered<U> &&
-    CommonReference<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
-    StrictTotallyOrdered<
+  concept totally_ordered_with =
+    totally_ordered<T> && totally_ordered<U> &&
+    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
+    totally_ordered<
       common_reference_t<
         const remove_reference_t<T>&,
         const remove_reference_t<U>&>> &&
-    EqualityComparableWith<T, U> &&
+    equality_comparable_with<T, U> &&
     requires(const remove_reference_t<T>& t,
              const remove_reference_t<U>& u) {
-      { t <  u } -> Boolean;
-      { t >  u } -> Boolean;
-      { t <= u } -> Boolean;
-      { t >= u } -> Boolean;
-      { u <  t } -> Boolean;
-      { u >  t } -> Boolean;
-      { u <= t } -> Boolean;
-      { u >= t } -> Boolean;
+      { t <  u } -> boolean;
+      { t >  u } -> boolean;
+      { t <= u } -> boolean;
+      { t >= u } -> boolean;
+      { u <  t } -> boolean;
+      { u >  t } -> boolean;
+      { u <= t } -> boolean;
+      { u >= t } -> boolean;
     };
 \end{itemdecl}
 
@@ -1014,7 +1014,7 @@
 common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>
 \end{codeblock}
 \tcode{T} and \tcode{U} model
-\tcode{\libconcept{StrictTotallyOrderedWith}<T, U>} only if
+\tcode{\libconcept{totally_ordered_with}<T, U>} only if
 
 \begin{itemize}
 \item \tcode{bool(t <  u) == bool(C(t) <  C(u)).}
@@ -1034,32 +1034,34 @@
 This subclause describes concepts that specify the basis of the
 value-oriented programming style on which the library is based.
 
-\indexlibrary{\idxcode{Movable}}%
-\indexlibrary{\idxcode{Copyable}}%
-\indexlibrary{\idxcode{Semiregular}}%
-\indexlibrary{\idxcode{Regular}}%
+\indexlibrary{\idxcode{movable}}%
+\indexlibrary{\idxcode{copyable}}%
+\indexlibrary{\idxcode{semiregular}}%
+\indexlibrary{\idxcode{regular}}%
 \begin{itemdecl}
 template<class T>
-  concept Movable = is_object_v<T> && MoveConstructible<T> && Assignable<T&, T> && Swappable<T>;
+  concept movable = is_object_v<T> && move_constructible<T> &&
+                    assignable_from<T&, T> && swappable<T>;
 template<class T>
-  concept Copyable = CopyConstructible<T> && Movable<T> && Assignable<T&, const T&>;
+  concept copyable = copy_constructible<T> && movable<T> &&
+                     assignable_from<T&, const T&>;
 template<class T>
-  concept Semiregular = Copyable<T> && DefaultConstructible<T>;
+  concept semiregular = copyable<T> && default_constructible<T>;
 template<class T>
-  concept Regular = Semiregular<T> && EqualityComparable<T>;
+  concept regular = semiregular<T> && equality_comparable<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \begin{note}
-The \libconcept{Semiregular} concept is modeled by types that behave similarly
+The \libconcept{semiregular} concept is modeled by types that behave similarly
 to built-in types like \tcode{int}, except that they might not
 be comparable with \tcode{==}.
 \end{note}
 
 \pnum
 \begin{note}
-The \libconcept{Regular} concept is modeled by types that behave similarly to
+The \libconcept{regular} concept is modeled by types that behave similarly to
 built-in types like \tcode{int} and that are comparable with
 \tcode{==}.
 \end{note}
@@ -1073,17 +1075,17 @@
 The concepts in this subclause describe the requirements on function
 objects\iref{function.objects} and their arguments.
 
-\rSec2[concept.invocable]{Concept \libconcept{Invocable}}
+\rSec2[concept.invocable]{Concept \libconcept{invocable}}
 
 \pnum
-The \libconcept{Invocable} concept specifies a relationship between a callable
+The \libconcept{invocable} concept specifies a relationship between a callable
 type\iref{func.def} \tcode{F} and a set of argument types \tcode{Args...} which
 can be evaluated by the library function \tcode{invoke}\iref{func.invoke}.
 
-\indexlibrary{\idxcode{Invocable}}%
+\indexlibrary{\idxcode{invocable}}%
 \begin{itemdecl}
 template<class F, class... Args>
-  concept Invocable = requires(F&& f, Args&&... args) {
+  concept invocable = requires(F&& f, Args&&... args) {
     invoke(std::forward<F>(f), std::forward<Args>(args)...); // not required to be equality-preserving
   };
 \end{itemdecl}
@@ -1091,18 +1093,18 @@
 \begin{itemdescr}
 \pnum
 \begin{example}
-A function that generates random numbers can model \libconcept{Invocable},
+A function that generates random numbers can model \libconcept{invocable},
 since the \tcode{invoke} function call expression is not required to be
 equality-preserving\iref{concepts.equality}.
 \end{example}
 \end{itemdescr}
 
-\rSec2[concept.regularinvocable]{Concept \libconcept{RegularInvocable}}
+\rSec2[concept.regularinvocable]{Concept \libconcept{regular_invocable}}
 
-\indexlibrary{\idxcode{RegularInvocable}}%
+\indexlibrary{\idxcode{regular_invocable}}%
 \begin{itemdecl}
 template<class F, class... Args>
-  concept RegularInvocable = Invocable<F, Args...>;
+  concept regular_invocable = invocable<F, Args...>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1112,50 +1114,50 @@
 arguments\iref{concepts.equality}.
 \begin{note}
 This requirement supersedes the annotation in the definition of
-\libconcept{Invocable}.
+\libconcept{invocable}.
 \end{note}
 
 \pnum
 \begin{example}
-A random number generator does not model \libconcept{RegularInvocable}.
+A random number generator does not model \libconcept{regular_invocable}.
 \end{example}
 
 \pnum
 \begin{note}
-The distinction between \libconcept{Invocable} and \libconcept{RegularInvocable}
+The distinction between \libconcept{invocable} and \libconcept{regular_invocable}
 is purely semantic.
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.predicate]{Concept \libconcept{Predicate}}
+\rSec2[concept.predicate]{Concept \libconcept{predicate}}
 
-\indexlibrary{\idxcode{Predicate}}%
+\indexlibrary{\idxcode{predicate}}%
 \begin{itemdecl}
 template<class F, class... Args>
-  concept Predicate = RegularInvocable<F, Args...> && Boolean<invoke_result_t<F, Args...>>;
+  concept predicate = regular_invocable<F, Args...> && boolean<invoke_result_t<F, Args...>>;
 \end{itemdecl}
 
-\rSec2[concept.relation]{Concept \libconcept{Relation}}
+\rSec2[concept.relation]{Concept \libconcept{relation}}
 
-\indexlibrary{\idxcode{Relation}}%
+\indexlibrary{\idxcode{relation}}%
 \begin{itemdecl}
 template<class R, class T, class U>
-  concept Relation =
-    Predicate<R, T, T> && Predicate<R, U, U> &&
-    Predicate<R, T, U> && Predicate<R, U, T>;
+  concept relation =
+    predicate<R, T, T> && predicate<R, U, U> &&
+    predicate<R, T, U> && predicate<R, U, T>;
 \end{itemdecl}
 
-\rSec2[concept.strictweakorder]{Concept \libconcept{StrictWeakOrder}}
+\rSec2[concept.strictweakorder]{Concept \libconcept{strict_weak_order}}
 
-\indexlibrary{\idxcode{Relation}}%
+\indexlibrary{\idxcode{strict_weak_order}}%
 \begin{itemdecl}
 template<class R, class T, class U>
-  concept StrictWeakOrder = Relation<R, T, U>;
+  concept strict_weak_order = relation<R, T, U>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-A \libconcept{Relation} models \libconcept{StrictWeakOrder} only if
+A \libconcept{relation} models \libconcept{strict_weak_order} only if
 it imposes a \term{strict weak ordering} on its arguments.
 
 \pnum
diff --git a/source/containers.tex b/source/containers.tex
index df227bfcd6..2424fdd9a9 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -456,7 +456,7 @@
 whose member types \tcode{iterator} and \tcode{const_iterator}
 meet the
 \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators} and
-model \libconcept{ContiguousIterator}\iref{iterator.concept.contiguous}.
+model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous}.
 
 \pnum
 \tref{container.opt} lists operations that are provided
@@ -10967,7 +10967,7 @@
 \begin{itemdescr}
 \pnum
 The types
-model \libconcept{ContiguousIterator}\iref{iterator.concept.contiguous},
+model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
 meet the \oldconcept{RandomAccessIterator}
 requirements\iref{random.access.iterators},
 and
diff --git a/source/expressions.tex b/source/expressions.tex
index b8401275c6..83df175a89 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -4934,7 +4934,7 @@
 
 \begin{example}
 \begin{codeblock}
-  void mergeable(int x) {
+  void can_merge(int x) {
     // These allocations are safe for merging:
     std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
     std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
@@ -4943,7 +4943,7 @@
     g(a.get(), b.get(), c.get());
   }
 
-  void unmergeable(int x) {
+  void cannot_merge(int x) {
     std::unique_ptr<char[]> a{new char[8]};
     try {
       // Merging this allocation would change its catch handler.
diff --git a/source/iterators.tex b/source/iterators.tex
index 625394b367..5ace8b9b90 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -81,128 +81,128 @@
     = decltype(ranges::iter_move(declval<T&>()));
 
   // \ref{iterator.concepts}, iterator concepts
-  // \ref{iterator.concept.readable}, concept \libconcept{Readable}
+  // \ref{iterator.concept.readable}, concept \libconcept{readable}
   template<class In>
-    concept Readable = @\seebelow@;
+    concept readable = @\seebelow@;
 
-  template<Readable T>
+  template<readable T>
     using iter_common_reference_t =
       common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
 
-  // \ref{iterator.concept.writable}, concept \libconcept{Writable}
+  // \ref{iterator.concept.writable}, concept \libconcept{writable}
   template<class Out, class T>
-    concept Writable = @\seebelow@;
+    concept writable = @\seebelow@;
 
-  // \ref{iterator.concept.winc}, concept \libconcept{WeaklyIncrementable}
+  // \ref{iterator.concept.winc}, concept \libconcept{weakly_incrementable}
   template<class I>
-    concept WeaklyIncrementable = @\seebelow@;
+    concept weakly_incrementable = @\seebelow@;
 
-  // \ref{iterator.concept.inc}, concept \libconcept{Incrementable}
+  // \ref{iterator.concept.inc}, concept \libconcept{incrementable}
   template<class I>
-    concept Incrementable = @\seebelow@;
+    concept incrementable = @\seebelow@;
 
-  // \ref{iterator.concept.iterator}, concept \libconcept{Iterator}
+  // \ref{iterator.concept.iterator}, concept \libconcept{input_or_output_iterator}
   template<class I>
-    concept Iterator = @\seebelow@;
+    concept input_or_output_iterator = @\seebelow@;
 
-  // \ref{iterator.concept.sentinel}, concept \libconcept{Sentinel}
+  // \ref{iterator.concept.sentinel}, concept \libconcept{sentinel_for}
   template<class S, class I>
-    concept Sentinel = @\seebelow@;
+    concept sentinel_for = @\seebelow@;
 
-  // \ref{iterator.concept.sizedsentinel}, concept \libconcept{SizedSentinel}
+  // \ref{iterator.concept.sizedsentinel}, concept \libconcept{sized_sentinel_for}
   template<class S, class I>
     inline constexpr bool disable_sized_sentinel = false;
 
   template<class S, class I>
-    concept SizedSentinel = @\seebelow@;
+    concept sized_sentinel_for = @\seebelow@;
 
-  // \ref{iterator.concept.input}, concept \libconcept{InputIterator}
+  // \ref{iterator.concept.input}, concept \libconcept{input_iterator}
   template<class I>
-    concept InputIterator = @\seebelow@;
+    concept input_iterator = @\seebelow@;
 
-  // \ref{iterator.concept.output}, concept \libconcept{OutputIterator}
+  // \ref{iterator.concept.output}, concept \libconcept{output_iterator}
   template<class I, class T>
-    concept OutputIterator = @\seebelow@;
+    concept output_iterator = @\seebelow@;
 
-  // \ref{iterator.concept.forward}, concept \libconcept{ForwardIterator}
+  // \ref{iterator.concept.forward}, concept \libconcept{forward_iterator}
   template<class I>
-    concept ForwardIterator = @\seebelow@;
+    concept forward_iterator = @\seebelow@;
 
-  // \ref{iterator.concept.bidir}, concept \libconcept{BidirectionalIterator}
+  // \ref{iterator.concept.bidir}, concept \libconcept{bidirectional_iterator}
   template<class I>
-    concept BidirectionalIterator = @\seebelow@;
+    concept bidirectional_iterator = @\seebelow@;
 
-  // \ref{iterator.concept.random.access}, concept \libconcept{RandomAccessIterator}
+  // \ref{iterator.concept.random.access}, concept \libconcept{random_access_iterator}
   template<class I>
-    concept RandomAccessIterator = @\seebelow@;
+    concept random_access_iterator = @\seebelow@;
 
-  // \ref{iterator.concept.contiguous}, concept \libconcept{ContiguousIterator}
+  // \ref{iterator.concept.contiguous}, concept \libconcept{contiguous_iterator}
   template<class I>
-    concept ContiguousIterator = @\seebelow@;
+    concept contiguous_iterator = @\seebelow@;
 
   // \ref{indirectcallable}, indirect callable requirements
   // \ref{indirectcallable.indirectinvocable}, indirect callables
   template<class F, class I>
-    concept IndirectUnaryInvocable = @\seebelow@;
+    concept indirectly_unary_invocable = @\seebelow@;
 
   template<class F, class I>
-    concept IndirectRegularUnaryInvocable = @\seebelow@;
+    concept indirectly_regular_unary_invocable = @\seebelow@;
 
   template<class F, class I>
-    concept IndirectUnaryPredicate = @\seebelow@;
+    concept indirect_unary_predicate = @\seebelow@;
 
   template<class F, class I1, class I2 = I1>
-    concept IndirectRelation = @\seebelow@;
+    concept indirect_relation = @\seebelow@;
 
   template<class F, class I1, class I2 = I1>
-    concept IndirectStrictWeakOrder = @\seebelow@;
+    concept indirect_strict_weak_order = @\seebelow@;
 
   template<class F, class... Is>
-    requires (Readable<Is> && ...) && Invocable<F, iter_reference_t<Is>...>
+    requires (readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
       using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;
 
   // \ref{projected}, projected
-  template<Readable I, IndirectRegularUnaryInvocable<I> Proj>
+  template<readable I, indirectly_regular_unary_invocable<I> Proj>
     struct projected;
 
-  template<WeaklyIncrementable I, class Proj>
+  template<weakly_incrementable I, class Proj>
     struct incrementable_traits<projected<I, Proj>>;
 
   // \ref{alg.req}, common algorithm requirements
-  // \ref{alg.req.ind.move}, concept \libconcept{IndirectlyMovable}
+  // \ref{alg.req.ind.move}, concept \libconcept{indirectly_movable}
   template<class In, class Out>
-    concept IndirectlyMovable = @\seebelow@;
+    concept indirectly_movable = @\seebelow@;
 
   template<class In, class Out>
-    concept IndirectlyMovableStorable = @\seebelow@;
+    concept indirectly_movable_storable = @\seebelow@;
 
-  // \ref{alg.req.ind.copy}, concept \libconcept{IndirectlyCopyable}
+  // \ref{alg.req.ind.copy}, concept \libconcept{indirectly_copyable}
   template<class In, class Out>
-    concept IndirectlyCopyable = @\seebelow@;
+    concept indirectly_copyable = @\seebelow@;
 
   template<class In, class Out>
-    concept IndirectlyCopyableStorable = @\seebelow@;
+    concept indirectly_copyable_storable = @\seebelow@;
 
-  // \ref{alg.req.ind.swap}, concept \libconcept{IndirectlySwappable}
+  // \ref{alg.req.ind.swap}, concept \libconcept{indirectly_swappable}
   template<class I1, class I2 = I1>
-    concept IndirectlySwappable = @\seebelow@;
+    concept indirectly_swappable = @\seebelow@;
 
-  // \ref{alg.req.ind.cmp}, concept \libconcept{IndirectlyComparable}
+  // \ref{alg.req.ind.cmp}, concept \libconcept{indirectly_comparable}
   template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
-    concept IndirectlyComparable = @\seebelow@;
+    concept indirectly_comparable = @\seebelow@;
 
-  // \ref{alg.req.permutable}, concept \libconcept{Permutable}
+  // \ref{alg.req.permutable}, concept \libconcept{permutable}
   template<class I>
-    concept Permutable = @\seebelow@;
+    concept permutable = @\seebelow@;
 
-  // \ref{alg.req.mergeable}, concept \libconcept{Mergeable}
+  // \ref{alg.req.mergeable}, concept \libconcept{mergeable}
   template<class I1, class I2, class Out,
       class R = ranges::less, class P1 = identity, class P2 = identity>
-    concept Mergeable = @\seebelow@;
+    concept mergeable = @\seebelow@;
 
-  // \ref{alg.req.sortable}, concept \libconcept{Sortable}
+  // \ref{alg.req.sortable}, concept \libconcept{sortable}
   template<class I, class R = ranges::less, class P = identity>
-    concept Sortable = @\seebelow@;
+    concept sortable = @\seebelow@;
 
   // \ref{iterator.primitives}, primitives
   // \ref{std.iterator.tags}, iterator tags
@@ -232,35 +232,35 @@
   // \ref{range.iter.ops}, range iterator operations
   namespace ranges {
     // \ref{range.iter.op.advance}, \tcode{ranges::advance}
-    template<Iterator I>
+    template<input_or_output_iterator I>
       constexpr void advance(I& i, iter_difference_t<I> n);
-    template<Iterator I, Sentinel<I> S>
+    template<input_or_output_iterator I, sentinel_for<I> S>
       constexpr void advance(I& i, S bound);
-    template<Iterator I, Sentinel<I> S>
+    template<input_or_output_iterator I, sentinel_for<I> S>
       constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound);
 
     // \ref{range.iter.op.distance}, \tcode{ranges::distance}
-    template<Iterator I, Sentinel<I> S>
+    template<input_or_output_iterator I, sentinel_for<I> S>
       constexpr iter_difference_t<I> distance(I first, S last);
-    template<Range R>
+    template<range R>
       constexpr iter_difference_t<iterator_t<R>> distance(R&& r);
 
     // \ref{range.iter.op.next}, \tcode{ranges::next}
-    template<Iterator I>
+    template<input_or_output_iterator I>
       constexpr I next(I x);
-    template<Iterator I>
+    template<input_or_output_iterator I>
       constexpr I next(I x, iter_difference_t<I> n);
-    template<Iterator I, Sentinel<I> S>
+    template<input_or_output_iterator I, sentinel_for<I> S>
       constexpr I next(I x, S bound);
-    template<Iterator I, Sentinel<I> S>
+    template<input_or_output_iterator I, sentinel_for<I> S>
       constexpr I next(I x, iter_difference_t<I> n, S bound);
 
     // \ref{range.iter.op.prev}, \tcode{ranges::prev}
-    template<BidirectionalIterator I>
+    template<bidirectional_iterator I>
       constexpr I prev(I x);
-    template<BidirectionalIterator I>
+    template<bidirectional_iterator I>
       constexpr I prev(I x, iter_difference_t<I> n);
-    template<BidirectionalIterator I>
+    template<bidirectional_iterator I>
       constexpr I prev(I x, iter_difference_t<I> n, I bound);
   }
 
@@ -307,7 +307,7 @@
     constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 
   template<class Iterator1, class Iterator2>
-      requires (!SizedSentinel<Iterator1, Iterator2>)
+      requires (!sized_sentinel_for<Iterator1, Iterator2>)
     inline constexpr bool disable_sized_sentinel<reverse_iterator<Iterator1>,
                                                  reverse_iterator<Iterator2>> = true;
 
@@ -358,17 +358,17 @@
   template<class Iterator>
     constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
 
-  template<Semiregular S> class move_sentinel;
+  template<semiregular S> class move_sentinel;
 
   // \ref{iterators.common}, common iterators
-  template<Iterator I, Sentinel<I> S>
-    requires (!Same<I, S>)
+  template<input_or_output_iterator I, sentinel_for<I> S>
+    requires (!same_to<I, S>)
       class common_iterator;
 
   template<class I, class S>
     struct incrementable_traits<common_iterator<I, S>>;
 
-  template<InputIterator I, class S>
+  template<input_iterator I, class S>
     struct iterator_traits<common_iterator<I, S>>;
 
   // \ref{default.sentinels}, default sentinels
@@ -376,12 +376,12 @@
   inline constexpr default_sentinel_t default_sentinel{};
 
   // \ref{iterators.counted}, counted iterators
-  template<Iterator I> class counted_iterator;
+  template<input_or_output_iterator I> class counted_iterator;
 
   template<class I>
     struct incrementable_traits<counted_iterator<I>>;
 
-  template<InputIterator I>
+  template<input_iterator I>
     struct iterator_traits<counted_iterator<I>>;
 
   // \ref{unreachable.sentinels}, unreachable sentinels
@@ -514,16 +514,16 @@
 
 \pnum
 The six categories of iterators correspond to the iterator concepts
-\libconcept{Input\-Iterator}\iref{iterator.concept.input},
-\libconcept{Output\-Iterator}\iref{iterator.concept.output},
-\libconcept{Forward\-Iterator}\iref{iterator.concept.forward},
-\libconcept{Bidirectional\-Iterator}\iref{iterator.concept.bidir}
-\libconcept{RandomAccess\-Iterator}\iref{iterator.concept.random.access},
+\libconcept{input_iterator}\iref{iterator.concept.input},
+\libconcept{out\-put_iterator}\iref{iterator.concept.output},
+\libconcept{forward_iterator}\iref{iterator.concept.forward},
+\libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}
+\libconcept{random_ac\-cess_iterator}\iref{iterator.concept.random.access},
 and
-\libconcept{Contiguous\-Iterator}\iref{iterator.concept.contiguous},
+\libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
 respectively.
 The generic term \defn{iterator} refers to any type that models the
-\libconcept{Iterator} concept\iref{iterator.concept.iterator}.
+\libconcept{input_or_output_iterator} concept\iref{iterator.concept.iterator}.
 
 \pnum
 Forward iterators meet all the requirements of input
@@ -669,7 +669,7 @@
 it is often necessary to determine the difference type that
 corresponds to a particular incrementable type. Accordingly,
 it is required that if \tcode{WI} is the name of a type that models the
-\libconcept{WeaklyIncrementable} concept\iref{iterator.concept.winc},
+\libconcept{weakly_incrementable} concept\iref{iterator.concept.winc},
 the type
 \begin{codeblock}
 iter_difference_t<WI>
@@ -699,7 +699,7 @@
 
   template<class T>
     requires (!requires { typename T::difference_type; } &&
-              requires(const T& a, const T& b) { { a - b } -> Integral; })
+              requires(const T& a, const T& b) { { a - b } -> integral; })
   struct incrementable_traits<T> {
     using difference_type = make_signed_t<decltype(declval<T>() - declval<T>())>;
   };
@@ -731,7 +731,7 @@
 To implement algorithms only in terms of readable types, it is often necessary
 to determine the value type that corresponds to a particular readable type.
 Accordingly, it is required that if \tcode{R} is the name of a type that
-models the \libconcept{Readable} concept\iref{iterator.concept.readable},
+models the \libconcept{readable} concept\iref{iterator.concept.readable},
 the type
 \begin{codeblock}
 iter_value_t<R>
@@ -796,15 +796,15 @@
 \pnum
 \begin{note}
 Some legacy output iterators define a nested type named \tcode{value_type}
-that is an alias for \tcode{void}. These types are not \tcode{Readable}
+that is an alias for \tcode{void}. These types are not \libconcept{readable}
 and have no associated value types.
 \end{note}
 
 \pnum
 \begin{note}
-Smart pointers like \tcode{shared_ptr<int>} are \tcode{Readable} and
+Smart pointers like \tcode{shared_ptr<int>} are \libconcept{readable} and
 have an associated value type, but a smart pointer like \tcode{shared_ptr<void>}
-is not \tcode{Readable} and has no associated value type.
+is not \libconcept{readable} and has no associated value type.
 \end{note}
 
 \rSec3[iterator.traits]{Iterator traits}
@@ -856,52 +856,52 @@
 \begin{codeblock}
 template<class I>
 concept @\placeholder{cpp17-iterator}@ =
-  Copyable<I> && requires(I i) {
+  copyable<I> && requires(I i) {
     {   *i } -> @\placeholder{can-reference}@;
-    {  ++i } -> Same<I&>;
+    {  ++i } -> same_to<I&>;
     { *i++ } -> @\placeholder{can-reference}@;
   };
 
 template<class I>
 concept @\placeholder{cpp17-input-iterator}@ =
-  @\placeholder{cpp17-iterator}@<I> && EqualityComparable<I> && requires(I i) {
+  @\placeholder{cpp17-iterator}@<I> && equality_comparable<I> && requires(I i) {
     typename incrementable_traits<I>::difference_type;
     typename readable_traits<I>::value_type;
     typename common_reference_t<iter_reference_t<I>&&,
                                 typename readable_traits<I>::value_type&>;
     typename common_reference_t<decltype(*i++)&&,
                                 typename readable_traits<I>::value_type&>;
-    requires SignedIntegral<typename incrementable_traits<I>::difference_type>;
+    requires signed_integral<typename incrementable_traits<I>::difference_type>;
   };
 
 template<class I>
 concept @\placeholder{cpp17-forward-iterator}@ =
-  @\placeholder{cpp17-input-iterator}@<I> && Constructible<I> &&
+  @\placeholder{cpp17-input-iterator}@<I> && constructible_from<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
-  Same<remove_cvref_t<iter_reference_t<I>>, typename readable_traits<I>::value_type> &&
+  same_to<remove_cvref_t<iter_reference_t<I>>, typename readable_traits<I>::value_type> &&
   requires(I i) {
     {  i++ } -> const I&;
-    { *i++ } -> Same<iter_reference_t<I>>;
+    { *i++ } -> same_to<iter_reference_t<I>>;
   };
 
 template<class I>
 concept @\placeholder{cpp17-bidirectional-iterator}@ =
   @\placeholder{cpp17-forward-iterator}@<I> && requires(I i) {
-    {  --i } -> Same<I&>;
+    {  --i } -> same_to<I&>;
     {  i-- } -> const I&;
-    { *i-- } -> Same<iter_reference_t<I>>;
+    { *i-- } -> same_to<iter_reference_t<I>>;
   };
 
 template<class I>
 concept @\placeholder{cpp17-random-access-iterator}@ =
-  @\placeholder{cpp17-bidirectional-iterator}@<I> && StrictTotallyOrdered<I> &&
+  @\placeholder{cpp17-bidirectional-iterator}@<I> && totally_ordered<I> &&
   requires(I i, typename incrementable_traits<I>::difference_type n) {
-    { i += n } -> Same<I&>;
-    { i -= n } -> Same<I&>;
-    { i +  n } -> Same<I>;
-    { n +  i } -> Same<I>;
-    { i -  n } -> Same<I>;
-    { i -  i } -> Same<decltype(n)>;
+    { i += n } -> same_to<I&>;
+    { i -= n } -> same_to<I&>;
+    { i +  n } -> same_to<I>;
+    { n +  i } -> same_to<I>;
+    { i -  n } -> same_to<I>;
+    { i -  i } -> same_to<decltype(n)>;
     {  i[n]  } -> iter_reference_t<I>;
   };
 \end{codeblock}
@@ -1121,13 +1121,13 @@
 ill-formed with no diagnostic required.
 
 \item Otherwise, if the types of \tcode{E1} and \tcode{E2} each model
-\tcode{Readable}, and if the reference types of \tcode{E1} and \tcode{E2}
-model \libconcept{SwappableWith}\iref{concept.swappable},
+\libconcept{readable}, and if the reference types of \tcode{E1} and \tcode{E2}
+model \libconcept{swappable_with}\iref{concept.swappable},
 then \tcode{ranges::swap(*E1, *E2)}.
 
 \item Otherwise, if the types \tcode{T1} and \tcode{T2} of \tcode{E1} and
-\tcode{E2} model \tcode{\libconcept{IndirectlyMovableStorable}<T1, T2>} and
-\tcode{IndirectlyMovableStorable<T2, T1>}, then
+\tcode{E2} model \tcode{\libconcept{indirectly_movable_storable}<T1, T2>} and
+\tcode{\libconcept{indirectly_movable_storable}<T2, T1>}, then
 \tcode{(void)(*E1 = \placeholdernc{iter-exchange-move}(E2, E1))},
 except that \tcode{E1} is evaluated only once.
 
@@ -1188,45 +1188,45 @@
 and \tcode{\placeholder{ITER_CONCEPT}(I)} denotes \tcode{random_access_iterator_tag}.
 \end{example}
 
-\rSec3[iterator.concept.readable]{Concept \libconcept{Readable}}
+\rSec3[iterator.concept.readable]{Concept \libconcept{readable}}
 
 \pnum
 Types that are readable by applying \tcode{operator*}
-model the \libconcept{Readable} concept, including
+model the \libconcept{readable} concept, including
 pointers, smart pointers, and iterators.
 
-\indexlibrary{\idxcode{Readable}}%
+\indexlibrary{\idxcode{readable}}%
 \begin{codeblock}
 template<class In>
-  concept Readable =
+  concept readable =
     requires {
       typename iter_value_t<In>;
       typename iter_reference_t<In>;
       typename iter_rvalue_reference_t<In>;
     } &&
-    CommonReference<iter_reference_t<In>&&, iter_value_t<In>&> &&
-    CommonReference<iter_reference_t<In>&&, iter_rvalue_reference_t<In>&&> &&
-    CommonReference<iter_rvalue_reference_t<In>&&, const iter_value_t<In>&>;
+    common_reference_with<iter_reference_t<In>&&, iter_value_t<In>&> &&
+    common_reference_with<iter_reference_t<In>&&, iter_rvalue_reference_t<In>&&> &&
+    common_reference_with<iter_rvalue_reference_t<In>&&, const iter_value_t<In>&>;
 \end{codeblock}
 
 \pnum
-Given a value \tcode{i} of type \tcode{I}, \tcode{I} models \libconcept{Readable}
+Given a value \tcode{i} of type \tcode{I}, \tcode{I} models \libconcept{readable}
 only if the expression \tcode{*i} is equality-preserving.
 \begin{note}
 The expression \tcode{*i} is indirectly required to be valid via the
 exposition-only \placeholder{dereferenceable} concept\iref{iterator.synopsis}.
 \end{note}
 
-\rSec3[iterator.concept.writable]{Concept \libconcept{Writable}}
+\rSec3[iterator.concept.writable]{Concept \libconcept{writable}}
 
 \pnum
-The \libconcept{Writable} concept specifies the requirements for writing a value
+The \libconcept{writable} concept specifies the requirements for writing a value
 into an iterator's referenced object.
 
-\indexlibrary{\idxcode{Writable}}%
+\indexlibrary{\idxcode{writable}}%
 \begin{codeblock}
 template<class Out, class T>
-  concept Writable =
+  concept writable =
     requires(Out&& o, T&& t) {
       *o = std::forward<T>(t); // not required to be equality-preserving
       *std::forward<Out>(o) = std::forward<T>(t); // not required to be equality-preserving
@@ -1240,11 +1240,11 @@
 \pnum
 Let \tcode{E} be an an expression such that \tcode{decltype((E))} is \tcode{T},
 and let \tcode{o} be a dereferenceable object of type \tcode{Out}.
-\tcode{Out} and \tcode{T} model \tcode{\libconcept{Writable}<Out, T>} only if
+\tcode{Out} and \tcode{T} model \tcode{\libconcept{writable}<Out, T>} only if
 
 \begin{itemize}
 \item If \tcode{Out} and \tcode{T} model
-  \tcode{Readable<Out> \&\& Same<iter_value_t<Out>, decay_t<T>{>}},
+  \tcode{\libconcept{readable}<Out> \&\& \libconcept{same_to}<iter_value_t<Out>, decay_t<T>{>}},
   then \tcode{*o} after any above assignment is equal to
   the value of \tcode{E} before the assignment.
 \end{itemize}
@@ -1264,30 +1264,30 @@
 
 \pnum
 \begin{note}
-\tcode{Writable} has the awkward \tcode{const_cast} expressions to reject
+\libconcept{writable} has the awkward \tcode{const_cast} expressions to reject
 iterators with prvalue non-proxy reference types that permit rvalue
 assignment but do not also permit \tcode{const} rvalue assignment.
 Consequently, an iterator type \tcode{I} that returns \tcode{std::string}
-by value does not model \tcode{\libconcept{Writable}<I, std::string>}.
+by value does not model \tcode{\libconcept{writable}<I, std::string>}.
 \end{note}
 
-\rSec3[iterator.concept.winc]{Concept \libconcept{WeaklyIncrementable}}
+\rSec3[iterator.concept.winc]{Concept \libconcept{weakly_incrementable}}
 
 \pnum
-The \libconcept{WeaklyIncrementable} concept specifies the requirements on
+The \libconcept{weakly_incrementable} concept specifies the requirements on
 types that can be incremented with the pre- and post-increment operators.
 The increment operations are not required to be equality-preserving,
-nor is the type required to be \libconcept{EqualityComparable}.
+nor is the type required to be \libconcept{equality_comparable}.
 
-\indexlibrary{\idxcode{WeaklyIncrementable}}%
+\indexlibrary{\idxcode{weakly_incrementable}}%
 \begin{codeblock}
 template<class I>
-  concept WeaklyIncrementable =
-    Semiregular<I> &&
+  concept weakly_incrementable =
+    semiregular<I> &&
     requires(I i) {
       typename iter_difference_t<I>;
-      requires SignedIntegral<iter_difference_t<I>>;
-      { ++i } -> Same<I&>; // not required to be equality-preserving
+      requires signed_integral<iter_difference_t<I>>;
+      { ++i } -> same_to<I&>; // not required to be equality-preserving
       i++; // not required to be equality-preserving
     };
 \end{codeblock}
@@ -1295,7 +1295,7 @@
 \pnum
 Let \tcode{i} be an object of type \tcode{I}. When \tcode{i} is in the domain of
 both pre- and post-increment, \tcode{i} is said to be \term{incrementable}.
-\tcode{I} models \tcode{WeaklyIncrementable<I>} only if
+\tcode{I} models \tcode{\libconcept{weakly_incrementable}<I>} only if
 
 \begin{itemize}
 \item The expressions \tcode{++i} and \tcode{i++} have the same domain.
@@ -1308,7 +1308,7 @@
 
 \pnum
 \begin{note}
-For \tcode{WeaklyIncrementable} types, \tcode{a} equals \tcode{b} does not imply that \tcode{++a}
+For \libconcept{weakly_incrementable} types, \tcode{a} equals \tcode{b} does not imply that \tcode{++a}
 equals \tcode{++b}. (Equality does not guarantee the substitution property or referential
 transparency.) Algorithms on weakly incrementable types should never attempt to pass
 through the same incrementable value twice. They should be single-pass algorithms. These algorithms
@@ -1316,31 +1316,31 @@
 template.
 \end{note}
 
-\rSec3[iterator.concept.inc]{Concept \libconcept{Incrementable}}
+\rSec3[iterator.concept.inc]{Concept \libconcept{incrementable}}
 
 \pnum
-The \libconcept{Incrementable} concept specifies requirements on types that can be incremented with the pre-
+The \libconcept{incrementable} concept specifies requirements on types that can be incremented with the pre-
 and post-increment operators. The increment operations are required to be equality-preserving,
-and the type is required to be \libconcept{EqualityComparable}.
+and the type is required to be \libconcept{equality_comparable}.
 \begin{note}
 This supersedes the annotations on the increment expressions
-in the definition of \tcode{WeaklyIncrementable}.
+in the definition of \libconcept{weakly_incrementable}.
 \end{note}
 
-\indexlibrary{\idxcode{Incrementable}}%
+\indexlibrary{\idxcode{incrementable}}%
 \begin{codeblock}
 template<class I>
-  concept Incrementable =
-    Regular<I> &&
-    WeaklyIncrementable<I> &&
+  concept incrementable =
+    regular<I> &&
+    weakly_incrementable<I> &&
     requires(I i) {
-      { i++ } -> Same<I>;
+      { i++ } -> same_to<I>;
     };
 \end{codeblock}
 
 \pnum
 Let \tcode{a} and \tcode{b} be incrementable objects of type \tcode{I}.
-\tcode{I} models \libconcept{Incrementable} only if
+\tcode{I} models \libconcept{incrementable} only if
 
 \begin{itemize}
 \item If \tcode{bool(a == b)} then \tcode{bool(a++ == b)}.
@@ -1355,14 +1355,14 @@
 \tcode{++a} equals \tcode{++b}
 (which is not true for weakly incrementable types)
 allows the use of multi-pass one-directional
-algorithms with types that model \libconcept{Increment\-able}.
+algorithms with types that model \libconcept{increment\-able}.
 \end{note}
 
-\rSec3[iterator.concept.iterator]{Concept \libconcept{Iterator}}
+\rSec3[iterator.concept.iterator]{Concept \libconcept{input_or_output_iterator}}
 
 \pnum
-The \libconcept{Iterator} concept forms the basis
-of the iterator concept taxonomy; every iterator models \libconcept{Iterator}.
+The \libconcept{input_or_output_iterator} concept forms the basis
+of the iterator concept taxonomy; every iterator models \libconcept{input_or_output_iterator}.
 This concept specifies operations for dereferencing and incrementing
 an iterator. Most algorithms will require additional operations
 to compare iterators with sentinels\iref{iterator.concept.sentinel}, to
@@ -1370,29 +1370,29 @@
 to provide a richer set of iterator movements (\ref{iterator.concept.forward},
 \ref{iterator.concept.bidir}, \ref{iterator.concept.random.access}).
 
-\indexlibrary{\idxcode{Iterator}}%
+\indexlibrary{\idxcode{input_or_output_iterator}}%
 \begin{codeblock}
 template<class I>
-  concept Iterator =
+  concept input_or_output_iterator =
     requires(I i) {
       { *i } -> @\placeholder{can-reference}@;
     } &&
-    WeaklyIncrementable<I>;
+    weakly_incrementable<I>;
 \end{codeblock}
 
-\rSec3[iterator.concept.sentinel]{Concept \libconcept{Sentinel}}
+\rSec3[iterator.concept.sentinel]{Concept \libconcept{sentinel_for}}
 
 \pnum
-The \libconcept{Sentinel} concept specifies the relationship
-between an \libconcept{Iterator} type and a \libconcept{Semiregular} type
+The \libconcept{sentinel_for} concept specifies the relationship
+between an \libconcept{input_or_output_iterator} type and a \libconcept{semiregular} type
 whose values denote a range.
 
-\indexlibrary{\idxcode{Sentinel}}%
+\indexlibrary{\idxcode{sentinel_for}}%
 \begin{itemdecl}
 template<class S, class I>
-  concept Sentinel =
-    Semiregular<S> &&
-    Iterator<I> &&
+  concept sentinel_for =
+    semiregular<S> &&
+    input_or_output_iterator<I> &&
     @\placeholder{weakly-equality-comparable-with}@<S, I>; // See \ref{concept.equalitycomparable}
 \end{itemdecl}
 
@@ -1400,7 +1400,7 @@
 \pnum
 Let \tcode{s} and \tcode{i} be values of type \tcode{S} and
 \tcode{I} such that \range{i}{s} denotes a range. Types
-\tcode{S} and \tcode{I} model \tcode{\libconcept{Sentinel}<S, I>} only if
+\tcode{S} and \tcode{I} model \tcode{\libconcept{sentinel_for}<S, I>} only if
 
 \begin{itemize}
 \item \tcode{i == s} is well-defined.
@@ -1418,24 +1418,24 @@
 to \tcode{i}. Consequently, \tcode{i == s} is no longer required to be
 well-defined.
 
-\rSec3[iterator.concept.sizedsentinel]{Concept \libconcept{SizedSentinel}}
+\rSec3[iterator.concept.sizedsentinel]{Concept \libconcept{sized_sentinel_for}}
 
 \pnum
-The \libconcept{SizedSentinel} concept specifies
-requirements on an \libconcept{Iterator} and a \libconcept{Sentinel}
+The \libconcept{sized_sentinel_for} concept specifies
+requirements on an \libconcept{input_or_output_iterator} and a \libconcept{senti\-nel_for}
 that allow the use of the \tcode{-} operator to compute the distance
 between them in constant time.
 
-\indexlibrary{\idxcode{SizedSentinel}}%
+\indexlibrary{\idxcode{sized_sentinel_for}}%
 
 \begin{itemdecl}
 template<class S, class I>
-  concept SizedSentinel =
-    Sentinel<S, I> &&
+  concept sized_sentinel_for =
+    sentinel_for<S, I> &&
     !disable_sized_sentinel<remove_cv_t<S>, remove_cv_t<I>> &&
     requires(const I& i, const S& s) {
-      { s - i } -> Same<iter_difference_t<I>>;
-      { i - s } -> Same<iter_difference_t<I>>;
+      { s - i } -> same_to<iter_difference_t<I>>;
+      { i - s } -> same_to<iter_difference_t<I>>;
     };
 \end{itemdecl}
 
@@ -1445,7 +1445,7 @@
 a sentinel of type \tcode{S} such that \range{i}{s} denotes a range.
 Let $N$ be the smallest number of applications of \tcode{++i}
 necessary to make \tcode{bool(i == s)} be \tcode{true}.
-\tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>} only if
+\tcode{S} and \tcode{I} model \tcode{\libconcept{sized_sentinel_for}<S, I>} only if
 
 \begin{itemize}
 \item If $N$ is representable by \tcode{iter_difference_t<I>},
@@ -1459,55 +1459,55 @@
 \pnum
 \begin{note}
 \tcode{disable_sized_sentinel} allows use of sentinels and iterators with
-the library that satisfy but do not in fact model \libconcept{SizedSentinel}.
+the library that satisfy but do not in fact model \libconcept{sized_sentinel_for}.
 \end{note}
 
 \pnum
 \begin{example}
-The \libconcept{SizedSentinel} concept is modeled by pairs of
-\libconcept{RandomAccessIterator}s\iref{iterator.concept.random.access} and by
+The \libconcept{sized_sentinel_for} concept is modeled by pairs of
+\libconcept{random_access_iterator}s\iref{iterator.concept.random.access} and by
 counted iterators and their sentinels\iref{counted.iterator}.
 \end{example}
 
-\rSec3[iterator.concept.input]{Concept \libconcept{InputIterator}}
+\rSec3[iterator.concept.input]{Concept \libconcept{input_iterator}}
 
 \pnum
-The \libconcept{InputIterator} concept defines requirements for a type
+The \libconcept{input_iterator} concept defines requirements for a type
 whose referenced values can be read (from the requirement for
-\libconcept{Readable}\iref{iterator.concept.readable}) and which can be both pre- and
+\libconcept{readable}\iref{iterator.concept.readable}) and which can be both pre- and
 post-incremented.
 \begin{note}
 Unlike the \oldconcept{InputIterator} requirements\iref{input.iterators},
-the \libconcept{InputIterator} concept does not need
+the \libconcept{input_iterator} concept does not need
 equality comparison since iterators are typically compared to sentinels.
 \end{note}
 
-\indexlibrary{\idxcode{InputIterator}}%
+\indexlibrary{\idxcode{input_iterator}}%
 \begin{codeblock}
 template<class I>
-  concept InputIterator =
-    Iterator<I> &&
-    Readable<I> &&
+  concept input_iterator =
+    input_or_output_iterator<I> &&
+    readable<I> &&
     requires { typename @\placeholdernc{ITER_CONCEPT}@(I); } &&
-    DerivedFrom<@\placeholdernc{ITER_CONCEPT}@(I), input_iterator_tag>;
+    derived_from<@\placeholdernc{ITER_CONCEPT}@(I), input_iterator_tag>;
 \end{codeblock}
 
-\rSec3[iterator.concept.output]{Concept \libconcept{OutputIterator}}
+\rSec3[iterator.concept.output]{Concept \libconcept{output_iterator}}
 
 \pnum
-The \libconcept{OutputIterator} concept defines requirements for a type that
+The \libconcept{output_iterator} concept defines requirements for a type that
 can be used to write values (from the requirement for
-\libconcept{Writable}\iref{iterator.concept.writable}) and which can be both pre- and post-incremented.
+\libconcept{writable}\iref{iterator.concept.writable}) and which can be both pre- and post-incremented.
 \begin{note}
-Output iterators are not required to model \libconcept{EqualityComparable}.
+Output iterators are not required to model \libconcept{equality_comparable}.
 \end{note}
 
-\indexlibrary{\idxcode{OutputIterator}}%
+\indexlibrary{\idxcode{output_iterator}}%
 \begin{codeblock}
 template<class I, class T>
-  concept OutputIterator =
-    Iterator<I> &&
-    Writable<I, T> &&
+  concept output_iterator =
+    input_or_output_iterator<I> &&
+    writable<I, T> &&
     requires(I i, T&& t) {
       *i++ = std::forward<T>(t); // not required to be equality-preserving
     };
@@ -1515,7 +1515,7 @@
 
 \pnum
 Let \tcode{E} be an expression such that \tcode{decltype((E))} is \tcode{T}, and let \tcode{i} be a
-dereferenceable object of type \tcode{I}. \tcode{I} and \tcode{T} model \tcode{\libconcept{OutputIterator}<I, T>} only if
+dereferenceable object of type \tcode{I}. \tcode{I} and \tcode{T} model \tcode{\libconcept{output_iterator}<I, T>} only if
 \tcode{*i++ = E;} has effects equivalent to:
 \begin{codeblock}
   *i = E;
@@ -1528,20 +1528,20 @@
 They should be single-pass algorithms.
 \end{note}
 
-\rSec3[iterator.concept.forward]{Concept \libconcept{ForwardIterator}}
+\rSec3[iterator.concept.forward]{Concept \libconcept{forward_iterator}}
 
 \pnum
-The \libconcept{ForwardIterator} concept adds equality comparison and
+The \libconcept{forward_iterator} concept adds equality comparison and
 the multi-pass guarantee, specified below.
 
-\indexlibrary{\idxcode{ForwardIterator}}%
+\indexlibrary{\idxcode{forward_iterator}}%
 \begin{codeblock}
 template<class I>
-  concept ForwardIterator =
-    InputIterator<I> &&
-    DerivedFrom<@\placeholdernc{ITER_CONCEPT}@(I), forward_iterator_tag> &&
-    Incrementable<I> &&
-    Sentinel<I, I>;
+  concept forward_iterator =
+    input_iterator<I> &&
+    derived_from<@\placeholdernc{ITER_CONCEPT}@(I), forward_iterator_tag> &&
+    incrementable<I> &&
+    sentinel_for<I, I>;
 \end{codeblock}
 
 \pnum
@@ -1579,21 +1579,21 @@
 allow the use of multi-pass one-directional algorithms with forward iterators.
 \end{note}
 
-\rSec3[iterator.concept.bidir]{Concept \libconcept{BidirectionalIterator}}
+\rSec3[iterator.concept.bidir]{Concept \libconcept{bidirectional_iterator}}
 
 \pnum
-The \libconcept{BidirectionalIterator} concept adds the ability
+The \libconcept{bidirectional_iterator} concept adds the ability
 to move an iterator backward as well as forward.
 
-\indexlibrary{\idxcode{BidirectionalIterator}}%
+\indexlibrary{\idxcode{bidirectional_iterator}}%
 \begin{codeblock}
 template<class I>
-  concept BidirectionalIterator =
-    ForwardIterator<I> &&
-    DerivedFrom<@\placeholdernc{ITER_CONCEPT}@(I), bidirectional_iterator_tag> &&
+  concept bidirectional_iterator =
+    forward_iterator<I> &&
+    derived_from<@\placeholdernc{ITER_CONCEPT}@(I), bidirectional_iterator_tag> &&
     requires(I i) {
-      { --i } -> Same<I&>;
-      { i-- } -> Same<I>;
+      { --i } -> same_to<I&>;
+      { i-- } -> same_to<I>;
     };
 \end{codeblock}
 
@@ -1604,7 +1604,7 @@
 
 \pnum
 Let \tcode{a} and \tcode{b} be equal objects of type \tcode{I}.
-\tcode{I} models \libconcept{BidirectionalIterator} only if:
+\tcode{I} models \libconcept{bidirectional_iterator} only if:
 
 \begin{itemize}
 \item If \tcode{a} and \tcode{b} are decrementable,
@@ -1620,29 +1620,29 @@
     \tcode{bool(--(++a) == b)}.
 \end{itemize}
 
-\rSec3[iterator.concept.random.access]{Concept \libconcept{RandomAccessIterator}}
+\rSec3[iterator.concept.random.access]{Concept \libconcept{random_access_iterator}}
 
 \pnum
-The \libconcept{RandomAccessIterator} concept adds support for
+The \libconcept{random_access_iterator} concept adds support for
 constant-time advancement with \tcode{+=}, \tcode{+}, \tcode{-=}, and \tcode{-},
 as well as the computation of distance in constant time with \tcode{-}.
 Random access iterators also support array notation via subscripting.
 
-\indexlibrary{\idxcode{RandomAccessIterator}}%
+\indexlibrary{\idxcode{random_access_iterator}}%
 \begin{codeblock}
 template<class I>
-  concept RandomAccessIterator =
-    BidirectionalIterator<I> &&
-    DerivedFrom<@\placeholdernc{ITER_CONCEPT}@(I), random_access_iterator_tag> &&
-    StrictTotallyOrdered<I> &&
-    SizedSentinel<I, I> &&
+  concept random_access_iterator =
+    bidirectional_iterator<I> &&
+    derived_from<@\placeholdernc{ITER_CONCEPT}@(I), random_access_iterator_tag> &&
+    totally_ordered<I> &&
+    sized_sentinel_for<I, I> &&
     requires(I i, const I j, const iter_difference_t<I> n) {
-      { i += n } -> Same<I&>;
-      { j +  n } -> Same<I>;
-      { n +  j } -> Same<I>;
-      { i -= n } -> Same<I&>;
-      { j -  n } -> Same<I>;
-      {  j[n]  } -> Same<iter_reference_t<I>>;
+      { i += n } -> same_to<I&>;
+      { j +  n } -> same_to<I>;
+      { n +  j } -> same_to<I>;
+      { i -= n } -> same_to<I&>;
+      { j -  n } -> same_to<I>;
+      {  j[n]  } -> same_to<iter_reference_t<I>>;
     };
 \end{codeblock}
 
@@ -1652,7 +1652,7 @@
 after \tcode{n} applications of \tcode{++a},
 let \tcode{D} be \tcode{iter_difference_t<I>},
 and let \tcode{n} denote a value of type \tcode{D}.
-\tcode{I} models \libconcept{RandomAccessIterator} only if
+\tcode{I} models \libconcept{random_access_iterator} only if
 
 \begin{itemize}
 \item \tcode{(a += n)} is equal to \tcode{b}.
@@ -1674,27 +1674,27 @@
 \item \tcode{bool(a <= b)} is \tcode{true}.
 \end{itemize}
 
-\rSec3[iterator.concept.contiguous]{Concept \libconcept{ContiguousIterator}}
+\rSec3[iterator.concept.contiguous]{Concept \libconcept{contiguous_iterator}}
 
 \pnum
-The \libconcept{ContiguousIterator} concept provides a guarantee that
+The \libconcept{contiguous_iterator} concept provides a guarantee that
 the denoted elements are stored contiguously in memory.
 
-\indexlibrary{\idxcode{ContiguousIterator}}%
+\indexlibrary{\idxcode{contiguous_iterator}}%
 \begin{codeblock}
 template<class I>
-  concept @\libconcept{ContiguousIterator}@ =
-    RandomAccessIterator<I> &&
-    DerivedFrom<@\placeholdernc{ITER_CONCEPT}@(I), contiguous_iterator_tag> &&
+  concept @\libconcept{contiguous_iterator}@ =
+    random_access_iterator<I> &&
+    derived_from<@\placeholdernc{ITER_CONCEPT}@(I), contiguous_iterator_tag> &&
     is_lvalue_reference_v<iter_reference_t<I>> &&
-    Same<iter_value_t<I>, remove_cvref_t<iter_reference_t<I>>>;
+    same_to<iter_value_t<I>, remove_cvref_t<iter_reference_t<I>>>;
 \end{codeblock}
 
 \pnum
 Let \tcode{a} and \tcode{b} be dereferenceable iterators of type \tcode{I}
 such that \tcode{b} is reachable from \tcode{a},
 and let \tcode{D} be \tcode{iter_difference_t<I>}.
-The type \tcode{I} models \libconcept{ContiguousIterator} only if
+The type \tcode{I} models \libconcept{contiguous_iterator} only if
 \tcode{addressof(*(a + D(b - a)))}
 is equal to
 \tcode{addressof(*a) + D(b - a)}.
@@ -2171,62 +2171,62 @@
 The indirect callable concepts are used to constrain those algorithms
 that accept callable objects~(\ref{func.def}) as arguments.
 
-\indexlibrary{\idxcode{IndirectUnaryInvocable}}%
-\indexlibrary{\idxcode{IndirectRegularUnaryInvocable}}%
-\indexlibrary{\idxcode{IndirectUnaryPredicate}}%
-\indexlibrary{\idxcode{IndirectRelation}}%
-\indexlibrary{\idxcode{IndirectStrictWeakOrder}}%
+\indexlibrary{\idxcode{indirectly_unary_invocable}}%
+\indexlibrary{\idxcode{indirectly_regular_unary_invocable}}%
+\indexlibrary{\idxcode{indirect_unary_predicate}}%
+\indexlibrary{\idxcode{indirect_relation}}%
+\indexlibrary{\idxcode{indirect_strict_weak_order}}%
 \begin{codeblock}
 namespace std {
   template<class F, class I>
-    concept IndirectUnaryInvocable =
-      Readable<I> &&
-      CopyConstructible<F> &&
-      Invocable<F&, iter_value_t<I>&> &&
-      Invocable<F&, iter_reference_t<I>> &&
-      Invocable<F&, iter_common_reference_t<I>> &&
-      CommonReference<
+    concept indirectly_unary_invocable =
+      readable<I> &&
+      copy_constructible<F> &&
+      invocable<F&, iter_value_t<I>&> &&
+      invocable<F&, iter_reference_t<I>> &&
+      invocable<F&, iter_common_reference_t<I>> &&
+      common_reference_with<
         invoke_result_t<F&, iter_value_t<I>&>,
         invoke_result_t<F&, iter_reference_t<I>>>;
 
   template<class F, class I>
-    concept IndirectRegularUnaryInvocable =
-      Readable<I> &&
-      CopyConstructible<F> &&
-      RegularInvocable<F&, iter_value_t<I>&> &&
-      RegularInvocable<F&, iter_reference_t<I>> &&
-      RegularInvocable<F&, iter_common_reference_t<I>> &&
-      CommonReference<
+    concept indirectly_regular_unary_invocable =
+      readable<I> &&
+      copy_constructible<F> &&
+      regular_invocable<F&, iter_value_t<I>&> &&
+      regular_invocable<F&, iter_reference_t<I>> &&
+      regular_invocable<F&, iter_common_reference_t<I>> &&
+      common_reference_with<
         invoke_result_t<F&, iter_value_t<I>&>,
         invoke_result_t<F&, iter_reference_t<I>>>;
 
   template<class F, class I>
-    concept IndirectUnaryPredicate =
-      Readable<I> &&
-      CopyConstructible<F> &&
-      Predicate<F&, iter_value_t<I>&> &&
-      Predicate<F&, iter_reference_t<I>> &&
-      Predicate<F&, iter_common_reference_t<I>>;
+    concept indirect_unary_predicate =
+      readable<I> &&
+      copy_constructible<F> &&
+      predicate<F&, iter_value_t<I>&> &&
+      predicate<F&, iter_reference_t<I>> &&
+      predicate<F&, iter_common_reference_t<I>>;
 
   template<class F, class I1, class I2 = I1>
-    concept IndirectRelation =
-      Readable<I1> && Readable<I2> &&
-      CopyConstructible<F> &&
-      Relation<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      Relation<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      Relation<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
-      Relation<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
-      Relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
+    concept indirect_relation =
+      readable<I1> && readable<I2> &&
+      copy_constructible<F> &&
+      relation<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
+      relation<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
+      relation<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
+      relation<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
+      relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 
   template<class F, class I1, class I2 = I1>
-    concept IndirectStrictWeakOrder =
-      Readable<I1> && Readable<I2> &&
-      CopyConstructible<F> &&
-      StrictWeakOrder<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      StrictWeakOrder<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      StrictWeakOrder<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
-      StrictWeakOrder<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
-      StrictWeakOrder<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
+    concept indirect_strict_weak_order =
+      readable<I1> && readable<I2> &&
+      copy_constructible<F> &&
+      strict_weak_order<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
+      strict_weak_order<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
+      strict_weak_order<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
+      strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
+      strict_weak_order<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 }
 \end{codeblock}
 
@@ -2235,21 +2235,21 @@
 \pnum
 Class template \tcode{projected} is used to constrain algorithms
 that accept callable objects and projections\iref{defns.projection}.
-It combines a \libconcept{Readable} type \tcode{I} and
-a callable object type \tcode{Proj} into a new \libconcept{Readable} type
+It combines a \libconcept{readable} type \tcode{I} and
+a callable object type \tcode{Proj} into a new \libconcept{readable} type
 whose \tcode{reference} type is the result of applying
 \tcode{Proj} to the \tcode{iter_reference_t} of \tcode{I}.
 
 \indexlibrary{\idxcode{projected}}%
 \begin{codeblock}
 namespace std {
-  template<Readable I, IndirectRegularUnaryInvocable<I> Proj>
+  template<readable I, indirectly_regular_unary_invocable<I> Proj>
   struct projected {
     using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
     indirect_result_t<Proj&, I> operator*() const; // \notdef
   };
 
-  template<WeaklyIncrementable I, class Proj>
+  template<weakly_incrementable I, class Proj>
   struct incrementable_traits<projected<I, Proj>> {
     using difference_type = iter_difference_t<I>;
   };
@@ -2265,17 +2265,17 @@
 to families of algorithms. These group together iterator requirements
 of algorithm families.
 There are three relational concepts that specify
-how element values are transferred  between \libconcept{Readable} and
-\libconcept{Writable} types:
-\libconcept{Indirectly\-Movable},
-\libconcept{Indir\-ect\-ly\-Copy\-able}, and
-\libconcept{Indirectly\-Swappable}.
+how element values are transferred  between \libconcept{readable} and
+\libconcept{writable} types:
+\libconcept{indirectly_movable},
+\libconcept{indir\-ect\-ly_copy\-able}, and
+\libconcept{indirectly_swappable}.
 There are three relational concepts for rearrangements:
-\libconcept{Permut\-able},
-\libconcept{Mergeable}, and
-\libconcept{Sortable}.
+\libconcept{permut\-able},
+\libconcept{mergeable}, and
+\libconcept{sortable}.
 There is one relational concept for comparing values from different sequences:
-\libconcept{IndirectlyComparable}.
+\libconcept{indirectly_comparable}.
 
 \pnum
 \begin{note}
@@ -2284,41 +2284,41 @@
 in addition to those that appear in the concepts' bodies\iref{range.cmp}.
 \end{note}
 
-\rSec3[alg.req.ind.move]{Concept \libconcept{IndirectlyMovable}}
+\rSec3[alg.req.ind.move]{Concept \libconcept{indirectly_movable}}
 
 \pnum
-The \libconcept{IndirectlyMovable} concept specifies the relationship between
-a \libconcept{Readable} type and a \libconcept{Writable} type between which
+The \libconcept{indirectly_movable} concept specifies the relationship between
+a \libconcept{readable} type and a \libconcept{writable} type between which
 values may be moved.
 
-\indexlibrary{\idxcode{IndirectlyMovable}}%
+\indexlibrary{\idxcode{indirectly_movable}}%
 \begin{codeblock}
 template<class In, class Out>
-  concept IndirectlyMovable =
-    Readable<In> &&
-    Writable<Out, iter_rvalue_reference_t<In>>;
+  concept indirectly_movable =
+    readable<In> &&
+    writable<Out, iter_rvalue_reference_t<In>>;
 \end{codeblock}
 
 \pnum
-The \libconcept{IndirectlyMovableStorable} concept augments
-\libconcept{IndirectlyMovable} with additional requirements enabling
+The \libconcept{indirectly_movable_storable} concept augments
+\libconcept{indirectly_movable} with additional requirements enabling
 the transfer to be performed through an intermediate object of the
-\libconcept{Readable} type's value type.
+\libconcept{readable} type's value type.
 
-\indexlibrary{\idxcode{IndirectlyMovableStorable}}%
+\indexlibrary{\idxcode{indirectly_movable_storable}}%
 \begin{codeblock}
 template<class In, class Out>
-  concept IndirectlyMovableStorable =
-    IndirectlyMovable<In, Out> &&
-    Writable<Out, iter_value_t<In>> &&
-    Movable<iter_value_t<In>> &&
-    Constructible<iter_value_t<In>, iter_rvalue_reference_t<In>> &&
-    Assignable<iter_value_t<In>&, iter_rvalue_reference_t<In>>;
+  concept indirectly_movable_storable =
+    indirectly_movable<In, Out> &&
+    writable<Out, iter_value_t<In>> &&
+    movable<iter_value_t<In>> &&
+    constructible_from<iter_value_t<In>, iter_rvalue_reference_t<In>> &&
+    assignable_from<iter_value_t<In>&, iter_rvalue_reference_t<In>>;
 \end{codeblock}
 
 \pnum
 Let \tcode{i} be a dereferenceable value of type \tcode{In}.
-\tcode{In} and \tcode{Out} model \tcode{\libconcept{IndirectlyMovableStorable}<In, Out>}
+\tcode{In} and \tcode{Out} model \tcode{\libconcept{indirectly_movable_storable}<In, Out>}
 only if after the initialization of the object \tcode{obj} in
 \begin{codeblock}
 iter_value_t<In> obj(ranges::iter_move(i));
@@ -2328,42 +2328,42 @@
 the resulting state of the value denoted by \tcode{*i} is
 valid but unspecified\iref{lib.types.movedfrom}.
 
-\rSec3[alg.req.ind.copy]{Concept \libconcept{IndirectlyCopyable}}
+\rSec3[alg.req.ind.copy]{Concept \libconcept{indirectly_copyable}}
 
 \pnum
-The \libconcept{IndirectlyCopyable} concept specifies the relationship between
-a \libconcept{Readable} type and a \libconcept{Writable} type between which
+The \libconcept{indirectly_copyable} concept specifies the relationship between
+a \libconcept{readable} type and a \libconcept{writable} type between which
 values may be copied.
 
-\indexlibrary{\idxcode{IndirectlyCopyable}}%
+\indexlibrary{\idxcode{indirectly_copyable}}%
 \begin{codeblock}
 template<class In, class Out>
-  concept IndirectlyCopyable =
-    Readable<In> &&
-    Writable<Out, iter_reference_t<In>>;
+  concept indirectly_copyable =
+    readable<In> &&
+    writable<Out, iter_reference_t<In>>;
 \end{codeblock}
 
 \pnum
-The \libconcept{IndirectlyCopyableStorable} concept augments
-\libconcept{IndirectlyCopyable} with additional requirements enabling
+The \libconcept{indirectly_copyable_storable} concept augments
+\libconcept{indirectly_copyable} with additional requirements enabling
 the transfer to be performed through an intermediate object of the
-\libconcept{Readable} type's value type. It also requires the capability
+\libconcept{readable} type's value type. It also requires the capability
 to make copies of values.
 
-\indexlibrary{\idxcode{IndirectlyCopyableStorable}}%
+\indexlibrary{\idxcode{indirectly_copyable_storable}}%
 \begin{codeblock}
 template<class In, class Out>
-  concept IndirectlyCopyableStorable =
-    IndirectlyCopyable<In, Out> &&
-    Writable<Out, const iter_value_t<In>&> &&
-    Copyable<iter_value_t<In>> &&
-    Constructible<iter_value_t<In>, iter_reference_t<In>> &&
-    Assignable<iter_value_t<In>&, iter_reference_t<In>>;
+  concept indirectly_copyable_storable =
+    indirectly_copyable<In, Out> &&
+    writable<Out, const iter_value_t<In>&> &&
+    copyable<iter_value_t<In>> &&
+    constructible_from<iter_value_t<In>, iter_reference_t<In>> &&
+    assignable_from<iter_value_t<In>&, iter_reference_t<In>>;
 \end{codeblock}
 
 \pnum
 Let \tcode{i} be a dereferenceable value of type \tcode{In}.
-\tcode{In} and \tcode{Out} model \tcode{\libconcept{IndirectlyCopyableStorable}<In, Out>}
+\tcode{In} and \tcode{Out} model \tcode{\libconcept{indirectly_copyable_storable}<In, Out>}
 only if after the initialization of the object \tcode{obj} in
 \begin{codeblock}
 iter_value_t<In> obj(*i);
@@ -2373,17 +2373,17 @@
 of the value denoted by \tcode{*i} is
 valid but unspecified\iref{lib.types.movedfrom}.
 
-\rSec3[alg.req.ind.swap]{Concept \libconcept{IndirectlySwappable}}
+\rSec3[alg.req.ind.swap]{Concept \libconcept{indirectly_swappable}}
 
 \pnum
-The \libconcept{IndirectlySwappable} concept specifies a swappable relationship
-between the values referenced by two \libconcept{Readable} types.
+The \libconcept{indirectly_swappable} concept specifies a swappable relationship
+between the values referenced by two \libconcept{readable} types.
 
-\indexlibrary{\idxcode{IndirectlySwappable}}%
+\indexlibrary{\idxcode{indirectly_swappable}}%
 \begin{codeblock}
 template<class I1, class I2 = I1>
-  concept IndirectlySwappable =
-    Readable<I1> && Readable<I2> &&
+  concept indirectly_swappable =
+    readable<I1> && readable<I2> &&
     requires(I1& i1, I2& i2) {
       ranges::iter_swap(i1, i1);
       ranges::iter_swap(i2, i2);
@@ -2392,67 +2392,67 @@
     };
 \end{codeblock}
 
-\rSec3[alg.req.ind.cmp]{Concept \libconcept{IndirectlyComparable}}
+\rSec3[alg.req.ind.cmp]{Concept \libconcept{indirectly_comparable}}
 
 \pnum
-The \libconcept{IndirectlyComparable} concept specifies
+The \libconcept{indirectly_comparable} concept specifies
 the common requirements of algorithms that
 compare values from two different sequences.
 
-\indexlibrary{\idxcode{IndirectlyComparable}}%
+\indexlibrary{\idxcode{indirectly_comparable}}%
 \begin{codeblock}
 template<class I1, class I2, class R, class P1 = identity,
          class P2 = identity>
-  concept IndirectlyComparable =
-    IndirectRelation<R, projected<I1, P1>, projected<I2, P2>>;
+  concept indirectly_comparable =
+    indirect_relation<R, projected<I1, P1>, projected<I2, P2>>;
 \end{codeblock}
 
-\rSec3[alg.req.permutable]{Concept \libconcept{Permutable}}
+\rSec3[alg.req.permutable]{Concept \libconcept{permutable}}
 
 \pnum
-The \libconcept{Permutable} concept specifies the common requirements
+The \libconcept{permutable} concept specifies the common requirements
 of algorithms that reorder elements in place by moving or swapping them.
 
-\indexlibrary{\idxcode{Permutable}}%
+\indexlibrary{\idxcode{permutable}}%
 \begin{codeblock}
 template<class I>
-  concept Permutable =
-    ForwardIterator<I> &&
-    IndirectlyMovableStorable<I, I> &&
-    IndirectlySwappable<I, I>;
+  concept permutable =
+    forward_iterator<I> &&
+    indirectly_movable_storable<I, I> &&
+    indirectly_swappable<I, I>;
 \end{codeblock}
 
-\rSec3[alg.req.mergeable]{Concept \libconcept{Mergeable}}
+\rSec3[alg.req.mergeable]{Concept \libconcept{mergeable}}
 
 \pnum
-The \libconcept{Mergeable} concept specifies the requirements of algorithms
+The \libconcept{mergeable} concept specifies the requirements of algorithms
 that merge sorted sequences into an output sequence by copying elements.
 
-\indexlibrary{\idxcode{Mergeable}}%
+\indexlibrary{\idxcode{mergeable}}%
 \begin{codeblock}
 template<class I1, class I2, class Out, class R = ranges::less,
          class P1 = identity, class P2 = identity>
-  concept Mergeable =
-    InputIterator<I1> &&
-    InputIterator<I2> &&
-    WeaklyIncrementable<Out> &&
-    IndirectlyCopyable<I1, Out> &&
-    IndirectlyCopyable<I2, Out> &&
-    IndirectStrictWeakOrder<R, projected<I1, P1>, projected<I2, P2>>;
+  concept mergeable =
+    input_iterator<I1> &&
+    input_iterator<I2> &&
+    weakly_incrementable<Out> &&
+    indirectly_copyable<I1, Out> &&
+    indirectly_copyable<I2, Out> &&
+    indirect_strict_weak_order<R, projected<I1, P1>, projected<I2, P2>>;
 \end{codeblock}
 
-\rSec3[alg.req.sortable]{Concept \libconcept{Sortable}}
+\rSec3[alg.req.sortable]{Concept \libconcept{sortable}}
 
 \pnum
-The \libconcept{Sortable} concept specifies the common requirements of
+The \libconcept{sortable} concept specifies the common requirements of
 algorithms that permute sequences into ordered sequences (e.g., \tcode{sort}).
 
-\indexlibrary{\idxcode{Sortable}}%
+\indexlibrary{\idxcode{sortable}}%
 \begin{codeblock}
 template<class I, class R = ranges::less, class P = identity>
-  concept Sortable =
-    Permutable<I> &&
-    IndirectStrictWeakOrder<R, projected<I, P>>;
+  concept sortable =
+    permutable<I> &&
+    indirect_strict_weak_order<R, projected<I, P>>;
 \end{codeblock}
 
 \rSec1[iterator.primitives]{Iterator primitives}
@@ -2658,8 +2658,8 @@
 possible for a concrete iterator type.
 \begin{example}
 \tcode{ranges::advance} uses the \tcode{+} operator to move a
-\libconcept{RandomAccessIterator} forward \tcode{n} steps in constant time.
-For an iterator type that does not model \libconcept{RandomAccessIterator},
+\libconcept{random_access_iterator} forward \tcode{n} steps in constant time.
+For an iterator type that does not model \libconcept{random_access_iterator},
 \tcode{ranges::advance} instead performs \tcode{n} individual increments with
 the \tcode{++} operator.
 \end{example}
@@ -2696,20 +2696,20 @@
 
 \indexlibrary{\idxcode{advance}}%
 \begin{itemdecl}
-template<Iterator I>
+template<input_or_output_iterator I>
   constexpr void ranges::advance(I& i, iter_difference_t<I> n);
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \expects
-If \tcode{I} does not model \libconcept{BidirectionalIterator},
+If \tcode{I} does not model \libconcept{bidirectional_iterator},
 \tcode{n} is not negative.
 
 \pnum
 \effects
 \begin{itemize}
-\item If \tcode{I} models \libconcept{RandomAccessIterator},
+\item If \tcode{I} models \libconcept{random_access_iterator},
   equivalent to \tcode{i += n}.
 \item Otherwise, if \tcode{n} is non-negative, increments
   \tcode{i} by \tcode{n}.
@@ -2719,7 +2719,7 @@
 
 \indexlibrary{\idxcode{advance}}%
 \begin{itemdecl}
-template<Iterator I, Sentinel<I> S>
+template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr void ranges::advance(I& i, S bound);
 \end{itemdecl}
 
@@ -2731,9 +2731,9 @@
 \pnum
 \effects
 \begin{itemize}
-\item If \tcode{I} and \tcode{S} model \tcode{\libconcept{Assignable}<I\&, S>},
+\item If \tcode{I} and \tcode{S} model \tcode{\libconcept{assignable_from}<I\&, S>},
   equivalent to \tcode{i = std::move(bound)}.
-\item Otherwise, if \tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>},
+\item Otherwise, if \tcode{S} and \tcode{I} model \tcode{\libconcept{sized_sentinel_for}<S, I>},
   equivalent to \tcode{ranges::advance(i, bound - i)}.
 \item Otherwise, while \tcode{bool(i != bound)} is \tcode{true},
   increments \tcode{i}.
@@ -2742,7 +2742,7 @@
 
 \indexlibrary{\idxcode{advance}}%
 \begin{itemdecl}
-template<Iterator I, Sentinel<I> S>
+template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr iter_difference_t<I> ranges::advance(I& i, iter_difference_t<I> n, S bound);
 \end{itemdecl}
 
@@ -2752,13 +2752,13 @@
 If \tcode{n > 0}, \range{i}{bound} denotes a range.
 If \tcode{n == 0}, \range{i}{bound} or \range{bound}{i} denotes a range.
 If \tcode{n < 0}, \range{bound}{i} denotes a range,
-\tcode{I} models \libconcept{BidirectionalIterator}, and
-\tcode{I} and \tcode{S} model \tcode{\libconcept{Same}<I, S>}.
+\tcode{I} models \libconcept{bidirectional_iterator}, and
+\tcode{I} and \tcode{S} model \tcode{\libconcept{same_to}<I, S>}.
 
 \pnum
 \effects
 \begin{itemize}
-\item If \tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>}:
+\item If \tcode{S} and \tcode{I} model \tcode{\libconcept{sized_sentinel_for}<S, I>}:
   \begin{itemize}
   \item If \brk{}$|\tcode{n}| \ge |\tcode{bound - i}|$,
     equivalent to \tcode{ranges::advance(i, bound)}.
@@ -2784,7 +2784,7 @@
 \rSec3[range.iter.op.distance]{\tcode{ranges::distance}}
 \indexlibrary{\idxcode{distance}}%
 \begin{itemdecl}
-template<Iterator I, Sentinel<I> S>
+template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr iter_difference_t<I> ranges::distance(I first, S last);
 \end{itemdecl}
 
@@ -2794,11 +2794,11 @@
 \range{first}{last} denotes a range, or
 \range{last}{first} denotes a range and
 \tcode{S} and \tcode{I} model
-\tcode{Same<S, I> \&\& SizedSentinel<S, I>}.
+\tcode{\libconcept{same_to}<S, I> \&\& \libconcept{sized_sentinel_for}<S, I>}.
 
 \pnum
 \effects
-If \tcode{S} and \tcode{I} model \tcode{\libconcept{SizedSentinel}<S, I>},
+If \tcode{S} and \tcode{I} model \tcode{\libconcept{sized_sentinel_for}<S, I>},
 returns \tcode{(last - first)};
 otherwise, returns the number of increments needed to get from
 \tcode{first}
@@ -2808,14 +2808,14 @@
 
 \indexlibrary{\idxcode{distance}}%
 \begin{itemdecl}
-template<Range R>
+template<range R>
   constexpr iter_difference_t<iterator_t<R>> ranges::distance(R&& r);
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \effects
-If \tcode{R} models \libconcept{SizedRange}, equivalent to:
+If \tcode{R} models \libconcept{sized_range}, equivalent to:
 \begin{codeblock}
 return ranges::size(r);                                         // \ref{range.prim.size}
 \end{codeblock}
@@ -2829,7 +2829,7 @@
 
 \indexlibrary{\idxcode{next}}%
 \begin{itemdecl}
-template<Iterator I>
+template<input_or_output_iterator I>
   constexpr I ranges::next(I x);
 \end{itemdecl}
 
@@ -2840,7 +2840,7 @@
 
 \indexlibrary{\idxcode{next}}%
 \begin{itemdecl}
-template<Iterator I>
+template<input_or_output_iterator I>
   constexpr I ranges::next(I x, iter_difference_t<I> n);
 \end{itemdecl}
 
@@ -2851,7 +2851,7 @@
 
 \indexlibrary{\idxcode{next}}%
 \begin{itemdecl}
-template<Iterator I, Sentinel<I> S>
+template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr I ranges::next(I x, S bound);
 \end{itemdecl}
 
@@ -2862,7 +2862,7 @@
 
 \indexlibrary{\idxcode{next}}%
 \begin{itemdecl}
-template<Iterator I, Sentinel<I> S>
+template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr I ranges::next(I x, iter_difference_t<I> n, S bound);
 \end{itemdecl}
 
@@ -2874,7 +2874,7 @@
 \rSec3[range.iter.op.prev]{\tcode{ranges::prev}}
 \indexlibrary{\idxcode{prev}}%
 \begin{itemdecl}
-template<BidirectionalIterator I>
+template<bidirectional_iterator I>
   constexpr I ranges::prev(I x);
 \end{itemdecl}
 
@@ -2885,7 +2885,7 @@
 
 \indexlibrary{\idxcode{prev}}%
 \begin{itemdecl}
-template<BidirectionalIterator I>
+template<bidirectional_iterator I>
   constexpr I ranges::prev(I x, iter_difference_t<I> n);
 \end{itemdecl}
 
@@ -2896,7 +2896,7 @@
 
 \indexlibrary{\idxcode{prev}}%
 \begin{itemdecl}
-template<BidirectionalIterator I>
+template<bidirectional_iterator I>
   constexpr I ranges::prev(I x, iter_difference_t<I> n, I bound);
 \end{itemdecl}
 
@@ -2950,7 +2950,7 @@
 
     friend constexpr iter_rvalue_reference_t<Iterator>
       iter_move(const reverse_iterator& i) noexcept(@\seebelow@);
-    template<IndirectlySwappable<Iterator> Iterator2>
+    template<indirectly_swappable<Iterator> Iterator2>
       friend constexpr void
         iter_swap(const reverse_iterator& x,
                   const reverse_iterator<Iterator2>& y) noexcept(@\seebelow@);
@@ -2966,7 +2966,7 @@
 \begin{itemize}
 \item
 \tcode{random_access_iterator_tag} if \tcode{Iterator} models
-\libconcept{RandomAccessIterator}, and
+\libconcept{random_access_iterator}, and
 \item
 \tcode{bidirectional_iterator_tag} otherwise.
 \end{itemize}
@@ -2978,7 +2978,7 @@
 \tcode{random_access_iterator_tag} if
 the type
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} models
-\tcode{\libconcept{DerivedFrom}<random_access_iterator_tag>}, and
+\tcode{\libconcept{derived_from}<random_access_iterator_tag>}, and
 \item
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} otherwise.
 \end{itemize}
@@ -2991,7 +2991,7 @@
 shall either meet the requirements of a
 \oldconcept{BidirectionalIterator}\iref{bidirectional.iterators}
 or model
-\libconcept{BidirectionalIterator}\iref{iterator.concept.bidir}.
+\libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}.
 
 \pnum
 Additionally,
@@ -2999,7 +2999,7 @@
 shall either meet the requirements of a
 \oldconcept{RandomAccessIterator}\iref{random.access.iterators}
 or model
-\libconcept{RandomAccessIterator}\iref{iterator.concept.random.access}
+\libconcept{random_access_iterator}\iref{iterator.concept.random.access}
 if the definitions of any of the members
 \begin{itemize}
 \item
@@ -3431,7 +3431,7 @@
 
 \indexlibrarymember{iter_swap}{reverse_iterator}%
 \begin{itemdecl}
-template<IndirectlySwappable<Iterator> Iterator2>
+template<indirectly_swappable<Iterator> Iterator2>
   friend constexpr void
     iter_swap(const reverse_iterator& x,
               const reverse_iterator<Iterator2>& y) noexcept(@\seebelow@);
@@ -3923,28 +3923,28 @@
     constexpr move_iterator& operator-=(difference_type n);
     constexpr reference operator[](difference_type n) const;
 
-    template<Sentinel<Iterator> S>
+    template<sentinel_for<Iterator> S>
       friend constexpr bool
         operator==(const move_iterator& x, const move_sentinel<S>& y);
-    template<Sentinel<Iterator> S>
+    template<sentinel_for<Iterator> S>
       friend constexpr bool
         operator==(const move_sentinel<S>& x, const move_iterator& y);
-    template<Sentinel<Iterator> S>
+    template<sentinel_for<Iterator> S>
       friend constexpr bool
         operator!=(const move_iterator& x, const move_sentinel<S>& y);
-    template<Sentinel<Iterator> S>
+    template<sentinel_for<Iterator> S>
       friend constexpr bool
         operator!=(const move_sentinel<S>& x, const move_iterator& y);
-    template<SizedSentinel<Iterator> S>
+    template<sized_sentinel_for<Iterator> S>
       friend constexpr iter_difference_t<Iterator>
         operator-(const move_sentinel<S>& x, const move_iterator& y);
-    template<SizedSentinel<Iterator> S>
+    template<sized_sentinel_for<Iterator> S>
       friend constexpr iter_difference_t<Iterator>
         operator-(const move_iterator& x, const move_sentinel<S>& y);
     friend constexpr iter_rvalue_reference_t<Iterator>
       iter_move(const move_iterator& i)
         noexcept(noexcept(ranges::iter_move(i.current)));
-    template<IndirectlySwappable<Iterator> Iterator2>
+    template<indirectly_swappable<Iterator> Iterator2>
       friend constexpr void
         iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
           noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
@@ -3962,7 +3962,7 @@
 \tcode{random_access_iterator_tag} if
 the type
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} models
-\tcode{\libconcept{DerivedFrom}<random_access_iterator_tag>}, and
+\tcode{\libconcept{derived_from}<random_access_iterator_tag>}, and
 \item
 \tcode{iterator_traits<\brk{}Iterator>::iterator_category} otherwise.
 \end{itemize}
@@ -3972,16 +3972,16 @@
 \pnum
 The template parameter \tcode{Iterator} shall either
 meet the \oldconcept{InputIterator} requirements\iref{input.iterators}
-or model \libconcept{InputIterator}\iref{iterator.concept.input}.
+or model \libconcept{input_iterator}\iref{iterator.concept.input}.
 Additionally, if any of the bidirectional traversal
 functions are instantiated, the template parameter shall either
 meet the \oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators}
-or model \libconcept{BidirectionalIterator}\iref{iterator.concept.bidir}.
+or model \libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}.
 If any of the random access traversal functions are instantiated, the
 template parameter shall either
 meet the \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
 or model
-\libconcept{RandomAccess\-Iterator}\iref{iterator.concept.random.access}.
+\libconcept{random_access_iterator}\iref{iterator.concept.random.access}.
 
 \rSec3[move.iter.cons]{Construction and assignment}
 
@@ -4096,7 +4096,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-If \tcode{Iterator} models \libconcept{ForwardIterator}, equivalent to:
+If \tcode{Iterator} models \libconcept{forward_iterator}, equivalent to:
 \begin{codeblock}
 move_iterator tmp = *this;
 ++current;
@@ -4187,10 +4187,10 @@
 template<class Iterator1, class Iterator2>
   constexpr bool operator==(const move_iterator<Iterator1>& x,
                             const move_iterator<Iterator2>& y);
-template<Sentinel<Iterator> S>
+template<sentinel_for<Iterator> S>
   friend constexpr bool operator==(const move_iterator& x,
                                    const move_sentinel<S>& y);
-template<Sentinel<Iterator> S>
+template<sentinel_for<Iterator> S>
   friend constexpr bool operator==(const move_sentinel<S>& x,
                                    const move_iterator& y);
 \end{itemdecl}
@@ -4210,10 +4210,10 @@
 template<class Iterator1, class Iterator2>
   constexpr bool operator!=(const move_iterator<Iterator1>& x,
                             const move_iterator<Iterator2>& y);
-template<Sentinel<Iterator> S>
+template<sentinel_for<Iterator> S>
   friend constexpr bool operator!=(const move_iterator& x,
                                    const move_sentinel<S>& y);
-template<Sentinel<Iterator> S>
+template<sentinel_for<Iterator> S>
   friend constexpr bool operator!=(const move_sentinel<S>& x,
                                    const move_iterator& y);
 \end{itemdecl}
@@ -4300,10 +4300,10 @@
   constexpr auto operator-(const move_iterator<Iterator1>& x,
                            const move_iterator<Iterator2>& y)
     -> decltype(x.base() - y.base());
-template<SizedSentinel<Iterator> S>
+template<sized_sentinel_for<Iterator> S>
   friend constexpr iter_difference_t<Iterator>
     operator-(const move_sentinel<S>& x, const move_iterator& y);
-template<SizedSentinel<Iterator> S>
+template<sized_sentinel_for<Iterator> S>
   friend constexpr iter_difference_t<Iterator>
     operator-(const move_iterator& x, const move_sentinel<S>& y);
 \end{itemdecl}
@@ -4343,7 +4343,7 @@
 
 \indexlibrarymember{iter_swap}{move_iterator}%
 \begin{itemdecl}
-template<IndirectlySwappable<Iterator> Iterator2>
+template<indirectly_swappable<Iterator> Iterator2>
   friend constexpr void
     iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
@@ -4370,9 +4370,9 @@
 \pnum
 Class template \tcode{move_sentinel} is a sentinel adaptor useful for denoting
 ranges together with \tcode{move_iterator}. When an input iterator type
-\tcode{I} and sentinel type \tcode{S} model \tcode{\libconcept{Sentinel}<S, I>},
+\tcode{I} and sentinel type \tcode{S} model \tcode{\libconcept{sentinel_for}<S, I>},
 \tcode{move_sentinel<S>} and \tcode{move_iterator<I>} model
-\tcode{Sentinel<move_sentinel<S>, move_iterator<I>{>}} as well.
+\tcode{\libconcept{sentinel_for}<move_sentinel<S>, move_iterator<I>{>}} as well.
 
 \pnum
 \begin{example}
@@ -4380,9 +4380,9 @@
 \tcode{copy_if} using \tcode{move_iterator} and \tcode{move_sentinel}:
 
 \begin{codeblock}
-template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
-         IndirectUnaryPredicate<I> Pred>
-  requires IndirectlyMovable<I, O>
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         indirect_unary_predicate<I> Pred>
+  requires indirectly_movable<I, O>
 void move_if(I first, S last, O out, Pred pred) {
   std::ranges::copy_if(move_iterator<I>{first}, move_sentinel<S>{last}, out, pred);
 }
@@ -4392,16 +4392,16 @@
 \indexlibrary{\idxcode{move_sentinel}}%
 \begin{codeblock}
 namespace std {
-  template<Semiregular S>
+  template<semiregular S>
   class move_sentinel {
   public:
     constexpr move_sentinel();
     constexpr explicit move_sentinel(S s);
     template<class S2>
-      requires ConvertibleTo<const S2&, S>
+      requires convertible_to<const S2&, S>
         constexpr move_sentinel(const move_sentinel<S2>& s);
     template<class S2>
-      requires Assignable<S&, const S2&>
+      requires assignable_from<S&, const S2&>
         constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
 
     constexpr S base() const;
@@ -4438,7 +4438,7 @@
 \indexlibrary{\idxcode{move_sentinel}!constructor}%
 \begin{itemdecl}
 template<class S2>
-  requires ConvertibleTo<const S2&, S>
+  requires convertible_to<const S2&, S>
     constexpr move_sentinel(const move_sentinel<S2>& s);
 \end{itemdecl}
 
@@ -4451,7 +4451,7 @@
 \indexlibrary{\idxcode{move_sentinel}!\idxcode{operator=}}%
 \begin{itemdecl}
 template<class S2>
-  requires Assignable<S&, const S2&>
+  requires assignable_from<S&, const S2&>
     constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
 \end{itemdecl}
 
@@ -4494,20 +4494,20 @@
 \indexlibrary{\idxcode{common_iterator}}%
 \begin{codeblock}
 namespace std {
-  template<Iterator I, Sentinel<I> S>
-    requires (!Same<I, S>)
+  template<input_or_output_iterator I, sentinel_for<I> S>
+    requires (!same_to<I, S>)
   class common_iterator {
   public:
     constexpr common_iterator() = default;
     constexpr common_iterator(I i);
     constexpr common_iterator(S s);
     template<class I2, class S2>
-      requires ConvertibleTo<const I2&, I> && ConvertibleTo<const S2&, S>
+      requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
         constexpr common_iterator(const common_iterator<I2, S2>& x);
 
     template<class I2, class S2>
-      requires ConvertibleTo<const I2&, I> && ConvertibleTo<const S2&, S> &&
-               Assignable<I&, const I2&> && Assignable<S&, const S2&>
+      requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
+               assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
         common_iterator& operator=(const common_iterator<I2, S2>& x);
 
     decltype(auto) operator*();
@@ -4519,28 +4519,28 @@
     common_iterator& operator++();
     decltype(auto) operator++(int);
 
-    template<class I2, Sentinel<I> S2>
-      requires Sentinel<S, I2>
+    template<class I2, sentinel_for<I> S2>
+      requires sentinel_for<S, I2>
     friend bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
-    template<class I2, Sentinel<I> S2>
-      requires Sentinel<S, I2> && EqualityComparableWith<I, I2>
+    template<class I2, sentinel_for<I> S2>
+      requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
     friend bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
-    template<class I2, Sentinel<I> S2>
-      requires Sentinel<S, I2>
+    template<class I2, sentinel_for<I> S2>
+      requires sentinel_for<S, I2>
     friend bool operator!=(
       const common_iterator& x, const common_iterator<I2, S2>& y);
 
-    template<SizedSentinel<I> I2, SizedSentinel<I> S2>
-      requires SizedSentinel<S, I2>
+    template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
+      requires sized_sentinel_for<S, I2>
     friend iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
 
     friend iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
-        requires InputIterator<I>;
-    template<IndirectlySwappable<I> I2, class S2>
+        requires input_iterator<I>;
+    template<indirectly_swappable<I> I2, class S2>
       friend void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 
@@ -4553,7 +4553,7 @@
     using difference_type = iter_difference_t<I>;
   };
 
-  template<InputIterator I, class S>
+  template<input_iterator I, class S>
   struct iterator_traits<common_iterator<I, S>> {
     using iterator_concept = @\seebelow@;
     using iterator_category = @\seebelow@;
@@ -4573,14 +4573,14 @@
 \begin{itemize}
 \item
 \tcode{iterator_concept} denotes \tcode{forward_iterator_tag}
-if \tcode{I} models \libconcept{ForwardIterator};
+if \tcode{I} models \libconcept{forward_iterator};
 otherwise it denotes \tcode{input_iterator_tag}.
 
 \item
 \tcode{iterator_category} denotes
 \tcode{forward_iterator_tag}
 if \tcode{iterator_traits<I>::iterator_category}
-models \tcode{DerivedFrom<forward_iterator_tag>};
+models \tcode{\libconcept{derived_from}<forward_iterator_tag>};
 otherwise it denotes \tcode{input_iterator_tag}.
 
 \item
@@ -4617,7 +4617,7 @@
 \indexlibrary{\idxcode{common_iterator}!constructor}%
 \begin{itemdecl}
 template<class I2, class S2>
-  requires ConvertibleTo<const I2&, I> && ConvertibleTo<const S2&, S>
+  requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
     constexpr common_iterator(const common_iterator<I2, S2>& x);
 \end{itemdecl}
 
@@ -4635,8 +4635,8 @@
 \indexlibrarymember{operator=}{common_iterator}%
 \begin{itemdecl}
 template<class I2, class S2>
-  requires ConvertibleTo<const I2&, I> && ConvertibleTo<const S2&, S> &&
-           Assignable<I&, const I2&> && Assignable<S&, const S2&>
+  requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
+           assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
     common_iterator& operator=(const common_iterator<I2, S2>& x);
 \end{itemdecl}
 
@@ -4686,10 +4686,10 @@
 \pnum
 The expression in the requires clause is equivalent to:
 \begin{codeblock}
-Readable<const I> &&
+readable<const I> &&
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
- Constructible<iter_value_t<I>, iter_reference_t<I>>)
+ constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 \end{codeblock}
 
 \pnum
@@ -4757,7 +4757,7 @@
 
 \pnum
 \effects
-If \tcode{I} models \libconcept{ForwardIterator}, equivalent to:
+If \tcode{I} models \libconcept{forward_iterator}, equivalent to:
 \begin{codeblock}
 common_iterator tmp = *this;
 ++*this;
@@ -4770,8 +4770,8 @@
 
 \indexlibrarymember{operator==}{common_iterator}%
 \begin{itemdecl}
-template<class I2, Sentinel<I> S2>
-  requires Sentinel<S, I2>
+template<class I2, sentinel_for<I> S2>
+  requires sentinel_for<S, I2>
 friend bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 \end{itemdecl}
@@ -4791,8 +4791,8 @@
 
 \indexlibrarymember{operator==}{common_iterator}%
 \begin{itemdecl}
-template<class I2, Sentinel<I> S2>
-  requires Sentinel<S, I2> && EqualityComparableWith<I, I2>
+template<class I2, sentinel_for<I> S2>
+  requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
 friend bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 \end{itemdecl}
@@ -4812,8 +4812,8 @@
 
 \indexlibrarymember{operator"!=}{common_iterator}%
 \begin{itemdecl}
-template<class I2, Sentinel<I> S2>
-  requires Sentinel<S, I2>
+template<class I2, sentinel_for<I> S2>
+  requires sentinel_for<S, I2>
 friend bool operator!=(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 \end{itemdecl}
@@ -4825,8 +4825,8 @@
 
 \indexlibrarymember{operator-}{common_iterator}%
 \begin{itemdecl}
-template<SizedSentinel<I> I2, SizedSentinel<I> S2>
-  requires SizedSentinel<S, I2>
+template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
+  requires sized_sentinel_for<S, I2>
 friend iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 \end{itemdecl}
@@ -4850,7 +4850,7 @@
 \begin{itemdecl}
 friend iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
-    requires InputIterator<I>;
+    requires input_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4863,7 +4863,7 @@
 
 \indexlibrarymember{iter_swap}{common_iterator}%
 \begin{itemdecl}
-template<IndirectlySwappable<I> I2, class S2>
+template<indirectly_swappable<I> I2, class S2>
   friend void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 \end{itemdecl}
@@ -4930,7 +4930,7 @@
 \indexlibrary{\idxcode{counted_iterator}}%
 \begin{codeblock}
 namespace std {
-  template<Iterator I>
+  template<input_or_output_iterator I>
   class counted_iterator {
   public:
     using iterator_type = I;
@@ -4938,11 +4938,11 @@
     constexpr counted_iterator() = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
-      requires ConvertibleTo<const I2&, I>
+      requires convertible_to<const I2&, I>
         constexpr counted_iterator(const counted_iterator<I2>& x);
 
     template<class I2>
-      requires Assignable<I&, const I2&>
+      requires assignable_from<I&, const I2&>
         constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
 
     constexpr I base() const;
@@ -4954,23 +4954,23 @@
     constexpr counted_iterator& operator++();
     decltype(auto) operator++(int);
     constexpr counted_iterator operator++(int)
-      requires ForwardIterator<I>;
+      requires forward_iterator<I>;
     constexpr counted_iterator& operator--()
-      requires BidirectionalIterator<I>;
+      requires bidirectional_iterator<I>;
     constexpr counted_iterator operator--(int)
-      requires BidirectionalIterator<I>;
+      requires bidirectional_iterator<I>;
 
     constexpr counted_iterator operator+(iter_difference_t<I> n) const
-      requires RandomAccessIterator<I>;
+      requires random_access_iterator<I>;
     friend constexpr counted_iterator operator+(
       iter_difference_t<I> n, const counted_iterator& x)
-        requires RandomAccessIterator<I>;
+        requires random_access_iterator<I>;
     constexpr counted_iterator& operator+=(iter_difference_t<I> n)
-      requires RandomAccessIterator<I>;
+      requires random_access_iterator<I>;
 
     constexpr counted_iterator operator-(iter_difference_t<I> n) const
-      requires RandomAccessIterator<I>;
-    template<Common<I> I2>
+      requires random_access_iterator<I>;
+    template<common_with<I> I2>
       friend constexpr iter_difference_t<I2> operator-(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr iter_difference_t<I> operator-(
@@ -4978,12 +4978,12 @@
     friend constexpr iter_difference_t<I> operator-(
       default_sentinel_t, const counted_iterator& y);
     constexpr counted_iterator& operator-=(iter_difference_t<I> n)
-      requires RandomAccessIterator<I>;
+      requires random_access_iterator<I>;
 
     constexpr decltype(auto) operator[](iter_difference_t<I> n) const
-      requires RandomAccessIterator<I>;
+      requires random_access_iterator<I>;
 
-    template<Common<I> I2>
+    template<common_with<I> I2>
       friend constexpr bool operator==(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr bool operator==(
@@ -4991,7 +4991,7 @@
     friend constexpr bool operator==(
       default_sentinel_t, const counted_iterator& x);
 
-    template<Common<I> I2>
+    template<common_with<I> I2>
       friend constexpr bool operator!=(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr bool operator!=(
@@ -4999,23 +4999,23 @@
     friend constexpr bool operator!=(
       default_sentinel_t x, const counted_iterator& y);
 
-    template<Common<I> I2>
+    template<common_with<I> I2>
       friend constexpr bool operator<(
         const counted_iterator& x, const counted_iterator<I2>& y);
-    template<Common<I> I2>
+    template<common_with<I> I2>
       friend constexpr bool operator>(
         const counted_iterator& x, const counted_iterator<I2>& y);
-    template<Common<I> I2>
+    template<common_with<I> I2>
       friend constexpr bool operator<=(
         const counted_iterator& x, const counted_iterator<I2>& y);
-    template<Common<I> I2>
+    template<common_with<I> I2>
       friend constexpr bool operator>=(
         const counted_iterator& x, const counted_iterator<I2>& y);
 
     friend constexpr iter_rvalue_reference_t<I> iter_move(const counted_iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current)))
-        requires InputIterator<I>;
-    template<IndirectlySwappable<I> I2>
+        requires input_iterator<I>;
+    template<indirectly_swappable<I> I2>
       friend constexpr void iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
         noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 
@@ -5029,7 +5029,7 @@
     using difference_type = iter_difference_t<I>;
   };
 
-  template<InputIterator I>
+  template<input_iterator I>
   struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
     using pointer = void;
   };
@@ -5056,7 +5056,7 @@
 \indexlibrary{\idxcode{counted_iterator}!constructor}%
 \begin{itemdecl}
 template<class I2>
-  requires ConvertibleTo<const I2&, I>
+  requires convertible_to<const I2&, I>
     constexpr counted_iterator(const counted_iterator<I2>& x);
 \end{itemdecl}
 
@@ -5070,7 +5070,7 @@
 \indexlibrarymember{operator=}{counted_iterator}%
 \begin{itemdecl}
 template<class I2>
-  requires Assignable<I&, const I2&>
+  requires assignable_from<I&, const I2&>
     constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
 \end{itemdecl}
 
@@ -5123,7 +5123,7 @@
 \indexlibrarymember{operator[]}{counted_iterator}%
 \begin{itemdecl}
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
-  requires RandomAccessIterator<I>;
+  requires random_access_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5175,7 +5175,7 @@
 \indexlibrarymember{operator++}{counted_iterator}%
 \begin{itemdecl}
 constexpr counted_iterator operator++(int)
-  requires ForwardIterator<I>;
+  requires forward_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5191,7 +5191,7 @@
 \indexlibrarymember{operator{-}-}{counted_iterator}%
 \begin{itemdecl}
   constexpr counted_iterator& operator--();
-    requires BidirectionalIterator<I>
+    requires bidirectional_iterator<I>
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5207,7 +5207,7 @@
 \indexlibrarymember{operator{-}-}{counted_iterator}%
 \begin{itemdecl}
   constexpr counted_iterator operator--(int)
-    requires BidirectionalIterator<I>;
+    requires bidirectional_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5223,7 +5223,7 @@
 \indexlibrarymember{operator+}{counted_iterator}%
 \begin{itemdecl}
   constexpr counted_iterator operator+(iter_difference_t<I> n) const
-    requires RandomAccessIterator<I>;
+    requires random_access_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5235,7 +5235,7 @@
 \begin{itemdecl}
 friend constexpr counted_iterator operator+(
   iter_difference_t<I> n, const counted_iterator& x)
-    requires RandomAccessIterator<I>;
+    requires random_access_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5246,7 +5246,7 @@
 \indexlibrarymember{operator+=}{counted_iterator}%
 \begin{itemdecl}
   constexpr counted_iterator& operator+=(iter_difference_t<I> n)
-    requires RandomAccessIterator<I>;
+    requires random_access_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5265,7 +5265,7 @@
 \indexlibrarymember{operator-}{counted_iterator}%
 \begin{itemdecl}
   constexpr counted_iterator operator-(iter_difference_t<I> n) const
-    requires RandomAccessIterator<I>;
+    requires random_access_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5275,7 +5275,7 @@
 
 \indexlibrarymember{operator-}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr iter_difference_t<I2> operator-(
     const counted_iterator& x, const counted_iterator<I2>& y);
 \end{itemdecl}
@@ -5316,7 +5316,7 @@
 \indexlibrarymember{operator-=}{counted_iterator}%
 \begin{itemdecl}
 constexpr counted_iterator& operator-=(iter_difference_t<I> n)
-  requires RandomAccessIterator<I>;
+  requires random_access_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5336,7 +5336,7 @@
 
 \indexlibrarymember{operator==}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr bool operator==(
     const counted_iterator& x, const counted_iterator<I2>& y);
 \end{itemdecl}
@@ -5366,7 +5366,7 @@
 
 \indexlibrarymember{operator"!=}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr bool operator!=(
     const counted_iterator& x, const counted_iterator<I2>& y);
 friend constexpr bool operator!=(
@@ -5382,7 +5382,7 @@
 
 \indexlibrarymember{operator<}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr bool operator<(
     const counted_iterator& x, const counted_iterator<I2>& y);
 \end{itemdecl}
@@ -5405,7 +5405,7 @@
 
 \indexlibrarymember{operator>}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr bool operator>(
     const counted_iterator& x, const counted_iterator<I2>& y);
 \end{itemdecl}
@@ -5417,7 +5417,7 @@
 
 \indexlibrarymember{operator<=}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr bool operator<=(
     const counted_iterator& x, const counted_iterator<I2>& y);
 \end{itemdecl}
@@ -5429,7 +5429,7 @@
 
 \indexlibrarymember{operator>=}{counted_iterator}%
 \begin{itemdecl}
-template<Common<I> I2>
+template<common_with<I> I2>
   friend constexpr bool operator>=(
     const counted_iterator& x, const counted_iterator<I2>& y);
 \end{itemdecl}
@@ -5446,7 +5446,7 @@
 friend constexpr iter_rvalue_reference_t<I>
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
-    requires InputIterator<I>;
+    requires input_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5456,7 +5456,7 @@
 
 \indexlibrarymember{iter_swap}{counted_iterator}%
 \begin{itemdecl}
-template<IndirectlySwappable<I> I2>
+template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
@@ -5474,7 +5474,7 @@
 \indexlibrary{\idxcode{unreachable_sentinel_t}}%
 \pnum
 Class \tcode{unreachable_sentinel_t} can be used with
-any \libconcept{WeaklyIncrementable} type
+any \libconcept{weakly_incrementable} type
 to denote the ``upper bound'' of an unbounded interval.
 
 \pnum
@@ -5494,13 +5494,13 @@
 \begin{codeblock}
 namespace std {
   struct unreachable_sentinel_t {
-    template<WeaklyIncrementable I>
+    template<weakly_incrementable I>
       friend constexpr bool operator==(unreachable_sentinel_t, const I&) noexcept;
-    template<WeaklyIncrementable I>
+    template<weakly_incrementable I>
       friend constexpr bool operator==(const I&, unreachable_sentinel_t) noexcept;
-    template<WeaklyIncrementable I>
+    template<weakly_incrementable I>
       friend constexpr bool operator!=(unreachable_sentinel_t, const I&) noexcept;
-    template<WeaklyIncrementable I>
+    template<weakly_incrementable I>
       friend constexpr bool operator!=(const I&, unreachable_sentinel_t) noexcept;
   };
 }
@@ -5511,9 +5511,9 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{unreachable_sentinel_t}}%
 \indexlibrary{\idxcode{unreachable_sentinel_t}!\idxcode{operator==}}%
 \begin{itemdecl}
-template<WeaklyIncrementable I>
+template<weakly_incrementable I>
   friend constexpr bool operator==(unreachable_sentinel_t, const I&) noexcept;
-template<WeaklyIncrementable I>
+template<weakly_incrementable I>
   friend constexpr bool operator==(const I&, unreachable_sentinel_t) noexcept;
 \end{itemdecl}
 
@@ -5525,9 +5525,9 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{unreachable_sentinel_t}}%
 \indexlibrary{\idxcode{unreachable_sentinel_t}!\idxcode{operator"!=}}%
 \begin{itemdecl}
-template<WeaklyIncrementable I>
+template<weakly_incrementable I>
   friend constexpr bool operator!=(unreachable_sentinel_t, const I&) noexcept;
-template<WeaklyIncrementable I>
+template<weakly_incrementable I>
   friend constexpr bool operator!=(const I&, unreachable_sentinel_t) noexcept;
 \end{itemdecl}
 
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 4e0f17489f..1860d4662e 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -512,7 +512,7 @@
 requirement. Names in \tcode{constant width} type refer to library concepts
 which are presented as a concept definition\iref{temp}, possibly with additional
 prose semantic requirements. For example,
-\libconcept{Destructible}\iref{concept.destructible}
+\libconcept{destructible}\iref{concept.destructible}
 is such a named requirement.
 
 \pnum
@@ -532,7 +532,7 @@
 total functions; that is, some arguments to a required operation may
 result in the required semantics failing to be met.
 \begin{example}
-The required \tcode{<} operator of the \libconcept{StrictTotallyOrdered}
+The required \tcode{<} operator of the \libconcept{totally_ordered}
 concept\iref{concept.stricttotallyordered} does not meet the
 semantic requirements of that concept when operating on NaNs.
 \end{example}
@@ -998,7 +998,7 @@
 
 \pnum
 The type of a customization point object shall model
-\libconcept{Semiregular}\iref{concepts.object}.
+\libconcept{semiregular}\iref{concepts.object}.
 
 \pnum
 All instances of a specific customization point object type shall
@@ -1006,7 +1006,7 @@
 
 \pnum
 The type \tcode{T} of a customization point object shall model
-\tcode{\libconcept{Invocable}<const T\&, Args...>}\iref{concept.invocable}
+\tcode{\libconcept{invocable}<const T\&, Args...>}\iref{concept.invocable}
 when the types in \tcode{Args...} meet the requirements specified in that
 customization point object's definition. When the types of \tcode{Args...} do
 not meet the customization point object's requirements, \tcode{T} shall not have
diff --git a/source/numerics.tex b/source/numerics.tex
index 5f1defb9d6..5a49b408b9 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -1554,7 +1554,7 @@
 namespace std {
   // \ref{rand.req.urng}, uniform random bit generator requirements
   template<class G>
-    concept UniformRandomBitGenerator = @\seebelow@;
+    concept uniform_random_bit_generator = @\seebelow@;
 
   // \ref{rand.eng.lcong}, class template \tcode{linear_congruential_engine}
   template<class UIntType, UIntType a, UIntType c, UIntType m>
@@ -1947,17 +1947,17 @@
 
 \begin{codeblock}
 template<class G>
-  concept UniformRandomBitGenerator =
-    Invocable<G&> && UnsignedIntegral<invoke_result_t<G&>> &&
+  concept uniform_random_bit_generator =
+    invocable<G&> && unsigned_integral<invoke_result_t<G&>> &&
     requires {
-      { G::min() } -> Same<invoke_result_t<G&>>;
-      { G::max() } -> Same<invoke_result_t<G&>>;
+      { G::min() } -> same_to<invoke_result_t<G&>>;
+      { G::max() } -> same_to<invoke_result_t<G&>>;
     };
 \end{codeblock}
 
 \pnum
 Let \tcode{g} be an object of type \tcode{G}. \tcode{G} models
-\libconcept{UniformRandomBitGenerator} only if
+\libconcept{uniform_random_bit_generator} only if
 
 \begin{itemize}
 \item both \tcode{G::min()} and \tcode{G::max()} are constant
@@ -1972,7 +1972,7 @@
 \indextext{uniform random bit generator!requirements|)}%
 \pnum
 A class \tcode{G} meets the \term{uniform random bit generator} requirements if
-\tcode{G} models \libconcept{UniformRandomBitGenerator},
+\tcode{G} models \libconcept{uniform_random_bit_generator},
 \tcode{invoke_result_t<G\&>} is an unsigned integer type\iref{basic.fundamental},
 and
 \tcode{G} provides a nested \grammarterm{typedef-name} \tcode{result_type}
@@ -8491,12 +8491,12 @@
 In the \tcode{begin} and \tcode{end} function templates that follow, \unspec{1}
 is a type that meets the requirements of a mutable
 \oldconcept{RandomAccessIterator}\iref{random.access.iterators}
-and models \libconcept{ContiguousIterator}\iref{iterator.concept.contiguous},
+and models \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
 whose \tcode{value_type} is the template
 parameter \tcode{T} and whose \tcode{reference} type is \tcode{T\&}. \unspec{2} is a
 type that meets the requirements of a constant
 \oldconcept{RandomAccessIterator}
-and models \libconcept{ContiguousIterator},
+and models \libconcept{contiguous_iterator},
 whose \tcode{value_type} is the template
 parameter \tcode{T} and whose \tcode{reference} type is \tcode{const T\&}.
 
diff --git a/source/ranges.tex b/source/ranges.tex
index 671c82b245..2c0b31be6e 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -54,14 +54,14 @@
     using sentinel_t = decltype(ranges::end(declval<T&>()));
 
   template<class T>
-    concept Range = @\seebelow@;
+    concept range = @\seebelow@;
 
   // \ref{range.sized}, sized ranges
   template<class>
     inline constexpr bool disable_sized_range = false;
 
   template<class T>
-    concept SizedRange = @\seebelow@;
+    concept sized_range = @\seebelow@;
 
   // \ref{range.view}, views
   template<class T>
@@ -70,52 +70,52 @@
   struct view_base { };
 
   template<class T>
-    concept View = @\seebelow@;
+    concept view = @\seebelow@;
 
   // \ref{range.refinements}, other range refinements
   template<class R, class T>
-    concept OutputRange = @\seebelow@;
+    concept output_range = @\seebelow@;
 
   template<class T>
-    concept InputRange = @\seebelow@;
+    concept input_range = @\seebelow@;
 
   template<class T>
-    concept ForwardRange = @\seebelow@;
+    concept forward_range = @\seebelow@;
 
   template<class T>
-    concept BidirectionalRange = @\seebelow@;
+    concept bidirectional_range = @\seebelow@;
 
   template<class T>
-    concept RandomAccessRange = @\seebelow@;
+    concept random_access_range = @\seebelow@;
 
   template<class T>
-    concept ContiguousRange = @\seebelow@;
+    concept contiguous_range = @\seebelow@;
 
   template<class T>
-    concept CommonRange = @\seebelow@;
+    concept common_range = @\seebelow@;
 
   template<class T>
-    concept ViewableRange = @\seebelow@;
+    concept viewable_range = @\seebelow@;
 
   // \ref{view.interface}, class template \tcode{view_interface}
   template<class D>
-    requires is_class_v<D> && Same<D, remove_cv_t<D>>
+    requires is_class_v<D> && same_to<D, remove_cv_t<D>>
   class view_interface;
 
   // \ref{range.subrange}, sub-ranges
   enum class subrange_kind : bool { unsized, sized };
 
-  template<Iterator I, Sentinel<I> S = I, subrange_kind K = @\seebelow@>
-    requires (K == subrange_kind::sized || !SizedSentinel<S, I>)
+  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = @\seebelow@>
+    requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
   class subrange;
 
   // \ref{range.dangling}, dangling iterator handling
   struct dangling;
 
-  template<Range R>
+  template<range R>
     using safe_iterator_t = conditional_t<@\placeholder{forwarding-range}@<R>, iterator_t<R>, dangling>;
 
-  template<Range R>
+  template<range R>
     using safe_subrange_t =
       conditional_t<@\placeholder{forwarding-range}@<R>, subrange<iterator_t<R>>, dangling>;
 
@@ -124,96 +124,96 @@
     requires is_object_v<T>
   class empty_view;
 
-  namespace view {
+  namespace views {
     template<class T>
       inline constexpr empty_view<T> empty{};
   }
 
   // \ref{range.single}, single view
-  template<CopyConstructible T>
+  template<copy_constructible T>
     requires is_object_v<T>
   class single_view;
 
-  namespace view { inline constexpr @\unspec@ single = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ single = @\unspec@; }
 
   // \ref{range.iota}, iota view
-  template<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t>
+  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
     requires @\placeholder{weakly-equality-comparable-with}@<W, Bound>
   class iota_view;
 
-  namespace view { inline constexpr @\unspec@ iota = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ iota = @\unspec@; }
 
   // \ref{range.all}, all view
-  namespace view { inline constexpr @\unspec@ all = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ all = @\unspec@; }
 
-  template<ViewableRange R>
+  template<viewable_range R>
     using all_view = decltype(view::all(declval<R>()));
 
-  template<Range R>
+  template<range R>
     requires is_object_v<R>
   class ref_view;
 
   // \ref{range.filter}, filter view
-  template<InputRange V, IndirectUnaryPredicate<iterator_t<V>> Pred>
-    requires View<V> && is_object_v<Pred>
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
   class filter_view;
 
-  namespace view { inline constexpr @\unspec@ filter = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ filter = @\unspec@; }
 
   // \ref{range.transform}, transform view
-  template<InputRange V, CopyConstructible F>
-    requires View<V> && is_object_v<F> &&
-             RegularInvocable<F&, iter_reference_t<iterator_t<V>>>
+  template<input_range V, copy_constructible F>
+    requires view<V> && is_object_v<F> &&
+             regular_invocable<F&, iter_reference_t<iterator_t<V>>>
   class transform_view;
 
-  namespace view { inline constexpr @\unspec@ transform = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ transform = @\unspec@; }
 
   // \ref{range.take}, take view
-  template<View> class take_view;
+  template<view> class take_view;
 
-  namespace view { inline constexpr @\unspec@ take = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ take = @\unspec@; }
 
   // \ref{range.join}, join view
-  template<InputRange V>
-    requires View<V> && InputRange<iter_reference_t<iterator_t<V>>> &&
+  template<input_range V>
+    requires view<V> && input_range<iter_reference_t<iterator_t<V>>> &&
              (is_reference_v<iter_reference_t<iterator_t<V>>> ||
-              View<iter_value_t<iterator_t<V>>>)
+              view<iter_value_t<iterator_t<V>>>)
   class join_view;
 
-  namespace view { inline constexpr @\unspec@ join = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ join = @\unspec@; }
 
   // \ref{range.split}, split view
   template<class R>
     concept @\placeholder{tiny-range}@ = @\seebelow@;   // \expos
 
-  template<InputRange V, ForwardRange Pattern>
-    requires View<V> && View<Pattern> &&
-             IndirectlyComparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
-             (ForwardRange<V> || @\placeholder{tiny-range}@<Pattern>)
+  template<input_range V, forward_range Pattern>
+    requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
+             (forward_range<V> || @\placeholder{tiny-range}@<Pattern>)
   class split_view;
 
-  namespace view { inline constexpr @\unspec@ split = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ split = @\unspec@; }
 
   // \ref{range.counted}, counted view
-  namespace view { inline constexpr @\unspec@ counted = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ counted = @\unspec@; }
 
   // \ref{range.common}, common view
-  template<View V>
-    requires (!CommonRange<V>)
+  template<view V>
+    requires (!common_range<V>)
   class common_view;
 
-  namespace view { inline constexpr @\unspec@ common = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ common = @\unspec@; }
 
   // \ref{range.reverse}, reverse view
-  template<View V>
-    requires BidirectionalRange<V>
+  template<view V>
+    requires bidirectional_range<V>
   class reverse_view;
 
-  namespace view { inline constexpr @\unspec@ reverse = @\unspec@; }
+  namespace views { inline constexpr @\unspec@ reverse = @\unspec@; }
 }
 
 namespace std {
-  namespace view = ranges::view;
+  namespace views = ranges::views;
 
   template<class I, class S, ranges::subrange_kind K>
   struct tuple_size<ranges::subrange<I, S, K>>
@@ -250,11 +250,11 @@
 \item
   Otherwise, if \tcode{E} is an lvalue,
   \tcode{\placeholdernc{decay-copy}(E.begin())}
-  if it is a valid expression and its type \tcode{I} models \tcode{Iterator}.
+  if it is a valid expression and its type \tcode{I} models \libconcept{input_or_output_iterator}.
 
 \item
   Otherwise, \tcode{\placeholdernc{decay-copy}(begin(E))} if it is a
-  valid expression and its type \tcode{I} models \tcode{Iterator} with overload
+  valid expression and its type \tcode{I} models \libconcept{input_or_output_iterator} with overload
   resolution performed in a context that includes the declarations:
   \begin{codeblock}
   template<class T> void begin(T&&) = delete;
@@ -274,7 +274,7 @@
 \pnum
 \begin{note}
 Whenever \tcode{ranges::begin(E)} is a valid expression, its type models
-\tcode{Iterator}.
+\libconcept{input_or_output_iterator}.
 \end{note}
 
 \rSec2[range.access.end]{\tcode{ranges::end}}
@@ -293,12 +293,12 @@
   Otherwise, if \tcode{E} is an lvalue,
   \tcode{\placeholdernc{decay-copy}(E.end())}
   if it is a valid expression and its type \tcode{S} models
-  \tcode{Sentinel<decltype(\brk{}ranges::\brk{}begin(E))>}.
+  \tcode{\libconcept{sentinel_for}<decltype(\brk{}ranges::\brk{}begin(E))>}.
 
 \item
   Otherwise, \tcode{\placeholdernc{decay-copy}(end(E))} if it is a valid
   expression and its type \tcode{S} models
-  \tcode{Sentinel<decltype(\brk{}ranges::\brk{}begin(E))>} with overload
+  \tcode{\libconcept{sentinel_for}<decl\-type(ranges::begin(E))>} with overload
   resolution performed in a context that includes the declarations:
   \begin{codeblock}
   template<class T> void end(T&&) = delete;
@@ -320,7 +320,7 @@
 Whenever \tcode{ranges::end(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::end(E)} and \tcode{ranges::begin(E)}
-model \tcode{\libconcept{Sentinel}<S, I>}.
+model \tcode{\libconcept{sentinel_for}<S, I>}.
 \end{note}
 
 \rSec2[range.access.cbegin]{\tcode{ranges::cbegin}}
@@ -337,7 +337,7 @@
 \pnum
 \begin{note}
 Whenever \tcode{ranges::cbegin(E)} is a valid expression, its type models
-\tcode{Iterator}.
+\libconcept{input_or_output_iterator}.
 \end{note}
 
 \rSec2[range.access.cend]{\tcode{ranges::cend}}
@@ -357,7 +357,7 @@
 Whenever \tcode{ranges::cend(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::cend(E)} and \tcode{ranges::cbegin(E)}
-model \tcode{\libconcept{Sentinel}<S, I>}.
+model \tcode{\libconcept{sentinel_for}<S, I>}.
 \end{note}
 
 \rSec2[range.access.rbegin]{\tcode{ranges::rbegin}}
@@ -370,11 +370,11 @@
 \begin{itemize}
 \item
   If \tcode{E} is an lvalue, \tcode{\placeholdernc{decay-copy}(E.rbegin())}
-  if it is a valid expression and its type \tcode{I} models \tcode{Iterator}.
+  if it is a valid expression and its type \tcode{I} models \libconcept{input_or_output_iterator}.
 
 \item
   Otherwise, \tcode{\placeholdernc{decay-copy}(rbegin(E))} if it is a valid
-  expression and its type \tcode{I} models \tcode{Iterator} with overload
+  expression and its type \tcode{I} models \libconcept{input_or_output_iterator} with overload
   resolution performed in a context that includes the declaration:
   \begin{codeblock}
   template<class T> void rbegin(T&&) = delete;
@@ -386,7 +386,7 @@
   Otherwise, \tcode{make_reverse_iterator(ranges::end(E))} if both
   \tcode{ranges::begin(E)} and \tcode{ranges::end(\brk{}E)} are valid
   expressions of the same type \tcode{I} which models
-  \libconcept{BidirectionalIterator}\iref{iterator.concept.bidir}.
+  \libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}.
 
 \item
   Otherwise, \tcode{ranges::rbegin(E)} is ill-formed.
@@ -399,7 +399,7 @@
 \pnum
 \begin{note}
 Whenever \tcode{ranges::rbegin(E)} is a valid expression, its type models
-\tcode{Iterator}.
+\libconcept{input_or_output_iterator}.
 \end{note}
 
 \rSec2[range.access.rend]{\tcode{ranges::rend}}
@@ -413,12 +413,12 @@
 \item
   If \tcode{E} is an lvalue, \tcode{\placeholdernc{decay-copy}(E.rend())}
   if it is a valid expression and its type \tcode{S} models
-  \tcode{Sentinel<\brk{}decltype(ranges::rbegin(E))>}.
+  \tcode{\libconcept{sentinel_for}<\brk{}decltype(ranges::rbegin(E))>}.
 
 \item
   Otherwise, \tcode{\placeholdernc{decay-copy}(rend(E))} if it is a valid
   expression and its type \tcode{S} models
-  \tcode{Sentinel<decltype(\brk{}ranges::rbegin(E))>} with overload
+  \tcode{\libconcept{sentinel_for}<decl\-type(ranges::rbegin(E))>} with overload
   resolution performed in a context that includes the declaration:
   \begin{codeblock}
   template<class T> void rend(T&&) = delete;
@@ -430,7 +430,7 @@
   Otherwise, \tcode{make_reverse_iterator(ranges::begin(E))} if both
   \tcode{ranges::begin(E)} and \tcode{ranges::\brk{}end(E)} are valid
   expressions of the same type \tcode{I} which models
-  \libconcept{BidirectionalIterator}\iref{iterator.concept.bidir}.
+  \libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}.
 
 \item
   Otherwise, \tcode{ranges::rend(E)} is ill-formed.
@@ -445,7 +445,7 @@
 Whenever \tcode{ranges::rend(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::rend(E)} and \tcode{ranges::rbegin(E)}
-model \tcode{\libconcept{Sentinel}<S, I>}.
+model \tcode{\libconcept{sentinel_for}<S, I>}.
 \end{note}
 
 \rSec2[range.access.crbegin]{\tcode{ranges::crbegin}}
@@ -463,7 +463,7 @@
 \pnum
 \begin{note}
 Whenever \tcode{ranges::crbegin(E)} is a valid expression, its
-type models \tcode{Iterator}.
+type models \libconcept{input_or_output_iterator}.
 \end{note}
 
 \rSec2[range.access.crend]{\tcode{ranges::crend}}
@@ -483,7 +483,7 @@
 Whenever \tcode{ranges::crend(E)} is a valid expression,
 the types \tcode{S} and \tcode{I} of
 \tcode{ranges::crend(E)} and \tcode{ranges::crbegin(E)}
-model \tcode{\libconcept{Sentinel}<S, I>}.
+model \tcode{\libconcept{sentinel_for}<S, I>}.
 \end{note}
 
 \rSec2[range.prim.size]{\tcode{ranges::size}}
@@ -506,12 +506,12 @@
   \item
     \tcode{\placeholdernc{decay-copy}(E.size())}
     if it is a valid expression and its type \tcode{I}
-    models \libconcept{Integral}.
+    models \libconcept{integral}.
 
   \item
     Otherwise, \tcode{\placeholdernc{decay-copy}(size(E))}
     if it is a valid expression and its type \tcode{I}
-    models \libconcept{Integral}
+    models \libconcept{integral}
     with overload resolution performed in a context that includes
     the declaration:
     \begin{codeblock}
@@ -526,8 +526,8 @@
   if it is a valid expression and
   the types \tcode{I} and \tcode{S} of \tcode{ranges::begin(E)} and
   \tcode{ranges::end(E)} (respectively) model both
-  \tcode{\libconcept{SizedSentinel}<S, I>}\iref{iterator.concept.sizedsentinel} and
-  \tcode{\libconcept{Forward\-Iterator}<I>}.
+  \tcode{\libconcept{sized_sentinel_for}<S, I>}\iref{iterator.concept.sizedsentinel} and
+  \tcode{\libconcept{forward_iterator}<I>}.
   However, \tcode{E} is evaluated only once.
 
 \item
@@ -541,7 +541,7 @@
 \pnum
 \begin{note}
 Whenever \tcode{ranges::size(E)} is a valid expression, its
-type models \libconcept{Integral}.
+type models \libconcept{integral}.
 \end{note}
 
 \rSec2[range.prim.empty]{\tcode{ranges::empty}}
@@ -563,7 +563,7 @@
   \tcode{bool(ranges::begin(E) == ranges::end(E))}
   except that \tcode{E} is only evaluated once,
   if \tcode{EQ} is a valid expression and
-  the type of \tcode{ranges::begin(E)} models \libconcept{ForwardIterator}.
+  the type of \tcode{ranges::begin(E)} models \libconcept{forward_iterator}.
 
 \item
   Otherwise, \tcode{ranges::empty(E)} is ill-formed.
@@ -593,7 +593,7 @@
 
 \item
   Otherwise, if \tcode{ranges::begin(E)} is a valid expression whose type models
-  \tcode{ContiguousIterator},
+  \libconcept{contiguous_iterator},
   \begin{codeblock}
   ranges::begin(E) == ranges::end(E) ? nullptr : addressof(*ranges::begin(E))
   \end{codeblock}
@@ -640,33 +640,33 @@
 Ranges are an abstraction that allow a \Cpp{} program
 to operate on elements of data structures uniformly.
 Calling \tcode{ranges::begin} on a range returns an object
-whose type models \libconcept{Iterator}\iref{iterator.concept.iterator}.
+whose type models \libconcept{input_or_output_iterator}\iref{iterator.concept.iterator}.
 Calling \tcode{ranges::end} on a range returns an object whose type \tcode{S},
 together with the type \tcode{I} of the object returned by \tcode{ranges::begin},
-models \tcode{\libconcept{Sentinel}<S, I>}.
+models \tcode{\libconcept{sentinel_for}<S, I>}.
 The library formalizes the interfaces, semantics, and complexity of ranges
 to enable algorithms and range adaptors that work efficiently
 on different types of sequences.
 
 \pnum
-The \libconcept{Range} concept requires that
+The \libconcept{range} concept requires that
 \tcode{ranges::begin} and \tcode{ranges::end}
 return an iterator and a sentinel, respectively.
-The \libconcept{SizedRange} concept refines \libconcept{Range} with
+The \libconcept{sized_range} concept refines \libconcept{range} with
 the requirement that the number of elements in the range can be determined
 in constant time using the \tcode{ranges::size} function.
-The \libconcept{View} concept specifies requirements on a \libconcept{Range} type
+The \libconcept{view} concept specifies requirements on a \libconcept{range} type
 with constant-time copy and assign operations.
 
 \pnum
-Several refinements of \libconcept{Range} group requirements
+Several refinements of \libconcept{range} group requirements
 that arise frequently in concepts and algorithms.
 Common ranges are ranges for which
 \tcode{ranges::begin} and \tcode{ranges::end}
 return objects of the same type.
 Random access ranges are ranges for which \tcode{ranges::begin}
 returns a type that models
-\libconcept{RandomAccessIterator}\iref{iterator.concept.random.access}.
+\libconcept{random_access_iterator}\iref{iterator.concept.random.access}.
 (Contiguous, bidirectional, forward, input, and output ranges
 are defined similarly.)
 Viewable ranges can be converted to views.
@@ -674,11 +674,11 @@
 \rSec2[range.range]{Ranges}
 
 \pnum
-The \libconcept{Range} concept defines the requirements of a type that allows
+The \libconcept{range} concept defines the requirements of a type that allows
 iteration over its elements by providing an iterator and sentinel
 that denote the elements of the range.
 
-\indexlibrary{\idxcode{Range}}%
+\indexlibrary{\idxcode{range}}%
 \begin{itemdecl}
 template<class T>
   concept @\placeholder{range-impl}@ =          // \expos
@@ -688,11 +688,11 @@
     };
 
 template<class T>
-  concept Range = @\placeholdernc{range-impl}@<T&>;
+  concept range = @\placeholdernc{range-impl}@<T&>;
 
 template<class T>
   concept @\placeholder{forwarding-range}@ =    // \expos
-    Range<T> && @\placeholder{range-impl}@<T>;
+    range<T> && @\placeholder{range-impl}@<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -719,18 +719,18 @@
 are amortized constant time and non-modifying, and
 
 \item if the type of \tcode{ranges::begin(E)} models
-\libconcept{ForwardIterator}, \tcode{ranges::begin(E)} is equality-preserving.
+\libconcept{forward_iterator}, \tcode{ranges::begin(E)} is equality-preserving.
 \end{itemize}
 
 \pnum
 \begin{note}
 Equality preservation of both \tcode{ranges::begin} and
-\tcode{ranges::end} enables passing a \libconcept{Range} whose iterator
-type models \libconcept{ForwardIterator} to multiple
+\tcode{ranges::end} enables passing a \libconcept{range} whose iterator
+type models \libconcept{forward_iterator} to multiple
 algorithms and making multiple passes over the range by repeated calls to
 \tcode{ranges::begin} and \tcode{ranges::end}.
 Since \tcode{ranges::begin} is not required to be equality-preserving
-when the return type does not model \libconcept{ForwardIterator}, repeated calls
+when the return type does not model \libconcept{forward_iterator}, repeated calls
 might not return equal values or might not be well-defined;
 \tcode{ranges::begin} should be called at most once for such a range.
 \end{note}
@@ -770,15 +770,15 @@
 \rSec2[range.sized]{Sized ranges}
 
 \pnum
-The \libconcept{SizedRange} concept specifies the requirements
-of a \libconcept{Range} type that knows its size in constant time with the
+The \libconcept{sized_range} concept specifies the requirements
+of a \libconcept{range} type that knows its size in constant time with the
 \tcode{size} function.
 
-\indexlibrary{\idxcode{SizedRange}}%
+\indexlibrary{\idxcode{sized_range}}%
 \begin{itemdecl}
 template<class T>
-  concept SizedRange =
-    Range<T> &&
+  concept sized_range =
+    range<T> &&
     !disable_sized_range<remove_cvref_t<T>> &&
     requires(T& t) { ranges::size(t); };
 \end{itemdecl}
@@ -786,21 +786,21 @@
 \begin{itemdescr}
 \pnum
 Given an lvalue \tcode{t} of type \tcode{remove_reference_t<T>}, \tcode{T}
-models \libconcept{SizedRange} only if
+models \libconcept{sized_range} only if
 
 \begin{itemize}
 \item \tcode{ranges::size(t)} is \bigoh{1}, does not modify \tcode{t},
 and is equal to \tcode{ranges::distance(t)}, and
 
-\item if \tcode{iterator_t<T>} models \libconcept{ForwardIterator},
+\item if \tcode{iterator_t<T>} models \libconcept{forward_iterator},
 \tcode{ranges::size(t)} is well-defined regardless of the evaluation of
 \tcode{ranges::begin(t)}.
 \begin{note}
 \tcode{ranges::size(t)} is otherwise not required to be
 well-defined after evaluating \tcode{ranges::begin(t)}.
 For example, \tcode{ranges::size(t)} might be well-defined
-for a \libconcept{SizedRange} whose iterator type
-does not model \libconcept{ForwardIterator}
+for a \libconcept{sized_range} whose iterator type
+does not model \libconcept{forward_iterator}
 only if evaluated before the first call to \tcode{ranges::begin(t)}.
 \end{note}
 \end{itemize}
@@ -809,35 +809,35 @@
 \begin{note}
 The complexity requirement for the evaluation of \tcode{ranges::size}
 is non-amortized, unlike the case for the complexity of the evaluations of
-\tcode{ranges::begin} and \tcode{ranges::end} in the \libconcept{Range} concept.
+\tcode{ranges::begin} and \tcode{ranges::end} in the \libconcept{range} concept.
 \end{note}
 
 \pnum
 \begin{note}
 \tcode{disable_sized_range} allows use of range types with the library
-that satisfy but do not in fact model \libconcept{SizedRange}.
+that satisfy but do not in fact model \libconcept{sized_range}.
 \end{note}
 \end{itemdescr}
 
 \rSec2[range.view]{Views}
 
 \pnum
-The \libconcept{View} concept specifies the requirements of a \libconcept{Range} type
+The \libconcept{view} concept specifies the requirements of a \libconcept{range} type
 that has constant time copy, move, and assignment operators; that is, the cost of
 these operations is not proportional to the number of elements in the
-\tcode{View}.
+\tcode{view}.
 
 \pnum
 \begin{example}
-Examples of \tcode{View}s are:
+Examples of \tcode{view}s are:
 
 \begin{itemize}
-\item A \libconcept{Range} type that wraps a pair of iterators.
+\item A \libconcept{range} type that wraps a pair of iterators.
 
-\item A \libconcept{Range} type that holds its elements by \tcode{shared_ptr}
+\item A \libconcept{range} type that holds its elements by \tcode{shared_ptr}
 and shares ownership with all its copies.
 
-\item A \libconcept{Range} type that generates its elements on demand.
+\item A \libconcept{range} type that generates its elements on demand.
 \end{itemize}
 
 Most containers\iref{containers} are not views since
@@ -846,26 +846,26 @@
 \end{example}
 
 \indexlibrary{\idxcode{enable_view}}%
-\indexlibrary{\idxcode{View}}%
+\indexlibrary{\idxcode{view}}%
 \begin{itemdecl}
 template<class T>
   inline constexpr bool enable_view = @\seebelow@;
 
 template<class T>
-  concept View =
-    Range<T> && Semiregular<T> && enable_view<T>;
+  concept view =
+    range<T> && semiregular<T> && enable_view<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-Since the difference between \libconcept{Range} and \libconcept{View} is largely
+Since the difference between \libconcept{range} and \libconcept{view} is largely
 semantic, the two are differentiated with the help of \tcode{enable_view}.
 
 \pnum
 For a type \tcode{T}, the default value of \tcode{enable_view<T>} is:
 \begin{itemize}
 
-\item If \tcode{DerivedFrom<T, view_base>} is \tcode{true}, \tcode{true}.
+\item If \tcode{\libconcept{derived_from}<T, view_base>} is \tcode{true}, \tcode{true}.
 \item Otherwise, if \tcode{T} is a specialization of class template
   \tcode{initializer_list}\iref{support.initlist},
   \tcode{set}\iref{set},
@@ -873,7 +873,7 @@
   \tcode{unordered_set}\iref{unord.set},
   \tcode{unordered_multiset}\iref{unord.multiset}, or
   \tcode{match_results}\iref{re.results}, \tcode{false}.
-\item Otherwise, if both \tcode{T} and \tcode{const T} model \libconcept{Range}
+\item Otherwise, if both \tcode{T} and \tcode{const T} model \libconcept{range}
   and \tcode{iter_reference_t<iterator_t<T>{>}} is not the same type as
   \tcode{iter_reference_t<iterator_t<const T>{>}},
   \tcode{false}.
@@ -886,44 +886,44 @@
 
 \pnum
 Pursuant to \ref{namespace.std}, users may specialize \tcode{enable_view}
-to \tcode{true} for types which model \libconcept{View},
+to \tcode{true} for types which model \libconcept{view},
 and \tcode{false} for types which do not.
 \end{itemdescr}
 
 \rSec2[range.refinements]{Other range refinements}
 
 \pnum
-The \libconcept{OutputRange} concept specifies requirements of a
-\libconcept{Range} type for which \tcode{ranges::begin} returns
-a model of \libconcept{OutputIterator}\iref{iterator.concept.output}.
-\libconcept{InputRange}, \libconcept{ForwardRange}, \libconcept{BidirectionalRange},
-and \libconcept{RandomAccessRange} are defined similarly.
+The \libconcept{output_range} concept specifies requirements of a
+\libconcept{range} type for which \tcode{ranges::begin} returns
+a model of \libconcept{output_iterator}\iref{iterator.concept.output}.
+\libconcept{input_range}, \libconcept{forward_range}, \libconcept{bidirectional_range},
+and \libconcept{random_access_range} are defined similarly.
 
-\indexlibrary{\idxcode{OutputRange}}%
-\indexlibrary{\idxcode{InputRange}}%
-\indexlibrary{\idxcode{ForwardRange}}%
-\indexlibrary{\idxcode{BidirectionalRange}}%
-\indexlibrary{\idxcode{RandomAccessRange}}%
+\indexlibrary{\idxcode{output_range}}%
+\indexlibrary{\idxcode{input_range}}%
+\indexlibrary{\idxcode{forward_range}}%
+\indexlibrary{\idxcode{bidirectional_range}}%
+\indexlibrary{\idxcode{random_access_range}}%
 \begin{itemdecl}
 template<class R, class T>
-  concept OutputRange =
-    Range<R> && OutputIterator<iterator_t<R>, T>;
+  concept output_range =
+    range<R> && output_iterator<iterator_t<R>, T>;
 
 template<class T>
-  concept InputRange =
-    Range<T> && InputIterator<iterator_t<T>>;
+  concept input_range =
+    range<T> && input_iterator<iterator_t<T>>;
 
 template<class T>
-  concept ForwardRange =
-    InputRange<T> && ForwardIterator<iterator_t<T>>;
+  concept forward_range =
+    input_range<T> && forward_iterator<iterator_t<T>>;
 
 template<class T>
-  concept BidirectionalRange =
-    ForwardRange<T> && BidirectionalIterator<iterator_t<T>>;
+  concept bidirectional_range =
+    forward_range<T> && bidirectional_iterator<iterator_t<T>>;
 
 template<class T>
-  concept RandomAccessRange =
-    BidirectionalRange<T> && RandomAccessIterator<iterator_t<T>>;
+  concept random_access_range =
+    bidirectional_range<T> && random_access_iterator<iterator_t<T>>;
 \end{itemdecl}
 
 \pnum
@@ -931,40 +931,40 @@
 the \tcode{ranges::data} customization point\iref{range.prim.data}
 is usable with the range.
 
-\indexlibrary{\idxcode{ContiguousRange}}%
+\indexlibrary{\idxcode{contiguous_range}}%
 \begin{itemdecl}
 template<class T>
-  concept ContiguousRange =
-    RandomAccessRange<T> && ContiguousIterator<iterator_t<T>> &&
+  concept contiguous_range =
+    random_access_range<T> && contiguous_iterator<iterator_t<T>> &&
     requires(T& t) {
-      { ranges::data(t) } -> Same<add_pointer_t<iter_reference_t<iterator_t<T>>>>;
+      { ranges::data(t) } -> same_to<add_pointer_t<iter_reference_t<iterator_t<T>>>>;
     };
 \end{itemdecl}
 
 \pnum
-The \libconcept{CommonRange} concept specifies requirements of
-a \libconcept{Range} type for which \tcode{ranges::begin} and
+The \libconcept{common_range} concept specifies requirements of
+a \libconcept{range} type for which \tcode{ranges::begin} and
 \tcode{ranges::end} return objects of the same type.
 \begin{example}
-The standard containers\iref{containers} model \libconcept{CommonRange}.
+The standard containers\iref{containers} model \libconcept{common_range}.
 \end{example}
 
-\indexlibrary{\idxcode{CommonRange}}%
+\indexlibrary{\idxcode{common_range}}%
 \begin{itemdecl}
 template<class T>
-  concept CommonRange =
-    Range<T> && Same<iterator_t<T>, sentinel_t<T>>;
+  concept common_range =
+    range<T> && same_to<iterator_t<T>, sentinel_t<T>>;
 \end{itemdecl}
 
 \pnum
-The \libconcept{ViewableRange} concept specifies the requirements of a
-\libconcept{Range} type that can be converted to a \libconcept{View} safely.
+The \libconcept{viewable_range} concept specifies the requirements of a
+\libconcept{range} type that can be converted to a \libconcept{view} safely.
 
-\indexlibrary{\idxcode{ViewableRange}}%
+\indexlibrary{\idxcode{viewable_range}}%
 \begin{itemdecl}
 template<class T>
-  concept ViewableRange =
-    Range<T> && (@\placeholder{forwarding-range}@<T> || View<decay_t<T>>);
+  concept viewable_range =
+    range<T> && (@\placeholder{forwarding-range}@<T> || view<decay_t<T>>);
 \end{itemdecl}
 
 \rSec1[range.utility]{Range utilities}
@@ -982,31 +982,31 @@
 \begin{codeblock}
 template<class R>
   concept @\placeholder{simple-view}@ =                         // \expos
-    View<R> && Range<const R> &&
-    Same<iterator_t<R>, iterator_t<const R>> &&
-    Same<sentinel_t<R>, sentinel_t<const R>>;
+    view<R> && range<const R> &&
+    same_to<iterator_t<R>, iterator_t<const R>> &&
+    same_to<sentinel_t<R>, sentinel_t<const R>>;
 
-template<InputIterator I>
+template<input_iterator I>
   concept @\placeholder{has-arrow}@ =                           // \expos
     is_pointer_v<I> || requires(I i) { i.operator->(); };
 
 template<class T, class U>
   concept @\placeholder{not-same-as}@ =                         // \expos
-    !Same<remove_cvref_t<T>, remove_cvref_t<U>>;
+    !same_to<remove_cvref_t<T>, remove_cvref_t<U>>;
 \end{codeblock}
 
 \rSec2[view.interface]{View interface}
 
 \pnum
 The class template \tcode{view_interface} is a helper for defining
-\tcode{View}-like types that offer a container-like interface. It is
+\tcode{view}-like types that offer a container-like interface. It is
 parameterized with the type that is derived from it.
 
 \indexlibrary{\idxcode{view_interface}}%
 \begin{codeblock}
 namespace std::ranges {
   template<class D>
-    requires is_class_v<D> && Same<D, remove_cv_t<D>>
+    requires is_class_v<D> && same_to<D, remove_cv_t<D>>
   class view_interface : public view_base {
   private:
     constexpr D& derived() noexcept {                   // \expos
@@ -1016,10 +1016,10 @@
       return static_cast<const D&>(*this);
     }
   public:
-    constexpr bool empty() requires ForwardRange<D> {
+    constexpr bool empty() requires forward_range<D> {
       return ranges::begin(derived()) == ranges::end(derived());
     }
-    constexpr bool empty() const requires ForwardRange<const D> {
+    constexpr bool empty() const requires forward_range<const D> {
       return ranges::begin(derived()) == ranges::end(derived());
     }
 
@@ -1032,35 +1032,35 @@
         return !ranges::empty(derived());
       }
 
-    constexpr auto data() requires ContiguousIterator<iterator_t<D>> {
+    constexpr auto data() requires contiguous_iterator<iterator_t<D>> {
       return ranges::empty(derived()) ? nullptr : addressof(*ranges::begin(derived()));
     }
     constexpr auto data() const
-      requires Range<const D> && ContiguousIterator<iterator_t<const D>> {
+      requires range<const D> && contiguous_iterator<iterator_t<const D>> {
         return ranges::empty(derived()) ? nullptr : addressof(*ranges::begin(derived()));
       }
 
-    constexpr auto size() requires ForwardRange<D> &&
-      SizedSentinel<sentinel_t<D>, iterator_t<D>> {
+    constexpr auto size() requires forward_range<D> &&
+      sized_sentinel_for<sentinel_t<D>, iterator_t<D>> {
         return ranges::end(derived()) - ranges::begin(derived());
       }
-    constexpr auto size() const requires ForwardRange<const D> &&
-      SizedSentinel<sentinel_t<const D>, iterator_t<const D>> {
+    constexpr auto size() const requires forward_range<const D> &&
+      sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>> {
         return ranges::end(derived()) - ranges::begin(derived());
       }
 
-    constexpr decltype(auto) front() requires ForwardRange<D>;
-    constexpr decltype(auto) front() const requires ForwardRange<const D>;
+    constexpr decltype(auto) front() requires forward_range<D>;
+    constexpr decltype(auto) front() const requires forward_range<const D>;
 
-    constexpr decltype(auto) back() requires BidirectionalRange<D> && CommonRange<D>;
+    constexpr decltype(auto) back() requires bidirectional_range<D> && common_range<D>;
     constexpr decltype(auto) back() const
-      requires BidirectionalRange<const D> && CommonRange<const D>;
+      requires bidirectional_range<const D> && common_range<const D>;
 
-    template<RandomAccessRange R = D>
+    template<random_access_range R = D>
       constexpr decltype(auto) operator[](iter_difference_t<iterator_t<R>> n) {
         return ranges::begin(derived())[n];
       }
-    template<RandomAccessRange R = const D>
+    template<random_access_range R = const D>
       constexpr decltype(auto) operator[](iter_difference_t<iterator_t<R>> n) const {
         return ranges::begin(derived())[n];
       }
@@ -1073,14 +1073,14 @@
 incomplete type. Before any member of the resulting specialization of
 \tcode{view_interface} other than special member functions
 is referenced, \tcode{D} shall be complete, and
-model both \tcode{\libconcept{DerivedFrom}<view_interface<D>>} and \libconcept{View}.
+model both \tcode{\libconcept{derived_from}<view_interface<D>>} and \libconcept{view}.
 
 \rSec3[view.interface.members]{Members}
 
 \indexlibrary{\idxcode{view_interface}!\idxcode{front}}%
 \begin{itemdecl}
-constexpr decltype(auto) front() requires ForwardRange<D>;
-constexpr decltype(auto) front() const requires ForwardRange<const D>;
+constexpr decltype(auto) front() requires forward_range<D>;
+constexpr decltype(auto) front() const requires forward_range<const D>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1093,9 +1093,9 @@
 
 \indexlibrary{\idxcode{view_interface}!\idxcode{back}}%
 \begin{itemdecl}
-constexpr decltype(auto) back() requires BidirectionalRange<D> && CommonRange<D>;
+constexpr decltype(auto) back() requires bidirectional_range<D> && common_range<D>;
 constexpr decltype(auto) back() const
-  requires BidirectionalRange<const D> && CommonRange<const D>;
+  requires bidirectional_range<const D> && common_range<const D>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1111,8 +1111,8 @@
 \pnum
 The \tcode{subrange} class template combines together an
 iterator and a sentinel into a single object that models the
-\libconcept{View} concept. Additionally, it models the
-\libconcept{SizedRange} concept when the final template parameter is
+\libconcept{view} concept. Additionally, it models the
+\libconcept{sized_range} concept when the final template parameter is
 \tcode{subrange_kind::sized}.
 
 \indexlibrary{\idxcode{subrange}}%
@@ -1122,7 +1122,7 @@
     concept @\placeholdernc{pair-like}@ =                                 // \expos
       !is_reference_v<T> && requires(T t) {
         typename tuple_size<T>::type;   // ensures \tcode{tuple_size<T>} is complete
-        requires DerivedFrom<tuple_size<T>, integral_constant<size_t, 2>>;
+        requires derived_from<tuple_size<T>, integral_constant<size_t, 2>>;
         typename tuple_element_t<0, remove_const_t<T>>;
         typename tuple_element_t<1, remove_const_t<T>>;
         { get<0>(t) } -> const tuple_element_t<0, T>&;
@@ -1131,28 +1131,28 @@
 
   template<class T, class U, class V>
     concept @\placeholdernc{pair-like-convertible-to}@ =                  // \expos
-      !Range<T> && @\placeholder{pair-like}@<remove_reference_t<T>> &&
+      !range<T> && @\placeholder{pair-like}@<remove_reference_t<T>> &&
       requires(T&& t) {
-        { get<0>(std::forward<T>(t)) } -> ConvertibleTo<U>;
-        { get<1>(std::forward<T>(t)) } -> ConvertibleTo<V>;
+        { get<0>(std::forward<T>(t)) } -> convertible_to<U>;
+        { get<1>(std::forward<T>(t)) } -> convertible_to<V>;
       };
 
   template<class T, class U, class V>
     concept @\placeholdernc{pair-like-convertible-from}@ =                // \expos
-      !Range<T> && @\placeholdernc{pair-like}@<T> && Constructible<T, U, V>;
+      !range<T> && @\placeholdernc{pair-like}@<T> && constructible_from<T, U, V>;
 
   template<class T>
     concept @\placeholdernc{iterator-sentinel-pair}@ =                    // \expos
-      !Range<T> && @\placeholdernc{pair-like}@<T> &&
-      Sentinel<tuple_element_t<1, T>, tuple_element_t<0, T>>;
+      !range<T> && @\placeholdernc{pair-like}@<T> &&
+      sentinel_for<tuple_element_t<1, T>, tuple_element_t<0, T>>;
 
-  template<Iterator I, Sentinel<I> S = I, subrange_kind K =
-      SizedSentinel<S, I> ? subrange_kind::sized : subrange_kind::unsized>
-    requires (K == subrange_kind::sized || !SizedSentinel<S, I>)
+  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =
+      sized_sentinel_for<S, I> ? subrange_kind::sized : subrange_kind::unsized>
+    requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
   class subrange : public view_interface<subrange<I, S, K>> {
   private:
     static constexpr bool StoreSize =                   // \expos
-      K == subrange_kind::sized && !SizedSentinel<S, I>;
+      K == subrange_kind::sized && !sized_sentinel_for<S, I>;
     I begin_ = I();                                     // \expos
     S end_ = S();                                       // \expos
     iter_difference_t<I> size_ = 0;                     // \expos; present only
@@ -1167,11 +1167,11 @@
 
     template<@\placeholdernc{not-same-as}@<subrange> R>
       requires @\placeholdernc{forwarding-range}@<R> &&
-        ConvertibleTo<iterator_t<R>, I> && ConvertibleTo<sentinel_t<R>, S>
-    constexpr subrange(R&& r) requires (!StoreSize || SizedRange<R>);
+        convertible_to<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>
+    constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);
 
     template<@\placeholdernc{forwarding-range}@ R>
-      requires ConvertibleTo<iterator_t<R>, I> && ConvertibleTo<sentinel_t<R>, S>
+      requires convertible_to<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>
     constexpr subrange(R&& r, iter_difference_t<I> n)
       requires (K == subrange_kind::sized)
         : subrange{ranges::begin(r), ranges::end(r), n}
@@ -1204,14 +1204,14 @@
 
     [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const;
     [[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
-      requires BidirectionalIterator<I>;
+      requires bidirectional_iterator<I>;
     constexpr subrange& advance(iter_difference_t<I> n);
 
     friend constexpr I begin(subrange&& r) { return r.begin(); }
     friend constexpr S end(subrange&& r) { return r.end(); }
   };
 
-  template<Iterator I, Sentinel<I> S>
+  template<input_or_output_iterator I, sentinel_for<I> S>
     subrange(I, S, iter_difference_t<I>) -> subrange<I, S, subrange_kind::sized>;
 
   template<@\placeholder{iterator-sentinel-pair}@ P>
@@ -1224,7 +1224,7 @@
   template<@\placeholder{forwarding-range}@ R>
     subrange(R&&) ->
       subrange<iterator_t<R>, sentinel_t<R>,
-               (SizedRange<R> || SizedSentinel<sentinel_t<R>, iterator_t<R>>)
+               (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                  ? subrange_kind::sized : subrange_kind::unsized>;
 
   template<@\placeholder{forwarding-range}@ R>
@@ -1276,9 +1276,9 @@
 \pnum
 \begin{note}
 Accepting the length of the range and storing it to later return  from
-\tcode{size()} enables \tcode{subrange} to model \libconcept{SizedRange} even
+\tcode{size()} enables \tcode{subrange} to model \libconcept{sized_range} even
 when it stores an iterator and sentinel that do not model
-\libconcept{SizedSentinel}.
+\libconcept{sized_sentinel_for}.
 \end{note}
 \end{itemdescr}
 
@@ -1286,8 +1286,8 @@
 \begin{itemdecl}
 template<@\placeholdernc{not-same-as}@<subrange> R>
   requires @\placeholdernc{forwarding-range}@<R> &&
-           ConvertibleTo<iterator_t<R>, I> && ConvertibleTo<sentinel_t<R>, S>
-constexpr subrange(R&& r) requires (!StoreSize || SizedRange<R>);
+           convertible_to<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>
+constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1375,7 +1375,7 @@
 
 \pnum
 \begin{note}
-If \tcode{I} does not model \libconcept{ForwardIterator}, \tcode{next}
+If \tcode{I} does not model \libconcept{forward_iterator}, \tcode{next}
 can invalidate \tcode{*this}.
 \end{note}
 \end{itemdescr}
@@ -1383,7 +1383,7 @@
 \indexlibrary{\idxcode{prev}!\idxcode{subrange}}%
 \begin{itemdecl}
 [[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
-  requires BidirectionalIterator<I>;
+  requires bidirectional_iterator<I>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1442,10 +1442,10 @@
 The tag type \tcode{dangling} is used together
 with the template aliases \tcode{safe_iterator_t} and \tcode{safe_subrange_t}
 to indicate that an algorithm
-that typically returns an iterator into or subrange of a \tcode{Range} argument
+that typically returns an iterator into or subrange of a \tcode{range} argument
 does not return an iterator or subrange
 which could potentially reference a range
-whose lifetime has ended for a particular rvalue \tcode{Range} argument
+whose lifetime has ended for a particular rvalue \tcode{range} argument
 which does not model \tcode{\placeholder{forwarding-range}}\iref{range.range}.
 \begin{codeblock}
 namespace std::ranges {
@@ -1462,12 +1462,12 @@
 \begin{codeblock}
 vector<int> f();
 auto result1 = ranges::find(f(), 42);                                   // \#1
-static_assert(Same<decltype(result1), ranges::dangling>);
+static_assert(same_to<decltype(result1), ranges::dangling>);
 auto vec = f();
 auto result2 = ranges::find(vec, 42);                                   // \#2
-static_assert(Same<decltype(result2), vector<int>::iterator>);
+static_assert(same_to<decltype(result2), vector<int>::iterator>);
 auto result3 = ranges::find(subrange{vec}, 42);                         // \#3
-static_assert(Same<decltype(result3), vector<int>::iterator>);
+static_assert(same_to<decltype(result3), vector<int>::iterator>);
 \end{codeblock}
 The call to \tcode{ranges::find} at \#1 returns \tcode{ranges::dangling}
 since \tcode{f()} is an rvalue \tcode{vector};
@@ -1482,17 +1482,17 @@
 
 \pnum
 This subclause defines \term{range factories},
-which are utilities to create a \libconcept{View}.
+which are utilities to create a \libconcept{view}.
 
 \pnum
-Range factories are declared in namespace \tcode{std::ranges::view}.
+Range factories are declared in namespace \tcode{std::ranges::views}.
 
 \rSec2[range.empty]{Empty view}
 
 \rSec3[range.empty.overview]{Overview}
 
 \pnum
-\tcode{empty_view} produces a \libconcept{View} of no elements of
+\tcode{empty_view} produces a \libconcept{view} of no elements of
 a particular type.
 
 \pnum
@@ -1529,7 +1529,7 @@
 \rSec3[range.single.overview]{Overview}
 
 \pnum
-\tcode{single_view} produces a \libconcept{View} that contains
+\tcode{single_view} produces a \libconcept{view} that contains
 exactly one element of a specified value.
 
 \pnum
@@ -1545,7 +1545,7 @@
 
 \begin{codeblock}
 namespace std::ranges {
-  template<CopyConstructible T>
+  template<copy_constructible T>
     requires is_object_v<T>
   class single_view : public view_interface<single_view<T>> {
   private:
@@ -1555,7 +1555,7 @@
     constexpr explicit single_view(const T& t);
     constexpr explicit single_view(T&& t);
     template<class... Args>
-      requires Constructible<T, Args...>
+      requires constructible_from<T, Args...>
     constexpr single_view(in_place_t, Args&&... args);
 
     constexpr T* begin() noexcept;
@@ -1680,7 +1680,7 @@
     concept @\placeholdernc{Advanceable}@ =       // \expos
       @\seebelow@;
 
-  template<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t>
+  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
     requires @\placeholdernc{weakly-equality-comparable-with}@<W, Bound>
   class iota_view : public view_interface<iota_view<W, Bound>> {
   private:
@@ -1698,17 +1698,17 @@
 
     constexpr iterator begin() const;
     constexpr sentinel end() const;
-    constexpr iterator end() const requires Same<W, Bound>;
+    constexpr iterator end() const requires same_to<W, Bound>;
 
     constexpr auto size() const
-      requires (Same<W, Bound> && @\placeholdernc{Advanceable}@<W>) ||
-               (Integral<W> && Integral<Bound>) ||
-               SizedSentinel<Bound, W>
+      requires (same_to<W, Bound> && @\placeholdernc{Advanceable}@<W>) ||
+               (integral<W> && integral<Bound>) ||
+               sized_sentinel_for<Bound, W>
     { return bound_ - value_; }
   };
 
   template<class W, class Bound>
-    requires (!Integral<W> || !Integral<Bound> || is_signed_v<W> == is_signed_v<Bound>)
+    requires (!integral<W> || !integral<Bound> || is_signed_v<W> == is_signed_v<Bound>)
   iota_view(W, Bound) -> iota_view<W, Bound>;
 }
 \end{codeblock}
@@ -1718,9 +1718,9 @@
 \begin{itemdecl}
 template<class I>
   concept @\placeholder{Decrementable}@ =
-    Incrementable<I> && requires(I i) {
-      { --i } -> Same<I&>;
-      { i-- } -> Same<I>;
+    incrementable<I> && requires(I i) {
+      { --i } -> same_to<I&>;
+      { i-- } -> same_to<I>;
     };
 \end{itemdecl}
 
@@ -1751,14 +1751,14 @@
 \begin{itemdecl}
 template<class I>
   concept @\placeholder{Advanceable}@ =
-    @\placeholdernc{Decrementable}@<I> && StrictTotallyOrdered<I> &&
+    @\placeholdernc{Decrementable}@<I> && totally_ordered<I> &&
     requires(I i, const I j, const iter_difference_t<I> n) {
-      { i += n } -> Same<I&>;
-      { i -= n } -> Same<I&>;
-      { j +  n } -> Same<I>;
-      { n +  j } -> Same<I>;
-      { j -  n } -> Same<I>;
-      { j -  j } -> Same<iter_difference_t<I>>;
+      { i += n } -> same_to<I&>;
+      { i -= n } -> same_to<I&>;
+      { j +  n } -> same_to<I>;
+      { n +  j } -> same_to<I>;
+      { j -  n } -> same_to<I>;
+      { j -  j } -> same_to<iter_difference_t<I>>;
     };
 \end{itemdecl}
 
@@ -1841,7 +1841,7 @@
 
 \indexlibrary{\idxcode{end}!\idxcode{iota_view}}%
 \begin{itemdecl}
-constexpr iterator end() const requires Same<W, Bound>;
+constexpr iterator end() const requires same_to<W, Bound>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1869,7 +1869,7 @@
 
     constexpr iterator& operator++();
     constexpr void operator++(int);
-    constexpr iterator operator++(int) requires Incrementable<W>;
+    constexpr iterator operator++(int) requires incrementable<W>;
 
     constexpr iterator& operator--() requires @\placeholdernc{Decrementable}@<W>;
     constexpr iterator operator--(int) requires @\placeholdernc{Decrementable}@<W>;
@@ -1882,18 +1882,18 @@
       requires @\placeholdernc{Advanceable}@<W>;
 
     friend constexpr bool operator==(const iterator& x, const iterator& y)
-      requires EqualityComparable<W>;
+      requires equality_comparable<W>;
     friend constexpr bool operator!=(const iterator& x, const iterator& y)
-      requires EqualityComparable<W>;
+      requires equality_comparable<W>;
 
     friend constexpr bool operator<(const iterator& x, const iterator& y)
-      requires StrictTotallyOrdered<W>;
+      requires totally_ordered<W>;
     friend constexpr bool operator>(const iterator& x, const iterator& y)
-      requires StrictTotallyOrdered<W>;
+      requires totally_ordered<W>;
     friend constexpr bool operator<=(const iterator& x, const iterator& y)
-      requires StrictTotallyOrdered<W>;
+      requires totally_ordered<W>;
     friend constexpr bool operator>=(const iterator& x, const iterator& y)
-      requires StrictTotallyOrdered<W>;
+      requires totally_ordered<W>;
 
     friend constexpr iterator operator+(iterator i, difference_type n)
       requires @\placeholdernc{Advanceable}@<W>;
@@ -1915,7 +1915,7 @@
 \tcode{iterator_category} is \tcode{random_access_iterator_tag}.
 \item Otherwise, if \tcode{W} models \tcode{\placeholder{Decrementable}}, then
 \tcode{iterator_category} is \tcode{bidirectional_iterator_tag}.
-\item Otherwise, if \tcode{W} models \libconcept{Incrementable}, then
+\item Otherwise, if \tcode{W} models \libconcept{incrementable}, then
 \tcode{iterator_category} is \tcode{forward_iterator_tag}.
 \item Otherwise, \tcode{iterator_category} is \tcode{input_iterator_tag}.
 \end{itemize}
@@ -1977,7 +1977,7 @@
 
 \indexlibrary{\idxcode{operator++}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
-constexpr iterator operator++(int) requires Incrementable<W>;
+constexpr iterator operator++(int) requires incrementable<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2063,7 +2063,7 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator==(const iterator& x, const iterator& y)
-  requires EqualityComparable<W>;
+  requires equality_comparable<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2074,7 +2074,7 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator!=(const iterator& x, const iterator& y)
-  requires EqualityComparable<W>;
+  requires equality_comparable<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2085,7 +2085,7 @@
 \indexlibrary{\idxcode{operator<}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator<(const iterator& x, const iterator& y)
-  requires StrictTotallyOrdered<W>;
+  requires totally_ordered<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2096,7 +2096,7 @@
 \indexlibrary{\idxcode{operator>}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator>(const iterator& x, const iterator& y)
-  requires StrictTotallyOrdered<W>;
+  requires totally_ordered<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2107,7 +2107,7 @@
 \indexlibrary{\idxcode{operator<=}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator<=(const iterator& x, const iterator& y)
-  requires StrictTotallyOrdered<W>;
+  requires totally_ordered<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2118,7 +2118,7 @@
 \indexlibrary{\idxcode{operator>=}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator>=(const iterator& x, const iterator& y)
-  requires StrictTotallyOrdered<W>;
+  requires totally_ordered<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2254,12 +2254,12 @@
 
 \pnum
 This subclause defines \term{range adaptors}, which are utilities that transform a
-\libconcept{Range} into a \libconcept{View} with custom behaviors. These
+\libconcept{range} into a \libconcept{view} with custom behaviors. These
 adaptors can be chained to create pipelines of range transformations that
 evaluate lazily as the resulting view is iterated.
 
 \pnum
-Range adaptors are declared in namespace \tcode{std::ranges::view}.
+Range adaptors are declared in namespace \tcode{std::ranges::views}.
 
 \pnum
 The bitwise \logop{OR} operator is overloaded for the purpose of creating adaptor chain
@@ -2283,10 +2283,10 @@
 
 \pnum
 A \term{range adaptor closure object} is a unary function object that accepts
-a \libconcept{ViewableRange} argument and returns a \libconcept{View}. For
+a \libconcept{viewable_range} argument and returns a \libconcept{view}. For
 a range adaptor closure object \tcode{C} and an expression \tcode{R} such that
-\tcode{decltype((R))} models \libconcept{ViewableRange}, the following
-expressions are equivalent and yield a \libconcept{View}:
+\tcode{decltype((R))} models \libconcept{viewable_range}, the following
+expressions are equivalent and yield a \libconcept{view}:
 
 \begin{codeblock}
 C(R)
@@ -2305,8 +2305,8 @@
 \pnum
 A \term{range adaptor object} is a
 customization point object\iref{customization.point.object}
-that accepts a \libconcept{ViewableRange} as its first argument and returns a
-\libconcept{View}.
+that accepts a \libconcept{viewable_range} as its first argument and returns a
+\libconcept{view}.
 
 \pnum
 If a range adaptor object accepts only one argument,
@@ -2336,9 +2336,9 @@
 \begin{itemize}
 \item \tcode{\placeholder{semiregular-box}<T>} constrains
 its type parameter \tcode{T} with
-\tcode{\libconcept{CopyConstructible}<T> \&\& is_object_v<T>}.
+\tcode{\libconcept{copy_constructible}<T> \&\& is_object_v<T>}.
 
-\item If \tcode{T} models \libconcept{DefaultConstructible}, the default
+\item If \tcode{T} models \libconcept{default_constructible}, the default
 constructor of \tcode{\placeholder{semiregular-box}<T>} is equivalent to:
 \begin{codeblock}
 constexpr @\placeholder{semiregular-box}@() noexcept(is_nothrow_default_constructible_v<T>)
@@ -2346,7 +2346,7 @@
 { }
 \end{codeblock}
 
-\item If \tcode{\libconcept{Assignable}<T\&, const T\&>} is not
+\item If \tcode{\libconcept{assignable_from}<T\&, const T\&>} is not
 modeled, the copy assignment operator is equivalent to:
 \begin{codeblock}
 @\placeholder{semiregular-box}@& operator=(const @\placeholder{semiregular-box}@& that)
@@ -2358,7 +2358,7 @@
 }
 \end{codeblock}
 
-\item If \tcode{\libconcept{Assignable}<T\&, T>} is not modeled,
+\item If \tcode{\libconcept{assignable_from}<T\&, T>} is not modeled,
 the move assignment operator is equivalent to:
 \begin{codeblock}
 @\placeholder{semiregular-box}@& operator=(@\placeholder{semiregular-box}@&& that)
@@ -2374,8 +2374,8 @@
 \rSec2[range.all]{All view}
 
 \pnum
-\tcode{view::all} returns a \libconcept{View} that includes all elements of
-its \libconcept{Range} argument.
+\tcode{view::all} returns a \libconcept{view} that includes all elements of
+its \libconcept{range} argument.
 
 \pnum
 The name \tcode{view::all} denotes a
@@ -2385,7 +2385,7 @@
 
 \begin{itemize}
 \item \tcode{\placeholdernc{decay-copy}(E)} if the decayed type of \tcode{E}
-models \libconcept{View}.
+models \libconcept{view}.
 
 \item Otherwise, \tcode{ref_view\{E\}} if that expression is well-formed.
 
@@ -2395,10 +2395,10 @@
 \rSec3[range.ref.view]{Class template \tcode{ref_view}}
 
 \pnum
-\tcode{ref_view} is a \tcode{View} of the elements of some other \tcode{Range}.
+\tcode{ref_view} is a \tcode{view} of the elements of some other \tcode{range}.
 \begin{codeblock}
 namespace std::ranges {
-  template<Range R>
+  template<range R>
     requires is_object_v<R>
   class ref_view : public view_interface<ref_view<R>> {
   private:
@@ -2419,10 +2419,10 @@
       requires requires { ranges::empty(*r_); }
     { return ranges::empty(*r_); }
 
-    constexpr auto size() const requires SizedRange<R>
+    constexpr auto size() const requires sized_range<R>
     { return ranges::size(*r_); }
 
-    constexpr auto data() const requires ContiguousRange<R>
+    constexpr auto data() const requires contiguous_range<R>
     { return ranges::data(*r_); }
 
     friend constexpr iterator_t<R> begin(ref_view r)
@@ -2452,7 +2452,7 @@
 \end{codeblock}
 The expression in the \grammarterm{requires-clause} is equivalent to
 \begin{codeblock}
-ConvertibleTo<T, R&> && requires { @\placeholder{FUN}@(declval<T>()); }
+convertible_to<T, R&> && requires { @\placeholder{FUN}@(declval<T>()); }
 \end{codeblock}
 
 \pnum
@@ -2467,7 +2467,7 @@
 \rSec3[range.filter.overview]{Overview}
 
 \pnum
-\tcode{filter_view} presents a \libconcept{View} of an underlying sequence
+\tcode{filter_view} presents a \libconcept{view} of an underlying sequence
 without the elements that fail to satisfy a predicate.
 
 \pnum
@@ -2484,8 +2484,8 @@
 
 \begin{codeblock}
 namespace std::ranges {
-  template<InputRange V, IndirectUnaryPredicate<iterator_t<V>> Pred>
-    requires View<V> && is_object_v<Pred>
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
   class filter_view : public view_interface<filter_view<V, Pred>> {
   private:
     V base_ = V();                // \expos
@@ -2499,15 +2499,15 @@
   public:
     filter_view() = default;
     constexpr filter_view(V base, Pred pred);
-    template<InputRange R>
-      requires ViewableRange<R> && Constructible<V, all_view<R>>
+    template<input_range R>
+      requires viewable_range<R> && constructible_from<V, all_view<R>>
     constexpr filter_view(R&& r, Pred pred);
 
     constexpr V base() const;
 
     constexpr iterator begin();
     constexpr auto end() {
-      if constexpr (CommonRange<V>)
+      if constexpr (common_range<V>)
         return iterator{*this, ranges::end(base_)};
       else
         return sentinel{*this};
@@ -2532,8 +2532,8 @@
 
 \indexlibrary{\idxcode{filter_view}!\idxcode{filter_view}}%
 \begin{itemdecl}
-template<InputRange R>
-  requires ViewableRange<R> && Constructible<V, all_view<R>>
+template<input_range R>
+  requires viewable_range<R> && constructible_from<V, all_view<R>>
 constexpr filter_view(R&& r, Pred pred);
 \end{itemdecl}
 
@@ -2569,7 +2569,7 @@
 
 \pnum
 \remarks In order to provide the amortized constant time complexity required by
-the \libconcept{Range} concept, this function caches the result within the
+the \libconcept{range} concept, this function caches the result within the
 \tcode{filter_view} for use on subsequent calls.
 \end{itemdescr}
 
@@ -2599,21 +2599,21 @@
 
     constexpr iterator& operator++();
     constexpr void operator++(int);
-    constexpr iterator operator++(int) requires ForwardRange<V>;
+    constexpr iterator operator++(int) requires forward_range<V>;
 
-    constexpr iterator& operator--() requires BidirectionalRange<V>;
-    constexpr iterator operator--(int) requires BidirectionalRange<V>;
+    constexpr iterator& operator--() requires bidirectional_range<V>;
+    constexpr iterator operator--(int) requires bidirectional_range<V>;
 
     friend constexpr bool operator==(const iterator& x, const iterator& y)
-      requires EqualityComparable<iterator_t<V>>;
+      requires equality_comparable<iterator_t<V>>;
     friend constexpr bool operator!=(const iterator& x, const iterator& y)
-      requires EqualityComparable<iterator_t<V>>;
+      requires equality_comparable<iterator_t<V>>;
 
     friend constexpr iter_rvalue_reference_t<iterator_t<V>> iter_move(const iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current_)));
     friend constexpr void iter_swap(const iterator& x, const iterator& y)
       noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
-      requires IndirectlySwappable<iterator_t<V>>;
+      requires indirectly_swappable<iterator_t<V>>;
   };
 }
 \end{codeblock}
@@ -2626,10 +2626,10 @@
 \pnum
 \tcode{iterator::iterator_concept} is defined as follows:
 \begin{itemize}
-\item If \tcode{V} models \libconcept{BidirectionalRange}, then
+\item If \tcode{V} models \libconcept{bidirectional_range}, then
 \tcode{iterator_concept} denotes \tcode{bidirectional_iterator_tag}.
 
-\item Otherwise, if \tcode{V} models \libconcept{ForwardRange}, then
+\item Otherwise, if \tcode{V} models \libconcept{forward_range}, then
 \tcode{iterator_concept} denotes \tcode{forward_iterator_tag}.
 
 \item Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
@@ -2641,10 +2641,10 @@
 \item Let \tcode{C} denote the type
 \tcode{iterator_traits<iterator_t<V>>::iterator_category}.
 
-\item If \tcode{C} models \tcode{DerivedFrom<bidirectional_iterator_tag>},
+\item If \tcode{C} models \tcode{\libconcept{derived_from}<bidirectional_iterator_tag>},
 then \tcode{iterator_category} denotes \tcode{bi\-directional_iterator_tag}.
 
-\item Otherwise, if  \tcode{C} models \tcode{DerivedFrom<forward_iterator_tag>},
+\item Otherwise, if  \tcode{C} models \tcode{\libconcept{derived_from}<forward_iterator_tag>},
 then \tcode{iterator_category} denotes \tcode{forward_iterator_tag}.
 
 \item Otherwise, \tcode{iterator_category} denotes \tcode{input_iterator_tag}.
@@ -2719,7 +2719,7 @@
 
 \indexlibrary{\idxcode{operator++}!\idxcode{filter_view::iterator}}%
 \begin{itemdecl}
-constexpr iterator operator++(int) requires ForwardRange<V>;
+constexpr iterator operator++(int) requires forward_range<V>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2734,7 +2734,7 @@
 
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{filter_view::iterator}}%
 \begin{itemdecl}
-constexpr iterator& operator--() requires BidirectionalRange<V>;
+constexpr iterator& operator--() requires bidirectional_range<V>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2750,7 +2750,7 @@
 
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{filter_view::iterator}}%
 \begin{itemdecl}
-constexpr iterator operator--(int) requires BidirectionalRange<V>;
+constexpr iterator operator--(int) requires bidirectional_range<V>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2766,7 +2766,7 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{filter_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator==(const iterator& x, const iterator& y)
-  requires EqualityComparable<iterator_t<V>>;
+  requires equality_comparable<iterator_t<V>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2777,7 +2777,7 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{filter_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator!=(const iterator& x, const iterator& y)
-  requires EqualityComparable<iterator_t<V>>;
+  requires equality_comparable<iterator_t<V>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2800,7 +2800,7 @@
 \begin{itemdecl}
 friend constexpr void iter_swap(const iterator& x, const iterator& y)
   noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
-  requires IndirectlySwappable<iterator_t<V>>;
+  requires indirectly_swappable<iterator_t<V>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2907,7 +2907,7 @@
 
 \pnum
 \tcode{transform_view} presents
-a \libconcept{View} of an underlying sequence after
+a \libconcept{view} of an underlying sequence after
 applying a transformation function to each element.
 
 \pnum
@@ -2924,9 +2924,9 @@
 
 \begin{codeblock}
 namespace std::ranges {
-  template<InputRange V, CopyConstructible F>
-    requires View<V> && is_object_v<F> &&
-             RegularInvocable<F&, iter_reference_t<iterator_t<V>>>
+  template<input_range V, copy_constructible F>
+    requires view<V> && is_object_v<F> &&
+             regular_invocable<F&, iter_reference_t<iterator_t<V>>>
   class transform_view : public view_interface<transform_view<V, F>> {
   private:
     // \ref{range.transform.iterator}, class template \tcode{transform_view::iterator}
@@ -2940,28 +2940,28 @@
   public:
     transform_view() = default;
     constexpr transform_view(V base, F fun);
-    template<InputRange R>
-      requires ViewableRange<R> && Constructible<V, all_view<R>>
+    template<input_range R>
+      requires viewable_range<R> && constructible_from<V, all_view<R>>
     constexpr transform_view(R&& r, F fun);
 
     constexpr V base() const;
 
     constexpr iterator<false> begin();
     constexpr iterator<true> begin() const
-      requires Range<const V> &&
-               RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
+      requires range<const V> &&
+               regular_invocable<const F&, iter_reference_t<iterator_t<const V>>>;
 
     constexpr sentinel<false> end();
-    constexpr iterator<false> end() requires CommonRange<V>;
+    constexpr iterator<false> end() requires common_range<V>;
     constexpr sentinel<true> end() const
-      requires Range<const V> &&
-               RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
+      requires range<const V> &&
+               regular_invocable<const F&, iter_reference_t<iterator_t<const V>>>;
     constexpr iterator<true> end() const
-      requires CommonRange<const V> &&
-               RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
+      requires common_range<const V> &&
+               regular_invocable<const F&, iter_reference_t<iterator_t<const V>>>;
 
-    constexpr auto size() requires SizedRange<V> { return ranges::size(base_); }
-    constexpr auto size() const requires SizedRange<const V>
+    constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
+    constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
   };
 
@@ -2983,8 +2983,8 @@
 
 \indexlibrary{\idxcode{transform_view}!\idxcode{transform_view}}%
 \begin{itemdecl}
-template<InputRange R>
-  requires ViewableRange<R> && Constructible<V, all_view<R>>
+template<input_range R>
+  requires viewable_range<R> && constructible_from<V, all_view<R>>
 constexpr transform_view(R&& r, F fun);
 \end{itemdecl}
 
@@ -3020,8 +3020,8 @@
 \indexlibrary{\idxcode{begin}!\idxcode{transform_view}}%
 \begin{itemdecl}
 constexpr iterator<true> begin() const
-  requires Range<const V> &&
-           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
+  requires range<const V> &&
+           regular_invocable<const F&, iter_reference_t<iterator_t<const V>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3047,7 +3047,7 @@
 
 \indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
 \begin{itemdecl}
-constexpr iterator<false> end() requires CommonRange<V>;
+constexpr iterator<false> end() requires common_range<V>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3061,8 +3061,8 @@
 \indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
 \begin{itemdecl}
 constexpr sentinel<true> end() const
-  requires Range<const V> &&
-           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
+  requires range<const V> &&
+           regular_invocable<const F&, iter_reference_t<iterator_t<const V>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3076,8 +3076,8 @@
 \indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
 \begin{itemdecl}
 constexpr iterator<true> end() const
-  requires CommonRange<const V> &&
-           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
+  requires common_range<const V> &&
+           regular_invocable<const F&, iter_reference_t<iterator_t<const V>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3113,7 +3113,7 @@
     iterator() = default;
     constexpr iterator(Parent& parent, iterator_t<Base> current);
     constexpr iterator(iterator<!Const> i)
-      requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>;
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
 
     constexpr iterator_t<Base> base() const;
     constexpr decltype(auto) operator*() const
@@ -3121,42 +3121,42 @@
 
     constexpr iterator& operator++();
     constexpr void operator++(int);
-    constexpr iterator operator++(int) requires ForwardRange<Base>;
+    constexpr iterator operator++(int) requires forward_range<Base>;
 
-    constexpr iterator& operator--() requires BidirectionalRange<Base>;
-    constexpr iterator operator--(int) requires BidirectionalRange<Base>;
+    constexpr iterator& operator--() requires bidirectional_range<Base>;
+    constexpr iterator operator--(int) requires bidirectional_range<Base>;
 
     constexpr iterator& operator+=(difference_type n)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     constexpr iterator& operator-=(difference_type n)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     constexpr decltype(auto) operator[](difference_type n) const
-      requires RandomAccessRange<Base>
+      requires random_access_range<Base>
     { return invoke(*parent_->fun_, current_[n]); }
 
     friend constexpr bool operator==(const iterator& x, const iterator& y)
-      requires EqualityComparable<iterator_t<Base>>;
+      requires equality_comparable<iterator_t<Base>>;
     friend constexpr bool operator!=(const iterator& x, const iterator& y)
-      requires EqualityComparable<iterator_t<Base>>;
+      requires equality_comparable<iterator_t<Base>>;
 
     friend constexpr bool operator<(const iterator& x, const iterator& y)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     friend constexpr bool operator>(const iterator& x, const iterator& y)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     friend constexpr bool operator<=(const iterator& x, const iterator& y)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     friend constexpr bool operator>=(const iterator& x, const iterator& y)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
 
     friend constexpr iterator operator+(iterator i, difference_type n)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     friend constexpr iterator operator+(difference_type n, iterator i)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
 
     friend constexpr iterator operator-(iterator i, difference_type n)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
     friend constexpr difference_type operator-(const iterator& x, const iterator& y)
-      requires RandomAccessRange<Base>;
+      requires random_access_range<Base>;
 
     friend constexpr decltype(auto) iter_move(const iterator& i)
       noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_)))
@@ -3169,7 +3169,7 @@
 
     friend constexpr void iter_swap(const iterator& x, const iterator& y)
       noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
-      requires IndirectlySwappable<iterator_t<Base>>;
+      requires indirectly_swappable<iterator_t<Base>>;
   };
 }
 \end{codeblock}
@@ -3177,13 +3177,13 @@
 \pnum
 \tcode{iterator::iterator_concept} is defined as follows:
 \begin{itemize}
-\item If \tcode{V} models \libconcept{RandomAccessRange}, then
+\item If \tcode{V} models \libconcept{random_access_range}, then
 \tcode{iterator_concept} denotes \tcode{random_access_iterator_tag}.
 
-\item Otherwise, if \tcode{V} models \libconcept{BidirectionalRange}, then
+\item Otherwise, if \tcode{V} models \libconcept{bidirectional_range}, then
 \tcode{iterator_concept} denotes \tcode{bidirectional_iterator_tag}.
 
-\item Otherwise, if \tcode{V} models \libconcept{ForwardRange}, then
+\item Otherwise, if \tcode{V} models \libconcept{forward_range}, then
 \tcode{iterator_concept} denotes \tcode{forward_iterator_tag}.
 
 \item Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
@@ -3192,7 +3192,7 @@
 \pnum
 Let \tcode{C} denote the type
 \tcode{iterator_traits<iterator_t<Base>>::iterator_category}.
-If \tcode{C} models \tcode{\libconcept{Derived\-From}<contiguous_iterator_tag>},
+If \tcode{C} models \tcode{\libconcept{derived_from}<contiguous_iterator_tag>},
 then \tcode{iterator_category} denotes
 \tcode{random_access_iterator_tag}; otherwise,
 \tcode{iterator_category} denotes \tcode{C}.
@@ -3211,7 +3211,7 @@
 \indexlibrary{\idxcode{iterator}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 constexpr iterator(iterator<!Const> i)
-  requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>;
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3256,7 +3256,7 @@
 
 \indexlibrary{\idxcode{operator++}!\idxcode{transform_view::iterator}}
 \begin{itemdecl}
-constexpr iterator operator++(int) requires ForwardRange<Base>;
+constexpr iterator operator++(int) requires forward_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3271,7 +3271,7 @@
 
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{transform_view::iterator}}
 \begin{itemdecl}
-constexpr iterator& operator--() requires BidirectionalRange<Base>;
+constexpr iterator& operator--() requires bidirectional_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3285,7 +3285,7 @@
 
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{transform_view::iterator}}
 \begin{itemdecl}
-constexpr iterator operator--(int) requires BidirectionalRange<Base>;
+constexpr iterator operator--(int) requires bidirectional_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3301,7 +3301,7 @@
 \indexlibrary{\idxcode{operator+=}!\idxcode{transform_view::iterator}}
 \begin{itemdecl}
 constexpr iterator& operator+=(difference_type n)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3316,7 +3316,7 @@
 \indexlibrary{\idxcode{operator-=}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 constexpr iterator& operator-=(difference_type n)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3331,7 +3331,7 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{transform_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator==(const iterator& x, const iterator& y)
-  requires EqualityComparable<iterator_t<Base>>;
+  requires equality_comparable<iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3342,7 +3342,7 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator!=(const iterator& x, const iterator& y)
-  requires EqualityComparable<iterator_t<Base>>;
+  requires equality_comparable<iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3353,7 +3353,7 @@
 \indexlibrary{\idxcode{operator<}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator<(const iterator& x, const iterator& y)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3364,7 +3364,7 @@
 \indexlibrary{\idxcode{operator>}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator>(const iterator& x, const iterator& y)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3375,7 +3375,7 @@
 \indexlibrary{\idxcode{operator<=}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator<=(const iterator& x, const iterator& y)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3386,7 +3386,7 @@
 \indexlibrary{\idxcode{operator>=}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator>=(const iterator& x, const iterator& y)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3397,9 +3397,9 @@
 \indexlibrary{\idxcode{operator+}!\idxcode{transform_view::iterator}}
 \begin{itemdecl}
 friend constexpr iterator operator+(iterator i, difference_type n)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 friend constexpr iterator operator+(difference_type n, iterator i)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3410,7 +3410,7 @@
 \indexlibrary{\idxcode{operator-}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr iterator operator-(iterator i, difference_type n)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3421,7 +3421,7 @@
 \indexlibrary{\idxcode{operator-}!\idxcode{transform_view::iterator}}%
 \begin{itemdecl}
 friend constexpr difference_type operator-(const iterator& x, const iterator& y)
-  requires RandomAccessRange<Base>;
+  requires random_access_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3433,7 +3433,7 @@
 \begin{itemdecl}
 friend constexpr void iter_swap(const iterator& x, const iterator& y)
   noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
-  requires IndirectlySwappable<iterator_t<Base>>;
+  requires indirectly_swappable<iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3458,7 +3458,7 @@
     sentinel() = default;
     constexpr explicit sentinel(sentinel_t<Base> end);
     constexpr sentinel(sentinel<!Const> i)
-      requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 
     constexpr sentinel_t<Base> base() const;
 
@@ -3469,10 +3469,10 @@
 
     friend constexpr iter_difference_t<iterator_t<Base>>
       operator-(const iterator<Const>& x, const sentinel& y)
-        requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
+        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
     friend constexpr iter_difference_t<iterator_t<Base>>
       operator-(const sentinel& y, const iterator<Const>& x)
-        requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
+        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
   };
 }
 \end{codeblock}
@@ -3490,7 +3490,7 @@
 \indexlibrary{\idxcode{sentinel}!\idxcode{transform_view::sentinel}}
 \begin{itemdecl}
 constexpr sentinel(sentinel<!Const> i)
-  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3552,7 +3552,7 @@
 \begin{itemdecl}
 friend constexpr iter_difference_t<iterator_t<Base>>
   operator-(const iterator<Const>& x, const sentinel& y)
-    requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
+    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3564,7 +3564,7 @@
 \begin{itemdecl}
 friend constexpr iter_difference_t<iterator_t<Base>>
   operator-(const sentinel& y, const iterator<Const>& x)
-    requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
+    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3587,9 +3587,9 @@
 \rSec3[range.take.overview]{Overview}
 
 \pnum
-\tcode{take_view} produces a \libconcept{View} of the first $N$ elements
-from another \libconcept{View}, or all the elements if the adapted
-\libconcept{View} contains fewer than $N$.
+\tcode{take_view} produces a \libconcept{view} of the first $N$ elements
+from another \libconcept{view}, or all the elements if the adapted
+\libconcept{view} contains fewer than $N$.
 
 \pnum
 \begin{example}
@@ -3605,7 +3605,7 @@
 
 \begin{codeblock}
 namespace std::ranges {
-  template<View V>
+  template<view V>
   class take_view : public view_interface<take_view<V>> {
   private:
     V base_ = V();                                      // \expos
@@ -3615,15 +3615,15 @@
   public:
     take_view() = default;
     constexpr take_view(V base, iter_difference_t<iterator_t<V>> count);
-    template<ViewableRange R>
-      requires Constructible<V, all_view<R>>
+    template<viewable_range R>
+      requires constructible_from<V, all_view<R>>
     constexpr take_view(R&& r, iter_difference_t<iterator_t<V>> count);
 
     constexpr V base() const;
 
     constexpr auto begin() requires (!@\placeholder{simple-view}@<V>) {
-      if constexpr (SizedRange<V>) {
-        if constexpr (RandomAccessRange<V>)
+      if constexpr (sized_range<V>) {
+        if constexpr (random_access_range<V>)
           return ranges::begin(base_);
         else
           return counted_iterator{ranges::begin(base_), size()};
@@ -3631,9 +3631,9 @@
         return counted_iterator{ranges::begin(base_), count_};
     }
 
-    constexpr auto begin() const requires Range<const V> {
-      if constexpr (SizedRange<const V>) {
-        if constexpr (RandomAccessRange<const V>)
+    constexpr auto begin() const requires range<const V> {
+      if constexpr (sized_range<const V>) {
+        if constexpr (random_access_range<const V>)
           return ranges::begin(base_);
         else
           return counted_iterator{ranges::begin(base_), size()};
@@ -3642,8 +3642,8 @@
     }
 
     constexpr auto end() requires (!@\placeholder{simple-view}@<V>) {
-      if constexpr (SizedRange<V>) {
-        if constexpr (RandomAccessRange<V>)
+      if constexpr (sized_range<V>) {
+        if constexpr (random_access_range<V>)
           return ranges::begin(base_) + size();
         else
           return default_sentinel;
@@ -3651,9 +3651,9 @@
         return sentinel<false>{ranges::end(base_)};
     }
 
-    constexpr auto end() const requires Range<const V> {
-      if constexpr (SizedRange<const V>) {
-        if constexpr (RandomAccessRange<const V>)
+    constexpr auto end() const requires range<const V> {
+      if constexpr (sized_range<const V>) {
+        if constexpr (random_access_range<const V>)
           return ranges::begin(base_) + size();
         else
           return default_sentinel;
@@ -3661,18 +3661,18 @@
         return sentinel<true>{ranges::end(base_)};
     }
 
-    constexpr auto size() requires SizedRange<V> {
+    constexpr auto size() requires sized_range<V> {
       auto n = ranges::size(base_);
       return ranges::min(n, static_cast<decltype(n)>(count_));
     }
 
-    constexpr auto size() const requires SizedRange<const V> {
+    constexpr auto size() const requires sized_range<const V> {
       auto n = ranges::size(base_);
       return ranges::min(n, static_cast<decltype(n)>(count_));
     }
   };
 
-  template<Range R>
+  template<range R>
     take_view(R&&, iter_difference_t<iterator_t<R>>)
       -> take_view<all_view<R>>;
 }
@@ -3691,8 +3691,8 @@
 
 \indexlibrary{\idxcode{take_view}!\idxcode{take_view}}%
 \begin{itemdecl}
-template<ViewableRange R>
-  requires Constructible<V, all_view<R>>
+template<viewable_range R>
+  requires constructible_from<V, all_view<R>>
 constexpr take_view(R&& r, iter_difference_t<iterator_t<V>> count);
 \end{itemdecl}
 
@@ -3727,7 +3727,7 @@
     sentinel() = default;
     constexpr explicit sentinel(sentinel_t<Base> end);
     constexpr sentinel(sentinel<!Const> s)
-      requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 
     constexpr sentinel_t<Base> base() const;
 
@@ -3752,7 +3752,7 @@
 \indexlibrary{\idxcode{sentinel}!\idxcode{take_view::sentinel}}%
 \begin{itemdecl}
 constexpr sentinel(sentinel<!Const> s)
-  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3808,8 +3808,8 @@
 \rSec3[range.join.overview]{Overview}
 
 \pnum
-\tcode{join_view} flattens a \libconcept{View} of ranges into a
-\libconcept{View}.
+\tcode{join_view} flattens a \libconcept{view} of ranges into a
+\libconcept{view}.
 
 \pnum
 \begin{example}
@@ -3825,10 +3825,10 @@
 
 \begin{codeblock}
 namespace std::ranges {
-  template<InputRange V>
-    requires View<V> && InputRange<iter_reference_t<iterator_t<V>>> &&
+  template<input_range V>
+    requires view<V> && input_range<iter_reference_t<iterator_t<V>>> &&
              (is_reference_v<iter_reference_t<iterator_t<V>>> ||
-              View<iter_value_t<iterator_t<V>>>)
+              view<iter_value_t<iterator_t<V>>>)
   class join_view : public view_interface<join_view<V>> {
   private:
     using InnerRng =                    // \expos
@@ -3847,8 +3847,8 @@
     join_view() = default;
     constexpr explicit join_view(V base);
 
-    template<InputRange R>
-      requires ViewableRange<R> && Constructible<V, all_view<R>>
+    template<input_range R>
+      requires viewable_range<R> && constructible_from<V, all_view<R>>
     constexpr explicit join_view(R&& r);
 
     constexpr auto begin() {
@@ -3856,28 +3856,28 @@
     }
 
     constexpr auto begin() const
-    requires InputRange<const V> &&
+    requires input_range<const V> &&
              is_reference_v<iter_reference_t<iterator_t<const V>>> {
       return iterator<true>{*this, ranges::begin(base_)};
     }
 
     constexpr auto end() {
-      if constexpr (ForwardRange<V> &&
-                    is_reference_v<InnerRng> && ForwardRange<InnerRng> &&
-                    CommonRange<V> && CommonRange<InnerRng>)
+      if constexpr (forward_range<V> &&
+                    is_reference_v<InnerRng> && forward_range<InnerRng> &&
+                    common_range<V> && common_range<InnerRng>)
         return iterator<@\placeholder{simple-view}@<V>>{*this, ranges::end(base_)};
       else
         return sentinel<@\placeholder{simple-view}@<V>>{*this};
     }
 
     constexpr auto end() const
-    requires InputRange<const V> &&
+    requires input_range<const V> &&
              is_reference_v<iter_reference_t<iterator_t<const V>>> {
-      if constexpr (ForwardRange<const V> &&
+      if constexpr (forward_range<const V> &&
                     is_reference_v<iter_reference_t<iterator_t<const V>>> &&
-                    ForwardRange<iter_reference_t<iterator_t<const V>>> &&
-                    CommonRange<const V> &&
-                    CommonRange<iter_reference_t<iterator_t<const V>>>)
+                    forward_range<iter_reference_t<iterator_t<const V>>> &&
+                    common_range<const V> &&
+                    common_range<iter_reference_t<iterator_t<const V>>>)
         return iterator<true>{*this, ranges::end(base_)};
       else
         return sentinel<true>{*this};
@@ -3901,8 +3901,8 @@
 
 \indexlibrary{\idxcode{join_view}!\idxcode{join_view}}%
 \begin{itemdecl}
-template<InputRange R>
-  requires ViewableRange<R> && Constructible<V, all_view<R>>
+template<input_range R>
+  requires viewable_range<R> && constructible_from<V, all_view<R>>
 constexpr explicit join_view(R&& r);
 \end{itemdecl}
 
@@ -3944,9 +3944,9 @@
     constexpr iterator(Parent& parent, iterator_t<V> outer);
     constexpr iterator(iterator<!Const> i)
       requires Const &&
-               ConvertibleTo<iterator_t<V>, iterator_t<Base>> &&
-               ConvertibleTo<iterator_t<InnerRng>,
-                             iterator_t<iter_reference_t<iterator_t<Base>>>>;
+               convertible_to<iterator_t<V>, iterator_t<Base>> &&
+               convertible_to<iterator_t<InnerRng>,
+                              iterator_t<iter_reference_t<iterator_t<Base>>>>;
 
     constexpr decltype(auto) operator*() const { return *inner_; }
 
@@ -3956,24 +3956,24 @@
     constexpr iterator& operator++();
     constexpr void operator++(int);
     constexpr iterator operator++(int)
-      requires ref_is_glvalue && ForwardRange<Base> &&
-               ForwardRange<iter_reference_t<iterator_t<Base>>>;
+      requires ref_is_glvalue && forward_range<Base> &&
+               forward_range<iter_reference_t<iterator_t<Base>>>;
 
     constexpr iterator& operator--()
-      requires ref_is_glvalue && BidirectionalRange<Base> &&
-               BidirectionalRange<iter_reference_t<iterator_t<Base>>>;
+      requires ref_is_glvalue && bidirectional_range<Base> &&
+               bidirectional_range<iter_reference_t<iterator_t<Base>>>;
 
     constexpr iterator operator--(int)
-      requires ref_is_glvalue && BidirectionalRange<Base> &&
-               BidirectionalRange<iter_reference_t<iterator_t<Base>>>;
+      requires ref_is_glvalue && bidirectional_range<Base> &&
+               bidirectional_range<iter_reference_t<iterator_t<Base>>>;
 
     friend constexpr bool operator==(const iterator& x, const iterator& y)
-      requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
-               EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
+      requires ref_is_glvalue && equality_comparable<iterator_t<Base>> &&
+               equality_comparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
 
     friend constexpr bool operator!=(const iterator& x, const iterator& y)
-      requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
-               EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
+      requires ref_is_glvalue && equality_comparable<iterator_t<Base>> &&
+               equality_comparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
 
     friend constexpr decltype(auto) iter_move(const iterator& i)
     noexcept(noexcept(ranges::iter_move(i.inner_))) {
@@ -3992,10 +3992,10 @@
 \item If \tcode{ref_is_glvalue} is \tcode{true},
   \begin{itemize}
   \item If \tcode{Base} and \tcode{iter_reference_t<iterator_t<Base>>} each model
-    \libconcept{BidirectionalRange}, then \tcode{iterator_concept} denotes
+    \libconcept{bidirectional_range}, then \tcode{iterator_concept} denotes
     \tcode{bidirectional_iterator_tag}.
   \item Otherwise, if \tcode{Base} and \tcode{iter_reference_t<iterator_t<Base>>}
-    each model \libconcept{ForwardRange}, then \tcode{iterator_concept} denotes
+    each model \libconcept{forward_range}, then \tcode{iterator_concept} denotes
     \tcode{forward_iterator_tag}.
   \end{itemize}
 \item Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
@@ -4011,10 +4011,10 @@
 \item If \tcode{ref_is_glvalue} is \tcode{true},
   \begin{itemize}
   \item If \placeholder{OUTERC} and \placeholder{INNERC} each model
-    \tcode{DerivedFrom<bidirectional_iterator_tag>}, \tcode{itera\-tor_category}
+    \tcode{\libconcept{derived_from}<bidirectional_iterator_tag>}, \tcode{itera\-tor_category}
     denotes \tcode{bidirectional_iterator_tag}.
   \item Otherwise, if \placeholder{OUTERC} and \placeholder{INNERC} each model
-    \tcode{DerivedFrom<forward_iterator_tag>}, \tcode{itera\-tor_category}
+    \tcode{\libconcept{derived_from}<forward_iterator_tag>}, \tcode{itera\-tor_category}
     denotes \tcode{forward_iterator_tag}.
   \end{itemize}
 \item Otherwise, \tcode{iterator_category} denotes \tcode{input_iterator_tag}.
@@ -4073,9 +4073,9 @@
 \begin{itemdecl}
 constexpr iterator(iterator<!Const> i)
   requires Const &&
-           ConvertibleTo<iterator_t<V>, iterator_t<Base>> &&
-           ConvertibleTo<iterator_t<InnerRng>,
-                         iterator_t<iter_reference_t<iterator_t<Base>>>>;
+           convertible_to<iterator_t<V>, iterator_t<Base>> &&
+           convertible_to<iterator_t<InnerRng>,
+                          iterator_t<iter_reference_t<iterator_t<Base>>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4134,8 +4134,8 @@
 \indexlibrary{\idxcode{operator++}!\idxcode{join_view::iterator}}
 \begin{itemdecl}
 constexpr iterator operator++(int)
-  requires ref_is_glvalue && ForwardRange<Base> &&
-           ForwardRange<iter_reference_t<iterator_t<Base>>>;
+  requires ref_is_glvalue && forward_range<Base> &&
+           forward_range<iter_reference_t<iterator_t<Base>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4151,8 +4151,8 @@
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{join_view::iterator}}
 \begin{itemdecl}
 constexpr iterator& operator--()
-  requires ref_is_glvalue && BidirectionalRange<Base> &&
-           BidirectionalRange<iter_reference_t<iterator_t<Base>>>;
+  requires ref_is_glvalue && bidirectional_range<Base> &&
+           bidirectional_range<iter_reference_t<iterator_t<Base>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4171,8 +4171,8 @@
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{join_view::iterator}}
 \begin{itemdecl}
 constexpr iterator operator--(int)
-  requires ref_is_glvalue && BidirectionalRange<Base> &&
-           BidirectionalRange<iter_reference_t<iterator_t<Base>>>;
+  requires ref_is_glvalue && bidirectional_range<Base> &&
+           bidirectional_range<iter_reference_t<iterator_t<Base>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4188,8 +4188,8 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{join_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator==(const iterator& x, const iterator& y)
-  requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
-           EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
+  requires ref_is_glvalue && equality_comparable<iterator_t<Base>> &&
+           equality_comparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4201,8 +4201,8 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{join_view::iterator}}
 \begin{itemdecl}
 friend constexpr bool operator!=(const iterator& x, const iterator& y)
-  requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
-           EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
+  requires ref_is_glvalue && equality_comparable<iterator_t<Base>> &&
+           equality_comparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4238,7 +4238,7 @@
 
     constexpr explicit sentinel(Parent& parent);
     constexpr sentinel(sentinel<!Const> s)
-      requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 
     friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
     friend constexpr bool operator==(const sentinel& x, const iterator<Const>& y);
@@ -4261,7 +4261,7 @@
 \indexlibrary{\idxcode{sentinel}!\idxcode{join_view::sentinel}}
 \begin{itemdecl}
 constexpr sentinel(sentinel<!Const> s)
-  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4323,9 +4323,9 @@
 \rSec3[range.split.overview]{Overview}
 
 \pnum
-\tcode{split_view} takes a \libconcept{View} and a delimiter, and splits
-the \libconcept{View} into subranges on the delimiter. The delimiter can be
-a single element or a \libconcept{View} of elements.
+\tcode{split_view} takes a \libconcept{view} and a delimiter, and splits
+the \libconcept{view} into subranges on the delimiter. The delimiter can be
+a single element or a \libconcept{view} of elements.
 
 \pnum
 \begin{example}
@@ -4349,14 +4349,14 @@
 
   template<class R>
   concept @\placeholdernc{tiny-range}@ =                          // \expos
-    SizedRange<R> &&
+    sized_range<R> &&
     requires { typename @\placeholdernc{require-constant}@<remove_reference_t<R>::size()>; } &&
     (remove_reference_t<R>::size() <= 1);
 
-  template<InputRange V, ForwardRange Pattern>
-    requires View<V> && View<Pattern> &&
-             IndirectlyComparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
-             (ForwardRange<V> || @\placeholdernc{tiny-range}@<Pattern>)
+  template<input_range V, forward_range Pattern>
+    requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
+             (forward_range<V> || @\placeholdernc{tiny-range}@<Pattern>)
   class split_view : public view_interface<split_view<V, Pattern>> {
   private:
     V base_ = V();                              // \expos
@@ -4370,18 +4370,18 @@
     split_view() = default;
     constexpr split_view(V base, Pattern pattern);
 
-    template<InputRange R, ForwardRange P>
-      requires Constructible<V, all_view<R>> &&
-               Constructible<Pattern, all_view<P>>
+    template<input_range R, forward_range P>
+      requires constructible_from<V, all_view<R>> &&
+               constructible_from<Pattern, all_view<P>>
     constexpr split_view(R&& r, P&& p);
 
-    template<InputRange R>
-      requires Constructible<V, all_view<R>> &&
-               Constructible<Pattern, single_view<iter_value_t<iterator_t<R>>>>
+    template<input_range R>
+      requires constructible_from<V, all_view<R>> &&
+               constructible_from<Pattern, single_view<iter_value_t<iterator_t<R>>>>
     constexpr split_view(R&& r, iter_value_t<iterator_t<R>> e);
 
     constexpr auto begin() {
-      if constexpr (ForwardRange<V>)
+      if constexpr (forward_range<V>)
         return outer_iterator<@\placeholder{simple-view}@<V>>{*this, ranges::begin(base_)};
       else {
         current_ = ranges::begin(base_);
@@ -4389,16 +4389,16 @@
       }
     }
 
-    constexpr auto begin() const requires ForwardRange<V> && ForwardRange<const V> {
+    constexpr auto begin() const requires forward_range<V> && forward_range<const V> {
       return outer_iterator<true>{*this, ranges::begin(base_)};
     }
 
-    constexpr auto end() requires ForwardRange<V> && CommonRange<V> {
+    constexpr auto end() requires forward_range<V> && common_range<V> {
       return outer_iterator<@\placeholder{simple-view}@<V>>{*this, ranges::end(base_)};
     }
 
     constexpr auto end() const {
-      if constexpr (ForwardRange<V> && ForwardRange<const V> && CommonRange<const V>)
+      if constexpr (forward_range<V> && forward_range<const V> && common_range<const V>)
         return outer_iterator<true>{*this, ranges::end(base_)};
       else
         return default_sentinel;
@@ -4408,7 +4408,7 @@
   template<class R, class P>
     split_view(R&&, P&&) -> split_view<all_view<R>, all_view<P>>;
 
-  template<InputRange R>
+  template<input_range R>
     split_view(R&&, iter_value_t<iterator_t<R>>)
       -> split_view<all_view<R>, single_view<iter_value_t<iterator_t<R>>>>;
 }
@@ -4427,9 +4427,9 @@
 
 \indexlibrary{\idxcode{split_view}!\idxcode{split_view}}%
 \begin{itemdecl}
-template<InputRange R, ForwardRange P>
-  requires Constructible<V, all_view<R>> &&
-           Constructible<Pattern, all_view<P>>
+template<input_range R, forward_range P>
+  requires constructible_from<V, all_view<R>> &&
+           constructible_from<Pattern, all_view<P>>
 constexpr split_view(R&& r, P&& p);
 \end{itemdecl}
 
@@ -4442,9 +4442,9 @@
 
 \indexlibrary{\idxcode{split_view}!\idxcode{split_view}}%
 \begin{itemdecl}
-template<InputRange R>
-  requires Constructible<V, all_view<R>> &&
-           Constructible<Pattern, single_view<iter_value_t<iterator_t<R>>>>
+template<input_range R>
+  requires constructible_from<V, all_view<R>> &&
+           constructible_from<Pattern, single_view<iter_value_t<iterator_t<R>>>>
 constexpr split_view(R&& r, iter_value_t<iterator_t<R>> e);
 \end{itemdecl}
 
@@ -4468,12 +4468,12 @@
     using Base   =                              // \expos
       conditional_t<Const, const V, V>;
     Parent* parent_ = nullptr;                  // \expos
-    iterator_t<Base> current_ =                 // \expos, present only if \tcode{V} models \libconcept{ForwardRange}
+    iterator_t<Base> current_ =                 // \expos, present only if \tcode{V} models \libconcept{forward_range}
       iterator_t<Base>();
 
   public:
     using iterator_concept  =
-      conditional_t<ForwardRange<Base>, forward_iterator_tag, input_iterator_tag>;
+      conditional_t<forward_range<Base>, forward_iterator_tag, input_iterator_tag>;
     using iterator_category = input_iterator_tag;
     // \ref{range.split.outer.value}, class \tcode{split_view::outer_iterator::value_type}
     struct value_type;
@@ -4481,17 +4481,17 @@
 
     outer_iterator() = default;
     constexpr explicit outer_iterator(Parent& parent)
-      requires (!ForwardRange<Base>);
+      requires (!forward_range<Base>);
     constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
-      requires ForwardRange<Base>;
+      requires forward_range<Base>;
     constexpr outer_iterator(outer_iterator<!Const> i)
-      requires Const && ConvertibleTo<iterator_t<V>, iterator_t<const V>>;
+      requires Const && convertible_to<iterator_t<V>, iterator_t<const V>>;
 
     constexpr value_type operator*() const;
 
     constexpr outer_iterator& operator++();
     constexpr decltype(auto) operator++(int) {
-      if constexpr (ForwardRange<Base>) {
+      if constexpr (forward_range<Base>) {
         auto tmp = *this;
         ++*this;
         return tmp;
@@ -4500,9 +4500,9 @@
     }
 
     friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
-      requires ForwardRange<Base>;
+      requires forward_range<Base>;
     friend constexpr bool operator!=(const outer_iterator& x, const outer_iterator& y)
-      requires ForwardRange<Base>;
+      requires forward_range<Base>;
 
     friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t);
     friend constexpr bool operator==(default_sentinel_t, const outer_iterator& x);
@@ -4516,12 +4516,12 @@
 Many of the following specifications refer to the notional member
 \tcode{\placeholder{current}} of \tcode{outer_iterator}.
 \tcode{\placeholder{current}} is equivalent to \tcode{current_} if \tcode{V}
-models \libconcept{ForwardRange}, and \tcode{parent_->current_} otherwise.
+models \libconcept{forward_range}, and \tcode{parent_->current_} otherwise.
 
 \indexlibrary{\idxcode{outer_iterator}!\idxcode{split_view::outer_iterator}}%
 \begin{itemdecl}
 constexpr explicit outer_iterator(Parent& parent)
-  requires (!ForwardRange<Base>);
+  requires (!forward_range<Base>);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4532,7 +4532,7 @@
 \indexlibrary{\idxcode{outer_iterator}!\idxcode{split_view::outer_iterator}}%
 \begin{itemdecl}
 constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
-  requires ForwardRange<Base>;
+  requires forward_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4544,7 +4544,7 @@
 \indexlibrary{\idxcode{outer_iterator}!\idxcode{split_view::outer_iterator}}%
 \begin{itemdecl}
 constexpr outer_iterator(outer_iterator<!Const> i)
-  requires Const && ConvertibleTo<iterator_t<V>, iterator_t<const V>>;
+  requires Const && convertible_to<iterator_t<V>, iterator_t<const V>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4592,7 +4592,7 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{split_view::outer_iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
-  requires ForwardRange<Base>;
+  requires forward_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4603,7 +4603,7 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{split_view::outer_iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator!=(const outer_iterator& x, const outer_iterator& y)
-  requires ForwardRange<Base>;
+  requires forward_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4708,7 +4708,7 @@
 
     constexpr inner_iterator& operator++();
     constexpr decltype(auto) operator++(int) {
-      if constexpr (ForwardRange<V>) {
+      if constexpr (forward_range<V>) {
         auto tmp = *this;
         ++*this;
         return tmp;
@@ -4717,9 +4717,9 @@
     }
 
     friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
-      requires ForwardRange<Base>;
+      requires forward_range<Base>;
     friend constexpr bool operator!=(const inner_iterator& x, const inner_iterator& y)
-      requires ForwardRange<Base>;
+      requires forward_range<Base>;
 
     friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t);
     friend constexpr bool operator==(default_sentinel_t, const inner_iterator& x);
@@ -4733,7 +4733,7 @@
 
     friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y)
       noexcept(noexcept(ranges::iter_swap(x.i_.@\placeholdernc{current}, y.i_.\placeholdernc{current}@)))
-      requires IndirectlySwappable<iterator_t<Base>>;
+      requires indirectly_swappable<iterator_t<Base>>;
   };
 }
 \end{codeblock}
@@ -4742,7 +4742,7 @@
 The \grammarterm{typedef-name} \tcode{iterator_category} denotes
 \tcode{forward_iterator_tag} if
 \tcode{iterator_traits<iterator_t<Base>>::iterator_category} models
-\tcode{DerivedFrom<forward_iterator_tag>}, and \tcode{input_iterator_tag}
+\tcode{\libconcept{derived_from}<forward_iterator_tag>}, and \tcode{input_iterator_tag}
 otherwise.
 
 \indexlibrary{\idxcode{inner_iterator}!\idxcode{split_view::inner_iterator}}%
@@ -4778,7 +4778,7 @@
 \indexlibrary{\idxcode{operator==}!\idxcode{split_view::inner_iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
-  requires ForwardRange<Base>;
+  requires forward_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4789,7 +4789,7 @@
 \indexlibrary{\idxcode{operator"!=}!\idxcode{split_view::inner_iterator}}%
 \begin{itemdecl}
 friend constexpr bool operator!=(const inner_iterator& x, const inner_iterator& y)
-  requires ForwardRange<Base>;
+  requires forward_range<Base>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4835,7 +4835,7 @@
 \begin{itemdecl}
 friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y)
   noexcept(noexcept(ranges::iter_swap(x.i_.@\placeholdernc{current}, y.i_.\placeholdernc{current}@)))
-  requires IndirectlySwappable<iterator_t<Base>>;
+  requires indirectly_swappable<iterator_t<Base>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4857,7 +4857,7 @@
 \rSec2[range.counted]{Counted view}
 
 \pnum
-A counted view presents a \libconcept{View} of the elements
+A counted view presents a \libconcept{view} of the elements
 of the counted range\iref{iterator.requirements.general} \range{i}{n}
 for some iterator \tcode{i} and non-negative integer \tcode{n}.
 
@@ -4869,11 +4869,11 @@
 Then the expression \tcode{view::counted(E, F)} is expression-equivalent to:
 
 \begin{itemize}
-\item If \tcode{T} models \libconcept{Iterator} and
-  \tcode{decltype((F))} models \tcode{\libconcept{ConvertibleTo}<iter_difference_t<T>>},
+\item If \tcode{T} models \libconcept{input_or_output_iterator} and
+  \tcode{decltype((F))} models \tcode{\libconcept{convertible_to}<iter_differ\-ence_t<T>>},
   \begin{itemize}
   \item \tcode{subrange\{E, E + static_cast<iter_difference_t<T>>(F)\}}
-    if \tcode{T} models \libconcept{RandomAccessItera\-tor}.
+    if \tcode{T} models \libconcept{random_access_it\-erator}.
   \item Otherwise,
     \tcode{subrange\{counted_iterator\{E, F\}, default_sentinel\}}.
 \end{itemize}
@@ -4891,8 +4891,8 @@
 \rSec3[range.common.overview]{Overview}
 
 \pnum
-\tcode{common_view} takes a \libconcept{View} which has different types for
-its iterator and sentinel and turns it into a \libconcept{View} of the same
+\tcode{common_view} takes a \libconcept{view} which has different types for
+its iterator and sentinel and turns it into a \libconcept{view} of the same
 elements with an iterator and sentinel of the same type.
 
 \pnum
@@ -4908,7 +4908,7 @@
 template<class ForwardIterator>
 size_t count(ForwardIterator first, ForwardIterator last);
 
-template<ForwardRange R>
+template<forward_range R>
 void my_algo(R&& r) {
   auto&& common = common_view{r};
   auto cnt = count(common.begin(), common.end());
@@ -4921,8 +4921,8 @@
 
 \begin{codeblock}
 namespace std::ranges {
-  template<View V>
-    requires (!CommonRange<V>)
+  template<view V>
+    requires (!common_range<V>)
   class common_view : public view_interface<common_view<V>> {
   private:
     V base_ = V();  // \expos
@@ -4931,42 +4931,42 @@
 
     constexpr explicit common_view(V r);
 
-    template<ViewableRange R>
-      requires (!CommonRange<R> && Constructible<V, all_view<R>>)
+    template<viewable_range R>
+      requires (!common_range<R> && constructible_from<V, all_view<R>>)
     constexpr explicit common_view(R&& r);
 
     constexpr V base() const;
 
-    constexpr auto size() requires SizedRange<V> {
+    constexpr auto size() requires sized_range<V> {
       return ranges::size(base_);
     }
-    constexpr auto size() const requires SizedRange<const V> {
+    constexpr auto size() const requires sized_range<const V> {
       return ranges::size(base_);
     }
 
     constexpr auto begin() {
-      if constexpr (RandomAccessRange<V> && SizedRange<V>)
+      if constexpr (random_access_range<V> && sized_range<V>)
         return ranges::begin(base_);
       else
         return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(base_));
     }
 
-    constexpr auto begin() const requires Range<const V> {
-      if constexpr (RandomAccessRange<const V> && SizedRange<const V>)
+    constexpr auto begin() const requires range<const V> {
+      if constexpr (random_access_range<const V> && sized_range<const V>)
         return ranges::begin(base_);
       else
         return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(base_));
     }
 
     constexpr auto end() {
-      if constexpr (RandomAccessRange<V> && SizedRange<V>)
+      if constexpr (random_access_range<V> && sized_range<V>)
         return ranges::begin(base_) + ranges::size(base_);
       else
         return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(base_));
     }
 
-    constexpr auto end() const requires Range<const V> {
-      if constexpr (RandomAccessRange<const V> && SizedRange<const V>)
+    constexpr auto end() const requires range<const V> {
+      if constexpr (random_access_range<const V> && sized_range<const V>)
         return ranges::begin(base_) + ranges::size(base_);
       else
         return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(base_));
@@ -4990,8 +4990,8 @@
 
 \indexlibrary{\idxcode{common_view}!\idxcode{common_view}}%
 \begin{itemdecl}
-template<ViewableRange R>
-  requires (!CommonRange<R> && Constructible<V, all_view<R>>)
+template<viewable_range R>
+  requires (!common_range<R> && constructible_from<V, all_view<R>>)
 constexpr explicit common_view(R&& r);
 \end{itemdecl}
 
@@ -5020,7 +5020,7 @@
 
 \begin{itemize}
 \item \tcode{view::all(E)},
-  if \tcode{decltype((E))} models \libconcept{CommonRange}
+  if \tcode{decltype((E))} models \libconcept{common_range}
   and \tcode{view::all(E)} is a well-formed expression.
 
 \item Otherwise, \tcode{common_view\{E\}}.
@@ -5032,8 +5032,8 @@
 \rSec3[range.reverse.overview]{Overview}
 
 \pnum
-\tcode{reverse_view} takes a bidirectional \libconcept{View} and produces
-another \libconcept{View} that iterates the same elements in reverse order.
+\tcode{reverse_view} takes a bidirectional \libconcept{view} and produces
+another \libconcept{view} that iterates the same elements in reverse order.
 
 \pnum
 \begin{example}
@@ -5050,8 +5050,8 @@
 \indexlibrary{\idxcode{weiv_esrever}}%
 \begin{codeblock}
 namespace std::ranges {
-  template<View V>
-    requires BidirectionalRange<V>
+  template<view V>
+    requires bidirectional_range<V>
   class reverse_view : public view_interface<reverse_view<V>> {
   private:
     V base_ = V();  // \expos
@@ -5060,25 +5060,25 @@
 
     constexpr explicit reverse_view(V r);
 
-    template<ViewableRange R>
-      requires BidirectionalRange<R> && Constructible<V, all_view<R>>
+    template<viewable_range R>
+      requires bidirectional_range<R> && constructible_from<V, all_view<R>>
     constexpr explicit reverse_view(R&& r);
 
     constexpr V base() const;
 
     constexpr reverse_iterator<iterator_t<V>> begin();
-    constexpr reverse_iterator<iterator_t<V>> begin() requires CommonRange<V>;
+    constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
     constexpr reverse_iterator<iterator_t<const V>> begin() const
-      requires CommonRange<const V>;
+      requires common_range<const V>;
 
     constexpr reverse_iterator<iterator_t<V>> end();
     constexpr reverse_iterator<iterator_t<const V>> end() const
-      requires CommonRange<const V>;
+      requires common_range<const V>;
 
-    constexpr auto size() requires SizedRange<V> {
+    constexpr auto size() requires sized_range<V> {
       return ranges::size(base_);
     }
-    constexpr auto size() const requires SizedRange<const V> {
+    constexpr auto size() const requires sized_range<const V> {
       return ranges::size(base_);
     }
   };
@@ -5100,8 +5100,8 @@
 
 \indexlibrary{\idxcode{reverse_view}!\idxcode{reverse_view}}%
 \begin{itemdecl}
-template<ViewableRange R>
-  requires BidirectionalRange<R> && Constructible<V, all_view<R>>
+template<viewable_range R>
+  requires bidirectional_range<R> && constructible_from<V, all_view<R>>
 constexpr explicit reverse_view(R&& r);
 \end{itemdecl}
 
@@ -5134,15 +5134,15 @@
 
 \pnum
 \remarks In order to provide the amortized constant time complexity required by
-the \libconcept{Range} concept, this function caches the result within the
+the \libconcept{range} concept, this function caches the result within the
 \tcode{reverse_view} for use on subsequent calls.
 \end{itemdescr}
 
 \indexlibrary{\idxcode{begin}!\idxcode{reverse_view}}%
 \begin{itemdecl}
-constexpr reverse_iterator<iterator_t<V>> begin() requires CommonRange<V>;
+constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
 constexpr reverse_iterator<iterator_t<const V>> begin() const
-  requires CommonRange<const V>;
+  requires common_range<const V>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5154,7 +5154,7 @@
 \begin{itemdecl}
 constexpr reverse_iterator<iterator_t<V>> end();
 constexpr reverse_iterator<iterator_t<const V>> end() const
-  requires CommonRange<const V>;
+  requires common_range<const V>;
 \end{itemdecl}
 
 \begin{itemdescr}
diff --git a/source/strings.tex b/source/strings.tex
index cbba04ae5d..eba4ea7f31 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -4149,7 +4149,7 @@
 A type that meets the requirements
 of a constant
 \oldconcept{RandomAccessIterator}\iref{random.access.iterators},
-models \libconcept{ContiguousIterator}\iref{iterator.concept.contiguous}, and
+models \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous}, and
 meets the constexpr iterator requirements\iref{iterator.requirements.general},
 whose \tcode{value_type} is the template parameter \tcode{charT}.
 
diff --git a/source/utilities.tex b/source/utilities.tex
index f273fe2c8a..a45d34534e 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -6631,14 +6631,14 @@
 
   namespace ranges {
     template<@\placeholdernc{no-throw-forward-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S>
-      requires DefaultConstructible<iter_value_t<I>>
+      requires default_constructible<iter_value_t<I>>
         I uninitialized_default_construct(I first, S last);
     template<@\placeholdernc{no-throw-forward-range}@ R>
-      requires DefaultConstructible<iter_value_t<iterator_t<R>>>
+      requires default_constructible<iter_value_t<iterator_t<R>>>
         safe_iterator_t<R> uninitialized_default_construct(R&& r);
 
     template<@\placeholdernc{no-throw-forward-iterator}@ I>
-      requires DefaultConstructible<iter_value_t<I>>
+      requires default_constructible<iter_value_t<I>>
         I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
   }
 
@@ -6655,14 +6655,14 @@
 
   namespace ranges {
     template<@\placeholdernc{no-throw-forward-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S>
-      requires DefaultConstructible<iter_value_t<I>>
+      requires default_constructible<iter_value_t<I>>
         I uninitialized_value_construct(I first, S last);
     template<@\placeholdernc{no-throw-forward-range}@ R>
-      requires DefaultConstructible<iter_value_t<iterator_t<R>>>
+      requires default_constructible<iter_value_t<iterator_t<R>>>
         safe_iterator_t<R> uninitialized_value_construct(R&& r);
 
     template<@\placeholdernc{no-throw-forward-iterator}@ I>
-      requires DefaultConstructible<iter_value_t<I>>
+      requires default_constructible<iter_value_t<I>>
         I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
   }
 
@@ -6684,20 +6684,20 @@
   namespace ranges {
     template<class I, class O>
     using uninitialized_copy_result = copy_result<I, O>;
-    template<InputIterator I, Sentinel<I> S1,
+    template<input_iterator I, sentinel_for<I> S1,
              @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S2>
-      requires Constructible<iter_value_t<O>, iter_reference_t<I>>
+      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<InputRange IR, @\placeholdernc{no-throw-forward-range}@ OR>
-      requires Constructible<iter_value_t<iterator_t<OR>>, iter_reference_t<iterator_t<IR>>>
+    template<input_range IR, @\placeholdernc{no-throw-forward-range}@ OR>
+      requires constructible_from<iter_value_t<iterator_t<OR>>, iter_reference_t<iterator_t<IR>>>
         uninitialized_copy_result<safe_iterator_t<IR>, safe_iterator_t<OR>>
-          uninitialized_copy(IR&& input_range, OR&& output_range);
+          uninitialized_copy(IR&& in_range, OR&& out_range);
 
     template<class I, class O>
       using uninitialized_copy_n_result = uninitialized_copy_result<I, O>;
-    template<InputIterator I, @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
-      requires Constructible<iter_value_t<O>, iter_reference_t<I>>
+    template<input_iterator I, @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
+      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
         uninitialized_copy_n_result<I, O>
           uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
   }
@@ -6720,22 +6720,22 @@
   namespace ranges {
     template<class I, class O>
       using uninitialized_move_result = uninitialized_copy_result<I, O>;
-    template<InputIterator I, Sentinel<I> S1,
+    template<input_iterator I, sentinel_for<I> S1,
              @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S2>
-      requires Constructible<iter_value_t<O>, iter_rvalue_reference_t<I>>
+      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<InputRange IR, @\placeholdernc{no-throw-forward-range}@ OR>
-      requires Constructible<iter_value_t<iterator_t<OR>>,
-                             iter_rvalue_reference_t<iterator_t<IR>>>
+    template<input_range IR, @\placeholdernc{no-throw-forward-range}@ OR>
+      requires constructible_from<iter_value_t<iterator_t<OR>>,
+                                  iter_rvalue_reference_t<iterator_t<IR>>>
         uninitialized_move_result<safe_iterator_t<IR>, safe_iterator_t<OR>>
-          uninitialized_move(IR&& input_range, OR&& output_range);
+          uninitialized_move(IR&& in_range, OR&& out_range);
 
     template<class I, class O>
       using uninitialized_move_n_result = uninitialized_copy_result<I, O>;
-    template<InputIterator I,
+    template<input_iterator I,
              @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
-      requires Constructible<iter_value_t<O>, iter_rvalue_reference_t<I>>
+      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);
   }
@@ -6753,14 +6753,14 @@
 
   namespace ranges {
     template<@\placeholdernc{no-throw-forward-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S, class T>
-      requires Constructible<iter_value_t<I>, const T&>
+      requires constructible_from<iter_value_t<I>, const T&>
         I uninitialized_fill(I first, S last, const T& x);
     template<@\placeholdernc{no-throw-forward-range}@ R, class T>
-      requires Constructible<iter_value_t<iterator_t<R>>, const T&>
+      requires constructible_from<iter_value_t<iterator_t<R>>, const T&>
         safe_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 
     template<@\placeholdernc{no-throw-forward-iterator}@ I, class T>
-      requires Constructible<iter_value_t<I>, const T&>
+      requires constructible_from<iter_value_t<I>, const T&>
         I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
   }
 
@@ -6778,18 +6778,18 @@
                               ForwardIterator first, Size n);
 
   namespace ranges {
-    template<Destructible T>
+    template<destructible T>
       void destroy_at(T* location) noexcept;
 
     template<@\placeholdernc{no-throw-input-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S>
-      requires Destructible<iter_value_t<I>>
+      requires destructible<iter_value_t<I>>
         I destroy(I first, S last) noexcept;
     template<@\placeholdernc{no-throw-input-range}@ R>
-      requires Destructible<iter_value_t<iterator_t<R>>
+      requires destructible<iter_value_t<iterator_t<R>>
         safe_iterator_t<R> destroy(R&& r) noexcept;
 
     template<@\placeholdernc{no-throw-input-iterator}@ I>
-      requires Destructible<iter_value_t<I>>
+      requires destructible<iter_value_t<I>>
         I destroy_n(I first, iter_difference_t<I> n) noexcept;
   }
 
@@ -8064,9 +8064,9 @@
   unqualified\iref{basic.lookup.unqual} name lookup for the
   \grammarterm{postfix-expression} in a function call\iref{expr.call}, they
   inhibit argument-dependent name lookup.
-\item Overloads of algorithms that take \libconcept{Range} arguments\iref{range.range}
+\item Overloads of algorithms that take \libconcept{range} arguments\iref{range.range}
   behave as if they are implemented by calling \tcode{ranges::begin}
-  and \tcode{ranges::end} on the \libconcept{Range}(s) and dispatching to the
+  and \tcode{ranges::end} on the \libconcept{range}(s) and dispatching to the
   overload that takes separate iterator and sentinel arguments.
 \item The number and order of deducible template parameters for algorithm declarations
   is unspecified, except where explicitly stated otherwise.
@@ -8103,9 +8103,9 @@
 \begin{itemdecl}
 template<class I>
 concept @\placeholdernc{no-throw-input-iterator}@ = // exposition only
-  InputIterator<I> &&
+  input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
-  Same<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
+  same_to<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -8118,14 +8118,14 @@
 
 \pnum
 \begin{note}
-This concept allows some \libconcept{InputIterator}\iref{iterator.concept.input}
+This concept allows some \libconcept{input_iterator}\iref{iterator.concept.input}
 operations to throw exceptions.
 \end{note}
 \end{itemdescr}
 
 \begin{itemdecl}
 template<class S, class I>
-concept @\placeholdernc{no-throw-sentinel}@ = Sentinel<S, I>; // exposition only
+concept @\placeholdernc{no-throw-sentinel}@ = sentinel_for<S, I>; // exposition only
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -8137,7 +8137,7 @@
 
 \pnum
 \begin{note}
-This concept allows some \libconcept{Sentinel}\iref{iterator.concept.sentinel}
+This concept allows some \libconcept{sentinel_for}\iref{iterator.concept.sentinel}
 operations to throw exceptions.
 \end{note}
 \end{itemdescr}
@@ -8145,7 +8145,7 @@
 \begin{itemdecl}
 template<class R>
 concept @\placeholdernc{no-throw-input-range}@ = // exposition only
-  Range<R> &&
+  range<R> &&
   @\placeholder{no-throw-input-iterator}@<iterator_t<R>> &&
   @\placeholdernc{no-throw-sentinel}@<sentinel_t<R>, iterator_t<R>>;
 \end{itemdecl}
@@ -8161,14 +8161,14 @@
 template<class I>
 concept @\placeholdernc{no-throw-forward-iterator}@ = // exposition only
   @\placeholder{no-throw-input-iterator}@<I> &&
-  ForwardIterator<I> &&
+  forward_iterator<I> &&
   @\placeholdernc{no-throw-sentinel}@<I, I>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \begin{note}
-This concept allows some \libconcept{ForwardIterator}\iref{iterator.concept.forward}
+This concept allows some \libconcept{forward_iterator}\iref{iterator.concept.forward}
 operations to throw exceptions.
 \end{note}
 \end{itemdescr}
@@ -8221,11 +8221,11 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-forward-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S>
-      requires DefaultConstructible<iter_value_t<I>>
-    I uninitialized_default_construct(I first, S last);
+    requires default_constructible<iter_value_t<I>>
+      I uninitialized_default_construct(I first, S last);
   template<@\placeholdernc{no-throw-forward-range}@ R>
-      requires DefaultConstructible<iter_value_t<iterator_t<R>>>
-    safe_iterator_t<R> uninitialized_default_construct(R&& r);
+    requires default_constructible<iter_value_t<iterator_t<R>>>
+      safe_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 \end{itemdecl}
 
@@ -8261,8 +8261,8 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-forward-iterator}@ I>
-      requires DefaultConstructible<iter_value_t<I>>
-    I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
+    requires default_constructible<iter_value_t<I>>
+      I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 \end{itemdecl}
 
@@ -8298,11 +8298,11 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-forward-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S>
-      requires DefaultConstructible<iter_value_t<I>>
-    I uninitialized_value_construct(I first, S last);
+    requires default_constructible<iter_value_t<I>>
+      I uninitialized_value_construct(I first, S last);
   template<@\placeholdernc{no-throw-forward-range}@ R>
-      requires DefaultConstructible<iter_value_t<iterator_t<R>>>
-    safe_iterator_t<R> uninitialized_value_construct(R&& r);
+    requires default_constructible<iter_value_t<iterator_t<R>>>
+      safe_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 \end{itemdecl}
 
@@ -8338,8 +8338,8 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-forward-iterator}@ I>
-      requires DefaultConstructible<iter_value_t<I>>
-    I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
+    requires default_constructible<iter_value_t<I>>
+      I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 \end{itemdecl}
 
@@ -8383,15 +8383,15 @@
 \indexlibrary{\idxcode{uninitialized_copy}}%
 \begin{itemdecl}
 namespace ranges {
-  template<InputIterator I, Sentinel<I> S1,
+  template<input_iterator I, sentinel_for<I> S1,
            @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S2>
-      requires Constructible<iter_value_t<O>, iter_reference_t<I>>
-    uninitialized_copy_result<I, O>
-      uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
-  template<InputRange IR, @\placeholdernc{no-throw-forward-range}@ OR>
-      requires Constructible<iter_value_t<iterator_t<OR>>, iter_reference_t<iterator_t<IR>>>
-    uninitialized_copy_result<safe_iterator_t<IR>, safe_iterator_t<OR>>
-      uninitialized_copy(IR&& input_range, OR&& output_range);
+    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, @\placeholdernc{no-throw-forward-range}@ OR>
+    requires constructible_from<iter_value_t<iterator_t<OR>>, iter_reference_t<iterator_t<IR>>>
+      uninitialized_copy_result<safe_iterator_t<IR>, safe_iterator_t<OR>>
+        uninitialized_copy(IR&& in_range, OR&& out_range);
 }
 \end{itemdecl}
 
@@ -8438,10 +8438,10 @@
 \indexlibrary{\idxcode{uninitialized_copy_n}}%
 \begin{itemdecl}
 namespace ranges {
-  template<InputIterator I, @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
-      requires Constructible<iter_value_t<O>, iter_reference_t<I>>
-    uninitialized_copy_n_result<I, O>
-      uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
+  template<input_iterator I, @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
+    requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+      uninitialized_copy_n_result<I, O>
+        uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 \end{itemdecl}
 
@@ -8488,15 +8488,16 @@
 \indexlibrary{\idxcode{uninitialized_move}}%
 \begin{itemdecl}
 namespace ranges {
-  template<InputIterator I, Sentinel<I> S1,
+  template<input_iterator I, sentinel_for<I> S1,
            @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S2>
-      requires Constructible<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<InputRange IR, @\placeholdernc{no-throw-forward-range}@ OR>
-      requires Constructible<iter_value_t<iterator_t<OR>>, iter_rvalue_reference_t<iterator_t<IR>>>
-    uninitialized_move_result<safe_iterator_t<IR>, safe_iterator_t<OR>>
-      uninitialized_move(IR&& input_range, OR&& output_range);
+    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, @\placeholdernc{no-throw-forward-range}@ OR>
+    requires constructible_from<iter_value_t<iterator_t<OR>>,
+                                iter_rvalue_reference_t<iterator_t<IR>>>
+      uninitialized_move_result<safe_iterator_t<IR>, safe_iterator_t<OR>>
+        uninitialized_move(IR&& in_range, OR&& out_range);
 }
 \end{itemdecl}
 
@@ -8548,10 +8549,10 @@
 \indexlibrary{\idxcode{uninitialized_move_n}}%
 \begin{itemdecl}
 namespace ranges {
-  template<InputIterator I, @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
-      requires Constructible<iter_value_t<O>, iter_rvalue_reference_t<I>>
-    uninitialized_move_n_result<I, O>
-      uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
+  template<input_iterator I, @\placeholdernc{no-throw-forward-iterator}@ O, @\placeholdernc{no-throw-sentinel}@<O> S>
+    requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+      uninitialized_move_n_result<I, O>
+        uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 \end{itemdecl}
 
@@ -8600,11 +8601,11 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-forward-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S, class T>
-      requires Constructible<iter_value_t<I>, const T&>
-    I uninitialized_fill(I first, S last, const T& x);
+    requires constructible_from<iter_value_t<I>, const T&>
+      I uninitialized_fill(I first, S last, const T& x);
   template<@\placeholdernc{no-throw-forward-range}@ R, class T>
-      requires Constructible<iter_value_t<iterator_t<R>>, const T&>
-    safe_iterator_t<R> uninitialized_fill(R&& r, const T& x);
+    requires constructible_from<iter_value_t<iterator_t<R>>, const T&>
+      safe_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 }
 \end{itemdecl}
 
@@ -8640,8 +8641,8 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-forward-iterator}@ I, class T>
-      requires Constructible<iter_value_t<I>, const T&>
-    I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
+    requires constructible_from<iter_value_t<I>, const T&>
+      I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
 }
 \end{itemdecl}
 
@@ -8660,7 +8661,7 @@
 template<class T>
   void destroy_at(T* location);
 namespace ranges {
-  template<Destructible T>
+  template<destructible T>
     void destroy_at(T* location) noexcept;
 }
 \end{itemdecl}
@@ -8696,11 +8697,11 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-input-iterator}@ I, @\placeholdernc{no-throw-sentinel}@<I> S>
-      requires Destructible<iter_value_t<I>>
-    I destroy(I first, S last) noexcept;
+    requires destructible<iter_value_t<I>>
+      I destroy(I first, S last) noexcept;
   template<@\placeholdernc{no-throw-input-range}@ R>
-      requires Destructible<iter_value_t<iterator_t<R>>>
-    safe_iterator_t<R> destroy(R&& r) noexcept;
+    requires destructible<iter_value_t<iterator_t<R>>>
+      safe_iterator_t<R> destroy(R&& r) noexcept;
 }
 \end{itemdecl}
 
@@ -8735,8 +8736,8 @@
 \begin{itemdecl}
 namespace ranges {
   template<@\placeholdernc{no-throw-input-iterator}@ I>
-      requires Destructible<iter_value_t<I>>
-    I destroy_n(I first, iter_difference_t<I> n) noexcept;
+    requires destructible<iter_value_t<I>>
+      I destroy_n(I first, iter_difference_t<I> n) noexcept;
 }
 \end{itemdecl}
 
@@ -14778,7 +14779,7 @@
 \begin{itemdecl}
 struct ranges::equal_to {
   template<class T, class U>
-    requires EqualityComparableWith<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, ==, U)
+    requires equality_comparable_with<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, ==, U)
   constexpr bool operator()(T&& t, U&& u) const;
 
   using is_transparent = @\unspecnc@;
@@ -14813,7 +14814,7 @@
 \begin{itemdecl}
 struct ranges::not_equal_to {
   template<class T, class U>
-    requires EqualityComparableWith<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, ==, U)
+    requires equality_comparable_with<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, ==, U)
   constexpr bool operator()(T&& t, U&& u) const;
 
   using is_transparent = @\unspecnc@;
@@ -14832,7 +14833,7 @@
 \begin{itemdecl}
 struct ranges::greater {
   template<class T, class U>
-    requires StrictTotallyOrderedWith<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(U, <, T)
+    requires totally_ordered_with<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(U, <, T)
   constexpr bool operator()(T&& t, U&& u) const;
 
   using is_transparent = @\unspecnc@;
@@ -14851,7 +14852,7 @@
 \begin{itemdecl}
 struct ranges::less {
   template<class T, class U>
-    requires StrictTotallyOrderedWith<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, <, U)
+    requires totally_ordered_with<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, <, U)
   constexpr bool operator()(T&& t, U&& u) const;
 
   using is_transparent = @\unspecnc@;
@@ -14892,7 +14893,7 @@
 \begin{itemdecl}
 struct ranges::greater_equal {
   template<class T, class U>
-    requires StrictTotallyOrderedWith<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, <, U)
+    requires totally_ordered_with<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(T, <, U)
   constexpr bool operator()(T&& t, U&& u) const;
 
   using is_transparent = @\unspecnc@;
@@ -14911,7 +14912,7 @@
 \begin{itemdecl}
 struct ranges::less_equal {
   template<class T, class U>
-    requires StrictTotallyOrderedWith<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(U, <, T)
+    requires totally_ordered_with<T, U> || @\placeholdernc{BUILTIN_PTR_CMP}@(U, <, T)
   constexpr bool operator()(T&& t, U&& u) const;
 
   using is_transparent = @\unspecnc@;

From a02d2b1a03c69226baa67ced73fc2d1786c0144b Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Mon, 29 Jul 2019 15:02:38 -0700
Subject: [PATCH 03/10] [utilities] Use "\expos" instead of "exposition only"
 in declarations.

---
 source/utilities.tex | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/utilities.tex b/source/utilities.tex
index a45d34534e..e62cbddd00 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -1764,7 +1764,7 @@
 Given the exposition-only function:
 \begin{codeblock}
 template<class T, class Tuple, size_t... I>
-constexpr T @\placeholdernc{make-from-tuple-impl}@(Tuple&& t, index_sequence<I...>) {     // exposition only
+constexpr T @\placeholdernc{make-from-tuple-impl}@(Tuple&& t, index_sequence<I...>) {     // \expos
   return T(get<I>(std::forward<Tuple>(t))...);
 }
 \end{codeblock}
@@ -8102,7 +8102,7 @@
 
 \begin{itemdecl}
 template<class I>
-concept @\placeholdernc{no-throw-input-iterator}@ = // exposition only
+concept @\placeholdernc{no-throw-input-iterator}@ = // \expos
   input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
   same_to<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
@@ -8125,7 +8125,7 @@
 
 \begin{itemdecl}
 template<class S, class I>
-concept @\placeholdernc{no-throw-sentinel}@ = sentinel_for<S, I>; // exposition only
+concept @\placeholdernc{no-throw-sentinel}@ = sentinel_for<S, I>; // \expos
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -8144,7 +8144,7 @@
 
 \begin{itemdecl}
 template<class R>
-concept @\placeholdernc{no-throw-input-range}@ = // exposition only
+concept @\placeholdernc{no-throw-input-range}@ = // \expos
   range<R> &&
   @\placeholder{no-throw-input-iterator}@<iterator_t<R>> &&
   @\placeholdernc{no-throw-sentinel}@<sentinel_t<R>, iterator_t<R>>;
@@ -8159,7 +8159,7 @@
 
 \begin{itemdecl}
 template<class I>
-concept @\placeholdernc{no-throw-forward-iterator}@ = // exposition only
+concept @\placeholdernc{no-throw-forward-iterator}@ = // \expos
   @\placeholder{no-throw-input-iterator}@<I> &&
   forward_iterator<I> &&
   @\placeholdernc{no-throw-sentinel}@<I, I>;
@@ -8175,7 +8175,7 @@
 
 \begin{itemdecl}
 template<class R>
-concept @\placeholdernc{no-throw-forward-range}@ = // exposition only
+concept @\placeholdernc{no-throw-forward-range}@ = // \expos
   @\placeholder{no-throw-input-range}@<R> &&
   @\placeholder{no-throw-forward-iterator}@<iterator_t<R>>;
 \end{itemdecl}

From 932c1c2a1eaea873c8167c6720763c6a7dbff200 Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Tue, 30 Jul 2019 20:15:55 -0700
Subject: [PATCH 04/10] Fixup: "Same" should have become "same_as" not
 "same_to".

---
 source/algorithms.tex |  8 +++---
 source/concepts.tex   | 30 +++++++++++-----------
 source/iterators.tex  | 58 +++++++++++++++++++++----------------------
 source/numerics.tex   |  4 +--
 source/ranges.tex     | 42 +++++++++++++++----------------
 source/utilities.tex  |  2 +-
 6 files changed, 72 insertions(+), 72 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index 789bd25b7b..c4cffd23b2 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -1656,7 +1656,7 @@
              class Proj = identity, indirect_relation<projected<I, Proj>> C = ranges::equal_to>
       requires indirectly_copyable<I, O> &&
                (forward_iterator<I> ||
-                (input_iterator<O> && same_to<iter_value_t<I>, iter_value_t<O>>) ||
+                (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
                  indirectly_copyable_storable<I, O>)
       constexpr unique_copy_result<I, O>
         unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
@@ -1664,7 +1664,7 @@
              indirect_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
       requires indirectly_copyable<iterator_t<R>, O> &&
                (forward_iterator<iterator_t<R>> ||
-                (input_iterator<O> && same_to<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
+                (input_iterator<O> && same_as<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
                  indirectly_copyable_storable<iterator_t<R>, O>)
       constexpr unique_copy_result<safe_iterator_t<R>, O>
         unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
@@ -5216,7 +5216,7 @@
          class Proj = identity, indirect_relation<projected<I, Proj>> C = ranges::equal_to>
   requires indirectly_copyable<I, O> &&
            (forward_iterator<I> ||
-            (input_iterator<O> && same_to<iter_value_t<I>, iter_value_t<O>>) ||
+            (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
              indirectly_copyable_storable<I, O>)
   constexpr ranges::unique_copy_result<I, O>
     ranges::unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
@@ -5224,7 +5224,7 @@
          indirect_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
   requires indirectly_copyable<iterator_t<R>, O> &&
            (forward_iterator<iterator_t<R>> ||
-            (input_iterator<O> && same_to<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
+            (input_iterator<O> && same_as<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
              indirectly_copyable_storable<iterator_t<R>, O>)
   constexpr ranges::unique_copy_result<safe_iterator_t<R>, O>
     ranges::unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
diff --git a/source/concepts.tex b/source/concepts.tex
index 6f3e52d1c3..69a89ea783 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -147,9 +147,9 @@
 \begin{codeblock}
 namespace std {
   // \ref{concepts.lang}, language-related concepts
-  // \ref{concept.same}, concept \libconcept{same_to}
+  // \ref{concept.same}, concept \libconcept{same_as}
   template<class T, class U>
-    concept same_to = @\seebelow@;
+    concept same_as = @\seebelow@;
 
   // \ref{concept.derivedfrom}, concept \libconcept{derived_from}
   template<class Derived, class Base>
@@ -269,21 +269,21 @@
 features. These concepts express relationships between types, type
 classifications, and fundamental type properties.
 
-\rSec2[concept.same]{Concept \libconcept{same_to}}
+\rSec2[concept.same]{Concept \libconcept{same_as}}
 
-\indexlibrary{\idxcode{same_to}}%
+\indexlibrary{\idxcode{same_as}}%
 \begin{itemdecl}
 template<class T, class U>
   concept @\placeholdernc{same-impl}@ = is_same_v<T, U>;    // \expos
 
 template<class T, class U>
-  concept same_to = @\placeholdernc{same-impl}@<T, U> && @\placeholdernc{same-impl}@<U, T>;
+  concept same_as = @\placeholdernc{same-impl}@<T, U> && @\placeholdernc{same-impl}@<U, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \begin{note}
-\tcode{\libconcept{same_to}<T, U>} subsumes \tcode{\libconcept{same_to}<U, T>} and
+\tcode{\libconcept{same_as}<T, U>} subsumes \tcode{\libconcept{same_as}<U, T>} and
 vice versa.
 \end{note}
 \end{itemdescr}
@@ -380,7 +380,7 @@
 \begin{itemdecl}
 template<class T, class U>
   concept common_reference_with =
-    same_to<common_reference_t<T, U>, common_reference_t<U, T>> &&
+    same_as<common_reference_t<T, U>, common_reference_t<U, T>> &&
     convertible_to<T, common_reference_t<T, U>> &&
     convertible_to<U, common_reference_t<T, U>>;
 \end{itemdecl}
@@ -424,7 +424,7 @@
 \begin{itemdecl}
 template<class T, class U>
   concept common_with =
-    same_to<common_type_t<T, U>, common_type_t<U, T>> &&
+    same_as<common_type_t<T, U>, common_type_t<U, T>> &&
     requires {
       static_cast<common_type_t<T, U>>(declval<T>());
       static_cast<common_type_t<T, U>>(declval<U>());
@@ -501,7 +501,7 @@
     is_lvalue_reference_v<LHS> &&
     common_reference_with<const remove_reference_t<LHS>&, const remove_reference_t<RHS>&> &&
     requires(LHS lhs, RHS&& rhs) {
-      { lhs = std::forward<RHS>(rhs) } -> same_to<LHS>;
+      { lhs = std::forward<RHS>(rhs) } -> same_as<LHS>;
     };
 \end{itemdecl}
 
@@ -823,12 +823,12 @@
              const remove_reference_t<B>& b2, const bool a) {
       { b1 } -> convertible_to<bool>;
       { !b1 } -> convertible_to<bool>;
-      { b1 &&  a } -> same_to<bool>;
-      { b1 ||  a } -> same_to<bool>;
-      { b1 && b2 } -> same_to<bool>;
-      {  a && b2 } -> same_to<bool>;
-      { b1 || b2 } -> same_to<bool>;
-      {  a || b2 } -> same_to<bool>;
+      { b1 &&  a } -> same_as<bool>;
+      { b1 ||  a } -> same_as<bool>;
+      { b1 && b2 } -> same_as<bool>;
+      {  a && b2 } -> same_as<bool>;
+      { b1 || b2 } -> same_as<bool>;
+      {  a || b2 } -> same_as<bool>;
       { b1 == b2 } -> convertible_to<bool>;
       { b1 ==  a } -> convertible_to<bool>;
       {  a == b2 } -> convertible_to<bool>;
diff --git a/source/iterators.tex b/source/iterators.tex
index 5ace8b9b90..12c7f2537f 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -362,7 +362,7 @@
 
   // \ref{iterators.common}, common iterators
   template<input_or_output_iterator I, sentinel_for<I> S>
-    requires (!same_to<I, S>)
+    requires (!same_as<I, S>)
       class common_iterator;
 
   template<class I, class S>
@@ -858,7 +858,7 @@
 concept @\placeholder{cpp17-iterator}@ =
   copyable<I> && requires(I i) {
     {   *i } -> @\placeholder{can-reference}@;
-    {  ++i } -> same_to<I&>;
+    {  ++i } -> same_as<I&>;
     { *i++ } -> @\placeholder{can-reference}@;
   };
 
@@ -878,30 +878,30 @@
 concept @\placeholder{cpp17-forward-iterator}@ =
   @\placeholder{cpp17-input-iterator}@<I> && constructible_from<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
-  same_to<remove_cvref_t<iter_reference_t<I>>, typename readable_traits<I>::value_type> &&
+  same_as<remove_cvref_t<iter_reference_t<I>>, typename readable_traits<I>::value_type> &&
   requires(I i) {
     {  i++ } -> const I&;
-    { *i++ } -> same_to<iter_reference_t<I>>;
+    { *i++ } -> same_as<iter_reference_t<I>>;
   };
 
 template<class I>
 concept @\placeholder{cpp17-bidirectional-iterator}@ =
   @\placeholder{cpp17-forward-iterator}@<I> && requires(I i) {
-    {  --i } -> same_to<I&>;
+    {  --i } -> same_as<I&>;
     {  i-- } -> const I&;
-    { *i-- } -> same_to<iter_reference_t<I>>;
+    { *i-- } -> same_as<iter_reference_t<I>>;
   };
 
 template<class I>
 concept @\placeholder{cpp17-random-access-iterator}@ =
   @\placeholder{cpp17-bidirectional-iterator}@<I> && totally_ordered<I> &&
   requires(I i, typename incrementable_traits<I>::difference_type n) {
-    { i += n } -> same_to<I&>;
-    { i -= n } -> same_to<I&>;
-    { i +  n } -> same_to<I>;
-    { n +  i } -> same_to<I>;
-    { i -  n } -> same_to<I>;
-    { i -  i } -> same_to<decltype(n)>;
+    { i += n } -> same_as<I&>;
+    { i -= n } -> same_as<I&>;
+    { i +  n } -> same_as<I>;
+    { n +  i } -> same_as<I>;
+    { i -  n } -> same_as<I>;
+    { i -  i } -> same_as<decltype(n)>;
     {  i[n]  } -> iter_reference_t<I>;
   };
 \end{codeblock}
@@ -1244,7 +1244,7 @@
 
 \begin{itemize}
 \item If \tcode{Out} and \tcode{T} model
-  \tcode{\libconcept{readable}<Out> \&\& \libconcept{same_to}<iter_value_t<Out>, decay_t<T>{>}},
+  \tcode{\libconcept{readable}<Out> \&\& \libconcept{same_as}<iter_value_t<Out>, decay_t<T>{>}},
   then \tcode{*o} after any above assignment is equal to
   the value of \tcode{E} before the assignment.
 \end{itemize}
@@ -1287,7 +1287,7 @@
     requires(I i) {
       typename iter_difference_t<I>;
       requires signed_integral<iter_difference_t<I>>;
-      { ++i } -> same_to<I&>; // not required to be equality-preserving
+      { ++i } -> same_as<I&>; // not required to be equality-preserving
       i++; // not required to be equality-preserving
     };
 \end{codeblock}
@@ -1334,7 +1334,7 @@
     regular<I> &&
     weakly_incrementable<I> &&
     requires(I i) {
-      { i++ } -> same_to<I>;
+      { i++ } -> same_as<I>;
     };
 \end{codeblock}
 
@@ -1434,8 +1434,8 @@
     sentinel_for<S, I> &&
     !disable_sized_sentinel<remove_cv_t<S>, remove_cv_t<I>> &&
     requires(const I& i, const S& s) {
-      { s - i } -> same_to<iter_difference_t<I>>;
-      { i - s } -> same_to<iter_difference_t<I>>;
+      { s - i } -> same_as<iter_difference_t<I>>;
+      { i - s } -> same_as<iter_difference_t<I>>;
     };
 \end{itemdecl}
 
@@ -1592,8 +1592,8 @@
     forward_iterator<I> &&
     derived_from<@\placeholdernc{ITER_CONCEPT}@(I), bidirectional_iterator_tag> &&
     requires(I i) {
-      { --i } -> same_to<I&>;
-      { i-- } -> same_to<I>;
+      { --i } -> same_as<I&>;
+      { i-- } -> same_as<I>;
     };
 \end{codeblock}
 
@@ -1637,12 +1637,12 @@
     totally_ordered<I> &&
     sized_sentinel_for<I, I> &&
     requires(I i, const I j, const iter_difference_t<I> n) {
-      { i += n } -> same_to<I&>;
-      { j +  n } -> same_to<I>;
-      { n +  j } -> same_to<I>;
-      { i -= n } -> same_to<I&>;
-      { j -  n } -> same_to<I>;
-      {  j[n]  } -> same_to<iter_reference_t<I>>;
+      { i += n } -> same_as<I&>;
+      { j +  n } -> same_as<I>;
+      { n +  j } -> same_as<I>;
+      { i -= n } -> same_as<I&>;
+      { j -  n } -> same_as<I>;
+      {  j[n]  } -> same_as<iter_reference_t<I>>;
     };
 \end{codeblock}
 
@@ -1687,7 +1687,7 @@
     random_access_iterator<I> &&
     derived_from<@\placeholdernc{ITER_CONCEPT}@(I), contiguous_iterator_tag> &&
     is_lvalue_reference_v<iter_reference_t<I>> &&
-    same_to<iter_value_t<I>, remove_cvref_t<iter_reference_t<I>>>;
+    same_as<iter_value_t<I>, remove_cvref_t<iter_reference_t<I>>>;
 \end{codeblock}
 
 \pnum
@@ -2753,7 +2753,7 @@
 If \tcode{n == 0}, \range{i}{bound} or \range{bound}{i} denotes a range.
 If \tcode{n < 0}, \range{bound}{i} denotes a range,
 \tcode{I} models \libconcept{bidirectional_iterator}, and
-\tcode{I} and \tcode{S} model \tcode{\libconcept{same_to}<I, S>}.
+\tcode{I} and \tcode{S} model \tcode{\libconcept{same_as}<I, S>}.
 
 \pnum
 \effects
@@ -2794,7 +2794,7 @@
 \range{first}{last} denotes a range, or
 \range{last}{first} denotes a range and
 \tcode{S} and \tcode{I} model
-\tcode{\libconcept{same_to}<S, I> \&\& \libconcept{sized_sentinel_for}<S, I>}.
+\tcode{\libconcept{same_as}<S, I> \&\& \libconcept{sized_sentinel_for}<S, I>}.
 
 \pnum
 \effects
@@ -4495,7 +4495,7 @@
 \begin{codeblock}
 namespace std {
   template<input_or_output_iterator I, sentinel_for<I> S>
-    requires (!same_to<I, S>)
+    requires (!same_as<I, S>)
   class common_iterator {
   public:
     constexpr common_iterator() = default;
diff --git a/source/numerics.tex b/source/numerics.tex
index 5a49b408b9..3eb5375242 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -1950,8 +1950,8 @@
   concept uniform_random_bit_generator =
     invocable<G&> && unsigned_integral<invoke_result_t<G&>> &&
     requires {
-      { G::min() } -> same_to<invoke_result_t<G&>>;
-      { G::max() } -> same_to<invoke_result_t<G&>>;
+      { G::min() } -> same_as<invoke_result_t<G&>>;
+      { G::max() } -> same_as<invoke_result_t<G&>>;
     };
 \end{codeblock}
 
diff --git a/source/ranges.tex b/source/ranges.tex
index 2c0b31be6e..b4b3d6c977 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -99,7 +99,7 @@
 
   // \ref{view.interface}, class template \tcode{view_interface}
   template<class D>
-    requires is_class_v<D> && same_to<D, remove_cv_t<D>>
+    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
   class view_interface;
 
   // \ref{range.subrange}, sub-ranges
@@ -937,7 +937,7 @@
   concept contiguous_range =
     random_access_range<T> && contiguous_iterator<iterator_t<T>> &&
     requires(T& t) {
-      { ranges::data(t) } -> same_to<add_pointer_t<iter_reference_t<iterator_t<T>>>>;
+      { ranges::data(t) } -> same_as<add_pointer_t<iter_reference_t<iterator_t<T>>>>;
     };
 \end{itemdecl}
 
@@ -953,7 +953,7 @@
 \begin{itemdecl}
 template<class T>
   concept common_range =
-    range<T> && same_to<iterator_t<T>, sentinel_t<T>>;
+    range<T> && same_as<iterator_t<T>, sentinel_t<T>>;
 \end{itemdecl}
 
 \pnum
@@ -983,8 +983,8 @@
 template<class R>
   concept @\placeholder{simple-view}@ =                         // \expos
     view<R> && range<const R> &&
-    same_to<iterator_t<R>, iterator_t<const R>> &&
-    same_to<sentinel_t<R>, sentinel_t<const R>>;
+    same_as<iterator_t<R>, iterator_t<const R>> &&
+    same_as<sentinel_t<R>, sentinel_t<const R>>;
 
 template<input_iterator I>
   concept @\placeholder{has-arrow}@ =                           // \expos
@@ -992,7 +992,7 @@
 
 template<class T, class U>
   concept @\placeholder{not-same-as}@ =                         // \expos
-    !same_to<remove_cvref_t<T>, remove_cvref_t<U>>;
+    !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
 \end{codeblock}
 
 \rSec2[view.interface]{View interface}
@@ -1006,7 +1006,7 @@
 \begin{codeblock}
 namespace std::ranges {
   template<class D>
-    requires is_class_v<D> && same_to<D, remove_cv_t<D>>
+    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
   class view_interface : public view_base {
   private:
     constexpr D& derived() noexcept {                   // \expos
@@ -1462,12 +1462,12 @@
 \begin{codeblock}
 vector<int> f();
 auto result1 = ranges::find(f(), 42);                                   // \#1
-static_assert(same_to<decltype(result1), ranges::dangling>);
+static_assert(same_as<decltype(result1), ranges::dangling>);
 auto vec = f();
 auto result2 = ranges::find(vec, 42);                                   // \#2
-static_assert(same_to<decltype(result2), vector<int>::iterator>);
+static_assert(same_as<decltype(result2), vector<int>::iterator>);
 auto result3 = ranges::find(subrange{vec}, 42);                         // \#3
-static_assert(same_to<decltype(result3), vector<int>::iterator>);
+static_assert(same_as<decltype(result3), vector<int>::iterator>);
 \end{codeblock}
 The call to \tcode{ranges::find} at \#1 returns \tcode{ranges::dangling}
 since \tcode{f()} is an rvalue \tcode{vector};
@@ -1698,10 +1698,10 @@
 
     constexpr iterator begin() const;
     constexpr sentinel end() const;
-    constexpr iterator end() const requires same_to<W, Bound>;
+    constexpr iterator end() const requires same_as<W, Bound>;
 
     constexpr auto size() const
-      requires (same_to<W, Bound> && @\placeholdernc{Advanceable}@<W>) ||
+      requires (same_as<W, Bound> && @\placeholdernc{Advanceable}@<W>) ||
                (integral<W> && integral<Bound>) ||
                sized_sentinel_for<Bound, W>
     { return bound_ - value_; }
@@ -1719,8 +1719,8 @@
 template<class I>
   concept @\placeholder{Decrementable}@ =
     incrementable<I> && requires(I i) {
-      { --i } -> same_to<I&>;
-      { i-- } -> same_to<I>;
+      { --i } -> same_as<I&>;
+      { i-- } -> same_as<I>;
     };
 \end{itemdecl}
 
@@ -1753,12 +1753,12 @@
   concept @\placeholder{Advanceable}@ =
     @\placeholdernc{Decrementable}@<I> && totally_ordered<I> &&
     requires(I i, const I j, const iter_difference_t<I> n) {
-      { i += n } -> same_to<I&>;
-      { i -= n } -> same_to<I&>;
-      { j +  n } -> same_to<I>;
-      { n +  j } -> same_to<I>;
-      { j -  n } -> same_to<I>;
-      { j -  j } -> same_to<iter_difference_t<I>>;
+      { i += n } -> same_as<I&>;
+      { i -= n } -> same_as<I&>;
+      { j +  n } -> same_as<I>;
+      { n +  j } -> same_as<I>;
+      { j -  n } -> same_as<I>;
+      { j -  j } -> same_as<iter_difference_t<I>>;
     };
 \end{itemdecl}
 
@@ -1841,7 +1841,7 @@
 
 \indexlibrary{\idxcode{end}!\idxcode{iota_view}}%
 \begin{itemdecl}
-constexpr iterator end() const requires same_to<W, Bound>;
+constexpr iterator end() const requires same_as<W, Bound>;
 \end{itemdecl}
 
 \begin{itemdescr}
diff --git a/source/utilities.tex b/source/utilities.tex
index e62cbddd00..5e35b87fdb 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -8105,7 +8105,7 @@
 concept @\placeholdernc{no-throw-input-iterator}@ = // \expos
   input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
-  same_to<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
+  same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 \end{itemdecl}
 
 \begin{itemdescr}

From d7c7cd69bd222a4ffaf3c88bcbf9d69ecd7a188d Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Tue, 30 Jul 2019 20:31:24 -0700
Subject: [PATCH 05/10] Fixup: Whitespace fixes as suggested by reviewers.

---
 source/algorithms.tex | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index c4cffd23b2..cece562bbb 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -811,13 +811,13 @@
     template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
              class Proj1 = identity, class Proj2 = identity,
              indirect_relation<projected<I1, Proj1>,
-                                projected<I2, Proj2>> Pred = ranges::equal_to>
+                               projected<I2, Proj2>> Pred = ranges::equal_to>
       constexpr I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
                                  Pred pred = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
     template<input_range R1, forward_range R2, class Proj1 = identity, class Proj2 = identity,
              indirect_relation<projected<iterator_t<R1>, Proj1>,
-                                projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
+                               projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
       constexpr safe_iterator_t<R1>
         find_first_of(R1&& r1, R2&& r2,
                       Pred pred = {},
@@ -1434,9 +1434,8 @@
     template<class I, class O>
     using replace_copy_result = copy_result<I, O>;
 
-    template<input_iterator I, sentinel_for<I> S,
-             class T1, class T2, output_iterator<const T2&> O,
-             class Proj = identity>
+    template<input_iterator I, sentinel_for<I> S, class T1, class T2,
+             output_iterator<const T2&> O, class Proj = identity>
       requires indirectly_copyable<I, O> &&
                indirect_relation<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr replace_copy_result<I, O>

From 02301b971f0d883c3513cd82b7be9b5e50af44aa Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Tue, 30 Jul 2019 20:36:34 -0700
Subject: [PATCH 06/10] [alg.is.permutation] Add parameters to
 \libconcept{sized_sentinel_for} as suggested in PR #3099.

---
 source/algorithms.tex | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index cece562bbb..aa00115efd 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -3853,8 +3853,8 @@
 \complexity
 No applications of the corresponding predicate and projections if:
 \begin{itemize}
-\item \tcode{S1} and \tcode{I1} model \libconcept{sized_sentinel_for},
-\item \tcode{S2} and \tcode{I2} model \libconcept{sized_sentinel_for}, and
+\item \tcode{S1} and \tcode{I1} model \tcode{\libconcept{sized_sentinel_for}<S1, I1>},
+\item \tcode{S2} and \tcode{I2} model \tcode{\libconcept{sized_sentinel_for}<S2, I2>}, and
 \item \tcode{last1 - first1 != last2 - first2}.
 \end{itemize}
 Otherwise, exactly \tcode{last1 - first1} applications

From be63fb250444d10d702b5296f373e32778c3b01f Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Wed, 31 Jul 2019 12:41:47 -0700
Subject: [PATCH 07/10] [concept.same][ranges] Renamed exposition-only concepts
 to follow new naming scheme.

* \placeholdernc{Advanceable} => \placeholdernc{advanceable}
* \placeholdernc{same-impl} => \placeholdernc{same-as-impl}
* \placeholdernc{Decrementable} => \placeholdernc{decrementable}
---
 source/concepts.tex |  4 ++--
 source/ranges.tex   | 48 ++++++++++++++++++++++-----------------------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/source/concepts.tex b/source/concepts.tex
index 69a89ea783..a576dde9e1 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -274,10 +274,10 @@
 \indexlibrary{\idxcode{same_as}}%
 \begin{itemdecl}
 template<class T, class U>
-  concept @\placeholdernc{same-impl}@ = is_same_v<T, U>;    // \expos
+  concept @\placeholdernc{same-as-impl}@ = is_same_v<T, U>;     // \expos
 
 template<class T, class U>
-  concept same_as = @\placeholdernc{same-impl}@<T, U> && @\placeholdernc{same-impl}@<U, T>;
+  concept same_as = @\placeholdernc{same-as-impl}@<T, U> && @\placeholdernc{same-as-impl}@<U, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
diff --git a/source/ranges.tex b/source/ranges.tex
index b4b3d6c977..296abd8572 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -1674,10 +1674,10 @@
 \begin{codeblock}
 namespace std::ranges {
   template<class I>
-    concept @\placeholdernc{Decrementable}@ =     // \expos
+    concept @\placeholdernc{decrementable}@ =     // \expos
       @\seebelow@;
   template<class I>
-    concept @\placeholdernc{Advanceable}@ =       // \expos
+    concept @\placeholdernc{advanceable}@ =       // \expos
       @\seebelow@;
 
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
@@ -1701,7 +1701,7 @@
     constexpr iterator end() const requires same_as<W, Bound>;
 
     constexpr auto size() const
-      requires (same_as<W, Bound> && @\placeholdernc{Advanceable}@<W>) ||
+      requires (same_as<W, Bound> && @\placeholdernc{advanceable}@<W>) ||
                (integral<W> && integral<Bound>) ||
                sized_sentinel_for<Bound, W>
     { return bound_ - value_; }
@@ -1731,7 +1731,7 @@
 
 \pnum
 Let \tcode{a} and \tcode{b} be equal objects of type \tcode{I}.
-\tcode{I} models \tcode{\placeholdernc{Decrementable}} only if
+\tcode{I} models \tcode{\placeholdernc{decrementable}} only if
 \begin{itemize}
 \item If \tcode{a} and \tcode{b} are decrementable,
   then the following are all true:
@@ -1751,7 +1751,7 @@
 \begin{itemdecl}
 template<class I>
   concept @\placeholder{Advanceable}@ =
-    @\placeholdernc{Decrementable}@<I> && totally_ordered<I> &&
+    @\placeholdernc{decrementable}@<I> && totally_ordered<I> &&
     requires(I i, const I j, const iter_difference_t<I> n) {
       { i += n } -> same_as<I&>;
       { i -= n } -> same_as<I&>;
@@ -1767,7 +1767,7 @@
 after \tcode{n} applications of \tcode{++a},
 for some value \tcode{n} of type \tcode{iter_difference_t<I>},
 and let \tcode{D} be \tcode{iter_difference_t<I>}.
-\tcode{I} models \tcode{\placeholdernc{Advanceable}} only if
+\tcode{I} models \tcode{\placeholdernc{advanceable}} only if
 \begin{itemize}
 \item \tcode{(a += n)} is equal to \tcode{b}.
 \item \tcode{addressof(a += n)} is equal to \tcode{addressof(a)}.
@@ -1871,15 +1871,15 @@
     constexpr void operator++(int);
     constexpr iterator operator++(int) requires incrementable<W>;
 
-    constexpr iterator& operator--() requires @\placeholdernc{Decrementable}@<W>;
-    constexpr iterator operator--(int) requires @\placeholdernc{Decrementable}@<W>;
+    constexpr iterator& operator--() requires @\placeholdernc{decrementable}@<W>;
+    constexpr iterator operator--(int) requires @\placeholdernc{decrementable}@<W>;
 
     constexpr iterator& operator+=(difference_type n)
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
     constexpr iterator& operator-=(difference_type n)
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
     constexpr W operator[](difference_type n) const
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
 
     friend constexpr bool operator==(const iterator& x, const iterator& y)
       requires equality_comparable<W>;
@@ -1896,14 +1896,14 @@
       requires totally_ordered<W>;
 
     friend constexpr iterator operator+(iterator i, difference_type n)
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
     friend constexpr iterator operator+(difference_type n, iterator i)
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
 
     friend constexpr iterator operator-(iterator i, difference_type n)
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
     friend constexpr difference_type operator-(const iterator& x, const iterator& y)
-      requires @\placeholdernc{Advanceable}@<W>;
+      requires @\placeholdernc{advanceable}@<W>;
   };
 }
 \end{codeblock}
@@ -1992,7 +1992,7 @@
 
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
-constexpr iterator& operator--() requires @\placeholdernc{Decrementable}@<W>;
+constexpr iterator& operator--() requires @\placeholdernc{decrementable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2006,7 +2006,7 @@
 
 \indexlibrary{\idxcode{operator\dcr}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
-constexpr iterator operator--(int) requires @\placeholdernc{Decrementable}@<W>;
+constexpr iterator operator--(int) requires @\placeholdernc{decrementable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2022,7 +2022,7 @@
 \indexlibrary{\idxcode{operator+=}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 constexpr iterator& operator+=(difference_type n)
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2037,7 +2037,7 @@
 \indexlibrary{\idxcode{operator-=}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 constexpr iterator& operator-=(difference_type n)
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2052,7 +2052,7 @@
 \indexlibrary{\idxcode{operator[]}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 constexpr W operator[](difference_type n) const
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2129,7 +2129,7 @@
 \indexlibrary{\idxcode{operator+}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr iterator operator+(iterator i, difference_type n)
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2140,7 +2140,7 @@
 \indexlibrary{\idxcode{operator+}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr iterator operator+(difference_type n, iterator i)
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2151,7 +2151,7 @@
 \indexlibrary{\idxcode{operator-}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr iterator operator-(iterator i, difference_type n)
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2162,7 +2162,7 @@
 \indexlibrary{\idxcode{operator-}!\idxcode{iota_view::iterator}}
 \begin{itemdecl}
 friend constexpr difference_type operator-(const iterator& x, const iterator& y)
-  requires @\placeholdernc{Advanceable}@<W>;
+  requires @\placeholdernc{advanceable}@<W>;
 \end{itemdecl}
 
 \begin{itemdescr}

From a6397a3929ebd40e68c27087f93cf1f67b796e56 Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Wed, 31 Jul 2019 12:52:26 -0700
Subject: [PATCH 08/10] [concepts] Renamed concepts' section names to remove
 trailing prepositions for consistency.

* concept.convertibleto => concept.convertible
* concept.derivedfrom => concept.derived
* concept.stricttotallyordered => concept.totallyordered
---
 source/concepts.tex | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/concepts.tex b/source/concepts.tex
index a576dde9e1..e8c244fdcd 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -151,11 +151,11 @@
   template<class T, class U>
     concept same_as = @\seebelow@;
 
-  // \ref{concept.derivedfrom}, concept \libconcept{derived_from}
+  // \ref{concept.derived}, concept \libconcept{derived_from}
   template<class Derived, class Base>
     concept derived_from = @\seebelow@;
 
-  // \ref{concept.convertibleto}, concept \libconcept{convertible_to}
+  // \ref{concept.convertible}, concept \libconcept{convertible_to}
   template<class From, class To>
     concept convertible_to = @\seebelow@;
 
@@ -221,7 +221,7 @@
   template<class T, class U>
     concept equality_comparable_with = @\seebelow@;
 
-  // \ref{concept.stricttotallyordered}, concept \libconcept{totally_ordered}
+  // \ref{concept.totallyordered}, concept \libconcept{totally_ordered}
   template<class T>
     concept totally_ordered = @\seebelow@;
   template<class T, class U>
@@ -288,7 +288,7 @@
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.derivedfrom]{Concept \libconcept{derived_from}}
+\rSec2[concept.derived]{Concept \libconcept{derived_from}}
 
 \indexlibrary{\idxcode{derived_from}}%
 \begin{itemdecl}
@@ -307,7 +307,7 @@
 \end{note}
 \end{itemdescr}
 
-\rSec2[concept.convertibleto]{Concept \libconcept{convertible_to}}
+\rSec2[concept.convertible]{Concept \libconcept{convertible_to}}
 
 \pnum
 The \libconcept{convertible_to} concept requires an expression of a particular
@@ -947,7 +947,7 @@
 \tcode{bool(t == u) == bool(C(t) == C(u))}.
 \end{itemdescr}
 
-\rSec2[concept.stricttotallyordered]{Concept \libconcept{totally_ordered}}
+\rSec2[concept.totallyordered]{Concept \libconcept{totally_ordered}}
 
 \indexlibrary{\idxcode{totally_ordered}}%
 \begin{itemdecl}

From a33b3065938f705d562b27a22cf6560c8917f353 Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Wed, 31 Jul 2019 13:20:42 -0700
Subject: [PATCH 09/10] Fixup: Missed a reference to
 "concept.stricttotallyordered" in last commit.

---
 source/lib-intro.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 1860d4662e..1eff91bd38 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -533,7 +533,7 @@
 result in the required semantics failing to be met.
 \begin{example}
 The required \tcode{<} operator of the \libconcept{totally_ordered}
-concept\iref{concept.stricttotallyordered} does not meet the
+concept\iref{concept.totallyordered} does not meet the
 semantic requirements of that concept when operating on NaNs.
 \end{example}
 This does not affect whether a type models the concept.

From ce3ab9f5f47869a3b87a89f35e79b54ba88ec7c3 Mon Sep 17 00:00:00 2001
From: Dawn Perchik <dperchik@embarcadero.com>
Date: Fri, 2 Aug 2019 15:42:29 -0700
Subject: [PATCH 10/10] [range.subrange] Use single line for example's comment.

---
 source/ranges.tex | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/source/ranges.tex b/source/ranges.tex
index 296abd8572..7b28b524f8 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -1155,8 +1155,7 @@
       K == subrange_kind::sized && !sized_sentinel_for<S, I>;
     I begin_ = I();                                     // \expos
     S end_ = S();                                       // \expos
-    iter_difference_t<I> size_ = 0;                     // \expos; present only
-                                                        // when \tcode{StoreSize} is \tcode{true}
+    iter_difference_t<I> size_ = 0;                     // \expos; present only when \tcode{StoreSize} is \tcode{true}
   public:
     subrange() = default;