first update ... more to come

[SVN r40508]

doc/Jamfile.v2

@@ -2,7 +2,7 @@
 use-project boost : $(BOOST_ROOT) ;
 
 
-#import boostbook : boostbook ;
+import boostbook : boostbook ;
 import quickbook ;
 
 xml boost_range : boost_range.qbk ;
@@ -11,8 +11,12 @@ boostbook standalone
   :
     boost_range
   :
-    <xsl:param>generate.section.toc.level=4
+    <xsl:param>toc.max.depth=2
-    <xsl:param>chunk.first.sections=7
+    <xsl:param>toc.section.depth=4
-    <xsl:param>toc.section.depth=10
+    <xsl:param>chunk.section.depth=2
+ 
+#    <xsl:param>generate.section.toc.level=4
+#    <xsl:param>chunk.first.sections=7
+#    <xsl:param>toc.section.depth=10
   ;
 

doc/boost_range.html

@@ -31,19 +31,12 @@
         <a name="overview"></a>
         <h3>Overview</h3>
         <p>
-			Four types of objects are currently supported by the library:
+            Three types of objects are currently supported by the library:
             <ul>
                 <li>
                 standard-like containers
                 <li>
                     <code>std::pair&lt;iterator,iterator&gt;</code>
-				<li>
-					null terminated strings (this includes <code>char[]</code>,<code>wchar_t[]</code>,
-					<code>char*</code>, and <code>wchar_t*</code>)
-					<p>
-						<b>Warning:</b><i> support for null-terminated strings is deprecated and will 
-							disappear in the next Boost release (1.34). </i>
-					</p>
                   <li>
                     built-in arrays
                 </li>
@@ -69,17 +62,21 @@
     // Single Pass Range metafunctions
     //
                    
-    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#range_value"><span 
-class=identifier>range_value</span></a><span class=special>;
-                 
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
     </span><span class=keyword>struct </span><a href="#range_iterator"><span 
 class=identifier>range_iterator</span></a><span class=special>;
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#range_const_iterator"><span 
+    </span><span class=keyword>struct </span><a href="#range_value"><span 
-class=identifier>range_const_iterator</span></a><span class=special>;
+class=identifier>range_value</span></a><span class=special>;
+  
+    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
+    </span><span class=keyword>struct </span><a href="#range_pointer"><span 
+class=identifier>range_pointer</span></a><span class=special>;
+    
+    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
+    </span><span class=keyword>struct </span><a href="#range_category"><span 
+class=identifier>range_category</span></a><span class=special>;
 
     </span><span class=comment>//
     // Forward Range metafunctions
@@ -89,10 +86,6 @@ class=identifier>range_const_iterator</span></a><span class=special>;
     </span><span class=keyword>struct </span><a href="#range_difference"><span 
 class=identifier>range_difference</span></a><span class=special>;
     
-    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#range_size"><span 
-class=identifier>range_size</span></a><span class=special>;
-    
     </span><span class=comment>//
     // Bidirectional Range metafunctions
     //
@@ -102,23 +95,13 @@ class=identifier>range_size</span></a><span class=special>;
 href="#range_reverse_iterator"><span
 class=identifier>range_reverse_iterator</span></a><span class=special>;
 
-    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a 
-href="#range_const_reverse_iterator"><span
-class=identifier>range_const_reverse_iterator</span></a><span class=special>;
-    
     </span><span class=comment>//
-    // Special metafunctions
+    // Random Access Range metafunctions
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#range_result_iterator"><span 
+    </span><span class=keyword>struct </span><a href="#range_size"><span 
-class=identifier>range_result_iterator</span></a><span class=special>;
+class=identifier>range_size</span></a><span class=special>;
-                 
-    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a 
-href="#range_reverse_result_iterator"><span
-class=identifier>range_reverse_result_iterator</span></a><span class=special>;
     
     </span><span class=comment>//
     // Single Pass Range functions
@@ -129,7 +112,7 @@ class=identifier>range_reverse_result_iterator</span></a><span class=special>;
     </span><a href="#begin"><span class=identifier>begin</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#begin"><span class=identifier>begin</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
         
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
@@ -137,7 +120,7 @@ class=identifier>range_reverse_result_iterator</span></a><span class=special>;
     </span><a href="#end"><span class=identifier>end</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
                       
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#end"><span class=identifier>end</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
@@ -149,8 +132,8 @@ class=identifier>range_reverse_result_iterator</span></a><span class=special>;
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_size</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_difference</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
-    </span><a href="#size"><span class=identifier>size</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
+    </span><a href="#size"><span class=identifier>distance</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
                             
     </span><span class=comment>//
     // Bidirectional Range functions
@@ -161,7 +144,7 @@ class=identifier>range_reverse_result_iterator</span></a><span class=special>;
     </span><a href="#rbegin"><span class=identifier>rbegin</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#rbegin"><span class=identifier>rbegin</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
         
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
@@ -169,28 +152,37 @@ class=identifier>range_reverse_result_iterator</span></a><span class=special>;
     </span><a href="#rend"><span class=identifier>rend</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
                       
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#rend"><span class=identifier>rend</span></a><span class=special>( </span><span class=keyword>const </span><span 
 class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     </span>
+	               
+    </span><span class=comment>//
+    // Random Access Range functions
+    //
+    
+    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_size</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><a href="#size"><span class=identifier>size</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
+	
     <span class=comment>//
     // Special const Range functions
     // 
     </span>
     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
-    <span class=keyword>typename </span><span class=identifier>range_const_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
+    <span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
     <a href="#const_begin"><span class=identifier>const_begin</span></a><span class=special>(</span><span class=keyword> const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
     </span>
     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
-    <span class=keyword>typename </span><span class=identifier>range_const_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
+    <span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
     <a href="#const_end"><span class=identifier>const_end</span></a><span class=special>(</span><span class=keyword> const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
     </span>
     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
-    <span class=keyword>typename </span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
+    <span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
     <a href="#const_rbegin"><span class=identifier>const_rbegin</span></a><span class=special>(</span><span class=keyword> const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
     </span>
     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
-    <span class=keyword>typename </span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
+    <span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
     <a href="#const_rend"><span class=identifier>const_rend</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);</span>
 
 <span class=special>} </span><span class=comment>// namespace 'boost' 

doc/headers.html

@@ -49,6 +49,12 @@
             <td  ><a href="boost_range.html#range_iterator"
                                                 >range_iterator</a></td>
             <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
+        </tr>
+		<tr  >
+            <td  ><code  >&lt;boost/range/mutable_iterator.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#range_mutable_iterator"
+                                                >range_mutable_iterator</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/const_iterator.hpp&gt;</code></td>
@@ -68,26 +74,23 @@
             <td><a href="range.html#forward_range">Forward Range</a> </td>
         </tr>
 		<tr  >
-            <td  ><code  >&lt;boost/range/result_iterator.hpp&gt;</code></td>
+            <td  ><code  >&lt;boost/range/pointer.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#range_result_iterator"
+            <td  ><a href="boost_range.html#range_pointer" 
-                >range_result_iterator</a></td>
+				>range_pointer</a></td>
             <td>- </td>
         </tr>
+		<tr  >
+            <td  ><code  >&lt;boost/range/category.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#range_category" 
+				>range_category</a></td>
+            <td>- </td>
+        </tr>
+
         <tr  >
             <td  ><code  >&lt;boost/range/reverse_iterator.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#range_reverse_iterator" >range_reverse_iterator</a></td>
             <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
-        <tr  >
-            <td  ><code  >&lt;boost/range/const_reverse_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#range_const_reverse_iterator" >range_const_reverse_iterator</a></td>
-            <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
-        </tr>
-        <tr  >
-            <td  ><code  >&lt;boost/range/reverse_result_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#range_reverse_result_iterator">range_reverse_result_iterator</a></td>
-            <td>- </td>
-        </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/begin.hpp&gt;</code></td>
             <td  >
@@ -108,11 +111,17 @@
             <td  ><code  >&lt;boost/range/empty.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#empty" >empty</a></td>
             <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
+        </tr>
+		<tr  >
+            <td  ><code  >&lt;boost/range/distance.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#distance" >distance</a></td>
+            <td><a href="range.html#forward_range">Forward Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/size.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#size" >size</a></td>
-            <td><a href="range.html#forward_range">Forward Range</a> </td>
+            <td><a href="range.html#random_access_range">Random Access Range</a> 
+				</td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/rbegin.hpp&gt;</code></td>
@@ -130,6 +139,21 @@
             </td>
             <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
+		<tr  >
+            <td  ><code  >&lt;boost/range/as_array.hpp&gt;</code></td>
+            <td  >
+                 <a href="boost_range.html#as_array" >as_array</a>
+            </td>
+            <td>-</td>
+        </tr>
+	    <tr  >
+            <td  ><code  >&lt;boost/range/as_literal.hpp&gt;</code></td>
+            <td  >
+                 <a href="boost_range.html#as_literal" >as_literal</a>
+            </td>
+            <td>-</td>
+        </tr>
+
         <tr  >
             <td  ><code >&lt;boost/range/iterator_range.hpp&gt;</code></td>
             <td  ><a href="utility_class.html#iter_range"

doc/intro.html

@@ -60,22 +60,14 @@ free-standing functions so syntactic and/or semantic differences can be removed.
             more flexible, compact and maintainable client code
         </li>
         <li  >
-            correct handling of null-terminated strings
+        safe use of built-in arrays
-            <p>
-            <b>Warning:</b><i> support for null-terminated strings is deprecated and will
-              disappear in the next Boost release (1.34). </i>
-             </p>
         </li>
-        <li  >
-        safe use of built-in arrays (for legacy code; why else would you use
-        built-in arrays?) </li>
 
     </ul>
     </p>
     <p  >
-    Below are given a small example (the complete example can be found <a href="../test/algorithm_example.cpp" target="_self" >here</a>
+    Below are given a small example (the complete example can be found <a 
-    ):
+    href="../test/algorithm_example.cpp" target="_self" >here</a>): <blockquote>
-    <blockquote>
         <pre  >
 <span class=comment>
     //
@@ -89,7 +81,7 @@ free-standing functions so syntactic and/or semantic differences can be removed.
     </span><span class=special>}
 
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_const_iterator</span><span class=special>&lt; </span><span
+    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=keyword>const </span><span
 class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
     </span><span class=identifier>find</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardReadableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value </span><span class=special>)
     </span><span class=special>{
@@ -100,7 +92,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
     // replace first value and return its index
     //
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_size</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_difference</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type
     </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>replacement </span><span class=special>)
     </span><span class=special>{
        </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>found </span><span class=special>= </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>value </span><span class=special>);
@@ -146,7 +138,7 @@ Notice that we have to
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+    (C) Copyright Thorsten Ottosen 2003-2007
     </p>
 
     <br>

doc/utility_class.html

@@ -173,11 +173,11 @@ class=keyword>const;</span>
                          </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>End </span><span class=special>);
        
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
-    </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>iterator_of</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
+    </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>iterator</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
     </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
 
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
-    </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>const_iterator_of</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
+    </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>const_iterator</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
     </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
     </span>
     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Range </span><span class=special>&gt;</span>
@@ -305,7 +305,7 @@ class can propagate constness since it knows what a corresponding
         </span><span class=identifier>sub_range</span><span class=special>( </span><span class=identifier>ForwardRange2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
          
         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardRange2 </span><span class=special>&gt;
-        </span><span class=identifier>sub_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>Range2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
+        </span><span class=identifier>sub_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
          
         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardRange2 </span><span class=special>&gt;
         </span><span class=identifier>sub_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=identifier>ForwardRange2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);