Boost logo

Boost-Commit :

From: dgregor_at_[hidden]
Date: 2008-03-11 14:46:39


Author: dgregor
Date: 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
New Revision: 43567
URL: http://svn.boost.org/trac/boost/changeset/43567

Log:
Provide and integrate proposed resolutions for several concepts issues
Text files modified:
   sandbox/committee/concepts/issues/issues/issue1.xml | 122 +++++++++++++++++
   sandbox/committee/concepts/issues/issues/issue10.xml | 6
   sandbox/committee/concepts/issues/issues/issue17.xml | 32 ++++
   sandbox/committee/concepts/issues/issues/issue4.xml | 22 +++
   sandbox/committee/concepts/issues/issues/issue7.xml | 3
   sandbox/committee/concepts/issues/issues/issue9.xml | 18 ++
   sandbox/committee/concepts/stdlib/clib-algorithms.tex | 2
   sandbox/committee/concepts/stdlib/clib-concepts.tex | 276 ++++++++++++++-------------------------
   sandbox/committee/concepts/stdlib/clib-iterators.tex | 8
   sandbox/committee/concepts/stdlib/clib-numerics.tex | 2
   sandbox/committee/concepts/stdlib/macros.tex | 2
   sandbox/committee/concepts/wording/wording.tex | 2
   12 files changed, 301 insertions(+), 194 deletions(-)

Modified: sandbox/committee/concepts/issues/issues/issue1.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue1.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue1.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
   <!ENTITY nbsp "&#160;">
 ] >
 
-<issue num="1" status="New">
+<issue num="1" status="Ready">
   <title>Naming and symmetry in EqualityComparable</title>
   <section><sref ref="[concept.comparison]"/></section>
   <submitter>LWG</submitter>
@@ -36,4 +36,124 @@
       same thing? Is there any way to write defaults in the concept
       definition that won't ever give us an infinite loop?</p>
   </discussion>
+
+ <resolution>
+ <p>Split the <code>EqualityComparable</code>
+ and <code>LessThanComparable</code> concepts into purely syntactic
+ concepts (<code>HasEquals</code>, <code>HasLessThan</code>) and
+ semantic concepts that refine them
+ (<code>EqualityComparable</code>, <code>LessThanComparable</code>). In
+ [utility.concepts], update the &lt;concepts&gt; header synopsis as
+ follows:
+ <pre>
+<i>// 20.1.2, comparisons:</i>
+auto concept LessThanComparable&lt;typename T<del>, typename U = T</del>&gt; <i>see below</i>;
+auto concept EqualityComparable&lt;typename T<del>, typename U = T</del>&gt; <i>see below</i>;
+auto concept TriviallyEqualityComparable&lt;typename T&gt; <i>see below</i>;
+
+<i>...</i>
+<i>// 20.1.10, operator concepts:</i>
+<i>...</i>
+
+auto concept HasNegate&lt;typename T&gt; <i>see below</i>;
+<ins>auto concept HasLess&lt;typename T, typename U = T&gt; <i>see below</i>;</ins>
+<ins>auto concept HasEquals&lt;typename T, typename U = T&gt; <i>see below</i>;</ins>
+auto concept HasLogicalAnd&lt;typename T, typename U = T&gt; <i>see below</i>;
+ </pre>
+ </p>
+
+ <p>Change [concept.comparison] paragraph 1 as follows:
+ <pre>
+auto concept LessThanComparable&lt;typename T<del>, typename U = T</del>&gt;<ins> : HasLess&lt;T&gt;</ins> {
+ <del>bool operator&lt;(T const&amp; a, U const&amp; b);</del>
+ bool operator&gt;(<del>U</del><ins>T</ins> const&amp; a, T const&amp; b) { return b &lt; a; }
+ bool operator&lt;=(<del>U</del><ins>T</ins> const&amp; a, T const&amp; b) { return !(b &lt; a); }
+ bool operator&gt;=(T const&amp; a, <del>U</del><ins>T</ins> const&amp; b) { return !(a &lt; b); }
+
+ <ins>axiom Consistency(T a, T b) {
+ (a &gt; b) == (b &lt; a);
+ (a &lt;= b) == !(b &lt; a);
+ (a &gt;= b) == !(a &lt; b);
+ }
+
+ axiom Irreflexivity(T a) { (a &lt; a) == false; }
+
+ axiom Antisymmetry(T a, T b) {
+ if (a &lt; b) (b &lt; a) == false;
+ }
+
+ axiom Transitivity(T a, T b, T c) {
+ if (a &lt; b &amp;&amp; b &lt; c) (a &lt; c) == true;
+ }
+
+ axiom TransitivityOfEquivalence(T a, T b, T c) {
+ if (!(a &lt; b) &amp;&amp; !(b &lt; a) &amp;&amp; !(b &lt; c) &amp;&amp; !(c &lt; b))
+ (!(a &lt; c) &amp;&amp; !(c &lt; a)) == true;
+ }</ins>
+}
+ </pre>
+<ol>
+ <li>&nbsp;&nbsp;&nbsp;&nbsp;<del><i>Note</i>: describes types whose
+ values can be ordered via an inequality operator.</del></li>
+</ol>
+</p>
+
+ <p>Change [concept.comparison] paragraphs 3 and 4 as follows:
+ <pre>
+auto concept EqualityComparable&lt;typename T<del>, typename U = T</del>&gt;<ins> : HasEquals&lt;T&gt;</ins> {
+ <del>bool operator==(T const&amp; a, U const&amp; b);</del>
+ bool operator!=(T const&amp; a, <del>U</del><ins>T</ins> const&amp; b) { return !(a == b); }
+
+ <ins>axiom Consistency(T a, T b) {
+ (a == b) == !(a != b);
+ }
+
+ axiom Reflexivity(T a) { a == a; }
+
+ axiom Symmetry(T a, T b) { if (a == b) b == a; }
+
+ axiom Transitivity(T a, T b, T c) {
+ if (a == b &amp;&amp; b == c) a == c;
+ }</ins>
+}
+ </pre>
+<ol start="3">
+ <li>&nbsp;&nbsp;&nbsp;&nbsp;<del><i>Note</i>: describes types whose
+ values can be compared for equality with <code>operator==</code>.</del></li>
+
+ <li>&nbsp;&nbsp;&nbsp;&nbsp;<i>Requires</i>: <del>when <code>T</code> and <code>U</code> are identical, </del><code>operator==</code> is an equivalence relation<del> that is, it has the following properties:</del><ins>.</ins>
+ <ul>
+ <li><del>For all a, a == a.</del></li>
+ <li><del>If a == b, then b == a.</del></li>
+ <li><del>If a == b and b == c, then a == c.</del></li>
+ </ul>
+ </li>
+</ol>
+ </p>
+
+ <p>Add to [concept.operator]:
+ <pre>
+<ins>auto concept HasLess&lt; typename T, typename U = T&gt; {
+ bool operator&lt;(const T&amp; a, const U&amp; b);
+}</ins>
+ </pre>
+ <ol start="8">
+ <li>&nbsp;&nbsp;&nbsp;&nbsp;<ins><i>Note</i>: describes types with an <code>operator&lt;</code></ins></li>
+ </ol>
+
+ <pre>
+<ins>auto concept HasEquals&lt; typename T, typename U = T&gt; {
+ bool operator==(const T&amp; a, const U&amp; b);
+}</ins>
+ </pre>
+ <ol start="9">
+ <li>&nbsp;&nbsp;&nbsp;&nbsp;<ins><i>Note</i>: describes types with an <code>operator==</code></ins></li>
+ </ol>
+ </p>
+
+ <p>Note that this change also requires renaming two-parameter uses
+ of <code>EqualityComparable</code>
+ and <code>LessThanComparable</code> to <code>HasEquals</code>
+ and <code>HasLess</code>, respectively.</p>
+ </resolution>
 </issue>

Modified: sandbox/committee/concepts/issues/issues/issue10.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue10.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue10.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
   <!ENTITY nbsp "&#160;">
 ] >
 
-<issue num="10" status="New">
+<issue num="10" status="WP">
 <title>Remarks should be notes</title>
 <section><sref ref="[utility.concepts]"/></section>
 <submitter>LWG</submitter>
@@ -17,4 +17,8 @@
   editorial issue.</p>
 </discussion>
 
+<resolution>
+ <p>Replace all "Remark"s in the paper with "Note"s.</p>
+</resolution>
+
 </issue>

Modified: sandbox/committee/concepts/issues/issues/issue17.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue17.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue17.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
   <!ENTITY nbsp "&#160;">
 ] >
 
-<issue num="17" status="New">
+<issue num="17" status="WP">
 <title>Errors in Allocator concept</title>
 <section><sref ref="[concept.allocator]"/></section>
 <submitter>LWG</submitter>
@@ -25,4 +25,34 @@
   value_type&gt;</tt> as in the synopsis.</p>
 </discussion>
 
+<resolution>
+ <p>In [concept.allocator] paragraph 2, change the associated requirements of
+ the <code>Allocator</code> concept as follows:
+ <pre>
+concept Allocator&lt;typename X&gt; : DefaultConstructible&lt;X&gt;, CopyConstructible&lt;X&gt; {
+ <i>// ...</i>
+ requires Convertible&lt;pointer, const_pointer&gt; &amp;&amp;
+ <del>Convertible&lt;pointer, void*&gt; &amp;&amp;</del>
+ Convertible&lt;pointer, value_type*&gt; &amp;&amp;
+ SameType&lt;pointer::value_type, value_type&gt; &amp;&amp;
+ SameType&lt;pointer::reference, value_type&amp;&gt; &amp;&amp;
+ SameType&lt;pointer::reference, reference&gt;;
+ requires <del>Convertible&lt;const_pointer, const void*&gt; &amp;&amp;</del>
+ Convertible&lt;const_pointer, const value_type<del>&amp</del><ins>*</ins>;&gt; &amp;&amp;
+ SameType&lt;const_pointer::value_type, value_type&gt; &amp;&amp;
+ SameType&lt;const_pointer::reference, const value_type&amp;&gt; &amp;&amp;
+ SameType&lt;const_pointer::reference, const_reference&gt;;
+}
+ </pre>
+ </p>
+
+ <p>Change [concept.allocator] paragraph 11 as follows:
+ <pre>
+template&lt;typename V&gt;
+ requires Constructible&lt;value_type, V<del>&amp;&amp;</del>&gt;
+ void X::construct(pointer p, V&amp;&amp;);
+ </pre>
+ </p>
+</resolution>
+
 </issue>

Modified: sandbox/committee/concepts/issues/issues/issue4.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue4.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue4.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
   <!ENTITY nbsp "&#160;">
 ] >
 
-<issue num="4" status="New">
+<issue num="4" status="WP">
 <title>MoveConstructible should refine Constructible</title>
 <section><sref ref="[concept.copymove]"/></section>
 <submitter>LWG</submitter>
@@ -19,4 +19,24 @@
   body of <tt>MoveConstructible</tt> would go away.</p>
 </discussion>
 
+<resolution>
+<p>In [concept.copymove] paragraph 1, change as follows:
+<pre>
+auto concept MoveConstructible&lt;typename T&gt; : <ins>Constructible&lt;T, T&amp;&amp;&gt;, </ins>Destructible&lt;T&gt; {
+ <del>T::T(T&amp;&amp;);</del>
+}
+</pre></p>
+
+<p>In [concept.copymove] paragraph 3, change as follows:
+<pre>
+ auto concept CopyConstructible&lt;typename T&gt; : MoveConstructible&lt;T&gt;<ins>, Constructible&lt;T, const T&amp;&gt;</ins> {
+ <del>T::T(const T&amp;);</del>
+
+ axiom CopyPreservation(T x) {
+ T(x) == x;
+ }
+}
+</pre></p>
+</resolution>
+
 </issue>

Modified: sandbox/committee/concepts/issues/issues/issue7.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue7.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue7.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
   <!ENTITY nbsp "&#160;">
 ] >
 
-<issue num="7" status="New">
+<issue num="7" status="Open">
   <title>Meaning of "equivalent" in <tt>MoveAssignable</tt></title>
   <section><sref ref="[concept.copymove]"/></section>
   <submitter>LWG</submitter>
@@ -20,5 +20,4 @@
     of <tt>operator==</tt>, but this concept doesn't mention that
     operator.)</p>
 </discussion>
-
 </issue>

Modified: sandbox/committee/concepts/issues/issues/issue9.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue9.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue9.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
   <!ENTITY nbsp "&#160;">
 ] >
 
-<issue num="9" status="New">
+<issue num="9" status="WP">
 <title>Memory-allocation concepts are too fine-grained</title>
 <section><sref ref="[concept.memory]"/></section>
 <submitter>LWG</submitter>
@@ -20,8 +20,20 @@
 </discussion>
 
 <resolution>
-<p>
-</p>
+ <p>In [concept.memory], remove paragraphs 1-4 (describing
+ the <code>Newable</code>, <code>Deletable</code>, <code>ArrayNewable</code>,
+ and <code>ArrayDeletable</code> concepts). Change
+ the <code>HeapAllocatable</code> concept as follows:
+<pre>
+auto concept HeapAllocatable&lt;typename T&gt;
+ <del>: Newable&lt;T&gt;, Deletable&lt;T&gt;, ArrayNewable&lt;T&gt;, ArrayDeletable&lt;T&gt;</del> {
+ <ins>void* T::operator new(size_t size);</ins>
+ <ins>void* T::operator new(size_t size, void*);</ins>
+ <ins>void* T::operator new[](size_t size);</ins>
+ <ins>void T::operator delete(void*);</ins>
+ <ins>void T::operator delete[](void*);</ins>
+}
+ </pre></p>
 </resolution>
 
 </issue>

Modified: sandbox/committee/concepts/stdlib/clib-algorithms.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-algorithms.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-algorithms.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -42,7 +42,7 @@
 \end{center}
 
 \vspace{1in}
-\par\noindent Document number: DRAFT\vspace{-6pt}
+\par\noindent Document number: D2573=08-0083\vspace{-6pt}
 \par\noindent Revises document number: N2084=06-0154\vspace{-6pt}
 \par\noindent Date: \today\vspace{-6pt}
 \par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}

Modified: sandbox/committee/concepts/stdlib/clib-concepts.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-concepts.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-concepts.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -32,7 +32,8 @@
 \begin{titlepage}
 \begin{center}
 \huge
-Core Concepts for the C++0x Standard Library
+Core Concepts for the C++0x Standard Library\\
+(Revision 1)
 \vspace{0.25in}
 
 \normalsize
@@ -44,7 +45,7 @@
 \end{center}
 
 \vspace{0.25in}
-\par\noindent Document number: DRAFT\vspace{-6pt}
+\par\noindent Document number: D2572=08-0082\vspace{-6pt}
 \par\noindent Revises document number: N2502=08-0012\vspace{-6pt}
 \par\noindent Date: \today\vspace{-6pt}
 \par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}
@@ -95,7 +96,7 @@
   shaded box.}
 
 \paragraph*{Changes from N2502}
-Closed concept issues 6, 12, and 14.
+Applied the proposed resolutions for concept issues 4, 6, 9, 10, 12, 14, and 17.
 
 \end{titlepage}
 
@@ -173,8 +174,8 @@
   concept DerivedFrom<typename Derived, typename Base> { }
 
   // \ref{concept.comparison}, comparisons:
- auto concept LessThanComparable<typename T, typename U = T> @\textit{see below}@;
- auto concept EqualityComparable<typename T, typename U = T> @\textit{see below}@;
+ auto concept LessThanComparable<typename T> @\textit{see below}@;
+ auto concept EqualityComparable<typename T> @\textit{see below}@;
   auto concept TriviallyEqualityComparable<typename T> @\textit{see below}@;
 
   // \ref{concept.destruct}, destruction:
@@ -196,10 +197,6 @@
   auto concept Swappable<typename T> @\textit{see below}@;
 
   // \ref{concept.memory}, memory allocation:
- auto concept Newable<typename T, typename... Args> @\textit{see below}@;
- auto concept Deletable<typename T> @\textit{see below}@;
- auto concept ArrayNewable<typename T, typename... Args> @\textit{see below}@;
- auto concept ArrayDeletable<typename T> @\textit{see below}@;
   auto concept HeapAllocatable<typename T> @\textit{see below}@;
 
   // \ref{concept.regular}, regular types:
@@ -222,6 +219,8 @@
   auto concept HasModulus<typename T, typename U = T> @\textit{see below}@;
   auto concept HasUnaryPlus<typename T> @\textit{see below}@;
   auto concept HasNegate<typename T> @\textit{see below}@;
+ auto concept HasLess<typename T, typename U = T> @\textit{see below}@;
+ auto concept HasEquals<typename T, typename U = T> @\textit{see below}@;
   auto concept HasLogicalAnd<typename T, typename U = T> @\textit{see below}@;
   auto concept HasLogicalOr<typename T, typename U = T> @\textit{see below}@;
   auto concept HasLogicalNot<typename T> @\textit{see below}@;
@@ -267,7 +266,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} Describes types that can be used as the
+\addedConcepts{\mbox{\reallynote} Describes types that can be used as the
   return type of a function.}
 
 \pnum
@@ -285,7 +284,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note}
+\addedConcepts{\mbox{\reallynote}
 describes types to which a pointer can be
 created.}
 
@@ -303,7 +302,7 @@
 
 \begin{itemdescr}
 \pnum
-\mbox{\note}
+\mbox{\reallynote}
 describes types to which a reference or pointer-to-member can be
 created.
 
@@ -321,7 +320,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that can be used to
+\addedConcepts{\mbox{\reallynote} describes types that can be used to
   declare a variable.}
 
 \pnum
@@ -337,7 +336,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes object types ([basic.types]),
+\addedConcepts{\mbox{\reallynote} describes object types ([basic.types]),
   for which storage can be allocated.}
 
 \pnum
@@ -354,7 +353,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes class types (i.e., unions,
+\addedConcepts{\mbox{\reallynote} describes class types (i.e., unions,
   classes, and structs).}
 
 \pnum
@@ -369,7 +368,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes classes and structs ([class]).}
+\addedConcepts{\mbox{\reallynote} describes classes and structs ([class]).}
 
 \pnum
 \addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -384,7 +383,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes union types ([class.union]).}
+\addedConcepts{\mbox{\reallynote} describes union types ([class.union]).}
 
 \pnum
 \addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -398,7 +397,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes trivial types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes trivial types ([basic.types]).}
 
 \pnum
 \addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -412,7 +411,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes standard-layout types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes standard-layout types ([basic.types]).}
 
 \pnum
 \addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -427,7 +426,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes literal types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes literal types ([basic.types]).}
 
 \pnum
 \addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -442,7 +441,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes scalar types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes scalar types ([basic.types]).}
 
 \pnum
 \addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -456,7 +455,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describess type that can
+\addedConcepts{\mbox{\reallynote} describess type that can
 be used as the type of a non-type template parameter ([temp.param]).}
 
 \pnum
@@ -474,7 +473,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that
+\addedConcepts{\mbox{\reallynote} describes types that
 can be the type of an integral constant expression ([expr.const]).}
 
 \pnum
@@ -490,7 +489,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes integral types
+\addedConcepts{\mbox{\reallynote} describes integral types
 ([basic.fundamental]).}
 
 \pnum
@@ -506,7 +505,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes enumeration types
+\addedConcepts{\mbox{\reallynote} describes enumeration types
 ([dcl.enum]).}
 
 \pnum
@@ -522,7 +521,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes a same-type requirement
+\addedConcepts{\mbox{\reallynote} describes a same-type requirement
   ([temp.req]).}
 \end{itemdescr}
 
@@ -543,17 +542,27 @@
 \rSec2[concept.comparison]{Comparisons}
 
 \begin{itemdecl}
-auto concept LessThanComparable<typename T, typename U = T> {
+auto concept HasLess<typename T, typename U = T> {
   bool operator<(T const& a, U const& b);
- bool operator>(U const& a, T const& b) { return b < a; }
- bool operator<=(U const& a, T const& b) { return !(b < a); }
- bool operator>=(T const& a, U const& b) { return !(a < b); }
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types whose values can be
+\addedConcepts{\mbox{\reallynote} describes types with an operator <.}
+\end{itemdescr}
+
+\begin{itemdecl}
+auto concept LessThanComparable<typename T> : HasLess<T> {
+ bool operator>(T const& a, T const& b) { return b < a; }
+ bool operator<=(T const& a, T const& b) { return !(b < a); }
+ bool operator>=(T const& a, T const& b) { return !(a < b); }
+}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\addedConcepts{\mbox{\reallynote} describes types whose values can be
   ordered via an inequality operator.}
 
 \pnum
@@ -570,7 +579,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types whose values can be
+\addedConcepts{\mbox{\reallynote} describes types whose values can be
 compared for equality with \mbox{\tcode{operator==}}.}
 
 \pnum
@@ -593,7 +602,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types whose equality comparison
+\addedConcepts{\mbox{\reallynote} describes types whose equality comparison
   operators (\mbox{\tcode{==}}, \mbox{\tcode{!=}}) can be implemented
   via a bitwise equality comparison, as with \mbox{\tcode{memcmp}}.
 \mbox{\enternote} such types should not have
@@ -617,7 +626,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that can be destroyed,
+\addedConcepts{\mbox{\reallynote} describes types that can be destroyed,
   including scalar types, references, and class types with a public
   destructor.}
 
@@ -632,7 +641,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types whose
+\addedConcepts{\mbox{\reallynote} describes types whose
 destructors do not need to be executed when the object is destroyed.}
 
 \pnum
@@ -652,7 +661,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that can be constructed
+\addedConcepts{\mbox{\reallynote} describes types that can be constructed
   from a given set of arguments.}
 \end{itemdescr}
 
@@ -662,26 +671,24 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that can be default-constructed.}
+\addedConcepts{\mbox{\reallynote} describes types that can be default-constructed.}
 \end{itemdescr}
 
 \rSec2[concept.copymove]{Copy and move}
 \begin{itemdecl}
-auto concept MoveConstructible<typename T> : Destructible<T> {
- T::T(T&&);
-}
+auto concept MoveConstructible<typename T> : Constructible<T, T&&>, Destructible<T> { }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note}
+\addedConcepts{\mbox{\reallynote}
 describes types that can move-construct an
 object from a value of the same type, possibly altering that
 value.}
 \end{itemdescr}
 
 \begin{itemdecl}
-T::T(T&& rv);
+T::T(T&& rv); // note: inherited from Constructible<T, T\&\&>
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -694,9 +701,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-auto concept CopyConstructible<typename T> : MoveConstructible<T> {
- T::T(const T&);
-
+auto concept CopyConstructible<typename T> : MoveConstructible<T>, Constructible<T, const T&> {
+ @\addedCC{requires EqualityComparable<T>}@
   axiom CopyPreservation(T x) {
     T(x) == x;
   }
@@ -705,7 +711,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a public copy constructor.}
+\addedConcepts{\mbox{\reallynote} describes types with a public copy constructor.}
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -714,7 +720,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types whose copy
+\addedConcepts{\mbox{\reallynote} describes types whose copy
 constructor is equivalent to \mbox{\tcode{memcpy}}.}
 
 \pnum
@@ -728,13 +734,13 @@
 \begin{itemdecl}
 auto concept MoveAssignable<typename T, typename U = T> {
   typename result_type;
- result_type @\addedCC{T::}@operator=(@\removedCC{T\&, }@U&&);
+ result_type T::operator=(U&&);
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with the ability
+\addedConcepts{\mbox{\reallynote} describes types with the ability
   to assign to an object from an rvalue, potentially altering the rvalue.}
 \end{itemdescr}
 
@@ -757,6 +763,7 @@
   typename result_type;
   result_type T::operator=(const U&);
 
+ @\addedCC{requires EqualityComparable<T, U>}@
   axiom CopyPreservation(T& x, U y) {
     (x = y, x) == y;
   }
@@ -765,7 +772,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with the ability to assign to an
+\addedConcepts{\mbox{\reallynote} describes types with the ability to assign to an
 object.}
 \end{itemdescr}
 
@@ -782,7 +789,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types whose copy-assignment
+\addedConcepts{\mbox{\reallynote} describes types whose copy-assignment
   operator is equivalent to \mbox{\tcode{memcpy}}.}
 
 \pnum
@@ -801,7 +808,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types for which two values of
+\addedConcepts{\mbox{\reallynote} describes types for which two values of
   that type can be swapped.}
 \end{itemdescr}
 
@@ -818,61 +825,18 @@
 
 \rSec2[concept.memory]{Memory allocation}
 \begin{itemdecl}
-auto concept Newable<typename T, typename... Args> : ObjectType<T> {
- void* T::operator new(size_t size, Args...);
-}
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which objects can be
-allocated on the heap via \mbox{\tcode{new}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept Deletable<typename T> : ObjectType<T> {
+auto concept HeapAllocatable<typename T> {
+ void* T::operator new(size_t size);
+ void* T::operator new(size_t size, void*);
+ void* T::operator new[](size_t size);
   void T::operator delete(void*);
-}
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which objects on the
-heap can be freed with \mbox{\tcode{delete}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept ArrayNewable<typename T, typename... Args> : ObjectType<T> {
- void* T::operator new[](size_t size, Args...);
-}
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which arrays of
-objects can be allocated on the heap via array \mbox{\tcode{new}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept ArrayDeletable<typename T> : ObjectType<T> {
   void T::operator delete[](void*);
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types for which an array
-objects on the heap can be freed with \mbox{\tcode{delete[]}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept HeapAllocatable<typename T>
- : Newable<T>, Deletable<T>, ArrayNewable<T>, ArrayDeletable<T> { }
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which objects and
+\addedConcepts{\mbox{\reallynote} describes types for which objects and
 arrays of objects can be allocated on or freed from the heap with
 \mbox{\tcode{new}} and \mbox{\tcode{delete}}.}
 \end{itemdescr}
@@ -880,25 +844,25 @@
 \rSec2[concept.regular]{Regular types}
 
 \begin{itemdecl}
-auto concept Semiregular<typename T> : CopyConstructible<T>, CopyAssignable<T> {
+auto concept Semiregular<typename T> : CopyConstructible<T>, CopyAssignable<T>, HeapAllocatable<T> {
   requires SameType<CopyAssignable<T>::result_type, T&>;
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} collects several common
+\addedConcepts{\mbox{\reallynote} collects several common
 requirements supported by most types.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept Regular<typename T>
- : Semiregular<T>, DefaultConstructible<T>, EqualityComparable<T>, HeapAllocatable<T> { }
+ : Semiregular<T>, DefaultConstructible<T>, EqualityComparable<T> { }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes semi-regular types that are default
+\addedConcepts{\mbox{\reallynote} describes semi-regular types that are default
 constructible, have equality comparison operators, and can be
 allocated on the heap.}
 \end{itemdescr}
@@ -913,7 +877,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a conversion (explicit
+\addedConcepts{\mbox{\reallynote} describes types with a conversion (explicit
 or implicit) from one type to another.}
 \end{itemdescr}
 
@@ -925,7 +889,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an implicit conversion from one
+\addedConcepts{\mbox{\reallynote} describes types with an implicit conversion from one
 type to another.}
 \end{itemdescr}
 
@@ -938,7 +902,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} used to express the requirement that a
+\addedConcepts{\mbox{\reallynote} used to express the requirement that a
   particular integral constant expression evaluate true.}
 
 \pnum
@@ -951,199 +915,165 @@
 auto concept HasPlus<typename T, typename U = T> {
   typename result_type;
   result_type operator+(T const&, U const&);
- @\removedCC{result_type operator+(T const\&, U \&\&);}@
- @\removedCC{result_type operator+(T \&\&, U const\&);}@
- @\removedCC{result_type operator+(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a binary \mbox{\tcode{operator+}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator+}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasMinus<typename T, typename U = T> {
   typename result_type;
   result_type operator-(T const&, U const&);
- @\removedCC{result_type operator-(T const\&, U \&\&);}@
- @\removedCC{result_type operator-(T \&\&, U const\&);}@
- @\removedCC{result_type operator-(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a binary \mbox{\tcode{operator-}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator-}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasMultiply<typename T, typename U = T> {
   typename result_type;
   result_type operator*(T const&, U const&);
- @\removedCC{result_type operator*(T const\&, U \&\&);}@
- @\removedCC{result_type operator*(T \&\&, U const\&);}@
- @\removedCC{result_type operator*(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with} \changedCC{an}{a binary} \addedConcepts{\mbox{\tcode{operator*}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator*}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasDivide<typename T, typename U = T> {
   typename result_type;
   result_type operator/(T const&, U const&);
- @\removedCC{result_type operator/(T const\&, U \&\&);}@
- @\removedCC{result_type operator/(T \&\&, U const\&);}@
- @\removedCC{result_type operator/(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator/}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator/}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasModulus<typename T, typename U = T> {
   typename result_type;
   result_type operator%(T const&, U const&);
- @\removedCC{result_type operator\%(T const\&, U \&\&);}@
- @\removedCC{result_type operator\%(T \&\&, U const\&);}@
- @\removedCC{result_type operator\%(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator\%}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator\%}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasUnaryPlus<typename T> {
   typename result_type;
   result_type operator+(T const&);
- @\removedCC{result_type operator+(T \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\mbox{\note} describes types with a unary \mbox{\tcode{operator+}}.
+\mbox{\reallynote} describes types with a unary \mbox{\tcode{operator+}}.
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasNegate<typename T> {
   typename result_type;
   result_type operator-(T const&);
- @\removedCC{result_type operator-(T \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a unary \mbox{\tcode{operator-}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a unary \mbox{\tcode{operator-}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasLogicalAnd<typename T, typename U = T> {
   bool operator&&(T const&, U const&);
- @\removedCC{bool operator\&\&(T const\&, U \&\&);}@
- @\removedCC{bool operator\&\&(T \&\&, U const\&);}@
- @\removedCC{bool operator\&\&(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a logical conjunction operator.}
+\addedConcepts{\mbox{\reallynote} describes types with a logical conjunction operator.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasLogicalOr<typename T, typename U = T> {
   bool operator||(T const&, U const&);
- @\removedCC{bool operator||(T const\&, U \&\&);}@
- @\removedCC{bool operator||(T \&\&, U const\&);}@
- @\removedCC{bool operator||(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a logical disjunction operator.}
+\addedConcepts{\mbox{\reallynote} describes types with a logical disjunction operator.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasLogicalNot<typename T> {
   bool operator!(T const&);
- @\removedCC{bool operator!(T \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a logical negation operator.}
+\addedConcepts{\mbox{\reallynote} describes types with a logical negation operator.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasBitAnd<typename T, typename U = T> {
   typename result_type;
   result_type operator&(T const&, U const&);
- @\removedCC{result_type operator\&(T const\&, U \&\&);}@
- @\removedCC{result_type operator\&(T \&\&, U const\&);}@
- @\removedCC{result_type operator\&(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a binary \mbox{\tcode{operator\&}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator\&}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasBitOr<typename T, typename U = T> {
   typename result_type;
   result_type operator|(T const&, U const&);
- @\removedCC{result_type operator|(T const\&, U \&\&);}@
- @\removedCC{result_type operator|(T \&\&, U const\&);}@
- @\removedCC{result_type operator|(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator|}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator|}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasBitXor<typename T, typename U = T> {
   typename result_type;
   result_type operator^(T const&, U const&);
- @\removedCC{result_type operator\^(T const\&, U \&\&);}@
- @\removedCC{result_type operator\^(T \&\&, U const\&);}@
- @\removedCC{result_type operator\^(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator\^}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator\^}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasComplement<typename T> {
   typename result_type;
   result_type operator~(T const&);
- @\removedCC{result_type operator$\sim{}$(T \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an
+\addedConcepts{\mbox{\reallynote} describes types with an
   \mbox{\tcode{operator\~}}.}
 \end{itemdescr}
 
@@ -1151,30 +1081,24 @@
 auto concept HasLeftShift<typename T, typename U = T> {
   typename result_type;
   result_type operator<<(T const&, U const&);
- @\removedCC{result_type operator$\langle\langle$(T const\&, U \&\&);}@
- @\removedCC{result_type operator$\langle\langle$(T \&\&, U const\&);}@
- @\removedCC{result_type operator$\langle\langle$(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\mbox{\note} describes types with an \mbox{\tcode{operator$<<$}}.
+\mbox{\reallynote} describes types with an \mbox{\tcode{operator$<<$}}.
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept HasRightShift<typename T, typename U = T> {
   typename result_type;
   result_type operator>>(T const&, U const&);
- @\removedCC{result_type operator$\rangle\rangle$(T const\&, U \&\&);}@
- @\removedCC{result_type operator$\rangle\rangle$(T \&\&, U const\&);}@
- @\removedCC{result_type operator$\rangle\rangle$(T \&\&, U \&\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\mbox{\note} describes types with an \mbox{\tcode{operator$>>$}}.
+\mbox{\reallynote} describes types with an \mbox{\tcode{operator$>>$}}.
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -1186,21 +1110,19 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with a dereferencing \mbox{\tcode{operator*}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a dereferencing \mbox{\tcode{operator*}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
 auto concept Addressable<typename T> {
   typename pointer;
- @\removedCC{typename const_pointer;}@
   pointer operator&(T&);
- @\removedCC{const_pointer operator\&(const T\&);}@
 }
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types with an address-of \mbox{\tcode{operator\&}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an address-of \mbox{\tcode{operator\&}}.}
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -1212,7 +1134,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes function object types
+\addedConcepts{\mbox{\reallynote} describes function object types
 callable given arguments of types \mbox{\tcode{Args...}}.}
 \end{itemdescr}
 
@@ -1245,7 +1167,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the
   operations available on arithmetic types ([basic.fundamental]).}
 \end{itemdescr}
 
@@ -1272,7 +1194,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the operations
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the operations
   available on integral types.}
 \end{itemdescr}
 
@@ -1282,7 +1204,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the
   operations available on signed integral types.}
 
 \pnum
@@ -1299,7 +1221,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the
   operations available on unsigned integral types.}
 
 \pnum
@@ -1316,7 +1238,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes floating-point types.}
+\addedConcepts{\mbox{\reallynote} describes floating-point types.}
 
 \pnum
 \addedConcepts{\mbox{\requires}
@@ -1335,7 +1257,7 @@
 
 \begin{itemdescr}
 \pnum
-\addedConcepts{\mbox{\note} describes function objects
+\addedConcepts{\mbox{\reallynote} describes function objects
 callable with some set of arguments, the result of which can be used in a
 context that requires a \mbox{\tcode{bool}}.}
 
@@ -1388,14 +1310,12 @@
   template<ObjectType T> class rebind = @\textit{see below}@;
 
   requires Convertible<pointer, const_pointer> &&
- Convertible<pointer, void*> &&
            Convertible<pointer, value_type*> &&
            SameType<pointer::value_type, value_type> &&
            SameType<pointer::reference, value_type&> &&
            SameType<pointer::reference, reference>;
 
- requires Convertible<const_pointer, const void*> &&
- @\textcolor{addclr}{Convertible}@<const_pointer, const value_type&> &&
+ requires @\textcolor{addclr}{Convertible}@<const_pointer, const value_type*> &&
            SameType<const_pointer::value_type, value_type> &&
            SameType<const_pointer::reference, const value_type&> &&
            SameType<const_pointer::reference, const_reference>;
@@ -1556,7 +1476,7 @@
 \color{addclr}
 \begin{itemdecl}
 template<typename V>
- requires Constructible<value_type, V&&>
+ requires Constructible<value_type, V>
   void X::construct(pointer p, V&&);
 \end{itemdecl}
 \color{black}

Modified: sandbox/committee/concepts/stdlib/clib-iterators.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-iterators.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-iterators.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -30,8 +30,8 @@
 \begin{titlepage}
 \begin{center}
 \huge
-Iterator Concepts for the C++0x Standard Library
-
+Iterator Concepts for the C++0x Standard Library\\
+(Revision 1)
 \vspace{0.5in}
 
 \normalsize
@@ -40,8 +40,8 @@
 \end{center}
 
 \vspace{1in}
-\par\noindent Document number: N2500=08-0010 \vspace{-6pt}
-\par\noindent Revises document number: N2323=07-0183 \vspace{-6pt}
+\par\noindent Document number: D2570=08-0080 \vspace{-6pt}
+\par\noindent Revises document number: N2500=08-0010 \vspace{-6pt}
 \par\noindent Date: \today\vspace{-6pt}
 \par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}
 \par\noindent Reply-to: Douglas Gregor $<$\href{mailto:dgregor_at_[hidden]}{dgregor_at_[hidden]}$>$\vspace{-6pt}

Modified: sandbox/committee/concepts/stdlib/clib-numerics.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-numerics.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-numerics.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -44,7 +44,7 @@
 \end{center}
 
 \vspace{1in}
-\par\noindent Document number: DRAFT\vspace{-6pt}
+\par\noindent Document number: D2574=08-0084\vspace{-6pt}
 \par\noindent Revises document number: N2041=06-0111\vspace{-6pt}
 \par\noindent Date: \today\vspace{-6pt}
 \par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}

Modified: sandbox/committee/concepts/stdlib/macros.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/macros.tex (original)
+++ sandbox/committee/concepts/stdlib/macros.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -168,6 +168,8 @@
 \newcommand{\complexity}{\Fundesc{Complexity}}
 \newcommand{\note}{\Fundesc{Remark}}
 \newcommand{\notes}{\Fundesc{Remarks}}
+\newcommand{\reallynote}{\Fundesc{Note}}
+\newcommand{\reallynotes}{\Fundesc{Notes}}
 \newcommand{\implimits}{\Fundesc{Implementation limits}}
 \newcommand{\replaceable}{\Fundesc{Replaceable}}
 \newcommand{\exceptionsafety}{\Fundesc{Exception safety}}

Modified: sandbox/committee/concepts/wording/wording.tex
==============================================================================
--- sandbox/committee/concepts/wording/wording.tex (original)
+++ sandbox/committee/concepts/wording/wording.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -44,7 +44,7 @@
 Jeremy Siek, University of Colorado at Boulder \\
 James Widman, Gimpel Software
 \end{tabular}\vspace{-6pt}
-\par\noindent Document number: DRAFT \vspace{-6pt}
+\par\noindent Document number: D2571=08-0081 \vspace{-6pt}
 \par\noindent Revises document number: N2501=08-0011 \vspace{-6pt}
 \par\noindent Date: \today\vspace{-6pt}
 \par\noindent Project: Programming Language C++, Core Working Group\vspace{-6pt}


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk