added tons of functions to stl_concept_covering.cpp

[SVN r8359]

concept_checking.html

@@ -249,9 +249,9 @@ with foo: <tt>EqualityComparableConcept&lt;foo&gt;</tt> and then find
 a way to get the compiler to compile the <tt>constraints()</tt>
 function without actually calling it. The Boost Concept Checking
 Library defines two utilities that make this easy:
-<tt>function_requires()</tt> and <tt>class_requires</tt>.
+<tt>function_requires()</tt> and <tt>BOOST_CLASS_REQUIRES</tt>.
 <tt>function_requires()</tt> function can be used in function bodies
-and the <tt>class_requires</tt> class can be used inside class
+and the <tt>BOOST_CLASS_REQUIRES</tt> macro can be used inside class
 bodies. The <tt>function_requires()</tt> function takes no arguments,
 but has a template parameter for the concept checking class. This
 means that the instantiated concept checking class must be given as an
@@ -264,14 +264,12 @@ explicit template argument, as shown below.
   };
 </pre>
 
-The <tt>class_requires</tt> is a class template with a template
+The <tt>BOOST_CLASS_REQUIRES</tt> macro can be used inside a class
-parameter for the concept checking class. Accessing the nested
+definition to check whether some type models a concept. 
-<tt>check</tt> type within <tt>class_requires</tt> triggers the the
-concept checking.
 
 <pre>
   struct some_class_using_foo {
-    typedef class_requires&lt; EqualityComparableConcept&lt;foo&gt; &gt;::check req1;
+    BOOST_CLASS_REQUIRES(foo, EqualityComparableConcept);
   };
 </pre>
 

concept_checks_test.cpp

@@ -21,17 +21,24 @@ int
 main()
 {
   using namespace boost;
+
+  //===========================================================================
+  // Basic Concepts
   {
     typedef default_constructible_archetype<> foo;
     function_requires< DefaultConstructibleConcept<foo> >();
   }
+  {
+    typedef assignable_archetype<> foo;
+    function_requires< AssignableConcept<foo> >();
+  }
   {
     typedef copy_constructible_archetype<> foo;
     function_requires< CopyConstructibleConcept<foo> >();
   }
   {
-    typedef assignable_archetype<> foo;
+    typedef sgi_assignable_archetype<> foo;
-    function_requires< AssignableConcept<foo> >();
+    function_requires< SGIAssignableConcept<foo> >();
   }
   {
     typedef copy_constructible_archetype<> foo;
@@ -41,6 +48,66 @@ main()
   {
     function_requires< ConvertibleConcept<boolean_archetype, bool> >();
   }
+  {
+    typedef equality_comparable_archetype<> foo;
+    function_requires< EqualityComparableConcept<foo> >();
+  }
+  {
+    typedef less_than_comparable_archetype<> foo;
+    function_requires< LessThanComparableConcept<foo> >();
+  }
+  {
+    typedef comparable_archetype<> foo;
+    function_requires< ComparableConcept<foo> >();
+  }
+  {
+    typedef equal_op_first_archetype<> First;
+    typedef equal_op_second_archetype<> Second;
+    function_requires< EqualOpConcept<First, Second> >();
+  }
+  {
+    typedef not_equal_op_first_archetype<> First;
+    typedef not_equal_op_second_archetype<> Second;
+    function_requires< NotEqualOpConcept<First, Second> >();
+  }
+  {
+    typedef less_than_op_first_archetype<> First;
+    typedef less_than_op_second_archetype<> Second;
+    function_requires< LessThanOpConcept<First, Second> >();
+  }
+  {
+    typedef less_equal_op_first_archetype<> First;
+    typedef less_equal_op_second_archetype<> Second;
+    function_requires< LessEqualOpConcept<First, Second> >();
+  }
+  {
+    typedef greater_than_op_first_archetype<> First;
+    typedef greater_than_op_second_archetype<> Second;
+    function_requires< GreaterThanOpConcept<First, Second> >();
+  }
+  {
+    typedef greater_equal_op_first_archetype<> First;
+    typedef greater_equal_op_second_archetype<> Second;
+    function_requires< GreaterEqualOpConcept<First, Second> >();
+  }
+
+  {
+    typedef copy_constructible_archetype<> Return;
+    typedef plus_op_first_archetype<Return> First;
+    typedef plus_op_second_archetype<Return> Second;
+    function_requires< PlusOpConcept<Return, First, Second> >();
+  }
+
+  //===========================================================================
+  // Function Object Concepts
+
+  {
+    typedef generator_archetype<null_archetype<> > foo;
+    function_requires< GeneratorConcept<foo, null_archetype<> > >();
+  }
+  {
+    function_requires< GeneratorConcept< void_generator_archetype, void > >();
+  }
   {
     typedef unary_function_archetype<int, int> F;
     function_requires< UnaryFunctionConcept<F, int, int> >();
@@ -59,16 +126,19 @@ main()
     typedef const_binary_predicate_archetype<int, int> const_F;
     function_requires< Const_BinaryPredicateConcept<const_F, int, int> >();
   }
+
+  //===========================================================================
+  // Iterator Concepts
   {
-    typedef trivial_iterator_archetype<null_archetype> Iter;
+    typedef trivial_iterator_archetype<null_archetype<> > Iter;
     function_requires< TrivialIteratorConcept<Iter> >();
   }
   {
-    typedef mutable_trivial_iterator_archetype<null_archetype> Iter;
+    typedef mutable_trivial_iterator_archetype<null_archetype<> > Iter;
     function_requires< Mutable_TrivialIteratorConcept<Iter> >();
   }
   {
-    typedef input_iterator_archetype<null_archetype> Iter;
+    typedef input_iterator_archetype<null_archetype<> > Iter;
     function_requires< InputIteratorConcept<Iter> >();
   }
   {
@@ -76,17 +146,40 @@ main()
     function_requires< OutputIteratorConcept<Iter, int> >();
   }
   {
-    typedef forward_iterator_archetype<null_archetype> Iter;
+    typedef forward_iterator_archetype<null_archetype<> > Iter;
     function_requires< ForwardIteratorConcept<Iter> >();
   }
   {
-    typedef bidirectional_iterator_archetype<null_archetype> Iter;
+    typedef forward_iterator_archetype<assignable_archetype<> > Iter;
+    function_requires< Mutable_ForwardIteratorConcept<Iter> >();
+  }
+  {
+    typedef bidirectional_iterator_archetype<null_archetype<> > Iter;
     function_requires< BidirectionalIteratorConcept<Iter> >();
   }
   {
-    typedef random_access_iterator_archetype<null_archetype> Iter;
+    typedef bidirectional_iterator_archetype<assignable_archetype<> > Iter;
+    function_requires< Mutable_BidirectionalIteratorConcept<Iter> >();
+  }
+  {
+    typedef random_access_iterator_archetype<null_archetype<> > Iter;
     function_requires< RandomAccessIteratorConcept<Iter> >();
   }
+  {
+    typedef random_access_iterator_archetype<assignable_archetype<> > Iter;
+    function_requires< Mutable_RandomAccessIteratorConcept<Iter> >();
+  }
+
+  //===========================================================================
+  // Container Concepts
+
+  {
+    
+    function_requires< ContainerConcept< > >();
+  }
+  {
+    
+  }
 
   return 0;
 }

stl_concept_covering.cpp

@@ -10,12 +10,40 @@
 
 /*
 
-  This file uses the archetype classes to verify whether the concept
+  This file uses the archetype classes to find out which concepts
-  requirements documented for the STL algorithms actually *cover* the
+  actually *cover* the algorithms true requirements. The
-  algorithms true requirements.
+  archetypes/concepts chosen do not necessarily match the C++ standard
+  or the SGI STL documentation, but instead were chosen based on the
+  minimal concepts that current STL implementations require, which in
+  many cases is less stringent than the standard. It is an open issue
+  as to whether the C++ standard should be changed to reflect these
+  weaker requirements.
 
 */
 
+#define BOOST_HIDE_EXPECTED_ERRORS
+
+  // This is a special concept needed for std::swap_ranges.
+  // It is mutually convertible, and also SGIAssignable
+  template <class T>
+  class mutually_convertible_archetype
+  {
+  private:
+    mutually_convertible_archetype() { }
+  public:
+    mutually_convertible_archetype(const mutually_convertible_archetype&) { }
+    mutually_convertible_archetype& 
+    operator=(const mutually_convertible_archetype&)
+      { return *this; }
+    mutually_convertible_archetype(boost::detail::dummy_constructor) { }
+
+    template <class U>
+    mutually_convertible_archetype& 
+    operator=(const mutually_convertible_archetype<U>&)
+      { return *this; }
+
+  };
+
 int
 main()
 {
@@ -24,33 +52,22 @@ main()
   //===========================================================================
   // Non-mutating Algorithms
   {
-    input_iterator_archetype< convertible_to_archetype< null_archetype > > in;
+    input_iterator_archetype< 
-    unary_function_archetype< null_archetype, null_archetype> f;
+      convertible_to_archetype< null_archetype<>  > > in;
+    unary_function_archetype< null_archetype<> , null_archetype<> > 
+      f(dummy_cons);
     std::for_each(in, in, f);
   }
   {
-    /*
+    typedef equality_comparable2_first_archetype<> Left;
-      SGI STL Docs and the C++ standard (25.1.2) requirements for
+    input_iterator_archetype< Left > in;
-      std::for_each() are broken. They should be specified as follows:
+    equality_comparable2_second_archetype<> value(dummy_cons);
-
-      template <class InputIterator, class T>
-      InputIterator find(InputIterator first, InputIterator last,
-                         const T& value)
-      {
-        function_requires< InputIteratorConcept<InputIterator> >();
-        typedef typename std::iterator_traits<InputIterator>::value_type 
-          value_type;
-        function_requires< EqualityComparable2<value_type, T> >();
-        ...
-      }
-    */
-    input_iterator_archetype< null_archetype > in;
-    left_equality_comparable_archetype< null_archetype > value(dummy_cons);
     in = std::find(in, in, value);
   }
   {
-    input_iterator_archetype< convertible_to_archetype< null_archetype > > in;
+    input_iterator_archetype< 
-    unary_predicate_archetype< null_archetype > pred;
+      convertible_to_archetype< null_archetype<>  > > in;
+    unary_predicate_archetype< null_archetype<>  > pred(dummy_cons);
     in = std::find_if(in, in, pred);
   }
   {
@@ -58,146 +75,447 @@ main()
     fo = std::adjacent_find(fo, fo);
   }
   {
-    forward_iterator_archetype< convertible_to_archetype< null_archetype > > fo;
+    forward_iterator_archetype< 
-    binary_predicate_archetype<null_archetype, null_archetype> pred;
+      convertible_to_archetype< null_archetype<>  > > fo;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
     fo = std::adjacent_find(fo, fo, pred);
   }
   {
-    /* SGI STL documentation is wrong. The value type of the
+    typedef equal_op_first_archetype<> Left;
-       input iterator does not need to be equality comparable.
+    input_iterator_archetype<Left> in;
-    */
+    typedef equal_op_second_archetype<> Right;
-    input_iterator_archetype<null_archetype> in;
-    typedef left_equality_comparable_archetype<null_archetype> Right;
     forward_iterator_archetype<Right> fo;
     in = std::find_first_of(in, in, fo, fo);
   }
   {
-    typedef input_iterator_archetype<null_archetype> InIter;
+    typedef equal_op_first_archetype<> Left;
+    typedef input_iterator_archetype<Left> InIter;
     InIter in;
     function_requires< InputIteratorConcept<InIter> >();
-    left_equality_comparable_archetype<null_archetype> value(dummy_cons);
+    equal_op_second_archetype<> value(dummy_cons);
     std::iterator_traits<InIter>::difference_type
       n = std::count(in, in, value);
     ignore_unused_variable_warning(n);
   }
+#if !defined(__KCC) && !defined(BOOST_HIDE_EXPECTED_ERRORS)
   {
-    typedef input_iterator_archetype<null_archetype> InIter;
+    typedef equal_op_first_archetype<> Left;
+    typedef input_iterator_archetype<Left> InIter;
     InIter in;
-    left_equality_comparable_archetype<null_archetype> value(dummy_cons);
+    equal_op_second_archetype<> value(dummy_cons);
     unsigned long n;
     std::count(in, in, value, n);
   }
   {
-    typedef input_iterator_archetype< convertible_to_archetype<null_archetype> > InIter;
+    input_iterator_archetype< convertible_to_archetype<null_archetype<> > > in;
+    unary_predicate_archetype<null_archetype<> > pred;
+    unsigned long n;
+    std::count_if(in, in, pred, n);
+  }
+#endif
+  {
+    typedef input_iterator_archetype<
+      convertible_to_archetype<null_archetype<> > > InIter;
     InIter in;
-    unary_predicate_archetype<null_archetype> pred;
+    unary_predicate_archetype<null_archetype<> > pred(dummy_cons);
     std::iterator_traits<InIter>::difference_type
       n = std::count_if(in, in, pred);
     ignore_unused_variable_warning(n);
   }
   {
-    input_iterator_archetype< convertible_to_archetype<null_archetype> > in;
+    typedef equal_op_first_archetype<> Left;
-    unary_predicate_archetype<null_archetype> pred;
+    typedef input_iterator_archetype<Left> InIter1;
-    unsigned long n;
-    std::count_if(in, in, pred, n);
-  }
-  {
-    /*
-      SGI STL Documentation wrong. EqualityComparable not needed.
-     */
-    typedef input_iterator_archetype<null_archetype> InIter1;
     InIter1 in1;
-    typedef left_equality_comparable_archetype<null_archetype> Right;
+    typedef equal_op_second_archetype<> Right;
     typedef input_iterator_archetype<Right> InIter2;
     InIter2 in2;
     std::pair<InIter1, InIter2> p = std::mismatch(in1, in1, in2);
     ignore_unused_variable_warning(p);
   }
   {
-    typedef input_iterator_archetype< convertible_to_archetype<null_archetype> > InIter;
+    typedef input_iterator_archetype<
+      convertible_to_archetype<null_archetype<> > > InIter;
     InIter in1, in2;
-    binary_predicate_archetype<null_archetype, null_archetype> pred;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
     std::pair<InIter, InIter> p = std::mismatch(in1, in1, in2, pred);
     ignore_unused_variable_warning(p);
   }
   {
-    // SGI STL docs: EqualityComparable not needed
+    typedef equality_comparable2_first_archetype<> Left;
-    input_iterator_archetype<null_archetype> in1;
+    input_iterator_archetype<Left> in1;
-    typedef left_equality_comparable_archetype<null_archetype> Right;
+    typedef equality_comparable2_second_archetype<> Right;
     input_iterator_archetype<Right> in2;
     bool b = std::equal(in1, in1, in2);
     ignore_unused_variable_warning(b);
   }
   {
-    input_iterator_archetype< convertible_to_archetype<null_archetype> > in1, in2;
+    input_iterator_archetype< convertible_to_archetype<null_archetype<> > >
-    binary_predicate_archetype<null_archetype, null_archetype> pred;
+      in1, in2;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
     bool b = std::equal(in1, in1, in2, pred);
     ignore_unused_variable_warning(b);
   }
   {
-    // SGI STL docs: EqualityComparable not needed
+    typedef equality_comparable2_first_archetype<> Left;
-    forward_iterator_archetype<null_archetype> fo1;
+    forward_iterator_archetype<Left> fo1;
-    typedef left_equality_comparable_archetype<null_archetype> Right;
+    typedef equality_comparable2_second_archetype<> Right;
     forward_iterator_archetype<Right> fo2;
     fo1 = std::search(fo1, fo1, fo2, fo2);
   }
   {
-    // SGI STL docs: LeftEqualityComparable missing
+    typedef equality_comparable2_first_archetype< 
-    // search() calls find()
+      convertible_to_archetype<null_archetype<> > > Left;
-    typedef convertible_to_archetype<null_archetype> Left;
     forward_iterator_archetype<Left> fo1;
-    typedef convertible_to_archetype<null_archetype,
+    typedef equality_comparable2_second_archetype<
-      left_equality_comparable_archetype<Left> > Right;
+      convertible_to_archetype<null_archetype<> > > Right;
     forward_iterator_archetype<Right> fo2;
-    binary_predicate_archetype<null_archetype, null_archetype> pred;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
     fo1 = std::search(fo1, fo1, fo2, fo2, pred);
   }
   {
-    // SGI STL docs: EqualityComparable not needed
+    typedef equality_comparable2_first_archetype<> Left;
-    forward_iterator_archetype<null_archetype> fo;
+    forward_iterator_archetype<Left> fo;
-    left_equality_comparable_archetype<null_archetype> value(dummy_cons);
+    equality_comparable2_second_archetype<> value(dummy_cons);
-    int n;
+    int n = 1;
     fo = std::search_n(fo, fo, n, value);
   }
   {
-    // SGI STL docs: EqualityComparable not needed
+    forward_iterator_archetype< 
-    forward_iterator_archetype< convertible_to_archetype<null_archetype> > fo;
+      convertible_to_archetype<null_archetype<> > > fo;
-    convertible_to_archetype<null_archetype> value(dummy_cons);
+    convertible_to_archetype<null_archetype<> > value(dummy_cons);
-    binary_predicate_archetype<null_archetype, null_archetype> pred;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
-    int n;
+      pred(dummy_cons);
+    int n = 1;
     fo = std::search_n(fo, fo, n, value, pred);
   }
   {
-    forward_iterator_archetype<null_archetype> fo1;
+    typedef equality_comparable2_first_archetype<> Left;
-    typedef left_equality_comparable_archetype<null_archetype> Right;
+    forward_iterator_archetype<Left> fo1;
+    typedef equality_comparable2_second_archetype<null_archetype<> > Right;
     forward_iterator_archetype<Right> fo2;
     fo1 = std::find_end(fo1, fo1, fo2, fo2);
   }
   {
-    // SGI STL docs: LeftEqualityComparable missing
+    // equality comparable required because find_end() calls search
-    typedef convertible_to_archetype<null_archetype> Left;
+    typedef equality_comparable2_first_archetype<
+      convertible_to_archetype<null_archetype<> > > Left;
     forward_iterator_archetype<Left> fo1;
-    typedef convertible_to_archetype<null_archetype,
+    typedef equality_comparable2_second_archetype<
-      left_equality_comparable_archetype<Left> > Right;
+      convertible_to_archetype<null_archetype<> > > Right;
     forward_iterator_archetype<Right> fo2;
-    binary_predicate_archetype<null_archetype, null_archetype> pred;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
     fo1 = std::find_end(fo1, fo1, fo2, fo2, pred);
   }
 
   //===========================================================================
   // Mutating Algorithms
 
-  // UNDER CONSTRUCTION
-
   {
-    // SGI STL docs missing CopyConstructible and Assignable
+    typedef null_archetype<> OutT;
-    typedef equality_comparable_archetype< copy_constructible_archetype< 
+    typedef convertible_to_archetype<OutT> InT;
-      assignable_archetype<> > > T;
+    input_iterator_archetype<InT> in;
+    output_iterator_archetype<OutT> out;
+    out = std::copy(in, in, out);
+  }
+#if !defined(__KCC)
+  {
+    // Not in the C++ standard
+    typedef null_archetype<> OutT;
+    typedef convertible_to_archetype<OutT> InT;
+    input_iterator_archetype<InT> in;
+    output_iterator_archetype<OutT> out;
+    int count = 1;
+    std::pair<input_iterator_archetype<InT>,
+      output_iterator_archetype<OutT> > result = std::copy_n(in, count, out);
+    ignore_unused_variable_warning(result);
+  }
+#endif
+  {
+    typedef assignable_archetype<> OutT;
+    typedef convertible_to_archetype<OutT> InT;
+    bidirectional_iterator_archetype<InT> bid_in;
+    bidirectional_iterator_archetype<OutT> bid_out;
+    bid_out = std::copy_backward(bid_in, bid_in, bid_out);
+  }
+  {
+    sgi_assignable_archetype<> a(dummy_cons), b(dummy_cons);
+    std::swap(a, b);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    forward_iterator_archetype<T> a, b;
+    std::iter_swap(a, b);
+  }
+  {
+    typedef mutually_convertible_archetype<int> Tin;
+    typedef mutually_convertible_archetype<char> Tout;
+    forward_iterator_archetype<Tin> fi1;
+    forward_iterator_archetype<Tout> fi2;
+    fi2 = std::swap_ranges(fi1, fi1, fi2);
+  }
+  {
+    typedef convertible_to_archetype<null_archetype<> > Tin;
+    typedef null_archetype<> Tout;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    unary_function_archetype<null_archetype<> , 
+      convertible_to_archetype<Tout> > op(dummy_cons);
+    out = std::transform(in, in, out, op);
+  }
+  {
+    typedef convertible_to_archetype<null_archetype<int> > Tin1;
+    typedef convertible_to_archetype<null_archetype<char> > Tin2;
+    typedef null_archetype<> Tout;
+    input_iterator_archetype<Tin1> in1;
+    input_iterator_archetype<Tin2> in2;
+    output_iterator_archetype<Tout> out;
+    binary_function_archetype<null_archetype<int>, null_archetype<char>,
+      convertible_to_archetype<Tout> > op(dummy_cons);
+    out = std::transform(in1, in1, in2, out, op);
+  }
+  {
+    typedef equality_comparable2_first_archetype<
+      assignable_archetype<> > FT;
+    forward_iterator_archetype<FT> fi;
+    equality_comparable2_second_archetype<
+      convertible_to_archetype<FT> > value(dummy_cons);
+    std::replace(fi, fi, value, value);
+  }
+  {
+    typedef null_archetype<> PredArg;
+    typedef assignable_archetype< 
+      convertible_to_archetype<PredArg> > FT;
+    forward_iterator_archetype<FT> fi;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    convertible_to_archetype<FT> value(dummy_cons);
+    std::replace_if(fi, fi, pred, value);
+  }
+  {
+#if 0
+    // Issue, the use of ?: inside replace_copy() complicates things
+    typedef equal_op_first_archetype<> Tin;
+    typedef null_archetype<> Tout;
+    typedef equal_op_second_archetype< convertible_to_archetype<Tout> > T;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    T value(dummy_cons);
+    out = std::replace_copy(in, in, out, value, value);
+#else
+    typedef null_archetype<> Tout;
+    typedef equal_op_second_archetype< convertible_to_archetype<Tout> > T;
+    // Adding convertible to T for Tin solves the problem, so would
+    // making T convertible to Tin. Not sure what the right way to
+    // express the requirement would be. Also, perhaps the
+    // implementation's use of ?: is invalid.
+    typedef equal_op_first_archetype< convertible_to_archetype<T> > Tin;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    T value(dummy_cons);
+    out = std::replace_copy(in, in, out, value, value);
+#endif
+  }
+  {
+    // The issue of ?: also affects this function
+    typedef null_archetype<int> PredArg;
+    typedef null_archetype<char> Tout;
+    typedef convertible_to_archetype<Tout, 
+      convertible_to_archetype<PredArg> > T;
+    typedef convertible_to_archetype<PredArg,
+      convertible_to_archetype<Tout,
+      convertible_to_archetype<T> > > Tin;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    T value(dummy_cons);
+    out = std::replace_copy_if(in, in, out, pred, value);
+  }
+  {
+    typedef assignable_archetype<> FT;
+    forward_iterator_archetype<FT> fi;
+    typedef convertible_to_archetype<FT> T;
+    T value(dummy_cons);
+    std::fill(fi, fi, value);
+  }  
+  {
+    typedef null_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> T;
+    output_iterator_archetype<Tout> out;
+    T value(dummy_cons);
+    int n = 1;
+    out = std::fill_n(out, n, value);
+  }
+  {
+    typedef assignable_archetype<> FT;
+    typedef convertible_to_archetype<FT> Ret;
+    forward_iterator_archetype<FT> fi;
+    generator_archetype<Ret> gen;
+    std::generate(fi, fi, gen);
+  }
+  {
+    typedef assignable_archetype<> FT;
+    typedef convertible_to_archetype<FT> Ret;
+    forward_iterator_archetype<FT> fi;
+    generator_archetype<Ret> gen;
+    int n = 1;
+    std::generate_n(fi, n, gen);
+  }
+  {
+    typedef assignable_archetype< equality_comparable2_first_archetype<> > FT;
+    typedef equality_comparable2_second_archetype<> T;
+    forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    fi = std::remove(fi, fi, value);
+  }
+  {
+    typedef assignable_archetype<> FT;
+    forward_iterator_archetype<FT> fi;
+    typedef null_archetype<> PredArg;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    fi = std::remove_if(fi, fi, pred);
+  }
+  {
+    typedef null_archetype<> Tout;
+    typedef equality_comparable2_first_archetype<
+      convertible_to_archetype<Tout> > Tin;
+    typedef equality_comparable2_second_archetype<> T;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    T value(dummy_cons);
+    out = std::remove_copy(in, in, out, value);
+  }
+  {
+    typedef null_archetype<int> Tout;
+    typedef null_archetype<char> PredArg;
+    typedef convertible_to_archetype<PredArg,
+      convertible_to_archetype<Tout> > Tin;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    out = std::remove_copy_if(in, in, out, pred);
+  }
+  {
+    typedef sgi_assignable_archetype< equality_comparable_archetype<> > T;
+    forward_iterator_archetype<T> fi;
+    fi = std::unique(fi, fi);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Arg1,
+      convertible_to_archetype<Arg2> > > FT;
+    forward_iterator_archetype<FT> fi;
+    binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
+    fi = std::unique(fi, fi, pred);
+  }
+  {
+    typedef equality_comparable_archetype< sgi_assignable_archetype<> > T;
     input_iterator_archetype<T> in;
-    output_iterator_archetype out;
+    output_iterator_archetype<T> out;
     out = std::unique_copy(in, in, out);
   }
-
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef null_archetype<short> Tout;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Tout,
+      convertible_to_archetype<Arg1,
+      convertible_to_archetype<Arg2> > > > Tin;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out;
+    binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
+    out = std::unique_copy(in, in, out, pred);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    bidirectional_iterator_archetype<T> bi;
+    std::reverse(bi, bi);
+  }
+  {
+    typedef null_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> Tin;
+    bidirectional_iterator_archetype<Tin> bi;
+    output_iterator_archetype<Tout> out;
+    out = std::reverse_copy(bi, bi, out);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    forward_iterator_archetype<T> fi;
+    // Issue, SGI STL is not have void return type, C++ standard does
+    std::rotate(fi, fi, fi);
+  }
+  {
+    typedef null_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> FT;
+    forward_iterator_archetype<FT> fi;
+    output_iterator_archetype<Tout> out;
+    out = std::rotate_copy(fi, fi, fi, out);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    random_access_iterator_archetype<T> ri;
+    std::random_shuffle(ri, ri);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    random_access_iterator_archetype<T> ri;
+    unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
+    std::random_shuffle(ri, ri, ran);
+  }
+#if !defined(__KCC)
+  {
+    typedef assignable_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> Tin;
+    input_iterator_archetype<Tin> in; 
+    random_access_iterator_archetype<Tout> ri_out;
+    ri_out = std::random_sample(in, in, ri_out, ri_out);
+  }
+  {
+    typedef assignable_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> Tin;
+    input_iterator_archetype<Tin> in; 
+    random_access_iterator_archetype<Tout> ri_out;
+    unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
+    ri_out = std::random_sample(in, in, ri_out, ri_out, ran);
+  }
+  {
+    typedef assignable_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> Tin;
+    forward_iterator_archetype<Tin> in; 
+    output_iterator_archetype<Tout> out;
+    int n = 1;
+    out = std::random_sample_n(in, in, out, n);
+  }
+  {
+    typedef assignable_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> Tin;
+    input_iterator_archetype<Tin> in; 
+    forward_iterator_archetype<Tout> out;
+    unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
+    int n = 1;
+    out = std::random_sample_n(in, in, out, n, ran);
+  }
+#endif
+  {
+    typedef null_archetype<> PredArg;
+    typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
+    bidirectional_iterator_archetype<FT> bi;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    bi = std::partition(bi, bi, pred);
+  }
+  {
+    typedef null_archetype<> PredArg;
+    typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
+    forward_iterator_archetype<FT> fi;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    fi = std::stable_partition(fi, fi, pred);
+  }
   //===========================================================================
   // Sorting Algorithms