diff --git a/source/algorithms.tex b/source/algorithms.tex
index 8a304cbb35..69d7e08921 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -81,14 +81,14 @@
   \tcode{InputIterator1}, or
   \tcode{Input\-Iterator2},
   the template argument shall meet the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
 \item
   If an algorithm's template parameter is named
   \tcode{OutputIterator},
   \tcode{OutputIterator1}, or
   \tcode{Output\-Iterator2},
   the template argument shall meet the
-  \oldconcept{OutputIterator} requirements\iref{output.iterators}.
+  \oldconceptref{OutputIterator} requirements\iref{output.iterators}.
 \item
   If an algorithm's template parameter is named
   \tcode{ForwardIterator},
@@ -96,7 +96,7 @@
   \tcode{ForwardItera\-tor2}, or
   \tcode{NoThrowForwardIterator},
   the template argument shall meet the
-  \oldconcept{ForwardIterator} requirements\iref{forward.iterators}
+  \oldconceptref{ForwardIterator} requirements\iref{forward.iterators}
   if it is required to be a mutable iterator, or
   model \libconcept{forward_iterator}\iref{iterator.concept.forward} otherwise.
 \item
@@ -112,7 +112,7 @@
   \tcode{Bidirectional\-Iterator1}, or
   \tcode{BidirectionalIterator2},
   the template argument shall meet the
-  \oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators}
+  \oldconceptref{BidirectionalIterator} requirements\iref{bidirectional.iterators}
   if it is required to be a mutable iterator, or model
   \libconcept{bidirectional_iterator}\iref{iterator.concept.bidir} otherwise.
 \item
@@ -121,7 +121,7 @@
   \tcode{Random\-AccessIterator1}, or
   \tcode{RandomAccessIterator2},
   the template argument shall meet the
-  \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   if it is required to be a mutable iterator, or model
   \libconcept{random_access_iterator}\iref{iterator.concept.random.access} otherwise.
 \end{itemize}
@@ -3458,10 +3458,10 @@
 \pnum
 \expects
 \tcode{Function} meets
-the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}).
+the \oldconceptref{MoveConstructible} requirements (\tref{cpp17.moveconstructible}).
 \begin{note}
 \tcode{Function} need not meet the requirements of
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}).
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}).
 \end{note}
 
 \pnum
@@ -3498,7 +3498,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Function} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{Function} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -3584,10 +3584,10 @@
 \pnum
 \expects
 \tcode{n >= 0} is \tcode{true}.
-\tcode{Function} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{Function} meets the \oldconceptref{MoveConstructible} requirements.
 \begin{note}
 \tcode{Function} need not meet
-the requirements of \oldconcept{CopyConstructible}.
+the requirements of \oldconceptref{CopyConstructible}.
 \end{note}
 
 \pnum
@@ -3624,7 +3624,7 @@
 \pnum
 \expects
 \tcode{n >= 0} is \tcode{true}.
-\tcode{Function} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{Function} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -4290,7 +4290,7 @@
 \item
   the types of \tcode{first1}, \tcode{last1}, \tcode{first2}, and \tcode{last2}
   meet the
-  \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   and \tcode{last1 - first1 != last2 - first2}
   for the overloads in namespace \tcode{std};
 \item
@@ -4614,7 +4614,7 @@
 
 \pnum
 \remarks
-\tcode{Searcher} need not meet the \oldconcept{CopyConstructible} requirements.
+\tcode{Searcher} need not meet the \oldconceptref{CopyConstructible} requirements.
 \end{itemdescr}
 
 \rSec2[alg.starts.with]{Starts with}
@@ -5029,7 +5029,7 @@
 For the overload with an \tcode{ExecutionPolicy},
 there might be a performance cost
 if \tcode{iterator_traits<For\-ward\-It\-er\-ator1>::value_type}
-is not \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}).
+is not \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}).
 \end{note}
 
 \pnum
@@ -5840,7 +5840,7 @@
 \expects
 For the algorithms in namespace \tcode{std},
 the type of \tcode{*first}
-meets the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+meets the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -5950,7 +5950,7 @@
 For the overloads with an \tcode{ExecutionPolicy},
 there might be a performance cost
 if \tcode{iterator_traits<ForwardIterator1>::value_type} does not meet
-the \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \end{note}
 
 \pnum
@@ -6023,7 +6023,7 @@
 For the overloads in namespace \tcode{std},
 \tcode{pred} is an equivalence relation and
 the type of \tcode{*first} meets
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -6126,18 +6126,18 @@
     \libconcept{forward_iterator}\iref{iterator.concept.forward},
     then there are no additional requirements for \tcode{T}.
     Otherwise, if \tcode{OutputIterator} meets
-    the \oldconcept{ForwardIterator} requirements and
+    the \oldconceptref{ForwardIterator} requirements and
     its value type is the same as \tcode{T},
     then \tcode{T} meets
-    the \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+    the \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
     Otherwise, \tcode{T} meets both
-    the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
-    \oldconcept{CopyAssignable} requirements.
+    the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}) and
+    \oldconceptref{CopyAssignable} requirements.
     \begin{note}
     For the overloads with an \tcode{ExecutionPolicy},
     there might be a performance cost
     if the value type of \tcode{ForwardIterator1} does not meet both the
-    \oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} requirements.
+    \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements.
     \end{note}
   \end{itemize}
 \end{itemize}
@@ -6185,7 +6185,7 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -6277,10 +6277,10 @@
 \range{first}{middle} and \range{middle}{last} are valid ranges.
 For the overloads in namespace \tcode{std},
 \tcode{ForwardIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -6421,13 +6421,13 @@
 \begin{itemize}
 \item
   \tcode{PopulationIterator} meets
-  the \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  the \oldconceptref{InputIterator} requirements\iref{input.iterators}.
 \item
   \tcode{SampleIterator} meets
-  the \oldconcept{OutputIterator} requirements\iref{output.iterators}.
+  the \oldconceptref{OutputIterator} requirements\iref{output.iterators}.
 \item
   \tcode{SampleIterator} meets
-  the \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  the \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   unless \tcode{Pop\-ulat\-ion\-Iter\-ator}
   models \libconcept{forward_iterator}\iref{iterator.concept.forward}.
 \item
@@ -6495,7 +6495,7 @@
 \begin{itemize}
 \item
   \tcode{RandomAccessIterator} meets
-  the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}.
+  the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 \item
   The type \tcode{remove_reference_t<UniformRandomBitGenerator>} meets
   the uniform random bit generator\iref{rand.req.urng} requirements.
@@ -6547,7 +6547,7 @@
 \expects
 \tcode{n >= 0} is \tcode{true}.
 For the overloads in namespace \tcode{std},
-the type of \tcode{*first} meets the \oldconcept{MoveAssignable} requirements.
+the type of \tcode{*first} meets the \oldconceptref{MoveAssignable} requirements.
 
 \pnum
 \effects
@@ -6601,10 +6601,10 @@
 \expects
 \tcode{n >= 0} is \tcode{true}.
 For the overloads in namespace \tcode{std},
-the type of \tcode{*first} meets the \oldconcept{MoveAssignable} requirements,
+the type of \tcode{*first} meets the \oldconceptref{MoveAssignable} requirements,
 and \tcode{ForwardIterator} meets
-the \oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators} or
-the \oldconcept{ValueSwap\-pable} requirements.
+the \oldconceptref{BidirectionalIterator} requirements\iref{bidirectional.iterators} or
+the \oldconceptref{ValueSwappable} requirements.
 
 \pnum
 \effects
@@ -6618,7 +6618,7 @@
 \item
 for the overload in namespace \tcode{std}
 without an \tcode{ExecutionPolicy} template parameter,
-\tcode{Forward\-Iterator} meets the \oldconcept{BidirectionalIterator} requirements,
+\tcode{Forward\-Iterator} meets the \oldconceptref{BidirectionalIterator} requirements,
 \item
 for the overloads in namespace \tcode{ranges},
 \tcode{I} models \libconcept{bidirectional_iterator}.
@@ -6774,10 +6774,10 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -6832,10 +6832,10 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -6902,10 +6902,10 @@
 \range{first}{middle} and \range{middle}{last} are valid ranges.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7010,10 +7010,10 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements},
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements},
 the type of \tcode{*result_first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{\-Move\-Assignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 For iterators \tcode{a1} and \tcode{b1} in \range{first}{last}, and
@@ -7215,10 +7215,10 @@
 \range{first}{nth} and \range{nth}{last} are valid ranges.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7566,7 +7566,7 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{ForwardIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -7593,7 +7593,7 @@
   For the overload with no \tcode{ExecutionPolicy},
   exactly $N$ applications of the predicate and projection.
   At most $N / 2$ swaps if the type of \tcode{first} meets
-  the \oldconcept{BidirectionalIterator} requirements
+  the \oldconceptref{BidirectionalIterator} requirements
   for the overloads in namespace \tcode{std} or
   models \libconcept{bidirectional_iterator}
   for the overloads in namespace \tcode{ranges},
@@ -7635,10 +7635,10 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7721,7 +7721,7 @@
 \begin{note}
 For the overload with an \tcode{ExecutionPolicy},
 there might be a performance cost if \tcode{first}'s value type
-does not meet the \oldconcept{CopyConstructible} requirements.
+does not meet the \oldconceptref{CopyConstructible} requirements.
 \end{note}
 
 \pnum
@@ -7926,10 +7926,10 @@
 sorted with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8495,10 +8495,10 @@
 is a valid heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}) and
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+the \oldconceptref{MoveConstructible} requirements (\tref{cpp17.moveconstructible}) and
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -8548,10 +8548,10 @@
 is a valid non-empty heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8604,10 +8604,10 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwap\-pable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8657,10 +8657,10 @@
 a valid heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConst\-ruct\-ible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{Move\-Assign\-able} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8819,7 +8819,7 @@
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -8859,8 +8859,8 @@
 \expects
 \tcode{ranges::distance(r) > 0}.
 For the overloads in namespace \tcode{std},
-\tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
-For the first form, \tcode{T} meets the \oldconcept{LessThanComparable}
+\tcode{T} meets the \oldconceptref{CopyConstructible} requirements.
+For the first form, \tcode{T} meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -8897,7 +8897,7 @@
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -8937,8 +8937,8 @@
 \expects
 \tcode{ranges::distance(r) > 0}.
 For the overloads in namespace \tcode{std},
-\tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
-For the first form, \tcode{T} meets the \oldconcept{LessThanComparable}
+\tcode{T} meets the \oldconceptref{CopyConstructible} requirements.
+For the first form, \tcode{T} meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -8977,7 +8977,7 @@
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -9018,8 +9018,8 @@
 \expects
 \tcode{ranges::distance(r) > 0}.
 For the overloads in namespace \tcode{std},
-\tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
-For the first form, type \tcode{T} meets the \oldconcept{LessThanComparable}
+\tcode{T} meets the \oldconceptref{CopyConstructible} requirements.
+For the first form, type \tcode{T} meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -9211,7 +9211,7 @@
 \expects
 \tcode{bool(invoke(comp, invoke(proj, hi), invoke(proj, lo)))} is \tcode{false}.
 For the first form, type \tcode{T}
-meets the \oldconcept{LessThan\-Comparable}
+meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -9400,7 +9400,7 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -9459,7 +9459,7 @@
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -9777,8 +9777,8 @@
 \pnum
 \expects
 \tcode{T} meets
-the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 In the range \crange{first}{last},
 \tcode{binary_op} neither modifies elements
 nor invalidates iterators or subranges.
@@ -9900,7 +9900,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in the range \crange{first}{last}.
@@ -9944,8 +9944,8 @@
 \pnum
 \expects
 \tcode{T} meets
-the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 In the ranges \crange{first1}{last1} and
 \crange{first2}{first2 + (last1 - first1)}
 \tcode{binary_op1} and \tcode{binary_op2}
@@ -10040,7 +10040,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   Neither \tcode{binary_op1} nor \tcode{binary_op2}
   invalidates subranges, nor modifies elements in the ranges
@@ -10090,7 +10090,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op} invalidates subranges,
   nor modifies elements in the range \crange{first}{last}.
@@ -10239,7 +10239,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in
@@ -10360,9 +10360,9 @@
 \begin{itemize}
 \item
   If \tcode{init} is provided,
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
   otherwise, \tcode{U}
-  meets the \oldconcept{MoveConstructible} requirements.
+  meets the \oldconceptref{MoveConstructible} requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in
@@ -10439,7 +10439,7 @@
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op}
   invalidates iterators or subranges, nor modifies elements in
@@ -10538,9 +10538,9 @@
 \begin{itemize}
 \item
   If \tcode{init} is provided, \tcode{T} meets the
-  \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
+  \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
   otherwise, \tcode{U} meets the
-  \oldconcept{MoveConstructible} requirements.
+  \oldconceptref{MoveConstructible} requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op} invalidates
   iterators or subranges, nor modifies elements in
@@ -10639,7 +10639,7 @@
 \begin{itemize}
 \item
   For the overloads with no \tcode{ExecutionPolicy},
-  \tcode{T} meets the \oldconcept{MoveAssignable} (\tref{cpp17.moveassignable})
+  \tcode{T} meets the \oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable})
   requirements.
 \item
   For all overloads, in the ranges \crange{first}{last}
diff --git a/source/concepts.tex b/source/concepts.tex
index 0bfd861231..b166e3a9bf 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -495,7 +495,7 @@
 template<class T>
   concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;
 template<class T>
-  concept @\deflibconcept{floating_point}@ = @\libglobalref{is_floating_point_v}@<T>;
+  concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -747,7 +747,7 @@
 \begin{itemdescr}
 \pnum
 \begin{note}
-Unlike the \oldconcept{Destructible} requirements~(\tref{cpp17.destructible}), this
+Unlike the \oldconceptref{Destructible} requirements~(\tref{cpp17.destructible}), this
 concept forbids destructors that are potentially throwing, even if a particular
 invocation of the destructor does not actually throw.
 \end{note}
diff --git a/source/diagnostics.tex b/source/diagnostics.tex
index b658ca11f9..802b7abd20 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -833,9 +833,9 @@
 
   // \ref{syserr}, system error support
   template<class T>
-    constexpr bool @\libglobal{is_error_code_enum_v}@ = is_error_code_enum<T>::value;
+    constexpr bool @\libglobal{is_error_code_enum_v}@ = @\libglobalref{is_error_code_enum}@<T>::value;
   template<class T>
-    constexpr bool is_error_condition_enum_v = is_error_condition_enum<T>::value;
+    constexpr bool @\libglobal{is_error_condition_enum_v}@ = @\libglobalref{is_error_condition_enum}@<T>::value;
 }
 \end{codeblock}
 
@@ -846,9 +846,9 @@
 exposes the \libheader{cerrno} macros is unspecified.
 
 \pnum
-The \tcode{is_error_code_enum} and \tcode{is_error_condition_enum} templates may be
+The \libglobalref{is_error_code_enum} and \libglobalref{is_error_condition_enum} templates may be
 specialized for program-defined types to indicate that such types are eligible
-for \tcode{class error_code} and \tcode{class error_condition} implicit
+for \tcode{class \libglobalref{error_code}} and \tcode{class \libglobalref{error_condition}} implicit
 conversions, respectively.
 
 \rSec2[syserr.errcat]{Class \tcode{error_category}}
@@ -873,8 +873,6 @@
 \indexlibraryglobal{error_category}%
 \indexlibraryctor{error_category}%
 \indexlibrarydtor{error_category}%
-\indexlibraryglobal{generic_category}%
-\indexlibraryglobal{system_category}%
 \begin{codeblock}
 namespace std {
   class error_category {
@@ -893,8 +891,8 @@
     strong_ordering operator<=>(const error_category& rhs) const noexcept;
   };
 
-  const error_category& generic_category() noexcept;
-  const error_category& system_category() noexcept;
+  const error_category& @\libglobal{generic_category}@() noexcept;
+  const error_category& @\libglobal{system_category}@() noexcept;
 }
 \end{codeblock}
 
@@ -1165,7 +1163,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{is_error_code_enum_v<ErrorCodeEnum>} is \tcode{true}.
+\tcode{\libglobalref{is_error_code_enum_v}<ErrorCodeEnum>} is \tcode{true}.
 
 \pnum
 \effects
@@ -1198,7 +1196,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{is_error_code_enum_v<ErrorCodeEnum>} is \tcode{true}.
+\tcode{\libglobalref{is_error_code_enum_v}<ErrorCodeEnum>} is \tcode{true}.
 
 \pnum
 \effects
diff --git a/source/exec.tex b/source/exec.tex
index 9d7f60c6fe..50e880fe49 100644
--- a/source/exec.tex
+++ b/source/exec.tex
@@ -31,25 +31,25 @@
 \capsep
 core &
   provide core execution functionality, and connection between core components &
-  e.g., \tcode{connect}, \tcode{start} \\
+  e.g., \libglobalref{connect}, \libglobalref{start} \\
 completion functions &
   called by senders to announce the completion of the work (success, error, or cancellation) &
-  \tcode{set_value}, \tcode{set_error}, \tcode{set_stopped} \\
+  \libglobalref{set_value}, \libglobalref{set_error}, \libglobalref{set_stopped} \\
 senders &
   allow the specialization of the provided sender algorithms &
   \begin{itemize}
-  \item sender factories (e.g., \tcode{schedule}, \tcode{just}, \tcode{read_env})
-  \item sender adaptors (e.g., \tcode{continues_on}, \tcode{then}, \tcode{let_value})
-  \item sender consumers (e.g., \tcode{sync_wait})
+  \item sender factories (e.g., \libglobalref{schedule}, \libglobalref{just}, \libglobalref{read_env})
+  \item sender adaptors (e.g., \libglobalref{continues_on}, \libglobalref{then}, \libglobalref{let_value})
+  \item sender consumers (e.g., \libglobalref{sync_wait})
   \end{itemize}
     \\
 queries &
   allow querying different properties of objects &
   \begin{itemize}
-  \item general queries (e.g., \tcode{get_allocator}, \tcode{get_stop_token})
-  \item environment queries (e.g., \tcode{get_scheduler}, \tcode{get_delegation_scheduler})
-  \item scheduler queries (e.g., \tcode{get_forward_progress_guarantee})
-  \item sender attribute queries (e.g., \tcode{get_completion_scheduler})
+  \item general queries (e.g., \libglobalref{get_allocator}, \libglobalref{get_stop_token})
+  \item environment queries (e.g., \tcode{get_scheduler}, \libglobalref{get_delegation_scheduler})
+  \item scheduler queries (e.g., \libglobalref{get_forward_progress_guarantee})
+  \item sender attribute queries (e.g., \libglobalref{get_completion_scheduler})
   \end{itemize}
     \\
 \end{floattable}
diff --git a/source/future.tex b/source/future.tex
index b39c2b36f9..2fc290b5cf 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -270,7 +270,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{EqualityComparable} requirements (\tref{cpp17.equalitycomparable}).
+\tcode{T} meets the \oldconceptref{EqualityComparable} requirements (\tref{cpp17.equalitycomparable}).
 
 \pnum
 \returns
@@ -285,7 +285,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\tcode{T} meets the \oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -300,7 +300,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\tcode{T} meets the \oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -315,7 +315,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\tcode{T} meets the \oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -401,7 +401,7 @@
 
 \pnum
 \remarks
-\tcode{is_pod<T>} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\tcode{is_pod<T>} is a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of \tcode{true_type}
 if \tcode{T} is a POD type,
 and \tcode{false_type} otherwise.
@@ -505,7 +505,7 @@
 If the expression \tcode{TS::value} is well-formed
 when treated as an \deflink{unevaluated operand}{expr.context},
 then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements with a base characteristic of
+the \oldconceptref{TransformationTrait} requirements with a base characteristic of
 \tcode{integral_constant<size_t, TS::value>}.
 Otherwise, they have no member \tcode{value}.
 
@@ -533,7 +533,7 @@
 Let \tcode{TE} denote \tcode{tuple_element_t<I, T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements
+the \oldconceptref{TransformationTrait} requirements
 with a member typedef \tcode{type} that names the following type:
 \begin{itemize}
 \item for the first specialization, \tcode{add_volatile_t<TE>}, and
@@ -573,7 +573,7 @@
 Let \tcode{VS} denote \tcode{variant_size<T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{UnaryTypeTrait} requirements
+the \oldconceptref{UnaryTypeTrait} requirements
 with a base characteristic of \tcode{integral_constant<size_t, VS::value>}.
 \end{itemdescr}
 
@@ -587,7 +587,7 @@
 Let \tcode{VA} denote \tcode{variant_alternative<I, T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements
+the \oldconceptref{TransformationTrait} requirements
 with a member typedef \tcode{type} that names the following type:
 \begin{itemize}
 \item for the first specialization, \tcode{add_volatile_t<VA::type>}, and
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 281619d99a..292f7b2bf4 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -1695,10 +1695,10 @@
 It holds a state object
 whose type is equal to the template parameter \tcode{stateT}.
 Type \tcode{stateT} shall meet
-the \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+the \oldconceptref{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}), and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 If \tcode{is_trivially_copy_constructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy constructor.
 If \tcode{is_trivially_copy_assignable_v<stateT>} is \tcode{true},
@@ -1706,11 +1706,11 @@
 If \tcode{is_trivially_destructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial destructor.
 All specializations of \tcode{fpos} meet
-the \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable},
-\oldconcept{Destructible},
-and \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable},
+\oldconceptref{Destructible},
+and \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 In addition, the expressions shown in \tref{fpos.operations}
 are valid and have the indicated semantics.
 In that table,
@@ -12965,7 +12965,7 @@
 
 \pnum
 \tcode{Allocator} shall meet
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \begin{example}
@@ -13258,7 +13258,7 @@
 
 \pnum
 Template parameters named \tcode{InputIterator} shall meet the
-\oldconcept{InputIterator} requirements\iref{input.iterators} and shall
+\oldconceptref{InputIterator} requirements\iref{input.iterators} and shall
 have a value type that is one of the encoded character types.
 
 \pnum
@@ -13272,7 +13272,7 @@
 
 \pnum
 Template parameters named \tcode{Allocator} shall meet
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \rSec2[fs.filesystem.syn]{Header \tcode{<filesystem>} synopsis}
 
@@ -14085,7 +14085,7 @@
 \item \tcode{basic_string_view<EcharT, traits>}. A function
   argument \tcode{const Source\&} \tcode{source} shall have an
   effective range \range{source.begin()}{source.end()}.
-\item A type meeting the \oldconcept{InputIterator} requirements that iterates over a NTCTS\@.
+\item A type meeting the \oldconceptref{InputIterator} requirements that iterates over a NTCTS\@.
   The value type shall be an encoded character type. A function argument
   \tcode{const Source\&} \tcode{source} shall have an effective range
   \range{source}{end} where \tcode{end} is the first
@@ -16569,7 +16569,7 @@
 
 \pnum
 \tcode{directory_iterator} meets the
-\oldconcept{InputIterator} requirements\iref{input.iterators}.
+\oldconceptref{InputIterator} requirements\iref{input.iterators}.
 
 \pnum
 If an iterator of type \tcode{directory_iterator} reports an error or
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 7205192c0a..00efca005a 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -1773,7 +1773,7 @@
 }\\
 \end{oldconcepttable}
 
-\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconcept{MoveConstructible})}{cpp17.copyconstructible}
+\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconceptref{MoveConstructible})}{cpp17.copyconstructible}
 {p{1in}p{4.15in}}
 \topline
 \hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
@@ -1800,7 +1800,7 @@
 }\\
 \end{oldconcepttable}
 
-\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconcept{MoveAssignable})}{cpp17.copyassignable}
+\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconceptref{MoveAssignable})}{cpp17.copyassignable}
 {p{1in}p{1in}p{1in}p{1.9in}}
 \topline
 \hdstyle{Expression} & \hdstyle{Return type} & \hdstyle{Return value} & \hdstyle{Post-condition} \\ \capsep
@@ -1814,7 +1814,7 @@
 \tcode{u.\~T()} &   All resources owned by \tcode{u} are reclaimed, no exception is propagated. \\ \rowsep
 \multicolumn{2}{|l|}{
   \begin{tailnote}
-  Array types and non-object types are not \oldconcept{Destructible}.
+  Array types and non-object types are not \oldconceptref{Destructible}.
   \end{tailnote}
 } \\
 \end{oldconcepttable}
@@ -1893,7 +1893,7 @@
                                                 // for rvalues and lvalues
 }
 
-// Preconditions: \tcode{T} meets the \oldconcept{Swappable} requirements.
+// Preconditions: \tcode{T} meets the \oldconceptref{Swappable} requirements.
 template<class T>
 void lv_swap(T& t1, T& t2) {
   using std::swap;
@@ -1930,9 +1930,9 @@
 A \oldconcept{NullablePointer} type is a pointer-like type that supports null values.
 A type \tcode{P} meets the \oldconcept{\-Nullable\-Pointer} requirements if
 \begin{itemize}
-\item \tcode{P} meets the \oldconcept{EqualityComparable},
-\oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
-\oldconcept{Swappable}, and \oldconcept{Destructible} requirements,
+\item \tcode{P} meets the \oldconceptref{EqualityComparable},
+\oldconceptref{DefaultConstructible}, \oldconceptref{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
+\oldconceptref{Swappable}, and \oldconceptref{Destructible} requirements,
 
 \item the expressions shown in \tref{cpp17.nullablepointer} are
 valid and have the indicated semantics, and
@@ -2008,8 +2008,8 @@
 A type \tcode{H} meets the \defnoldconcept{Hash} requirements if
 \begin{itemize}
 \item it is a function object type\iref{function.objects},
-\item it meets the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
-  \oldconcept{Destructible} (\tref{cpp17.destructible}) requirements, and
+\item it meets the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}) and
+  \oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements, and
 \item the expressions shown in \tref{cpp17.hash}
 are valid and have the indicated semantics.
 \end{itemize}
@@ -2693,7 +2693,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be copied
 when the client container is copy-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
+the \oldconceptref{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
 the copy operation shall not throw exceptions.
 
 \pnum
@@ -2715,7 +2715,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be moved
 when the client container is move-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
 the move operation shall not throw exceptions.
 
 \pnum
@@ -2737,7 +2737,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be swapped
 when the client container is swapped;
 if so,
-\tcode{X} shall meet the \oldconcept{Swappable} requirements\iref{swappable.requirements} and
+\tcode{X} shall meet the \oldconceptref{Swappable} requirements\iref{swappable.requirements} and
 the \tcode{swap} operation shall not throw exceptions.
 
 \pnum
@@ -2767,7 +2767,7 @@
 
 \pnum
 An allocator type \tcode{X} shall meet the
-\oldconcept{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
+\oldconceptref{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
 The \tcode{XX::pointer}, \tcode{XX::const_pointer}, \tcode{XX::void_pointer}, and
 \tcode{XX::const_void_pointer} types shall meet the
 \oldconcept{Nullable\-Pointer} requirements (\tref{cpp17.nullablepointer}).
@@ -2775,7 +2775,7 @@
 comparison operator function, copy operation, move operation, or swap operation on
 these pointer types shall exit via an exception. \tcode{XX::pointer} and \tcode{XX::const_pointer} shall also
 meet the requirements for
-a \oldconcept{RandomAccessIterator}\iref{random.access.iterators} and
+a \oldconceptref{RandomAccessIterator}\iref{random.access.iterators} and
 the additional requirement that, when \tcode{p} and \tcode{(p + n)} are
 dereferenceable pointer values for some integral value \tcode{n},
 \begin{codeblock}
diff --git a/source/memory.tex b/source/memory.tex
index dc8df77d5f..0b36bff3d2 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -977,7 +977,7 @@
 disambiguate constructor and function overloading. Specifically, several types (see
 \tcode{tuple}~\ref{tuple}) have constructors with \tcode{allocator_arg_t} as the first
 argument, immediately followed by an argument of a type that meets the
-\oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+\oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \rSec2[allocator.uses]{\tcode{uses_allocator}}
 
@@ -992,7 +992,7 @@
 \pnum
 \remarks
 Automatically detects whether \tcode{T} has a nested \tcode{allocator_type} that
-is convertible from \tcode{Alloc}. Meets the \oldconcept{BinaryTypeTrait}
+is convertible from \tcode{Alloc}. Meets the \oldconceptref{BinaryTypeTrait}
 requirements\iref{meta.rqmts}. The implementation shall provide a definition that is
 derived from \tcode{true_type} if the \grammarterm{qualified-id} \tcode{T::allocator_type}
 is valid and denotes a type\iref{temp.deduct} and
@@ -1917,8 +1917,8 @@
 Each object of a type \tcode{U} instantiated from the \tcode{unique_ptr} template
 specified in \ref{unique.ptr} has the strict ownership semantics, specified above,
 of a unique pointer. In partial satisfaction of these semantics, each such \tcode{U}
-is \oldconcept{MoveConstructible} and \oldconcept{MoveAssignable}, but is not
-\oldconcept{CopyConstructible} nor \oldconcept{CopyAssignable}.
+is \oldconceptref{MoveConstructible} and \oldconceptref{MoveAssignable}, but is not
+\oldconceptref{CopyConstructible} nor \oldconceptref{CopyAssignable}.
 The template parameter \tcode{T} of \tcode{unique_ptr} may be an incomplete type.
 
 \pnum
@@ -2097,7 +2097,7 @@
 
 \pnum
 If the deleter's type \tcode{D} is not a reference type, \tcode{D} shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 
 \pnum
 If the \grammarterm{qualified-id} \tcode{remove_reference_t<D>::pointer} is valid and denotes a
@@ -2105,7 +2105,7 @@
 D>::pointer} shall be a synonym for \tcode{remove_reference_t<D>::pointer}. Otherwise
 \tcode{unique_ptr<T, D>::pointer} shall be a synonym for \tcode{element_type*}. The type \tcode{unique_ptr<T,
 D>::pointer} shall
-meet the \oldconcept{NullablePointer} requirements (\tref{cpp17.nullablepointer}).
+meet the \oldconceptref{NullablePointer} requirements (\tref{cpp17.nullablepointer}).
 
 \pnum
 \begin{example}
@@ -2131,7 +2131,7 @@
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+\tcode{D} meets the \oldconceptref{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
 and that construction does not throw an exception.
 
 \pnum
@@ -2158,7 +2158,7 @@
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+\tcode{D} meets the \oldconceptref{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
 and that construction does not throw an exception.
 
 \pnum
@@ -2187,10 +2187,10 @@
 \pnum
 \expects
 For the first constructor, if \tcode{D} is not a reference type,
-\tcode{D} meets the \oldconcept{CopyConstructible} requirements and
+\tcode{D} meets the \oldconceptref{CopyConstructible} requirements and
 such construction does not exit via an exception.
 For the second constructor, if \tcode{D} is not a reference type,
-\tcode{D} meets the \oldconcept{MoveConstructible} requirements and
+\tcode{D} meets the \oldconceptref{MoveConstructible} requirements and
 such construction does not exit via an exception.
 
 \pnum
@@ -2215,8 +2215,8 @@
 \begin{example}
 \begin{codeblock}
 D d;
-unique_ptr<int, D> p1(new int, D());        // \tcode{D} must be \oldconcept{MoveConstructible}
-unique_ptr<int, D> p2(new int, d);          // \tcode{D} must be \oldconcept{CopyConstructible}
+unique_ptr<int, D> p1(new int, D());        // \tcode{D} must be \oldconceptref{MoveConstructible}
+unique_ptr<int, D> p2(new int, d);          // \tcode{D} must be \oldconceptref{CopyConstructible}
 unique_ptr<int, D&> p3(new int, d);         // \tcode{p3} holds a reference to \tcode{d}
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
@@ -2237,7 +2237,7 @@
 \pnum
 \expects
 If \tcode{D} is not a reference type,
-\tcode{D} meets the \oldconcept{MoveConstructible}
+\tcode{D} meets the \oldconceptref{MoveConstructible}
 requirements (\tref{cpp17.moveconstructible}).
 Construction
 of the deleter from an rvalue of type \tcode{D} does not
@@ -2346,10 +2346,10 @@
 \pnum
 \expects
 If \tcode{D} is not a reference type, \tcode{D} meets the
-\oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and assignment
+\oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and assignment
 of the deleter from an rvalue of type \tcode{D} does not throw an exception.
 Otherwise, \tcode{D} is a reference type;
-\tcode{remove_reference_t<D>} meets the \oldconcept{CopyAssignable}
+\tcode{remove_reference_t<D>} meets the \oldconceptref{CopyAssignable}
 requirements and assignment of the deleter from an
 lvalue of type \tcode{D} does not throw an exception.
 
@@ -3243,8 +3243,8 @@
 \end{codeblock}
 
 \pnum
-Specializations of \tcode{shared_ptr} shall be \oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable}, and \oldconcept{\-Less\-Than\-Comparable}, allowing their use in standard
+Specializations of \tcode{shared_ptr} shall be \oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable}, and \oldconceptref{LessThanComparable}, allowing their use in standard
 containers. Specializations of \tcode{shared_ptr} shall be
 contextually convertible to \tcode{bool},
 allowing their use in boolean expressions and declarations in conditions.
@@ -3389,7 +3389,7 @@
 The expression \tcode{d(p)}
 has well-defined behavior and does not throw exceptions.
 \tcode{A} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \effects
@@ -3906,7 +3906,7 @@
 \pnum
 \expects
 \tcode{A} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \effects
@@ -4560,8 +4560,8 @@
 \end{codeblock}
 
 \pnum
-Specializations of \tcode{weak_ptr} shall be \oldconcept{CopyConstructible} and
-\oldconcept{CopyAssignable}, allowing their use in standard
+Specializations of \tcode{weak_ptr} shall be \oldconceptref{CopyConstructible} and
+\oldconceptref{CopyAssignable}, allowing their use in standard
 containers.  The template parameter \tcode{T} of \tcode{weak_ptr} may be an
 incomplete type.
 
@@ -5140,7 +5140,7 @@
 \end{codeblock}
 
 \pnum
-\tcode{Pointer} shall meet the \oldconcept{NullablePointer} requirements.
+\tcode{Pointer} shall meet the \oldconceptref{NullablePointer} requirements.
 If \tcode{Smart} is a specialization of \tcode{shared_ptr} and
 \tcode{sizeof...(Args) == 0},
 the program is ill-formed.
@@ -5380,7 +5380,7 @@
 \end{codeblock}
 
 \pnum
-\tcode{Pointer} shall meet the \oldconcept{NullablePointer} requirements.
+\tcode{Pointer} shall meet the \oldconceptref{NullablePointer} requirements.
 If \tcode{Smart} is a specialization of \tcode{shared_ptr},
 the program is ill-formed.
 \begin{note}
diff --git a/source/meta.tex b/source/meta.tex
index 7f8c6cc6c8..54450c49eb 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -94,12 +94,12 @@
 A \defnoldconcept{UnaryTypeTrait} describes a property
 of a type. It shall be a class template that takes one template type
 argument and, optionally, additional arguments that help define the
-property being described. It shall be \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
+property being described. It shall be \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
 and publicly and unambiguously derived, directly or indirectly, from
 its \defn{base characteristic}, which is
 a specialization of the template
-\tcode{integral_constant}\iref{meta.help}, with
+\libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
 requirements for the particular property being described.
 The member names of the base characteristic shall not be hidden and shall be
@@ -110,12 +110,12 @@
 relationship between two types. It shall be a class template that
 takes two template type arguments and, optionally, additional
 arguments that help define the relationship being described. It shall
-be \oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible},
+be \oldconceptref{DefaultConstructible}, \oldconceptref{CopyConstructible},
 and publicly and unambiguously derived, directly or
 indirectly, from
 its \term{base characteristic}, which is a specialization
 of the template
-\tcode{integral_constant}\iref{meta.help}, with
+\libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
 requirements for the particular relationship being described.
 The member names of the base characteristic shall not be hidden and shall be
@@ -283,17 +283,17 @@
   template<class T> struct add_cv;
 
   template<class T>
-    using @\libglobal{remove_const_t}@    = typename remove_const<T>::type;
+    using @\libglobal{remove_const_t}@    = typename @\libglobalref{remove_const}@<T>::type;
   template<class T>
-    using @\libglobal{remove_volatile_t}@ = typename remove_volatile<T>::type;
+    using @\libglobal{remove_volatile_t}@ = typename @\libglobalref{remove_volatile}@<T>::type;
   template<class T>
-    using @\libglobal{remove_cv_t}@       = typename remove_cv<T>::type;
+    using @\libglobal{remove_cv_t}@       = typename @\libglobalref{remove_cv}@<T>::type;
   template<class T>
-    using @\libglobal{add_const_t}@       = typename add_const<T>::type;
+    using @\libglobal{add_const_t}@       = typename @\libglobalref{add_const}@<T>::type;
   template<class T>
-    using @\libglobal{add_volatile_t}@    = typename add_volatile<T>::type;
+    using @\libglobal{add_volatile_t}@    = typename @\libglobalref{add_volatile}@<T>::type;
   template<class T>
-    using @\libglobal{add_cv_t}@          = typename add_cv<T>::type;
+    using @\libglobal{add_cv_t}@          = typename @\libglobalref{add_cv}@<T>::type;
 
   // \ref{meta.trans.ref}, reference modifications
   template<class T> struct remove_reference;
@@ -301,38 +301,38 @@
   template<class T> struct add_rvalue_reference;
 
   template<class T>
-    using @\libglobal{remove_reference_t}@     = typename remove_reference<T>::type;
+    using @\libglobal{remove_reference_t}@     = typename @\libglobalref{remove_reference}@<T>::type;
   template<class T>
-    using @\libglobal{add_lvalue_reference_t}@ = typename add_lvalue_reference<T>::type;
+    using @\libglobal{add_lvalue_reference_t}@ = typename @\libglobalref{add_lvalue_reference}@<T>::type;
   template<class T>
-    using @\libglobal{add_rvalue_reference_t}@ = typename add_rvalue_reference<T>::type;
+    using @\libglobal{add_rvalue_reference_t}@ = typename @\libglobalref{add_rvalue_reference}@<T>::type;
 
   // \ref{meta.trans.sign}, sign modifications
   template<class T> struct make_signed;
   template<class T> struct make_unsigned;
 
   template<class T>
-    using @\libglobal{make_signed_t}@   = typename make_signed<T>::type;
+    using @\libglobal{make_signed_t}@   = typename @\libglobalref{make_signed}@<T>::type;
   template<class T>
-    using @\libglobal{make_unsigned_t}@ = typename make_unsigned<T>::type;
+    using @\libglobal{make_unsigned_t}@ = typename @\libglobalref{make_unsigned}@<T>::type;
 
   // \ref{meta.trans.arr}, array modifications
   template<class T> struct remove_extent;
   template<class T> struct remove_all_extents;
 
   template<class T>
-    using @\libglobal{remove_extent_t}@      = typename remove_extent<T>::type;
+    using @\libglobal{remove_extent_t}@      = typename @\libglobalref{remove_extent}@<T>::type;
   template<class T>
-    using @\libglobal{remove_all_extents_t}@ = typename remove_all_extents<T>::type;
+    using @\libglobal{remove_all_extents_t}@ = typename @\libglobalref{remove_all_extents}@<T>::type;
 
   // \ref{meta.trans.ptr}, pointer modifications
   template<class T> struct remove_pointer;
   template<class T> struct add_pointer;
 
   template<class T>
-    using @\libglobal{remove_pointer_t}@ = typename remove_pointer<T>::type;
+    using @\libglobal{remove_pointer_t}@ = typename @\libglobalref{remove_pointer}@<T>::type;
   template<class T>
-    using @\libglobal{add_pointer_t}@    = typename add_pointer<T>::type;
+    using @\libglobal{add_pointer_t}@    = typename @\libglobalref{add_pointer}@<T>::type;
 
   // \ref{meta.trans.other}, other transformations
   template<class T> struct type_identity;
@@ -350,27 +350,27 @@
   template<class T> struct unwrap_ref_decay;
 
   template<class T>
-    using @\libglobal{type_identity_t}@    = typename type_identity<T>::type;
+    using @\libglobal{type_identity_t}@    = typename @\libglobalref{type_identity}@<T>::type;
   template<class T>
-    using @\libglobal{remove_cvref_t}@     = typename remove_cvref<T>::type;
+    using @\libglobal{remove_cvref_t}@     = typename @\libglobalref{remove_cvref}@<T>::type;
   template<class T>
-    using @\libglobal{decay_t}@            = typename decay<T>::type;
+    using @\libglobal{decay_t}@            = typename @\libglobalref{decay}@<T>::type;
   template<bool B, class T = void>
-    using @\libglobal{enable_if_t}@        = typename enable_if<B, T>::type;
+    using @\libglobal{enable_if_t}@        = typename @\libglobalref{enable_if}@<B, T>::type;
   template<bool B, class T, class F>
-    using @\libglobal{conditional_t}@      = typename conditional<B, T, F>::type;
+    using @\libglobal{conditional_t}@      = typename @\libglobalref{conditional}@<B, T, F>::type;
   template<class... T>
-    using @\libglobal{common_type_t}@      = typename common_type<T...>::type;
+    using @\libglobal{common_type_t}@      = typename @\libglobalref{common_type}@<T...>::type;
   template<class... T>
-    using @\libglobal{common_reference_t}@ = typename common_reference<T...>::type;
+    using @\libglobal{common_reference_t}@ = typename @\libglobalref{common_reference}@<T...>::type;
   template<class T>
-    using @\libglobal{underlying_type_t}@  = typename underlying_type<T>::type;
+    using @\libglobal{underlying_type_t}@  = typename @\libglobalref{underlying_type}@<T>::type;
   template<class Fn, class... ArgTypes>
-    using @\libglobal{invoke_result_t}@    = typename invoke_result<Fn, ArgTypes...>::type;
+    using @\libglobal{invoke_result_t}@    = typename @\libglobalref{invoke_result}@<Fn, ArgTypes...>::type;
   template<class T>
-    using unwrap_reference_t = typename unwrap_reference<T>::type;
+    using @\libglobal{unwrap_reference_t}@ = typename @\libglobalref{unwrap_reference}@<T>::type;
   template<class T>
-    using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
+    using @\libglobal{unwrap_ref_decay_t}@ = typename @\libglobalref{unwrap_ref_decay}@<T>::type;
   template<class...>
     using @\libglobal{void_t}@             = void;
 
@@ -381,202 +381,202 @@
 
   // \ref{meta.unary.cat}, primary type categories
   template<class T>
-    constexpr bool @\libglobal{is_void_v}@ = is_void<T>::value;
+    constexpr bool @\libglobal{is_void_v}@ = @\libglobalref{is_void}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_null_pointer_v}@ = is_null_pointer<T>::value;
+    constexpr bool @\libglobal{is_null_pointer_v}@ = @\libglobalref{is_null_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_integral_v}@ = is_integral<T>::value;
+    constexpr bool @\libglobal{is_integral_v}@ = @\libglobalref{is_integral}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_floating_point_v}@ = is_floating_point<T>::value;
+    constexpr bool @\libglobal{is_floating_point_v}@ = @\libglobalref{is_floating_point}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_array_v}@ = is_array<T>::value;
+    constexpr bool @\libglobal{is_array_v}@ = @\libglobalref{is_array}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_pointer_v}@ = is_pointer<T>::value;
+    constexpr bool @\libglobal{is_pointer_v}@ = @\libglobalref{is_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_lvalue_reference_v}@ = is_lvalue_reference<T>::value;
+    constexpr bool @\libglobal{is_lvalue_reference_v}@ = @\libglobalref{is_lvalue_reference}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_rvalue_reference_v}@ = is_rvalue_reference<T>::value;
+    constexpr bool @\libglobal{is_rvalue_reference_v}@ = @\libglobalref{is_rvalue_reference}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_member_object_pointer_v}@ = is_member_object_pointer<T>::value;
+    constexpr bool @\libglobal{is_member_object_pointer_v}@ = @\libglobalref{is_member_object_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_member_function_pointer_v}@ = is_member_function_pointer<T>::value;
+    constexpr bool @\libglobal{is_member_function_pointer_v}@ = @\libglobalref{is_member_function_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_enum_v}@ = is_enum<T>::value;
+    constexpr bool @\libglobal{is_enum_v}@ = @\libglobalref{is_enum}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_union_v}@ = is_union<T>::value;
+    constexpr bool @\libglobal{is_union_v}@ = @\libglobalref{is_union}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_class_v}@ = is_class<T>::value;
+    constexpr bool @\libglobal{is_class_v}@ = @\libglobalref{is_class}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_function_v}@ = is_function<T>::value;
+    constexpr bool @\libglobal{is_function_v}@ = @\libglobalref{is_function}@<T>::value;
 
   // \ref{meta.unary.comp}, composite type categories
   template<class T>
-    constexpr bool @\libglobal{is_reference_v}@ = is_reference<T>::value;
+    constexpr bool @\libglobal{is_reference_v}@ = @\libglobalref{is_reference}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_arithmetic_v}@ = is_arithmetic<T>::value;
+    constexpr bool @\libglobal{is_arithmetic_v}@ = @\libglobalref{is_arithmetic}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_fundamental_v}@ = is_fundamental<T>::value;
+    constexpr bool @\libglobal{is_fundamental_v}@ = @\libglobalref{is_fundamental}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_object_v}@ = is_object<T>::value;
+    constexpr bool @\libglobal{is_object_v}@ = @\libglobalref{is_object}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_scalar_v}@ = is_scalar<T>::value;
+    constexpr bool @\libglobal{is_scalar_v}@ = @\libglobalref{is_scalar}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_compound_v}@ = is_compound<T>::value;
+    constexpr bool @\libglobal{is_compound_v}@ = @\libglobalref{is_compound}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_member_pointer_v}@ = is_member_pointer<T>::value;
+    constexpr bool @\libglobal{is_member_pointer_v}@ = @\libglobalref{is_member_pointer}@<T>::value;
 
   // \ref{meta.unary.prop}, type properties
   template<class T>
-    constexpr bool @\libglobal{is_const_v}@ = is_const<T>::value;
+    constexpr bool @\libglobal{is_const_v}@ = @\libglobalref{is_const}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_volatile_v}@ = is_volatile<T>::value;
+    constexpr bool @\libglobal{is_volatile_v}@ = @\libglobalref{is_volatile}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_trivial_v}@ = is_trivial<T>::value;
+    constexpr bool @\libglobal{is_trivial_v}@ = @\libglobalref{is_trivial}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_trivially_copyable_v}@ = is_trivially_copyable<T>::value;
+    constexpr bool @\libglobal{is_trivially_copyable_v}@ = @\libglobalref{is_trivially_copyable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_standard_layout_v}@ = is_standard_layout<T>::value;
+    constexpr bool @\libglobal{is_standard_layout_v}@ = @\libglobalref{is_standard_layout}@<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_empty_v}@ = is_empty<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_polymorphic_v}@ = is_polymorphic<T>::value;
+    constexpr bool @\libglobal{is_polymorphic_v}@ = @\libglobalref{is_polymorphic}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_abstract_v}@ = is_abstract<T>::value;
+    constexpr bool @\libglobal{is_abstract_v}@ = @\libglobalref{is_abstract}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_final_v}@ = is_final<T>::value;
+    constexpr bool @\libglobal{is_final_v}@ = @\libglobalref{is_final}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_aggregate_v}@ = is_aggregate<T>::value;
+    constexpr bool @\libglobal{is_aggregate_v}@ = @\libglobalref{is_aggregate}@<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_signed_v}@ = is_signed<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_unsigned_v}@ = is_unsigned<T>::value;
+    constexpr bool @\libglobal{is_unsigned_v}@ = @\libglobalref{is_unsigned}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_bounded_array_v}@ = is_bounded_array<T>::value;
+    constexpr bool @\libglobal{is_bounded_array_v}@ = @\libglobalref{is_bounded_array}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_unbounded_array_v}@ = is_unbounded_array<T>::value;
+    constexpr bool @\libglobal{is_unbounded_array_v}@ = @\libglobalref{is_unbounded_array}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_scoped_enum_v}@ = is_scoped_enum<T>::value;
+    constexpr bool @\libglobal{is_scoped_enum_v}@ = @\libglobalref{is_scoped_enum}@<T>::value;
   template<class T, class... Args>
-    constexpr bool @\libglobal{is_constructible_v}@ = is_constructible<T, Args...>::value;
+    constexpr bool @\libglobal{is_constructible_v}@ = @\libglobalref{is_constructible}@<T, Args...>::value;
   template<class T>
-    constexpr bool @\libglobal{is_default_constructible_v}@ = is_default_constructible<T>::value;
+    constexpr bool @\libglobal{is_default_constructible_v}@ = @\libglobalref{is_default_constructible}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_copy_constructible_v}@ = is_copy_constructible<T>::value;
+    constexpr bool @\libglobal{is_copy_constructible_v}@ = @\libglobalref{is_copy_constructible}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_move_constructible_v}@ = is_move_constructible<T>::value;
+    constexpr bool @\libglobal{is_move_constructible_v}@ = @\libglobalref{is_move_constructible}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_assignable_v}@ = is_assignable<T, U>::value;
+    constexpr bool @\libglobal{is_assignable_v}@ = @\libglobalref{is_assignable}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_copy_assignable_v}@ = is_copy_assignable<T>::value;
+    constexpr bool @\libglobal{is_copy_assignable_v}@ = @\libglobalref{is_copy_assignable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_move_assignable_v}@ = is_move_assignable<T>::value;
+    constexpr bool @\libglobal{is_move_assignable_v}@ = @\libglobalref{is_move_assignable}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_swappable_with_v}@ = is_swappable_with<T, U>::value;
+    constexpr bool @\libglobal{is_swappable_with_v}@ = @\libglobalref{is_swappable_with}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_swappable_v}@ = is_swappable<T>::value;
+    constexpr bool @\libglobal{is_swappable_v}@ = @\libglobalref{is_swappable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_destructible_v}@ = is_destructible<T>::value;
+    constexpr bool @\libglobal{is_destructible_v}@ = @\libglobalref{is_destructible}@<T>::value;
   template<class T, class... Args>
-    constexpr bool is_trivially_constructible_v
-      = is_trivially_constructible<T, Args...>::value;
+    constexpr @\libglobal{bool is_trivially_constructible_v}@
+      = @\libglobalref{is_trivially_constructible}@<T, Args...>::value;
   template<class T>
-    constexpr bool is_trivially_default_constructible_v
-      = is_trivially_default_constructible<T>::value;
+    constexpr bool @\libglobal{is_trivially_default_constructible_v}@
+      = @\libglobalref{is_trivially_default_constructible}@<T>::value;
   template<class T>
-    constexpr bool is_trivially_copy_constructible_v
-      = is_trivially_copy_constructible<T>::value;
+    constexpr bool @\libglobal{is_trivially_copy_constructible_v}@
+      = @\libglobalref{is_trivially_copy_constructible}@<T>::value;
   template<class T>
-    constexpr bool is_trivially_move_constructible_v
-      = is_trivially_move_constructible<T>::value;
+    constexpr bool @\libglobal{is_trivially_move_constructible_v}@
+      = @\libglobalref{is_trivially_move_constructible}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_trivially_assignable_v}@ = is_trivially_assignable<T, U>::value;
+    constexpr bool @\libglobal{is_trivially_assignable_v}@ = @\libglobalref{is_trivially_assignable}@<T, U>::value;
   template<class T>
-    constexpr bool is_trivially_copy_assignable_v
-      = is_trivially_copy_assignable<T>::value;
+    constexpr bool @\libglobal{is_trivially_copy_assignable_v}@
+      = @\libglobalref{is_trivially_copy_assignable}@<T>::value;
   template<class T>
-    constexpr bool is_trivially_move_assignable_v
-      = is_trivially_move_assignable<T>::value;
+    constexpr bool @\libglobal{is_trivially_move_assignable_v}@
+      = @\libglobalref{is_trivially_move_assignable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_trivially_destructible_v}@ = is_trivially_destructible<T>::value;
+    constexpr bool @\libglobal{is_trivially_destructible_v}@ = @\libglobalref{is_trivially_destructible}@<T>::value;
   template<class T, class... Args>
-    constexpr bool is_nothrow_constructible_v
-      = is_nothrow_constructible<T, Args...>::value;
+    constexpr bool @\libglobal{is_nothrow_constructible_v}@
+      = @\libglobalref{is_nothrow_constructible}@<T, Args...>::value;
   template<class T>
-    constexpr bool is_nothrow_default_constructible_v
-      = is_nothrow_default_constructible<T>::value;
+    constexpr bool @\libglobal{is_nothrow_default_constructible_v}@
+      = @\libglobalref{is_nothrow_default_constructible}@<T>::value;
   template<class T>
-    constexpr bool is_nothrow_copy_constructible_v
-      = is_nothrow_copy_constructible<T>::value;
+    constexpr bool @\libglobal{is_nothrow_copy_constructible_v}@
+      = @\libglobalref{is_nothrow_copy_constructible}@<T>::value;
   template<class T>
-    constexpr bool is_nothrow_move_constructible_v
-      = is_nothrow_move_constructible<T>::value;
+    constexpr bool @\libglobal{is_nothrow_move_constructible_v}@
+      = @\libglobalref{is_nothrow_move_constructible}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_nothrow_assignable_v}@ = is_nothrow_assignable<T, U>::value;
+    constexpr bool @\libglobal{is_nothrow_assignable_v}@ = @\libglobalref{is_nothrow_assignable}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = is_nothrow_copy_assignable<T>::value;
+    constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = @\libglobalref{is_nothrow_copy_assignable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = is_nothrow_move_assignable<T>::value;
+    constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = @\libglobalref{is_nothrow_move_assignable}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = is_nothrow_swappable_with<T, U>::value;
+    constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = @\libglobalref{is_nothrow_swappable_with}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_swappable_v}@ = is_nothrow_swappable<T>::value;
+    constexpr bool @\libglobal{is_nothrow_swappable_v}@ = @\libglobalref{is_nothrow_swappable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_destructible_v}@ = is_nothrow_destructible<T>::value;
+    constexpr bool @\libglobal{is_nothrow_destructible_v}@ = @\libglobalref{is_nothrow_destructible}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_implicit_lifetime_v}@ = is_implicit_lifetime<T>::value;
+    constexpr bool @\libglobal{is_implicit_lifetime_v}@ = @\libglobalref{is_implicit_lifetime}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{has_virtual_destructor_v}@ = has_virtual_destructor<T>::value;
+    constexpr bool @\libglobal{has_virtual_destructor_v}@ = @\libglobalref{has_virtual_destructor}@<T>::value;
   template<class T>
-    constexpr bool has_unique_object_representations_v
-      = has_unique_object_representations<T>::value;
+    constexpr bool @\libglobal{has_unique_object_representations_v}@
+      = @\libglobalref{has_unique_object_representations}@<T>::value;
   template<class T, class U>
     constexpr bool @\libglobal{reference_constructs_from_temporary_v}@
-      = reference_constructs_from_temporary<T, U>::value;
+      = @\libglobalref{reference_constructs_from_temporary}@<T, U>::value;
   template<class T, class U>
     constexpr bool @\libglobal{reference_converts_from_temporary_v}@
-      = reference_converts_from_temporary<T, U>::value;
+      = @\libglobalref{reference_converts_from_temporary}@<T, U>::value;
 
   // \ref{meta.unary.prop.query}, type property queries
   template<class T>
-    constexpr size_t @\libglobal{alignment_of_v}@ = alignment_of<T>::value;
+    constexpr size_t @\libglobal{alignment_of_v}@ = @\libglobalref{alignment_of}@<T>::value;
   template<class T>
-    constexpr size_t @\libglobal{rank_v}@ = rank<T>::value;
+    constexpr size_t @\libglobal{rank_v}@ = @\libglobalref{rank}@<T>::value;
   template<class T, unsigned I = 0>
-    constexpr size_t @\libglobal{extent_v}@ = extent<T, I>::value;
+    constexpr size_t @\libglobal{extent_v}@ = @\libglobalref{extent}@<T, I>::value;
 
   // \ref{meta.rel}, type relations
   template<class T, class U>
-    constexpr bool @\libglobal{is_same_v}@ = is_same<T, U>::value;
+    constexpr bool @\libglobal{is_same_v}@ = @\libglobalref{is_same}@<T, U>::value;
   template<class Base, class Derived>
-    constexpr bool @\libglobal{is_base_of_v}@ = is_base_of<Base, Derived>::value;
+    constexpr bool @\libglobal{is_base_of_v}@ = @\libglobalref{is_base_of}@<Base, Derived>::value;
   template<class Base, class Derived>
-    constexpr bool @\libglobal{is_virtual_base_of_v}@ = is_virtual_base_of<Base, Derived>::value;
+    constexpr bool @\libglobal{is_virtual_base_of_v}@ = @\libglobalref{is_virtual_base_of}@<Base, Derived>::value;
   template<class From, class To>
-    constexpr bool @\libglobal{is_convertible_v}@ = is_convertible<From, To>::value;
+    constexpr bool @\libglobal{is_convertible_v}@ = @\libglobalref{is_convertible}@<From, To>::value;
   template<class From, class To>
-    constexpr bool @\libglobal{is_nothrow_convertible_v}@ = is_nothrow_convertible<From, To>::value;
+    constexpr bool @\libglobal{is_nothrow_convertible_v}@ = @\libglobalref{is_nothrow_convertible}@<From, To>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_layout_compatible_v}@ = is_layout_compatible<T, U>::value;
+    constexpr bool @\libglobal{is_layout_compatible_v}@ = @\libglobalref{is_layout_compatible}@<T, U>::value;
   template<class Base, class Derived>
-    constexpr bool is_pointer_interconvertible_base_of_v
-      = is_pointer_interconvertible_base_of<Base, Derived>::value;
+    constexpr bool @\libglobal{is_pointer_interconvertible_base_of_v}@
+      = @\libglobalref{is_pointer_interconvertible_base_of}@<Base, Derived>::value;
   template<class Fn, class... ArgTypes>
-    constexpr bool @\libglobal{is_invocable_v}@ = is_invocable<Fn, ArgTypes...>::value;
+    constexpr bool @\libglobal{is_invocable_v}@ = @\libglobalref{is_invocable}@<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
-    constexpr bool @\libglobal{is_invocable_r_v}@ = is_invocable_r<R, Fn, ArgTypes...>::value;
+    constexpr bool @\libglobal{is_invocable_r_v}@ = @\libglobalref{is_invocable_r}@<R, Fn, ArgTypes...>::value;
   template<class Fn, class... ArgTypes>
-    constexpr bool @\libglobal{is_nothrow_invocable_v}@ = is_nothrow_invocable<Fn, ArgTypes...>::value;
+    constexpr bool @\libglobal{is_nothrow_invocable_v}@ = @\libglobalref{is_nothrow_invocable}@<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
     constexpr bool is_nothrow_invocable_r_v
-      = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
+      = @\libglobalref{is_nothrow_invocable_r}@<R, Fn, ArgTypes...>::value;
 
   // \ref{meta.logical}, logical operator traits
   template<class... B>
-    constexpr bool @\libglobal{conjunction_v}@ = conjunction<B...>::value;
+    constexpr bool @\libglobal{conjunction_v}@ = @\libglobalref{conjunction}@<B...>::value;
   template<class... B>
-    constexpr bool @\libglobal{disjunction_v}@ = disjunction<B...>::value;
+    constexpr bool @\libglobal{disjunction_v}@ = @\libglobalref{disjunction}@<B...>::value;
   template<class B>
-    constexpr bool @\libglobal{negation_v}@ = negation<B>::value;
+    constexpr bool @\libglobal{negation_v}@ = @\libglobalref{negation}@<B>::value;
 
   // \ref{meta.member}, member relationships
   template<class S, class M>
@@ -628,7 +628,7 @@
 
 \pnum
 Each of these templates shall be a
-\oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\oldconceptref{UnaryTypeTrait}
 with a base characteristic of
 \tcode{true_type} if the corresponding condition is \tcode{true}, otherwise
 \tcode{false_type}.
@@ -658,17 +658,14 @@
 \topline
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endhead
-\indexlibraryglobal{is_void}%
 \tcode{template<class T>}\br
- \tcode{struct is_void;}                &
+ \tcode{struct \libglobal{is_void};}                &
 \tcode{T} is \keyword{void}       &   \\ \rowsep
-\indexlibraryglobal{is_null_pointer}%
 \tcode{template<class T>}\br
- \tcode{struct is_null_pointer;}                &
+ \tcode{struct \libglobal{is_null_pointer};}                &
 \tcode{T} is \tcode{nullptr_t}\iref{basic.fundamental}       &   \\ \rowsep
-\indexlibraryglobal{is_integral}%
 \tcode{template<class T>}\br
- \tcode{struct is_integral;}        &
+ \tcode{struct \libglobal{is_integral};}        &
 \tcode{T} is an integral type\iref{basic.fundamental}                 &   \\ \rowsep
 \indexlibraryglobal{is_floating_point}%
 \tcode{template<class T>}\br
@@ -874,9 +871,8 @@
  \tcode{T} is an abstract class\iref{class.abstract}                              &
  If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type.                \\ \rowsep
 
-\indexlibraryglobal{is_final}%
 \tcode{template<class T>}\br
- \tcode{struct is_final;}               &
+ \tcode{struct \libglobal{is_final};}               &
  \tcode{T} is a class type marked with the \grammarterm{class-virt-specifier}
  \tcode{final}\iref{class.pre}.
 \begin{tailnote}
@@ -886,9 +882,8 @@
 &
  If \tcode{T} is a class type, \tcode{T} shall be a complete type.                          \\ \rowsep
 
-\indexlibraryglobal{is_aggregate}%
 \tcode{template<class T>}\br
-  \tcode{struct is_aggregate;}           &
+  \tcode{struct \libglobal{is_aggregate};}           &
  \tcode{T} is an aggregate type\iref{dcl.init.aggr} &
  \tcode{T} shall be an array type, a complete type, or \cv~\keyword{void}.              \\ \rowsep
 
@@ -899,16 +894,14 @@
   \tcode{T(-1) < T(0)};
   otherwise, \tcode{false}   &   \\  \rowsep
 
-\indexlibraryglobal{is_unsigned}%
 \tcode{template<class T>}\br
-  \tcode{struct is_unsigned;}            &
+  \tcode{struct \libglobal{is_unsigned};}            &
   If \tcode{is_arithmetic_v<T>} is \tcode{true}, the same result as
   \tcode{T(0) < T(-1)};
   otherwise, \tcode{false}   &   \\  \rowsep
 
-\indexlibraryglobal{is_bounded_array}%
 \tcode{template<class T>}\br
-  \tcode{struct is_bounded_array;}       &
+  \tcode{struct \libglobal{is_bounded_array};}       &
   \tcode{T} is an array type of known bound\iref{dcl.array}
                              &   \\  \rowsep
 
@@ -1402,7 +1395,7 @@
 \end{libreqtab2a}
 
 \pnum
-Each of these templates shall be a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts} with a
+Each of these templates shall be a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts} with a
 base characteristic of \tcode{integral_constant<size_t, Value>}.
 
 \pnum
@@ -1438,7 +1431,7 @@
 
 \pnum
 Each of these templates shall be a
-\oldconcept{BinaryTypeTrait}\iref{meta.rqmts}
+\oldconceptref{BinaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of
 \tcode{true_type} if the corresponding condition is true, otherwise
 \tcode{false_type}.
@@ -1452,7 +1445,7 @@
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endhead
 \tcode{template<class T, class U>}\br
- \tcode{struct is_same;}                    &
+ \tcode{struct \libglobal{is_same};}                    &
  \tcode{T} and \tcode{U} name the same type with the same cv-qualifications                            &   \\ \rowsep
 
 \indexlibraryglobal{is_base_of}%
@@ -1632,7 +1625,7 @@
 
 \pnum
 Each of the templates in \ref{meta.trans} shall be a
-\oldconcept{TransformationTrait}\iref{meta.rqmts}.
+\oldconceptref{TransformationTrait}\iref{meta.rqmts}.
 
 \rSec3[meta.trans.cv]{Const-volatile modifications}
 
@@ -1906,23 +1899,23 @@
 \endhead
 
 \tcode{template<class T>\br
- struct @\libglobal{type_identity}@;}
+ struct \libglobal{type_identity};}
  &
  The member typedef \tcode{type} denotes \tcode{T}. \\ \rowsep
 
-\tcode{template<class T>\br struct @\libglobal{remove_cvref}@;}
+\tcode{template<class T>\br struct \libglobal{remove_cvref};}
  &
  The member typedef \tcode{type} denotes
- \tcode{remove_cv_t<remove_reference_t<T>>}.
+ \tcode{\libglobalref{remove_cv_t}<\libglobalref{remove_reference_t}<T>>}.
  \\ \rowsep
 
-\tcode{template<class T>\br struct @\libglobal{decay}@;}
+\tcode{template<class T>\br struct \libglobal{decay};}
  &
- Let \tcode{U} be \tcode{remove_reference_t<T>}. If \tcode{is_array_v<U>} is
+ Let \tcode{U} be \tcode{\libglobalref{remove_reference_t}<T>}. If \tcode{\libglobalref{is_array_v}<U>} is
  \tcode{true}, the member typedef \tcode{type} denotes
- \tcode{remove_extent_t<U>*}. If \tcode{is_function_v<U>} is \tcode{true},
- the member typedef \tcode{type} denotes \tcode{add_pointer_t<U>}. Otherwise
- the member typedef \tcode{type} denotes \tcode{remove_cv_t<U>}.
+ \tcode{\libglobalref{remove_extent_t}<U>*}. If \tcode{\libglobalref{is_function_v}<U>} is \tcode{true},
+ the member typedef \tcode{type} denotes \tcode{\libglobalref{add_pointer_t}<U>}. Otherwise
+ the member typedef \tcode{type} denotes \tcode{\libglobalref{remove_cv_t}<U>}.
 \begin{tailnote}
 This behavior is similar to the lvalue-to-rvalue\iref{conv.lval},
 array-to-pointer\iref{conv.array}, and function-to-pointer\iref{conv.func}
@@ -1932,7 +1925,7 @@
 \end{tailnote}
  \\ \rowsep
 
-\tcode{template<bool B, class T = void>} \tcode{struct @\libglobal{enable_if}@;}
+\tcode{template<bool B, class T = void>} \tcode{struct \libglobal{enable_if};}
  &
  If \tcode{B} is \tcode{true}, the member typedef \tcode{type}
  denotes \tcode{T}; otherwise, there shall be no member
@@ -1940,7 +1933,7 @@
 
 \tcode{template<bool B, class T,}
  \tcode{class F>}\br
- \tcode{struct conditional;}
+ \tcode{struct \libglobal{conditional};}
  &
  If \tcode{B} is \tcode{true},  the member typedef \tcode{type} denotes \tcode{T}.
  If \tcode{B} is \tcode{false}, the member typedef \tcode{type} denotes \tcode{F}. \\ \rowsep
@@ -2007,7 +2000,7 @@
 \tcode{template<class T>} \tcode{struct unwrap_reference;}
  &
  If \tcode{T} is
- a specialization \tcode{reference_wrapper<X>} for some type \tcode{X},
+ a specialization \tcode{\libglobalref{reference_wrapper}<X>} for some type \tcode{X},
  the member typedef \tcode{type} of \tcode{unwrap_reference<T>}
  denotes \tcode{X\&},
  otherwise \tcode{type} denotes \tcode{T}. \\ \rowsep
@@ -2016,7 +2009,7 @@
 \tcode{template<class T>} \tcode{unwrap_ref_decay;}
  &
  The member typedef \tcode{type} of \tcode{unwrap_ref_decay<T>}
- denotes the type \tcode{unwrap_reference_t<decay_t<T>>}.\\
+ denotes the type \tcode{\libglobalref{unwrap_reference_t}<\libglobalref{decay_t}<T>>}.\\
 \end{libreqtab2a}
 
 \pnum
@@ -2034,7 +2027,7 @@
 Let:
 \begin{itemize}
 \item \tcode{\placeholdernc{CREF}(A)} be
-  \tcode{add_lvalue_reference_t<const remove_reference_t<A>{}>},
+  \tcode{\libglobalref{add_lvalue_reference_t}<const \libglobalref{remove_reference_t}<A>{}>},
 \item \tcode{\placeholdernc{XREF}(A)} denote a unary alias template \tcode{T}
   such that \tcode{T<U>} denotes the same type as \tcode{U} with the addition
   of \tcode{A}'s cv and reference qualifiers, for a non-reference cv-unqualified
@@ -2059,15 +2052,15 @@
     \placeholdernc{COPYCV}(\brk{}Y, X) \&)} if that type exists
   and is a reference type.
 \item Otherwise, let \tcode{C} be
-  \tcode{remove_reference_t<\placeholdernc{COMMON-REF}(X\&, Y\&)>\&\&}.
+  \tcode{\libglobalref{remove_reference_t}<\placeholdernc{COMMON-REF}(X\&, Y\&)>\&\&}.
   If \tcode{A} and \tcode{B} are both rvalue reference types,
   \tcode{C} is well-formed, and
-  \tcode{is_convertible_v<A, C> \&\& is_convertible_v<B, C>} is \tcode{true},
+  \tcode{\libglobalref{is_convertible_v}<A, C> \&\& \libglobalref{is_convertible_v}<B, C>} is \tcode{true},
   then \tcode{\placeholdernc{COMMON-REF}(A, B)} is \tcode{C}.
 \item Otherwise, let \tcode{D} be
   \tcode{\placeholdernc{COMMON-REF}(const X\&, Y\&)}. If \tcode{A} is an rvalue
   reference and \tcode{B} is an lvalue reference and \tcode{D} is
-  well-formed and \tcode{is_convertible_v<A, D>} is
+  well-formed and \tcode{\libglobalref{is_convertible_v}<A, D>} is
   \tcode{true}, then \tcode{\placeholdernc{COMMON-REF}(A, B)} is \tcode{D}.
 \item Otherwise, if \tcode{A} is an lvalue reference and \tcode{B}
   is an rvalue reference, then \tcode{\placeholdernc{COMMON-REF}(A, B)} is
@@ -2366,7 +2359,7 @@
 The class template \tcode{negation}
 forms the logical negation of its template type argument.
 The type \tcode{negation<B>}
-is a \oldconcept{UnaryTypeTrait} with a base characteristic of \tcode{bool_constant<!bool(B::\brk{}value)>}.
+is a \oldconceptref{UnaryTypeTrait} with a base characteristic of \tcode{bool_constant<!bool(B::\brk{}value)>}.
 \end{itemdescr}
 
 \rSec2[meta.member]{Member relationships}
diff --git a/source/numerics.tex b/source/numerics.tex
index 15a0d810e3..eccc25131e 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -40,10 +40,10 @@
 A \Cpp{} program shall instantiate these components only with a numeric type.
 A \defnadj{numeric}{type} is a cv-unqualified object type \tcode{T}
 that meets the
-\oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable}, and
-\oldconcept{Destructible}
+\oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable}, and
+\oldconceptref{Destructible}
 requirements\iref{utility.arg.requirements}.
 \begin{footnote}
 In other words, value types.
@@ -2074,8 +2074,8 @@
 
 \pnum
 \tcode{E} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 These operations shall each be of complexity
 no worse than \bigoh{\text{size of state}}.
 
@@ -2444,8 +2444,8 @@
 
 \pnum
 \tcode{D} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 
 \pnum
 The sequence of numbers
@@ -2476,10 +2476,10 @@
 
 \pnum
 \tcode{P} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}),
 and
-\oldconcept{Equality\-Comp\-arable} (\tref{cpp17.equalitycomparable}) requirements.
+\oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 For each of the constructors of \tcode{D}
@@ -4155,7 +4155,7 @@
 \pnum
 \expects
   \tcode{InputIterator} meets the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
 
 \pnum
 \effects
@@ -4182,7 +4182,7 @@
 \pnum
 \expects
   \tcode{RandomAccessIterator} meets the
-  \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   and the requirements of a mutable iterator.
 
 \pnum
@@ -4295,7 +4295,7 @@
 \pnum
 \expects
   \tcode{OutputIterator} meets the
-  \oldconcept{OutputIterator} requirements\iref{output.iterators}.
+  \oldconceptref{OutputIterator} requirements\iref{output.iterators}.
 
 \pnum
 \effects
@@ -6288,7 +6288,7 @@
 \pnum
 \expects
   \tcode{InputIterator} meets the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
  If \tcode{firstW == lastW},
  let $n = 1$ and $w_0 = 1$.
  Otherwise,
@@ -6486,7 +6486,7 @@
 \expects
   \tcode{InputIteratorB} and \tcode{InputIteratorW}
    each meet the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
  If \tcode{firstB == lastB}
  or \tcode{++firstB == lastB},
  let $n = 1$,
@@ -6721,7 +6721,7 @@
 \expects
   \tcode{InputIteratorB} and \tcode{InputIteratorW}
    each meet the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
  If \tcode{firstB == lastB}
  or \tcode{++firstB == lastB},
  let $n = 1$,
@@ -9067,12 +9067,12 @@
 \pnum
 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}
+\oldconceptref{RandomAccessIterator}\iref{random.access.iterators}
 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}
+\oldconceptref{RandomAccessIterator}
 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/regex.tex b/source/regex.tex
index 031a06c2cd..3af88ca780 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -1954,7 +1954,7 @@
 \pnum
 \expects
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{Swappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -2542,7 +2542,7 @@
 \pnum
 \expects
 \tcode{ready() == true} and \tcode{OutputIter} meets the requirements for a
-\oldconcept{OutputIterator}\iref{output.iterators}.
+\oldconceptref{OutputIterator}\iref{output.iterators}.
 
 \pnum
 \effects
diff --git a/source/strings.tex b/source/strings.tex
index 3e7d1c2cd4..2569d932b7 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -239,10 +239,10 @@
 \pnum
 \expects
 \tcode{state_type} meets the
-\oldconcept{Destructible} (\tref{cpp17.destructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}), and
-\oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}) requirements.
+\oldconceptref{Destructible} (\tref{cpp17.destructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}), and
+\oldconceptref{DefaultConstructible} (\tref{cpp17.defaultconstructible}) requirements.
 \end{itemdescr}
 
 \rSec2[char.traits.specializations]{\tcode{char_traits} specializations}
@@ -927,7 +927,7 @@
 \pnum
 A type that meets the requirements
 of a constant
-\oldconcept{RandomAccessIterator}\iref{random.access.iterators},
+\oldconceptref{RandomAccessIterator}\iref{random.access.iterators},
 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/support.tex b/source/support.tex
index 4c577bd4be..7b77df91a1 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -3398,11 +3398,11 @@
 
 \pnum
 The type \tcode{source_location} meets the
-\oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
-\oldconcept{Copy\-Assignable},
-\oldconcept{Swappable}, and
-\oldconcept{Destructible}
+\oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable},
+\oldconceptref{Swappable}, and
+\oldconceptref{Destructible}
 requirements\iref{utility.arg.requirements,swappable.requirements}.
 All of the following conditions are \tcode{true}:
 \begin{itemize}
@@ -3860,7 +3860,7 @@
 
 \pnum
 \tcode{exception_ptr} meets the requirements of
-\oldconcept{NullablePointer} (\tref{cpp17.nullablepointer}).
+\oldconceptref{NullablePointer} (\tref{cpp17.nullablepointer}).
 
 \pnum
 Two non-null values of type \tcode{exception_ptr} are equivalent and compare equal if and
@@ -4057,7 +4057,7 @@
 
 \pnum
 \expects
-\tcode{U} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{U} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \throws
diff --git a/source/threads.tex b/source/threads.tex
index e74ae4f8bd..e7cab4222a 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -41,7 +41,7 @@
 \tcode{false} otherwise.
 If a template parameter is named \tcode{Clock},
 the corresponding template argument shall be a type \tcode{C}
-that meets the \oldconcept{Clock} requirements\iref{time.clock.req};
+that meets the \oldconceptref{Clock} requirements\iref{time.clock.req};
 the program is ill-formed if \tcode{is_clock_v<C>} is \tcode{false}.
 
 \rSec2[thread.req.exception]{Exceptions}
@@ -156,7 +156,7 @@
 
 \pnum
 Implementation-provided clocks that are used for these functions meet the
-\oldconcept{TrivialClock} requirements\iref{time.clock.req}.
+\oldconceptref{TrivialClock} requirements\iref{time.clock.req}.
 
 \pnum
 A function that takes an argument which specifies a timeout will throw if,
@@ -195,10 +195,10 @@
 \tcode{lock_guard}\iref{thread.lock.guard}, \tcode{lock},
 \tcode{try_lock}\iref{thread.lock.algorithm}, and
 \tcode{condition_variable_any}\iref{thread.condition.condvarany} all operate on user-supplied
-lockable objects. The \oldconcept{BasicLockable} requirements, the \oldconcept{Lockable} requirements,
-the \oldconcept{TimedLockable} requirements,
-the \oldconcept{SharedLockable} requirements, and
-the \oldconcept{SharedTimedLock\-able} requirements
+lockable objects. The \oldconceptref{BasicLockable} requirements, the \oldconceptref{Lockable} requirements,
+the \oldconceptref{TimedLockable} requirements,
+the \oldconceptref{SharedLockable} requirements, and
+the \oldconceptref{SharedTimedLockable} requirements
 list the requirements imposed by these library types
 in order to acquire or release ownership of a \tcode{lock} by a given execution agent.
 \begin{note}
@@ -266,7 +266,7 @@
 \rSec3[thread.req.lockable.req]{\oldconcept{Lockable} requirements}
 
 \pnum
-A type \tcode{L} meets the \defnoldconcept{Lockable} requirements if it meets the \oldconcept{BasicLockable}
+A type \tcode{L} meets the \defnoldconcept{Lockable} requirements if it meets the \oldconceptref{BasicLockable}
 requirements and the following expressions are well-formed and have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L}).
 
@@ -291,7 +291,7 @@
 \rSec3[thread.req.lockable.timed]{\oldconcept{TimedLockable} requirements}
 
 \pnum
-A type \tcode{L} meets the \defnoldconcept{TimedLockable} requirements if it meets the \oldconcept{Lockable}
+A type \tcode{L} meets the \defnoldconcept{TimedLockable} requirements if it meets the \oldconceptref{Lockable}
 requirements and the following expressions are well-formed and have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L}, \tcode{rel_time} denotes a value of an
 instantiation of \link{\tcode{duration}}{time.duration}, and \tcode{abs_time} denotes a value
@@ -397,7 +397,7 @@
 
 \pnum
 A type \tcode{L} meets the \defnoldconcept{SharedTimedLockable} requirements if
-it meets the \oldconcept{SharedLockable} requirements, and
+it meets the \oldconceptref{SharedLockable} requirements, and
 the following expressions are well-formed, have type \tcode{bool}, and
 have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L},
@@ -4050,7 +4050,7 @@
 \indexlibraryglobal{atomic}%
 \pnum
 The template argument for \tcode{T} shall meet the
-\oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} requirements.
+\oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements.
 The program is ill-formed if any of
 \begin{itemize}
 \item \tcode{is_trivially_copyable_v<T>},
@@ -6527,11 +6527,11 @@
 They meet the requirements set out in \ref{thread.mutex.requirements.mutex}.
 In this description, \tcode{m} denotes an object of a mutex type.
 \begin{note}
-The mutex types meet the \oldconcept{Lockable} requirements\iref{thread.req.lockable.req}.
+The mutex types meet the \oldconceptref{Lockable} requirements\iref{thread.req.lockable.req}.
 \end{note}
 
 \pnum
-The mutex types meet \oldconcept{DefaultConstructible} and \oldconcept{Destructible}.
+The mutex types meet \oldconceptref{DefaultConstructible} and \oldconceptref{Destructible}.
 If initialization of an object of a mutex type fails,
 an exception of type \tcode{system_error} is thrown.
 The mutex types are neither copyable nor movable.
@@ -6800,7 +6800,7 @@
 object of an
 instantiation of \link{\tcode{time_point}}{time.point}.
 \begin{note}
-The timed mutex types meet the \oldconcept{TimedLockable}
+The timed mutex types meet the \oldconceptref{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
 \end{note}
 
@@ -7012,7 +7012,7 @@
 meet the requirements set out below. In this description,
 \tcode{m} denotes an object of a shared mutex type.
 \begin{note}
-The shared mutex types meet the \oldconcept{SharedLockable}
+The shared mutex types meet the \oldconceptref{SharedLockable}
 requirements\iref{thread.req.lockable.shared}.
 \end{note}
 
@@ -7189,7 +7189,7 @@
 \tcode{abs_time} denotes an object of an instantiation of
 \link{\tcode{time_point}}{time.point}.
 \begin{note}
-The shared timed mutex types meet the \oldconcept{SharedTimedLockable}
+The shared timed mutex types meet the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 \end{note}
 
@@ -7399,7 +7399,7 @@
 object throughout the \tcode{lock_guard} object's \deflink{lifetime}{basic.life}.
 The behavior of a program is undefined if the lockable object referenced by
 \tcode{pm} does not exist for the entire lifetime of the \tcode{lock_guard}
-object. The supplied \tcode{Mutex} type shall meet the \oldconcept{BasicLockable}
+object. The supplied \tcode{Mutex} type shall meet the \oldconceptref{BasicLockable}
 requirements\iref{thread.req.lockable.basic}.
 
 \indexlibraryctor{lock_guard}%
@@ -7478,12 +7478,12 @@
 If \tcode{sizeof...(MutexTypes)} is one,
 let \tcode{Mutex} denote the sole type constituting the pack \tcode{MutexTypes}.
 \tcode{Mutex}
-shall meet the \oldconcept{BasicLockable} requirements\iref{thread.req.lockable.basic}.
+shall meet the \oldconceptref{BasicLockable} requirements\iref{thread.req.lockable.basic}.
 The member \grammarterm{typedef-name} \tcode{mutex_type}
 denotes the same type as \tcode{Mutex}.
 \item
 Otherwise, all types in the template parameter pack \tcode{MutexTypes}
-shall meet the \oldconcept{Lockable} requirements\iref{thread.req.lockable.req}
+shall meet the \oldconceptref{Lockable} requirements\iref{thread.req.lockable.req}
 and there is no member \tcode{mutex_type}.
 \end{itemize}
 
@@ -7598,17 +7598,17 @@
 \tcode{pm} is not null and the lockable object pointed
 to by \tcode{pm} does not exist for the entire remaining
 lifetime\iref{basic.life} of the \tcode{unique_lock} object. The supplied
-\tcode{Mutex} type shall meet the \oldconcept{BasicLockable}
+\tcode{Mutex} type shall meet the \oldconceptref{BasicLockable}
 requirements\iref{thread.req.lockable.basic}.
 
 \pnum
 \begin{note}
-\tcode{unique_lock<Mutex>} meets the \oldconcept{BasicLockable} requirements. If \tcode{Mutex}
-meets the \oldconcept{Lockable} requirements\iref{thread.req.lockable.req},
-\tcode{unique_lock<Mutex>} also meets the \oldconcept{Lockable} requirements;
+\tcode{unique_lock<Mutex>} meets the \oldconceptref{BasicLockable} requirements. If \tcode{Mutex}
+meets the \oldconceptref{Lockable} requirements\iref{thread.req.lockable.req},
+\tcode{unique_lock<Mutex>} also meets the \oldconceptref{Lockable} requirements;
 if \tcode{Mutex}
-meets the \oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed},
-\tcode{unique_lock<Mutex>} also meets the \oldconcept{TimedLockable} requirements.
+meets the \oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed},
+\tcode{unique_lock<Mutex>} also meets the \oldconceptref{TimedLockable} requirements.
 \end{note}
 
 \rSec4[thread.lock.unique.cons]{Constructors, destructor, and assignment}
@@ -7658,7 +7658,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{Lockable}
+The supplied \tcode{Mutex} type meets the \oldconceptref{Lockable}
 requirements\iref{thread.req.lockable.req}.
 
 \pnum
@@ -7700,7 +7700,7 @@
 \pnum
 \expects
 The supplied \tcode{Mutex} type meets the
-\oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed}.
+\oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed}.
 
 \pnum
 \effects
@@ -7722,7 +7722,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed}.
+The supplied \tcode{Mutex} type meets the \oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed}.
 
 \pnum
 \effects
@@ -7818,7 +7818,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} meets the \oldconcept{Lockable}
+The supplied \tcode{Mutex} meets the \oldconceptref{Lockable}
 requirements\iref{thread.req.lockable.req}.
 
 \pnum
@@ -7857,7 +7857,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{TimedLockable}
+The supplied \tcode{Mutex} type meets the \oldconceptref{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
 
 \pnum
@@ -7896,7 +7896,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed}.
+The supplied \tcode{Mutex} type meets the \oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed}.
 
 \pnum
 \effects
@@ -8089,16 +8089,16 @@
 is undefined if the contained pointer \tcode{pm} is not null and the lockable
 object pointed to by \tcode{pm} does not exist for the entire remaining
 lifetime\iref{basic.life} of the \tcode{shared_lock} object. The supplied
-\tcode{Mutex} type shall meet the \oldconcept{SharedLockable}
+\tcode{Mutex} type shall meet the \oldconceptref{SharedLockable}
 requirements\iref{thread.req.lockable.shared}.
 
 \pnum
 \begin{note}
-\tcode{shared_lock<Mutex>} meets the \oldconcept{Lockable}
+\tcode{shared_lock<Mutex>} meets the \oldconceptref{Lockable}
 requirements\iref{thread.req.lockable.req}.
-If \tcode{Mutex} meets the \oldconcept{Shared\-TimedLockable}
+If \tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed},
-\tcode{shared_lock<Mutex>} also meets the \oldconcept{TimedLockable}
+\tcode{shared_lock<Mutex>} also meets the \oldconceptref{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
 \end{note}
 
@@ -8183,7 +8183,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -8207,7 +8207,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -8334,7 +8334,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -8374,7 +8374,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -8513,7 +8513,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-Each template parameter type meets the \oldconcept{Lockable} requirements.
+Each template parameter type meets the \oldconceptref{Lockable} requirements.
 \begin{note}
 The
 \tcode{unique_lock} class template meets these requirements when suitably instantiated.
@@ -8542,7 +8542,7 @@
 \begin{itemdescr}
 \pnum
 \expects
-Each template parameter type meets the \oldconcept{Lockable} requirements.
+Each template parameter type meets the \oldconceptref{Lockable} requirements.
 \begin{note}
 The
 \tcode{unique_lock} class template meets these requirements when suitably instantiated.
@@ -9209,7 +9209,7 @@
 \pnum
 In \ref{thread.condition.condvarany},
 template arguments for template parameters named \tcode{Lock}
-shall meet the \oldconcept{Basic\-Lockable}
+shall meet the \oldconceptref{BasicLockable}
 requirements\iref{thread.req.lockable.basic}.
 \begin{note}
 All of the standard
@@ -10147,24 +10147,24 @@
 
 \pnum
 \tcode{CompletionFunction} shall meet the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+\oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 \tcode{is_nothrow_invocable_v<CompletionFunction\&>} shall be \tcode{true}.
 
 \pnum
 The default value of the \tcode{CompletionFunction} template parameter is
 an unspecified type, such that,
 in addition to satisfying the requirements of \tcode{CompletionFunction},
-it meets the \oldconcept{DefaultConstructible}
+it meets the \oldconceptref{DefaultConstructible}
 requirements (\tref{cpp17.defaultconstructible}) and
 \tcode{completion()} has no effects.
 
 \pnum
 \tcode{barrier::arrival_token} is an unspecified type,
 such that it meets the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}),
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+\oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}),
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}), and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 
 \indexlibrarymember{max}{barrier}%
 \begin{itemdecl}
@@ -10666,7 +10666,7 @@
 
 \pnum
 For the primary template, \tcode{R} shall be an object type that
-meets the \oldconcept{Destructible} requirements.
+meets the \oldconceptref{Destructible} requirements.
 
 \pnum
 The implementation provides the template \tcode{promise} and two specializations,
@@ -10691,7 +10691,7 @@
 \pnum
 \expects
 \tcode{Alloc} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 \end{itemdescr}
 
 \indexlibraryctor{promise}%
@@ -11012,7 +11012,7 @@
 
 \pnum
 For the primary template, \tcode{R} shall be an object type that
-meets the \oldconcept{Destructible} requirements.
+meets the \oldconceptref{Destructible} requirements.
 
 \pnum
 The implementation provides the template \tcode{future} and two specializations,
@@ -11318,7 +11318,7 @@
 
 \pnum
 For the primary template, \tcode{R} shall be an object type that
-meets the \oldconcept{Destructible} requirements.
+meets the \oldconceptref{Destructible} requirements.
 
 \pnum
 The implementation provides the template \tcode{shared_future} and two
@@ -12229,7 +12229,7 @@
 
 \pnum
 \tcode{D} shall meet the requirements for
-\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}.
+\oldconceptref{DefaultConstructible} and \oldconceptref{MoveAssignable}.
 
 \pnum
 If \tcode{D} is trivially copyable,
@@ -12287,7 +12287,7 @@
 
 \pnum
 This class meets the requirements of
-\oldconcept{Lockable}\iref{thread.req.lockable.req} and
+\oldconceptref{Lockable}\iref{thread.req.lockable.req} and
 provides regions of RCU protection.
 \begin{example}
 \begin{codeblock}
@@ -12435,8 +12435,8 @@
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{MoveConstructible} and
-\oldconcept{Destructible} requirements.
+\tcode{D} meets the \oldconceptref{MoveConstructible} and
+\oldconceptref{Destructible} requirements.
 
 \pnum
 \effects
@@ -12628,7 +12628,7 @@
 
 \pnum
 \tcode{D} shall meet the requirements for
-\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}.
+\oldconceptref{DefaultConstructible} and \oldconceptref{MoveAssignable}.
 
 \pnum
 \tcode{T} may be an incomplete type.
diff --git a/source/time.tex b/source/time.tex
index 9646aaf6fc..357d3c6ba9 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -1039,13 +1039,13 @@
 A type \tcode{TC} meets the \defnoldconcept{TrivialClock} requirements if
 \begin{itemize}
 \item
-\tcode{TC} meets the \oldconcept{Clock} requirements,
+\tcode{TC} meets the \oldconceptref{Clock} requirements,
 
 \item
 the types \tcode{TC::rep}, \tcode{TC::duration}, and \tcode{TC::time_point}
-meet the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) and
-\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable})
-and \oldconcept{Swappable}\iref{swappable.requirements}
+meet the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) and
+\oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable})
+and \oldconceptref{Swappable}\iref{swappable.requirements}
 requirements and the requirements of
 numeric types\iref{numeric.requirements},
 \begin{note}
@@ -1203,15 +1203,15 @@
 \end{itemdecl}
 
 \pnum
-\tcode{is_clock} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\tcode{is_clock} is a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of \tcode{true_type}
-if \tcode{T} meets the \oldconcept{Clock} requirements\iref{time.clock.req},
+if \tcode{T} meets the \oldconceptref{Clock} requirements\iref{time.clock.req},
 otherwise \tcode{false_type}.
 For the purposes of the specification of this trait,
 the extent to which an implementation determines
-that a type cannot meet the \oldconcept{Clock} requirements is unspecified,
+that a type cannot meet the \oldconceptref{Clock} requirements is unspecified,
 except that as a minimum
-a type \tcode{T} shall not qualify as a \oldconcept{Clock}
+a type \tcode{T} shall not qualify as a \oldconceptref{Clock}
 unless it meets all of the following conditions:
 \begin{itemize}
 \item the \grammarterm{qualified-id}s
@@ -2632,7 +2632,7 @@
 
 \pnum
 The types defined in \ref{time.clock} meet the
-\oldconcept{TrivialClock}
+\oldconceptref{TrivialClock}
 requirements\iref{time.clock.req}
 unless otherwise specified.
 
@@ -2850,7 +2850,7 @@
 \end{example}
 
 \pnum
-\tcode{utc_clock} is not a \oldconcept{TrivialClock}
+\tcode{utc_clock} is not a \oldconceptref{TrivialClock}
 unless the implementation can guarantee that \tcode{utc_clock::now()}
 does not propagate an exception.
 \begin{note}
@@ -3069,7 +3069,7 @@
 (22s plus the initial 10s offset).
 
 \pnum
-\tcode{tai_clock} is not a \oldconcept{TrivialClock}
+\tcode{tai_clock} is not a \oldconceptref{TrivialClock}
 unless the implementation can guarantee that \tcode{tai_clock::now()}
 does not propagate an exception.
 \begin{note}
@@ -3231,7 +3231,7 @@
 and the additional 9 leap seconds inserted between 1970 and 1980.
 
 \pnum
-\tcode{gps_clock} is not a \oldconcept{TrivialClock}
+\tcode{gps_clock} is not a \oldconceptref{TrivialClock}
 unless the implementation can guarantee that
 \tcode{gps_clock::now()} does not propagate an exception.
 \begin{note}
@@ -3368,7 +3368,7 @@
 
 \pnum
 \tcode{file_clock} is an alias for a type
-meeting the \oldconcept{TrivialClock} requirements\iref{time.clock.req}, and
+meeting the \oldconceptref{TrivialClock} requirements\iref{time.clock.req}, and
 using a signed arithmetic type for \tcode{file_clock::rep}.
 \tcode{file_clock} is used to create the \tcode{time_point} system
 used for \tcode{file_time_type}\iref{filesystems}.
@@ -3971,8 +3971,8 @@
 but may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{day}'s unspecified internal storage.
-\tcode{day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{day} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
 and participates in basic arithmetic with \tcode{days} objects,
 which represent a difference between two \tcode{day} objects.
 
@@ -4264,8 +4264,8 @@
 but may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{month}'s unspecified internal storage.
-\tcode{month} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{month} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
 and participates in basic arithmetic with \tcode{months} objects,
 which represent a difference between two \tcode{month} objects.
 
@@ -4574,8 +4574,8 @@
 It can represent values in the range \crange{min()}{max()}.
 It can be constructed with any \tcode{int} value,
 which will be subsequently truncated to fit into \tcode{year}'s unspecified internal storage.
-\tcode{year} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{year} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
 and participates in basic arithmetic with \tcode{years} objects,
 which represent a difference between two \tcode{year} objects.
 
@@ -4929,10 +4929,10 @@
 it may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{weekday}'s unspecified internal storage.
-\tcode{weekday} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{weekday} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 \begin{note}
 \tcode{weekday} is not
-\oldconcept{LessThanComparable}
+\oldconceptref{LessThanComparable}
 because there is no universal consensus on which day is the first day of the week.
 \tcode{weekday}'s arithmetic operations treat the days of the week as a circular range,
 with no beginning and no end.
@@ -5512,8 +5512,8 @@
 \pnum
 \tcode{month_day} represents a specific day of a specific month,
 but with an unspecified year.
-\tcode{month_day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{month_day} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{month_day} is a trivially copyable and standard-layout class type.
@@ -6013,8 +6013,8 @@
 \tcode{year_month} represents a specific month of a specific year,
 but with an unspecified day.
 \tcode{year_month} is a field-based time point with a resolution of \tcode{months}.
-\tcode{year_month} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{year_month} is a trivially copyable and standard-layout class type.
@@ -6369,8 +6369,8 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month_day} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{year_month_day} is a trivially copyable and standard-layout class type.
@@ -6830,8 +6830,8 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day_last} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month_day_last} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{year_month_day_last} is a trivially copyable and standard-layout class type.
@@ -7201,7 +7201,7 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{year_month_weekday} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 \tcode{year_month_weekday} is a trivially copyable and standard-layout class type.
@@ -7594,7 +7594,7 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday_last} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{year_month_weekday_last} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 \tcode{year_month_weekday_last} is a trivially copyable and standard-layout class type.
@@ -8844,7 +8844,7 @@
 
 \pnum
 \tcode{tzdb_list::const_iterator} is a constant iterator
-which meets the \oldconcept{ForwardIterator} requirements
+which meets the \oldconceptref{ForwardIterator} requirements
 and has a value type of \tcode{tzdb}.
 
 \indexlibrarymember{front}{tzdb_list}%
@@ -11551,7 +11551,7 @@
 The specializations are enabled\iref{unord.hash}.
 \begin{note}
 All the \tcode{hash<Key>} specializations listed above meet the
-\oldconcept{Hash} requirements, even when called on objects \tcode{k}
+\oldconceptref{Hash} requirements, even when called on objects \tcode{k}
 of type \tcode{Key} such that \tcode{k.ok()} is \tcode{false}.
 \end{note}
 \end{itemdescr}
diff --git a/source/utilities.tex b/source/utilities.tex
index e9bc071854..aa07763d53 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -247,9 +247,9 @@
 Type
 \tcode{T}
 meets the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible})
+\oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible})
 and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable})
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable})
 requirements.
 
 \pnum
@@ -2116,7 +2116,7 @@
 \pnum
 \expects
 \tcode{Alloc} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \effects
@@ -2746,7 +2746,7 @@
 \pnum
 Except where specified otherwise,
 all specializations of \tcode{tuple_size} meet the
-\oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
+\oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
 base characteristic of \tcode{integral_constant<size_t, N>}
 for some \tcode{N}.
 \end{itemdescr}
@@ -2787,7 +2787,7 @@
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
 when treated as an \deflink{unevaluated operand}{expr.context}, then
-each specialization of the template meets the \oldconcept{Unary\-Type\-Trait} requirements\iref{meta.rqmts}
+each specialization of the template meets the \oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}
 with a base characteristic of
 \begin{codeblock}
 integral_constant<size_t, TS::value>
@@ -2824,7 +2824,7 @@
 \begin{itemdescr}
 \pnum
 Let \tcode{TE} denote \tcode{tuple_element_t<I, T>} of the cv-unqualified type \tcode{T}. Then
-each specialization of the template meets the \oldconcept{TransformationTrait} requirements\iref{meta.rqmts}
+each specialization of the template meets the \oldconceptref{TransformationTrait} requirements\iref{meta.rqmts}
 with a member typedef \tcode{type} that names the type \tcode{add_const_t<TE>}.
 
 \pnum
@@ -3103,7 +3103,7 @@
 \pnum
 \expects
 \tcode{Alloc} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \begin{note}
@@ -3357,7 +3357,7 @@
 \pnum
 \tcode{T} shall be a type
 other than \cv{} \tcode{in_place_t} or \cv{} \tcode{nullopt_t}
-that meets the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+that meets the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 
 \rSec3[optional.ctor]{Constructors}
 
@@ -3975,7 +3975,7 @@
 
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{Swappable} requirements\iref{swappable.requirements}.
+\tcode{T} meets the \oldconceptref{Swappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -4032,7 +4032,7 @@
 \pnum
 These types
 model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
-meet the \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}, and
+meet the \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}, and
 meet the requirements for constexpr iterators\iref{iterator.requirements.general},
 with value type \tcode{remove_cv_t<T>}.
 The reference type is \tcode{T\&} for \tcode{iterator} and
@@ -4472,7 +4472,7 @@
 The expression \tcode{*x == *y} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
-\tcode{T} need not be \oldconcept{EqualityComparable}.
+\tcode{T} need not be \oldconceptref{EqualityComparable}.
 \end{note}
 
 \pnum
@@ -4662,7 +4662,7 @@
 The expression \tcode{*x == v} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
-\tcode{T} need not be \oldconcept{EqualityComparable}.
+\tcode{T} need not be \oldconceptref{EqualityComparable}.
 \end{note}
 
 \pnum
@@ -5139,7 +5139,7 @@
 
 \pnum
 All types in \tcode{Types} shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 
 \pnum
 A program that instantiates the definition of \tcode{variant} with
@@ -5819,7 +5819,7 @@
 
 \pnum
 \expects
-Each $\tcode{T}_i$ meets the \oldconcept{Swappable} requirements\iref{swappable.requirements}.
+Each $\tcode{T}_i$ meets the \oldconceptref{Swappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -5864,7 +5864,7 @@
 \begin{itemdescr}
 \pnum
 All specializations of \tcode{variant_size} meet the
-\oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts}
+\oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}
 with a base characteristic of \tcode{integral_constant<size_t, N>} for some \tcode{N}.
 \end{itemdescr}
 
@@ -5877,7 +5877,7 @@
 \pnum
 Let \tcode{VS} denote \tcode{variant_size<T>} of the cv-unqualified
 type \tcode{T}. Then each specialization of the template meets the
-\oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
+\oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
 base characteristic of \tcode{integral_constant<size_t, VS::value>}.
 \end{itemdescr}
 
@@ -5897,7 +5897,7 @@
 \pnum
 Let \tcode{VA} denote \tcode{variant_alternative<I, T>} of the
 cv-unqualified type \tcode{T}. Then each specialization of the template
-meets the \oldconcept{TransformationTrait} requirements\iref{meta.rqmts} with a
+meets the \oldconceptref{TransformationTrait} requirements\iref{meta.rqmts} with a
 member typedef \tcode{type} that names the type \tcode{add_const_t<VA::type>}.
 \end{itemdescr}
 
@@ -6623,7 +6623,7 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -6651,7 +6651,7 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -6684,7 +6684,7 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -6769,7 +6769,7 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -6804,7 +6804,7 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -6848,7 +6848,7 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -7552,9 +7552,9 @@
 
 \pnum
 When \tcode{T} is not \cv{} \tcode{void}, it shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 \tcode{E} shall meet
-the \oldconcept{Destructible} requirements.
+the \oldconceptref{Destructible} requirements.
 
 \rSec3[expected.object.cons]{Constructors}
 
@@ -8791,7 +8791,7 @@
 The expression \tcode{*x == v} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
-\tcode{T} need not be \oldconcept{EqualityComparable}.
+\tcode{T} need not be \oldconceptref{EqualityComparable}.
 \end{note}
 
 \pnum
@@ -8929,7 +8929,7 @@
 
 \pnum
 \tcode{E} shall meet the requirements of
-\oldconcept{Destructible} (\tref{cpp17.destructible}).
+\oldconceptref{Destructible} (\tref{cpp17.destructible}).
 
 \rSec3[expected.void.cons]{Constructors}
 
@@ -10959,8 +10959,8 @@
 \indextext{call wrapper}%
 \indextext{call wrapper!simple}%
 \indextext{call wrapper!forwarding}%
-Every call wrapper\iref{func.def} meets the \oldconcept{MoveConstructible}
-and \oldconcept{Destructible} requirements.
+Every call wrapper\iref{func.def} meets the \oldconceptref{MoveConstructible}
+and \oldconceptref{Destructible} requirements.
 An \defn{argument forwarding call wrapper} is a
 call wrapper that can be called with an arbitrary argument list
 and delivers the arguments to the target object as references.
@@ -11000,7 +11000,7 @@
 \pnum
 \label{term.simple.call.wrapper}%
 A \defn{simple call wrapper} is a perfect forwarding call wrapper that meets
-the \oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} requirements
+the \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements
 and whose copy constructor, move constructor, and assignment operators
 are constexpr functions that do not throw exceptions.
 
@@ -11103,7 +11103,7 @@
 \end{codeblock}
 
 \pnum
-\tcode{reference_wrapper<T>} is a \oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} wrapper
+\tcode{reference_wrapper<T>} is a \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} wrapper
 around a reference to an object or function of type \tcode{T}.
 
 \pnum
@@ -12557,7 +12557,7 @@
 
 \pnum
 \expects
-\tcode{FD} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{FD} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \returns
@@ -12643,10 +12643,10 @@
 
 \pnum
 \expects
-\tcode{FD} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{FD} meets the \oldconceptref{MoveConstructible} requirements.
 For each $\tcode{T}_i$ in \tcode{BoundArgs},
 if $\tcode{T}_i$ is an object type,
-$\tcode{T}_i$ meets the \oldconcept{MoveConstructible} requirements.
+$\tcode{T}_i$ meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \returns
@@ -12712,7 +12712,7 @@
 \pnum
 \expects
 For each $\tcode{T}_i$ in \tcode{BoundArgs},
-$\tcode{T}_i$ meets the \oldconcept{MoveConstructible} requirements.
+$\tcode{T}_i$ meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \returns
@@ -12757,7 +12757,7 @@
 
 \pnum
 Specializations of the \tcode{is_bind_expression} template shall meet
-the \oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
+the \oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
 provides a definition that has a base characteristic of
 \tcode{true_type} if \tcode{T} is a type returned from \tcode{bind},
 otherwise it has a base characteristic of \tcode{false_type}.
@@ -12793,7 +12793,7 @@
 
 \pnum
 Specializations of the \tcode{is_placeholder} template shall meet
-the \oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
+the \oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
 provides a definition that has the base characteristic of
 \tcode{integral_constant<int, \placeholder{J}>} if \tcode{T} is the type of
 \tcode{std::placeholders::_\placeholder{J}}, otherwise it has a
@@ -12843,7 +12843,7 @@
 \pnum
 \expects
 \tcode{FD} and each $\tcode{TD}_i$ meet
-the \oldconcept{MoveConstructible} and \oldconcept{Destructible} requirements.
+the \oldconceptref{MoveConstructible} and \oldconceptref{Destructible} requirements.
 \tcode{\placeholdernc{INVOKE}(fd, $\tcode{w}_1$, $\tcode{w}_2$, $\dotsc$,
 $\tcode{w}_N$)}\iref{func.require} is a valid expression for some
 values $\tcode{w}_1$, $\tcode{w}_2$, $\dotsc{}$, $\tcode{w}_N$, where
@@ -12879,8 +12879,8 @@
 \pnum
 \begin{note}
 If all of \tcode{FD} and $\tcode{TD}_i$ meet
-the requirements of \oldconcept{CopyConstructible}, then
-the return type meets the requirements of \oldconcept{CopyConstructible}.
+the requirements of \oldconceptref{CopyConstructible}, then
+the return type meets the requirements of \oldconceptref{CopyConstructible}.
 \end{note}
 \end{itemdescr}
 
@@ -12951,13 +12951,13 @@
 \impldef{number of placeholders for bind expressions}.
 
 \pnum
-All placeholder types meet the \oldconcept{DefaultConstructible} and
-\oldconcept{CopyConstructible} requirements, and
+All placeholder types meet the \oldconceptref{DefaultConstructible} and
+\oldconceptref{CopyConstructible} requirements, and
 their default constructors and copy/move
 constructors are constexpr functions that
 do not throw exceptions. It is \impldef{assignability of placeholder
 objects} whether
-placeholder types meet the \oldconcept{CopyAssignable} requirements,
+placeholder types meet the \oldconceptref{CopyAssignable} requirements,
 but if so, their copy assignment operators are
 constexpr functions that do not throw exceptions.
 
@@ -13238,7 +13238,7 @@
 
 \pnum
 \expects
-\tcode{FD} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{FD} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -13664,9 +13664,9 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} requirements, and
+\tcode{VT} meets the \oldconceptref{Destructible} requirements, and
 if \tcode{is_move_constructible_v<VT>} is \tcode{true},
-\tcode{VT} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \ensures
@@ -13716,9 +13716,9 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} requirements, and
+\tcode{VT} meets the \oldconceptref{Destructible} requirements, and
 if \tcode{is_move_constructible_v<VT>} is \tcode{true},
-\tcode{VT} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \ensures
@@ -13758,9 +13758,9 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} requirements, and
+\tcode{VT} meets the \oldconceptref{Destructible} requirements, and
 if \tcode{is_move_constructible_v<VT>} is \tcode{true},
-\tcode{VT} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \ensures
@@ -14082,8 +14082,8 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} and
-\oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{Destructible} and
+\oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -14138,8 +14138,8 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} and
-\oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{Destructible} and
+\oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -14184,8 +14184,8 @@
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} and
-\oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{Destructible} and
+\oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -14700,7 +14700,7 @@
 
 \pnum
 Each specialization of a class template specified in \ref{func.search}
-shall meet the \oldconcept{CopyConst\-ruct\-ible} and \oldconcept{CopyAssignable} requirements.
+shall meet the \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements.
 Template parameters named
 \begin{itemize}
 \item \tcode{ForwardIterator},
@@ -14714,7 +14714,7 @@
 of templates specified in
 \ref{func.search} shall meet the same requirements and semantics as
 specified in \ref{algorithms.general}.
-Template parameters named \tcode{Hash} shall meet the \oldconcept{Hash}
+Template parameters named \tcode{Hash} shall meet the \oldconceptref{Hash}
 requirements (\tref{cpp17.hash}).
 
 \pnum
@@ -14823,9 +14823,9 @@
 \pnum
 \expects
 The value type of \tcode{RandomAccessIterator1} meets
-the \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible}, and
-\oldconcept{CopyAssignable} requirements.
+the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible}, and
+\oldconceptref{CopyAssignable} requirements.
 
 \pnum
 Let \tcode{V} be \tcode{iterator_traits<RandomAccessIterator1>::val\-ue_type}.
@@ -14924,8 +14924,8 @@
 \begin{itemdescr}
 \pnum
 \expects
-The value type of \tcode{RandomAccessIterator1} meets the \oldconcept{DefaultConstructible},
-\oldconcept{Copy\-Constructible}, and \oldconcept{CopyAssignable} requirements.
+The value type of \tcode{RandomAccessIterator1} meets the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible}, and \oldconceptref{CopyAssignable} requirements.
 
 \pnum
 Let \tcode{V} be \tcode{iterator_traits<RandomAccessIterator1>::val\-ue_type}.
@@ -14998,7 +14998,7 @@
 Each specialization of \tcode{hash} is either enabled or disabled,
 as described below.
 \begin{note}
-Enabled specializations meet the \oldconcept{Hash} requirements, and
+Enabled specializations meet the \oldconceptref{Hash} requirements, and
 disabled specializations do not.
 \end{note}
 Each header that declares the template \tcode{hash}
@@ -15025,17 +15025,17 @@
 are not function object types\iref{function.objects}.
 \begin{note}
 This means that the specialization of \tcode{hash} exists, but
-any attempts to use it as a \oldconcept{Hash} will be ill-formed.
+any attempts to use it as a \oldconceptref{Hash} will be ill-formed.
 \end{note}
 
 \pnum
 An enabled specialization \tcode{hash<Key>} will:
 \begin{itemize}
-\item meet the \oldconcept{Hash} requirements (\tref{cpp17.hash}),
+\item meet the \oldconceptref{Hash} requirements (\tref{cpp17.hash}),
 with \tcode{Key} as the function
-call argument type, the \oldconcept{Default\-Constructible} requirements (\tref{cpp17.defaultconstructible}),
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}),
-the \oldconcept{Swappable} requirements\iref{swappable.requirements},
+call argument type, the \oldconceptref{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+the \oldconceptref{CopyAssignable} requirements (\tref{cpp17.copyassignable}),
+the \oldconceptref{Swappable} requirements\iref{swappable.requirements},
 \item meet the requirement that if \tcode{k1 == k2} is \tcode{true}, \tcode{h(k1) == h(k2)} is
 also \tcode{true}, where \tcode{h} is an object of type \tcode{hash<Key>} and \tcode{k1} and \tcode{k2}
 are objects of type \tcode{Key};
@@ -15259,7 +15259,7 @@
 resolution participation.
 
 \pnum
-\tcode{is_execution_policy<T>} is a \oldconcept{UnaryTypeTrait} with a
+\tcode{is_execution_policy<T>} is a \oldconceptref{UnaryTypeTrait} with a
 base characteristic of \tcode{true_type} if \tcode{T} is the type of a standard
 or \impldef{additional execution policies supported by parallel algorithms}
 execution policy, otherwise \tcode{false_type}.
@@ -16985,11 +16985,11 @@
 A type \tcode{F} meets the \defnnewoldconcept{BasicFormatter} requirements if
 it meets the
 \begin{itemize}
-\item \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
-\item \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\item \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
-\item \oldconcept{Swappable}\iref{swappable.requirements}, and
-\item \oldconcept{Destructible} (\tref{cpp17.destructible})
+\item \oldconceptref{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
+\item \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\item \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}),
+\item \oldconceptref{Swappable}\iref{swappable.requirements}, and
+\item \oldconceptref{Destructible} (\tref{cpp17.destructible})
 \end{itemize}
 requirements, and
 the expressions shown in \tref{formatter.basic} are valid and