[EDITORIAL] add <experimental/ranges/concepts> synopsis (#324)

concepts.tex

@@ -22,9 +22,6 @@
 \ref{concepts.lib.callable}   & Callable concepts              &                      \\
 \end{libsumtab}
 
-\pnum
-The concepts in this Clause are defined in the namespace \tcode{std::experimental::ranges::v1}.
-
 \rSec2[concepts.lib.general.equality]{Equality Preservation}
 
 \pnum
@@ -127,6 +124,209 @@
 which requires \tcode{C<T>()}.
 \exitexample
 
+\rSec1[concepts.lib.synopsis]{Header \tcode{<experimental/ranges/concepts>} synopsis}
+
+\indexlibrary{\idxhdr{experimental/ranges/concepts}}%
+\begin{codeblock}
+namespace std { namespace experimental { namespace ranges { inline namespace v1 {
+  // \ref{concepts.lib.corelang}, core language concepts:
+  // \ref{concepts.lib.corelang.same}, Same:
+  template <class T, class U>
+  concept bool Same() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.derived}, DerivedFrom:
+  template <class T, class U>
+  concept bool DerivedFrom() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.convertibleto}, ConvertibleTo:
+  template <class T, class U>
+  concept bool ConvertibleTo() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.commonref}, CommonReference:
+  template <class T, class U>
+  concept bool CommonReference() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.common}, Common:
+  template <class T, class U>
+  concept bool Common() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.integral}, Integral:
+  template <class T>
+  concept bool Integral() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.signedintegral}, SignedIntegral:
+  template <class T>
+  concept bool SignedIntegral() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.unsignedintegral}, UnsignedIntegral:
+  template <class T>
+  concept bool UnsignedIntegral() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.assignable}, Assignable:
+  template <class T, class U>
+  concept bool Assignable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.corelang.swappable}, Swappable:
+  template <class T>
+  concept bool Swappable() {
+    return @\seebelow@;
+  }
+
+  template <class T, class U>
+  concept bool Swappable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.compare}, comparison concepts:
+  // \ref{concepts.lib.compare.boolean}, Boolean:
+  template <class B>
+  concept bool Boolean() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.compare.equalitycomparable}, EqualityComparable:
+  template <class T, class U>
+  concept bool WeaklyEqualityComparable() {
+    return @\seebelow@;
+  }
+
+  template <class T>
+  concept bool EqualityComparable() {
+    return @\seebelow@;
+  }
+
+  template <class T, class U>
+  concept bool EqualityComparable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.compare.stricttotallyordered}, StrictTotallyOrdered:
+  template <class T>
+  concept bool StrictTotallyOrdered() {
+    return @\seebelow@;
+  }
+
+  template <class T, class U>
+  concept bool StrictTotallyOrdered() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object}, object concepts:
+  // \ref{concepts.lib.object.destructible}, Destructible:
+  template <class T>
+  concept bool Destructible() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.constructible}, Constructible:
+  template <class T, class... Args>
+  concept bool Constructible() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.defaultconstructible}, DefaultConstructible:
+  template <class T>
+  concept bool DefaultConstructible() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.moveconstructible}, MoveConstructible:
+  template <class T>
+  concept bool MoveConstructible() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.copyconstructible}, CopyConstructible:
+  template <class T>
+  concept bool CopyConstructible() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.movable}, Movable:
+  template <class T>
+  concept bool Movable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.copyable}, Copyable:
+  template <class T>
+  concept bool Copyable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.semiregular}, Semiregular:
+  template <class T>
+  concept bool Semiregular() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.object.regular}, Regular:
+  template <class T>
+  concept bool Regular() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.callable}, callable concepts:
+  // \ref{concepts.lib.callable.invocable}, Invocable:
+  template <class F, class... Args>
+  concept bool Invocable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.callable.regularinvocable}, RegularInvocable:
+  template <class F, class... Args>
+  concept bool RegularInvocable() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.callable.predicate}, Predicate:
+  template <class F, class... Args>
+  concept bool Predicate() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.callable.relation}, Relation:
+  template <class R, class T>
+  concept bool Relation() {
+    return @\seebelow@;
+  }
+
+  template <class R, class T, class U>
+  concept bool Relation() {
+    return @\seebelow@;
+  }
+
+  // \ref{concepts.lib.callable.strictweakorder}, StrictWeakOrder:
+  template <class R, class T>
+  concept bool StrictWeakOrder() {
+    return @\seebelow@;
+  }
+
+  template <class R, class T, class U>
+  concept bool StrictWeakOrder() {
+    return @\seebelow@;
+  }
+}}}}
+\end{codeblock}
+
 \rSec1[concepts.lib.corelang]{Core language concepts}
 
 \rSec2[concepts.lib.corelang.general]{In general}