P0898R3 Standard Library Concepts: rename "old" concepts

Prefix the names of all named library requirement sets with "Cpp17" by annotating with new "\oldconcept" macro. Note that not all of these are called out by name in the proposal. The intent is to prefix *all* named library requirements, as discussed in LEWG/LWG.

Includes:
* Allocator
* BasicLockable
* BidirectionalIterator
* BinaryTypeTrait
* Clock
* CopyAssignable
* CopyConstructible
* CopyInsertable
* DefaultConstructible
* DefaultInsertable
* Destructible
* EmplaceConstructible
* EqualityComparable
* Erasable
* ForwardIterator
* Hash
* InputIterator
* Iterator
* LessThanComparable
* Lockable
* MoveAssignable
* MoveConstructible
* MoveInsertable
* NullablePointer
* OutputIterator
* RandomAccessIterator
* TimedLockable
* TransformationTrait
* TrivialClock
* UnaryTypeTrait
* ValueSwappable

Author: CaseyCarter

source/algorithms.tex

@@ -315,7 +315,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \tcode{EqualityComparable} (\tref{equalitycomparable}).
+Type \tcode{T} is \oldconcept{EqualityComparable} (\tref{equalitycomparable}).
 
 \pnum
 \returns
@@ -330,7 +330,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \tcode{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
 
 \pnum
 \returns
@@ -345,7 +345,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \tcode{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
 
 \pnum
 \returns
@@ -360,7 +360,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \tcode{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
 
 \pnum
 \returns
@@ -1448,7 +1448,7 @@
 \tcode{remove_all_extents_t<T>} shall be a complete type or \cv{} \tcode{void}.
 
 \pnum
-\tcode{is_pod<T>} is a \tcode{UnaryTypeTrait}\iref{meta.rqmts}
+\tcode{is_pod<T>} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of \tcode{true_type}
 if \tcode{T} is a POD type,
 and \tcode{false_type} otherwise.

source/containers.tex

@@ -1661,22 +1661,22 @@
 It holds a state object
 whose type is equal to the template parameter \tcode{stateT}.
 Type \tcode{stateT} shall meet
-the \tcode{DefaultConstructible} (\tref{defaultconstructible}),
-\tcode{CopyConstructible} (\tref{copyconstructible}),
-\tcode{CopyAssignable} (\tref{copyassignable}), and
-\tcode{Destructible} (\tref{destructible}) requirements.
+the \oldconcept{DefaultConstructible} (\tref{defaultconstructible}),
+\oldconcept{CopyConstructible} (\tref{copyconstructible}),
+\oldconcept{CopyAssignable} (\tref{copyassignable}), and
+\oldconcept{Destructible} (\tref{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<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy assignment operator.
 If \tcode{is_trivially_destructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial destructor.
 All specializations of \tcode{fpos} satisfy
-the \tcode{DefaultConstructible},
-\tcode{CopyConstructible},
-\tcode{CopyAssignable},
-\tcode{Destructible},
-and \tcode{EqualityComparable} (\tref{equalitycomparable}) requirements.
+the \oldconcept{DefaultConstructible},
+\oldconcept{CopyConstructible},
+\oldconcept{CopyAssignable},
+\oldconcept{Destructible},
+and \oldconcept{EqualityComparable} (\tref{equalitycomparable}) requirements.
 In addition, the expressions shown in \tref{iostreams.position.requirements}
 are valid and have the indicated semantics.
 In that table,
@@ -10441,7 +10441,7 @@
 \end{codeblock}
 
 \pnum
-\tcode{Allocator} shall satisfy the \tcode{Allocator} requirements
+\tcode{Allocator} shall satisfy the \oldconcept{Allocator} requirements
 (\tref{utilities.allocator.requirements}).
 
 \pnum
@@ -10773,7 +10773,7 @@
 
 \pnum
 Template parameters named \tcode{InputIterator} shall satisfy the
-input iterator requirements\iref{input.iterators} and shall
+\oldconcept{InputIterator} requirements\iref{input.iterators} and shall
 have a value type that is one of the encoded character types.
 
 \pnum
@@ -10785,7 +10785,7 @@
 
 \pnum
 Template parameters named \tcode{Allocator} shall satisfy the
-\tcode{Allocator} requirements (\tref{utilities.allocator.requirements}).
+\oldconcept{Allocator} requirements (\tref{utilities.allocator.requirements}).
 
 \rSec3[fs.req.namespace]{Namespaces and headers}
 
@@ -11010,7 +11010,7 @@
 
 \pnum
 \tcode{\textit{trivial-clock}} is an \impldef{type of filesystem trivial clock} type
-that satisfies the \tcode{TrivialClock} requirements\iref{time.clock.req}
+that satisfies the \oldconcept{TrivialClock} requirements\iref{time.clock.req}
 and that is capable of representing and measuring file time values.
 Implementations should ensure that the resolution and range of
 \tcode{file_time_type} reflect the operating system dependent resolution and range
@@ -11573,7 +11573,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 input iterator requirements that iterates over a NTCTS.
+\item A type meeting the \oldconcept{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
@@ -13888,8 +13888,8 @@
 \end{codeblock}
 
 \pnum
- \tcode{directory_iterator} satisfies the requirements of an input
-iterator\iref{input.iterators}.
+ \tcode{directory_iterator} satisfies the
+ \oldconcept{InputIterator} requirements\iref{input.iterators}.
 
 \pnum
 If an iterator of type \tcode{directory_iterator} reports an error or

source/future.tex

@@ -156,7 +156,7 @@
 the only exceptions are destroying an iterator that holds a singular value,
 the assignment of a non-singular value to
 an iterator that holds a singular value, and, for iterators that satisfy the
-\tcode{DefaultConstructible} requirements, using a value-initialized iterator
+\oldconcept{DefaultConstructible} requirements, using a value-initialized iterator
 as the source of a copy or move operation. \begin{note} This guarantee is not
 offered for default-initialization, although the distinction only matters for types
 with trivial default constructors such as pointers or aggregates holding pointers.
@@ -265,31 +265,31 @@
 \begin{note} For an iterator type \tcode{X} there must be an instantiation
 of \tcode{iterator_traits<X>}\iref{iterator.traits}. \end{note}
 
-\rSec2[iterator.iterators]{Iterator}
+\rSec2[iterator.iterators]{\oldconcept{Iterator}}
 
 \pnum
-The \tcode{Iterator} requirements form the basis of the iterator
-taxonomy; every iterator satisfies the \tcode{Iterator} requirements. This
+The \oldconcept{Iterator} requirements form the basis of the iterator
+taxonomy; every iterator satisfies the \oldconcept{Iterator} requirements. This
 set of requirements specifies operations for dereferencing and incrementing
 an iterator. Most algorithms will require additional operations to
 read\iref{input.iterators} or write\iref{output.iterators} values, or
 to provide a richer set of iterator movements~(\ref{forward.iterators},
 \ref{bidirectional.iterators}, \ref{random.access.iterators}).
 
 \pnum
-A type \tcode{X} satisfies the \tcode{Iterator} requirements if:
+A type \tcode{X} satisfies the \oldconcept{Iterator} requirements if:
 
 \begin{itemize}
-\item \tcode{X} satisfies the \tcode{CopyConstructible}, \tcode{CopyAssignable}, and
-\tcode{Destructible} requirements\iref{utility.arg.requirements} and lvalues
+\item \tcode{X} satisfies the \oldconcept{CopyConstructible}, \oldconcept{CopyAssignable}, and
+\oldconcept{Destructible} requirements\iref{utility.arg.requirements} and lvalues
 of type \tcode{X} are swappable\iref{swappable.requirements}, and
 
 \item the expressions in \tref{iterator.requirements} are valid and have
 the indicated semantics.
 \end{itemize}
 
 \begin{libreqtab4b}
-{Iterator requirements}
+{\oldconcept{Iterator} requirements}
 {tab:iterator.requirements}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
@@ -321,8 +321,8 @@
 satisfies the requirements of an input iterator for the value type
 \tcode{T}
 if
-\tcode{X} satisfies the \tcode{Iterator}\iref{iterator.iterators} and
-\tcode{EqualityComparable} (\tref{equalitycomparable}) requirements and
+\tcode{X} satisfies the \oldconcept{Iterator}\iref{iterator.iterators} and
+\oldconcept{EqualityComparable} (\tref{equalitycomparable}) requirements and
 the expressions in \tref{iterator.input.requirements} are valid and have
 the indicated semantics.
 
@@ -356,7 +356,7 @@
 \end{example}
 
 \begin{libreqtab4b}
-{Input iterator requirements (in addition to Iterator)}
+{\oldconcept{InputIterator} requirements (in addition to \oldconcept{Iterator})}
 {tab:iterator.input.requirements}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
@@ -414,7 +414,7 @@
 They should be
 \term{single pass}
 algorithms.
-Value type \tcode{T} is not required to be a \tcode{CopyAssignable} type (\tref{copyassignable}).
+Value type \tcode{T} is not required to be a \oldconcept{CopyAssignable} type (\tref{copyassignable}).
 These algorithms can be used with istreams as the source of the input data through the
 \tcode{istream_iterator}
 class template.
@@ -426,12 +426,12 @@
 A class or pointer type
 \tcode{X}
 satisfies the requirements of an output iterator
-if \tcode{X} satisfies the \tcode{Iterator} requirements\iref{iterator.iterators}
+if \tcode{X} satisfies the \oldconcept{Iterator} requirements\iref{iterator.iterators}
 and the expressions in \tref{iterator.output.requirements}
 are valid and have the indicated semantics.
 
 \begin{libreqtab4b}
-{Output iterator requirements (in addition to Iterator)}
+{\oldconcept{OutputIterator} requirements (in addition to \oldconcept{Iterator})}
 {tab:iterator.output.requirements}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
@@ -494,9 +494,9 @@
 satisfies the requirements of a forward iterator if
 
 \begin{itemize}
-\item \tcode{X} satisfies the requirements of an input iterator\iref{input.iterators},
+\item \tcode{X} satisfies the \oldconcept{InputIterator} requirements\iref{input.iterators},
 
-\item \tcode{X} satisfies the \tcode{DefaultConstructible}
+\item \tcode{X} satisfies the \oldconcept{DefaultConstructible}
 requirements\iref{utility.arg.requirements},
 
 \item if \tcode{X} is a mutable iterator, \tcode{reference} is a reference to \tcode{T};
@@ -539,7 +539,7 @@
 \end{note}
 
 \begin{libreqtab4b}
-{Forward iterator requirements (in addition to input iterator)}
+{\oldconcept{ForwardIterator} requirements (in addition to \oldconcept{InputIterator})}
 {tab:iterator.forward.requirements}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
@@ -576,11 +576,11 @@
 A class or pointer type
 \tcode{X}
 satisfies the requirements of a bidirectional iterator if,
-in addition to satisfying the requirements for forward iterators,
+in addition to satisfying the \oldconcept{ForwardIterator} requirements,
 the following expressions are valid as shown in \tref{iterator.bidirectional.requirements}.
 
 \begin{libreqtab4b}
-{Bidirectional iterator requirements (in addition to forward iterator)}
+{\oldconcept{BidirectionalIterator} requirements (in addition to \oldconcept{ForwardIterator})}
 {tab:iterator.bidirectional.requirements}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
@@ -621,11 +621,11 @@
 A class or pointer type
 \tcode{X}
 satisfies the requirements of a random access iterator if,
-in addition to satisfying the requirements for bidirectional iterators,
+in addition to satisfying the \oldconcept{BidirectionalIterator} requirements,
 the following expressions are valid as shown in \tref{iterator.random.access.requirements}.
 
 \begin{libreqtab4b}
-{Random access iterator requirements (in addition to bidirectional iterator)}
+{\oldconcept{RandomAccessIterator} requirements (in addition to \oldconcept{BidirectionalIterator})}
 {tab:iterator.random.access.requirements}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
@@ -1127,7 +1127,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-If \tcode{InputIterator} meets the requirements of random access iterator,
+If \tcode{InputIterator} meets the \oldconcept{RandomAccessIterator} requirements,
 returns \tcode{(last - first)}; otherwise, returns
 the number of increments needed to get from
 \tcode{first}
@@ -1136,7 +1136,7 @@
 
 \pnum
 \requires
-If \tcode{InputIterator} meets the requirements of random access iterator,
+If \tcode{InputIterator} meets the \oldconcept{RandomAccessIterator} requirements,
 \tcode{last} shall be reachable from \tcode{first} or \tcode{first} shall be
 reachable from \tcode{last}; otherwise,
 \tcode{last}
@@ -1261,12 +1261,12 @@
 \pnum
 The template parameter
 \tcode{Iterator}
-shall satisfy all the requirements of a Bidirectional Iterator\iref{bidirectional.iterators}.
+shall satisfy all the requirements of a \oldconcept{BidirectionalIterator}\iref{bidirectional.iterators}.
 
 \pnum
 Additionally,
 \tcode{Iterator}
-shall satisfy the requirements of a random access iterator\iref{random.access.iterators}
+shall satisfy the requirements of a \oldconcept{RandomAccessIterator}\iref{random.access.iterators}
 if any of the members
 \tcode{operator+},
 \tcode{operator-},
@@ -2148,11 +2148,11 @@
 
 \pnum
 The template parameter \tcode{Iterator} shall satisfy
-the requirements of an input iterator\iref{input.iterators}.
+the \oldconcept{InputIterator} requirements\iref{input.iterators}.
 Additionally, if any of the bidirectional or random access traversal
 functions are instantiated, the template parameter shall satisfy the
-requirements for a Bidirectional Iterator\iref{bidirectional.iterators}
-or a Random Access Iterator\iref{random.access.iterators}, respectively.
+\oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators}
+or \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}, respectively.
 
 \rSec3[move.iter.ops]{\tcode{move_iterator} operations}
 
@@ -2548,8 +2548,8 @@
 The behavior of a program that applies \tcode{operator++()} to an end-of-stream
 iterator is undefined.
 It is impossible to store things into istream iterators.
-The type \tcode{T} shall satisfy the \tcode{DefaultConstructible},
-\tcode{CopyConstructible}, and \tcode{CopyAssignable} requirements.
+The type \tcode{T} shall satisfy the \oldconcept{DefaultConstructible},
+\oldconcept{CopyConstructible}, and \oldconcept{CopyAssignable} requirements.
 
 \pnum
 Two end-of-stream iterators are always equal.