[iterator.concept.winc] Move concept definition near its description

jensmaurer · jensmaurer · commit f72b03360617 · 2021-03-18T19:56:35.000+01:00
Also rename the placeholder type I to T, used in the specification
of the exposition-only concepts is-integer-like and
is-signed-integer-like, to avoid a presentation conflict
with the placeholder type I referring to an iterator type.
diff --git a/source/iterators.tex b/source/iterators.tex
@@ -1312,20 +1312,10 @@
 
 template<class T>
   inline constexpr bool @\exposid{is-signed-integer-like}@ = @\seebelow@; @\itcorr[-2]@    // \expos
-
-template<class I>
-  concept @\deflibconcept{weakly_incrementable}@ =
-    @\libconcept{default_initializable}@<I> && @\libconcept{movable}@<I> &&
-    requires(I i) {
-      typename iter_difference_t<I>;
-      requires @\exposid{is-signed-integer-like}@<iter_difference_t<I>>;
-      { ++i } -> @\libconcept{same_as}@<I&>;   // not required to be equality-preserving
-      i++;                      // not required to be equality-preserving
-    };
 \end{codeblock}
 
 \pnum
-A type \tcode{I} is an \defnadj{integer-class}{type}
+A type \tcode{T} is an \defnadj{integer-class}{type}
 if it is in a set of \impldef{integer-class type} class types
 that behave as integer types do, as defined below.
 
@@ -1338,25 +1328,25 @@
 otherwise, it is an \defnadj{unsigned-integer-class}{type}.
 
 \pnum
-For every integer-class type \tcode{I},
-let \tcode{B(I)} be a hypothetical extended integer type
+For every integer-class type \tcode{T},
+let \tcode{B(T)} be a hypothetical extended integer type
 of the same signedness with the smallest width\iref{basic.fundamental}
 capable of representing the same range of values.
-The width of \tcode{I} is equal to the width of \tcode{B(I)}.
+The width of \tcode{T} is equal to the width of \tcode{B(T)}.
 
 \pnum
-Let \tcode{a} and \tcode{b} be objects of integer-class type \tcode{I},
-let \tcode{x} and \tcode{y} be objects of type \tcode{B(I)} as described above
+Let \tcode{a} and \tcode{b} be objects of integer-class type \tcode{T},
+let \tcode{x} and \tcode{y} be objects of type \tcode{B(T)} as described above
 that represent the same values as \tcode{a} and \tcode{b} respectively, and
 let \tcode{c} be an lvalue of any integral type.
 \begin{itemize}
 \item
   For every unary operator \tcode{@} for which the expression \tcode{@x}
   is well-formed, \tcode{@a} shall also be well-formed
   and have the same value, effects, and value category as \tcode{@x}
-  provided that value is representable by \tcode{I}.
+  provided that value is representable by \tcode{T}.
   If \tcode{@x} has type \tcode{bool}, so too does \tcode{@a};
-  if \tcode{@x} has type \tcode{B(I)}, then \tcode{@a} has type \tcode{I}.
+  if \tcode{@x} has type \tcode{B(T)}, then \tcode{@a} has type \tcode{T}.
 \item
   For every assignment operator \tcode{@=}
   for which \tcode{c @= x} is well-formed,
@@ -1367,9 +1357,9 @@
   For every binary operator \tcode{@} for which \tcode{x @ y} is well-formed,
   \tcode{a @ b} shall also be well-formed and
   shall have the same value, effects, and value category as \tcode{x @ y}
-  provided that value is representable by \tcode{I}.
+  provided that value is representable by \tcode{T}.
   If \tcode{x @ y} has type \tcode{bool}, so too does \tcode{a @ b};
-  if \tcode{x @ y} has type \tcode{B(I)}, then \tcode{a @ b} has type \tcode{I}.
+  if \tcode{x @ y} has type \tcode{B(T)}, then \tcode{a @ b} has type \tcode{T}.
 \end{itemize}
 
 \pnum
@@ -1381,9 +1371,9 @@
 do not exit via an exception.
 
 \pnum
-An expression \tcode{E} of integer-class type \tcode{I} is
+An expression \tcode{E} of integer-class type \tcode{T} is
 contextually convertible to \tcode{bool}
-as if by \tcode{bool(E != I(0))}.
+as if by \tcode{bool(E != T(0))}.
 
 \pnum
 All integer-class types model
@@ -1394,44 +1384,56 @@
 A value-initialized object of integer-class type has value 0.
 
 \pnum
-For every (possibly cv-qualified) integer-class type \tcode{I},
-\tcode{numeric_limits<I>} is specialized such that:
+For every (possibly cv-qualified) integer-class type \tcode{T},
+\tcode{numeric_limits<T>} is specialized such that:
 \begin{itemize}
 \item
-  \tcode{numeric_limits<I>::is_specialized} is \tcode{true},
+  \tcode{numeric_limits<T>::is_specialized} is \tcode{true},
 \item
-  \tcode{numeric_limits<I>::is_signed} is \tcode{true}
-  if and only if \tcode{I} is a signed-integer-class type,
+  \tcode{numeric_limits<T>::is_signed} is \tcode{true}
+  if and only if \tcode{T} is a signed-integer-class type,
 \item
-  \tcode{numeric_limits<I>::is_integer} is \tcode{true},
+  \tcode{numeric_limits<T>::is_integer} is \tcode{true},
 \item
-  \tcode{numeric_limits<I>::is_exact} is \tcode{true},
+  \tcode{numeric_limits<T>::is_exact} is \tcode{true},
 \item
-  \tcode{numeric_limits<I>::digits} is equal to the width of the integer-class type,
+  \tcode{numeric_limits<T>::digits} is equal to the width of the integer-class type,
 \item
-  \tcode{numeric_limits<I>::digits10} is equal to \tcode{static_cast<int>(digits * log10(2))}, and
+  \tcode{numeric_limits<T>::digits10} is equal to \tcode{static_cast<int>(digits * log10(2))}, and
 \item
-  \tcode{numeric_limits<I>::min()} and \tcode{numeric_limits<I>::max()} return
-  the lowest and highest representable values of \tcode{I}, respectively, and
-  \tcode{numeric_limits<I>::lowest()} returns \tcode{numeric_limits<I>::\brk{}min()}.
+  \tcode{numeric_limits<T>::min()} and \tcode{numeric_limits<T>::max()} return
+  the lowest and highest representable values of \tcode{T}, respectively, and
+  \tcode{numeric_limits<T>::lowest()} returns \tcode{numeric_limits<T>::\brk{}min()}.
 \end{itemize}
 
 \pnum
-A type \tcode{I} other than \cv{}~\tcode{bool} is \defn{integer-like}
-if it models \tcode{\libconcept{integral}<I>} or
+A type \tcode{T} other than \cv{}~\tcode{bool} is \defn{integer-like}
+if it models \tcode{\libconcept{integral}<T>} or
 if it is an integer-class type.
-An integer-like type \tcode{I} is \defn{signed-integer-like}
-if it models \tcode{\libconcept{signed_integral}<I>} or
+An integer-like type \tcode{T} is \defn{signed-integer-like}
+if it models \tcode{\libconcept{signed_integral}<T>} or
 if it is a signed-integer-class type.
-An integer-like type \tcode{I} is \defn{unsigned-integer-like}
-if it models \tcode{\libconcept{unsigned_integral}<I>} or
+An integer-like type \tcode{T} is \defn{unsigned-integer-like}
+if it models \tcode{\libconcept{unsigned_integral}<T>} or
 if it is an unsigned-integer-class type.
 
 \pnum
-\tcode{\exposid{is-integer-like}<I>} is \tcode{true}
-if and only if \tcode{I} is an integer-like type.
-\tcode{\exposid{is-signed-integer-like}<I>} is \tcode{true}
-if and only if \tcode{I} is a signed-integer-like type.
+\tcode{\exposid{is-integer-like}<T>} is \tcode{true}
+if and only if \tcode{T} is an integer-like type.
+\tcode{\exposid{is-signed-integer-like}<T>} is \tcode{true}
+if and only if \tcode{T} is a signed-integer-like type.
+
+\begin{codeblock}
+template<class I>
+  concept @\deflibconcept{weakly_incrementable}@ =
+    @\libconcept{default_initializable}@<I> && @\libconcept{movable}@<I> &&
+    requires(I i) {
+      typename iter_difference_t<I>;
+      requires @\exposid{is-signed-integer-like}@<iter_difference_t<I>>;
+      { ++i } -> @\libconcept{same_as}@<I&>;   // not required to be equality-preserving
+      i++;                      // not required to be equality-preserving
+    };
+\end{codeblock}
 
 \pnum
 Let \tcode{i} be an object of type \tcode{I}. When \tcode{i} is in the domain of
