Re: [boost] patch: boost/lambda/algorithm.hpp, count and mismatch

From: Jaakko Jarvi (jajarvi_at_[hidden])
Date: 2003-12-10 17:51:55

> Count and mismatch are broken,  While I was on the file I messed with
> some other stuff.  See below:

Thanks!
I committed in your patch (for the most part), and added a test file
for BLL algorithms, which was missing. The file still needs more tests,
though.

> My Q's and A's
>
> Q: Should all constant reference parameters in standard algorithms be
> constant int BLL clones?

I don't understand the question. Did you mean 'constant in ...'?
Or constant references in ...?

  Best, Jaakko

>

> A: Yes, why copy?
>
> Q: Should this use reference_wrapper instead?
>
> A: I don't know
>
> Q: Should all member functions be constant?  constant volatile?
>
> A: Yes. I don't know, is there any reason to make them volatile?
>
> Q: Should the number of template parameters be the same as in the standard?
>
> A: Yes.
>
> Q: Should we generate all of these via the preprocessor library?
>
> A: I don't know.
>
> Diff file is below.  Please excuse me not sending it as an attachment -
> my mail reader crashes when I try to do so.
>
> Jim Apple
>
> --- algorithm.hpp	2002-10-30 16:10:03.000000000 -0500
> +++ algorithm4.hpp	2003-12-08 19:20:41.000000000 -0500
> @@ -38,9 +38,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     C
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::for_each(a, b, c); }
>   };
>
> @@ -55,9 +55,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, const C& c) const
> +  operator()(A a, A b, const C& c) const
>     { return ::std::find(a, b, c); }
>   };
>
> @@ -73,9 +73,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::find_if(a, b, c); }
>   };
>
> @@ -90,14 +90,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, C d) const
>     { return ::std::find_end(a, b, c, d); }
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     A
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return ::std::find_end(a, b, c, d, e); }
>
>   };
> @@ -113,14 +113,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, C d) const
>     { return ::std::find_first_of(a, b, c, d); }
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     A
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return ::std::find_first_of(a, b, c, d, e); }
>
>   };
> @@ -136,14 +136,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     A
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { return ::std::adjacent_find(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::adjacent_find(a, b, c); }
>
>   };
> @@ -161,10 +161,10 @@
>       >::difference_type type;
>     };
>
> -  template <class A, class B >
> +  template <class A, class C >
>     typename ::std::iterator_traits<A>::difference_type
> -  operator()(A a, B b) const
> -  { return ::std::count(a, b); }
> +  operator()(A a, A b, const C& c) const
> +  { return ::std::count(a, b, c); }
>   };
>
>   // count_if  ---------------------------------
> @@ -180,9 +180,9 @@
>       >::difference_type type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     typename ::std::iterator_traits<A>::difference_type
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::count_if(a, b, c); }
>   };
>
> @@ -195,21 +195,25 @@
>     struct sig {
>       typedef typename boost::remove_const<
>           typename boost::tuples::element<1, Args>::type
> -     >::type element_type;
> +     >::type element1_type;
>
> -    typedef ::std::pair< element_type, element_type > type;
> -   };
> +    typedef typename boost::remove_const<
> +      typename boost::tuples::element<3, Args>::type
> +    >::type element2_type;
>
> -  template <class A, class B >
> -  ::std::pair<A,A>
> -  operator()(A a, B b) const
> -  { return ::std::mismatch(a, b); }
> +    typedef ::std::pair< element1_type, element2_type > type;
> +   };
>
> -  template <class A, class B, class C>
> -  ::std::pair<A,A>
> -  operator()(A a, B b, C c) const
> +  template <class A, class C>
> +  ::std::pair<A,C>
> +  operator()(A a, A b, C c) const
>     { return ::std::mismatch(a, b, c); }
>
> +  template <class A, class C, class D>
> +  ::std::pair<A,C>
> +  operator()(A a, A b, C c, D d) const
> +  { return ::std::mismatch(a, b, c, d); }
> +
>   };
>
>   // equal  ---------------------------------
> @@ -221,14 +225,14 @@
>       typedef bool type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     bool
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::equal(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     bool
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, D d) const
>     { return ::std::equal(a, b, c, d); }
>
>   };
> @@ -244,14 +248,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, C d) const
>     { return std::search(a, b, c, d);}
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     A
> -  operator()(A a,  B b,  C c,  D d,  E e)
> +  operator()(A a, A b, C c, C d, E e) const
>     { return std::search(a, b, c, d, e);}
>
>   };
> @@ -267,9 +271,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     C
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::copy(a, b, c); }
>
>   };
> @@ -285,9 +289,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     C
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::copy_backward(a, b, c); }
>
>   };
> @@ -301,9 +305,9 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::swap(a, b); }
>
>   };
> @@ -319,9 +323,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     C
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::swap_ranges(a, b, c); }
>
>   };
> @@ -335,9 +339,9 @@
>        typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::iter_swap(a, b); }
>
>   };
> @@ -357,14 +361,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     C
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, D d) const
>     { return std::transform(a, b, c, d);}
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class D, class E>
>     D
> -  operator()(A a,  B b,  C c,  D d,  E e)
> +  operator()(A a, A b, C c, D d, E e) const
>     { return std::transform(a, b, c, d, e);}
>
>   };
> @@ -378,9 +382,9 @@
>       typedef void type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, const C& c, const C& d) const
>     { ::std::replace(a, b, c, d); }
>
>   };
> @@ -394,9 +398,9 @@
>       typedef void type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     void
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, const D& d) const
>     { ::std::replace_if(a, b, c, d); }
>
>   };
> @@ -412,9 +416,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class D>
>     C
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, const D& d, const D& e) const
>     { return ::std::replace_copy(a, b, c, d, e); }
>
>   };
> @@ -430,9 +434,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class D, class E>
>     C
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, D d, const E& e) const
>     { return ::std::replace_copy_if(a, b, c, d, e); }
>
>   };
> @@ -446,9 +450,9 @@
>        typedef void type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { ::std::fill(a, b, c); }
>
>   };
> @@ -464,7 +468,7 @@
>
>     template <class A, class B, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, B b, const C& c) const
>     { ::std::fill_n(a, b, c); }
>
>   };
> @@ -478,9 +482,9 @@
>        typedef void type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::generate(a, b, c); }
>
>   };
> @@ -512,9 +516,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { return ::std::remove(a, b, c); }
>   };
>
> @@ -529,9 +533,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::remove_if(a, b, c); }
>   };
>
> @@ -546,9 +550,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D >
> +  template <class A, class C, class D >
>     C
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, const D& d) const
>     { return ::std::remove_copy(a, b, c, d); }
>   };
>
> @@ -563,9 +567,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D >
> +  template <class A, class C, class D >
>     C
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, D d) const
>     { return ::std::remove_copy_if(a, b, c, d); }
>   };
>
> @@ -580,14 +584,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     A
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { return ::std::unique(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::unique(a, b, c); }
>
>   };
> @@ -603,14 +607,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     C
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::unique_copy(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     C
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, D d) const
>     { return ::std::unique_copy(a, b, c, d); }
>
>   };
> @@ -624,9 +628,9 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::reverse(a, b); }
>
>   };
> @@ -642,9 +646,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     C
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::reverse_copy(a, b, c); }
>
>   };
> @@ -658,9 +662,9 @@
>       typedef void type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, A c) const
>     { ::std::rotate(a, b, c); }
>
>   };
> @@ -676,9 +680,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class D>
>     C
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, A c, D d) const
>     { return ::std::rotate_copy(a, b, c, d); }
>
>   };
> @@ -692,14 +696,14 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::random_shuffle(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { ::std::random_shuffle(a, b, c); }
>
>   };
> @@ -716,9 +720,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::partition(a, b, c); }
>
>   };
> @@ -734,9 +738,9 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::stable_partition(a, b, c); }
>
>   };
> @@ -750,14 +754,14 @@
>        typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::sort(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::sort(a, b, c); }
>
>   };
> @@ -771,14 +775,14 @@
>        typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::stable_sort(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::stable_sort(a, b, c); }
>
>   };
> @@ -792,14 +796,14 @@
>        typedef void type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, A c) const
>     { ::std::partial_sort(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class D>
>     void
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, A c, D d) const
>     { ::std::partial_sort(a, b, c, d); }
>
>   };
> @@ -815,14 +819,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D >
> +  template <class A, class C>
>     C
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, C d) const
>     { return ::std::partial_sort_copy(a, b, c, d); }
>
> -  template <class A, class B, class C, class D, class E >
> +  template <class A, class C, class E >
>     C
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return ::std::partial_sort_copy(a, b, c, d, e); }
>   };
>
> @@ -835,14 +839,14 @@
>        typedef void type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, A c) const
>     { ::std::nth_element(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class D>
>     void
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, A c, D d) const
>     { ::std::nth_element(a, b, c, d); }
>
>   };
> @@ -858,14 +862,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { return ::std::lower_bound(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     A
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, const C& c, D d) const
>     { return ::std::lower_bound(a, b, c, d); }
>
>   };
> @@ -881,14 +885,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { return ::std::upper_bound(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     A
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, const C& c, D d) const
>     { return ::std::upper_bound(a, b, c, d); }
>
>   };
> @@ -906,14 +910,14 @@
>       typedef ::std::pair< element_type, element_type > type;
>      };
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     ::std::pair<A,A>
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { return ::std::equal_range(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     ::std::pair<A,A>
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, const C& c, D d) const
>     { return ::std::equal_range(a, b, c, d); }
>
>   };
> @@ -927,14 +931,14 @@
>       typedef bool type;
>     };
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     bool
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, const C& c) const
>     { return ::std::binary_search(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C, class D>
>     bool
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, const C& c, D d) const
>     { return ::std::binary_search(a, b, c, d); }
>
>   };
> @@ -950,14 +954,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     E
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return std::merge(a, b, c, d, e);}
>
> -  template <class A, class B, class C, class D, class E, class F>
> +  template <class A, class C, class E, class F>
>     E
> -  operator()(A a,  B b,  C c,  D d,  E e, F f)
> +  operator()(A a, A b, C c, C d, E e, F f) const
>     { return std::merge(a, b, c, d, e, f);}
>
>   };
> @@ -971,14 +975,14 @@
>       typedef void type;
>     };
>
> -  template <class A, class B, class C>
> +  template <class A>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, A c) const
>     { ::std::inplace_merge(a, b, c); }
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class D>
>     void
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, A c, D d) const
>     { ::std::inplace_merge(a, b, c, d); }
>
>   };
> @@ -992,14 +996,14 @@
>       typedef bool type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C>
>     bool
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, C d) const
>     { return ::std::includes(a, b, c, d); }
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     bool
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return ::std::includes(a, b, c, d, e); }
>
>   };
> @@ -1015,14 +1019,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     E
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return std::set_union(a, b, c, d, e);}
>
> -  template <class A, class B, class C, class D, class E, class F>
> +  template <class A, class C, class E, class F>
>     E
> -  operator()(A a,  B b,  C c,  D d, E e, F f)
> +  operator()(A a, A b, C c, C d, E e, F f) const
>     { return std::set_union(a, b, c, d, e, f);}
>
>   };
> @@ -1038,14 +1042,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     E
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return std::set_intersection(a, b, c, d, e);}
>
> -  template <class A, class B, class C, class D, class E, class F>
> +  template <class A, class C, class E, class F>
>     E
> -  operator()(A a,  B b,  C c,  D d, E e, F f)
> +  operator()(A a,  A b, C c, C d, E e, F f) const
>     { return std::set_intersection(a, b, c, d, e, f);}
>
>   };
> @@ -1061,14 +1065,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     E
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return std::set_difference(a, b, c, d, e);}
>
> -  template <class A, class B, class C, class D, class E, class F>
> +  template <class A, class C, class E, class F>
>     E
> -  operator()(A a,  B b,  C c,  D d, E e, F f)
> +  operator()(A a, A b, C c, C d, E e, F f) const
>     { return std::set_difference(a, b, c, d, e, f);}
>
>   };
> @@ -1085,14 +1089,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     E
>     operator()(A a, B b, C c, D d, E e) const
>     { return std::set_symmetric_difference(a, b, c, d, e);}
>
> -  template <class A, class B, class C, class D, class E, class F>
> +  template <class A, class C, class E, class F>
>     E
> -  operator()(A a,  B b,  C c,  D d, E e, F f)
> +  operator()(A a, A b, C c, C d, E e, F f) const
>     { return std::set_symmetric_difference(a, b, c, d, e, f);}
>
>   };
> @@ -1106,14 +1110,14 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::push_heap(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::push_heap(a, b, c); }
>
>   };
> @@ -1127,14 +1131,14 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::pop_heap(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::pop_heap(a, b, c); }
>
>   };
> @@ -1149,14 +1153,14 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::make_heap(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::make_heap(a, b, c); }
>
>   };
> @@ -1170,14 +1174,14 @@
>       typedef void type;
>     };
>
> -  template <class A, class B>
> +  template <class A>
>     void
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { ::std::sort_heap(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     void
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { ::std::sort_heap(a, b, c); }
>
>   };
> @@ -1193,14 +1197,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     A
> -  operator()(A a, B b) const
> +  operator()(const A& a, const A& b) const
>     { return ::std::min(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(const A& a, const A& b, C c) const
>     { return ::std::min(a, b, c); }
>
>   };
> @@ -1216,14 +1220,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     A
> -  operator()(A a, B b) const
> +  operator()(const A& a, const A& b) const
>     { return ::std::max(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(const A& a, const A& b, C c) const
>     { return ::std::max(a, b, c); }
>
>   };
> @@ -1237,14 +1241,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     A
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { return ::std::min_element(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::min_element(a, b, c); }
>
>   };
> @@ -1260,14 +1264,14 @@
>        >::type type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     A
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { return ::std::max_element(a, b); }
>
> -  template <class A, class B, class C>
> +  template <class A, class C>
>     A
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::max_element(a, b, c); }
>
>   };
> @@ -1282,14 +1286,14 @@
>       typedef bool type;
>     };
>
> -  template <class A, class B, class C, class D>
> +  template <class A, class C>
>     bool
> -  operator()(A a, B b, C c, D d) const
> +  operator()(A a, A b, C c, C d) const
>     { return ::std::lexicographical_compare(a, b, c, d); }
>
> -  template <class A, class B, class C, class D, class E>
> +  template <class A, class C, class E>
>     bool
> -  operator()(A a, B b, C c, D d, E e) const
> +  operator()(A a, A b, C c, C d, E e) const
>     { return ::std::lexicographical_compare(a, b, c, d, e); }
>
>   };
> @@ -1303,14 +1307,14 @@
>       typedef bool type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     bool
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { return ::std::next_permutation(a, b); }
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     bool
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::next_permutation(a, b, c); }
>
>   };
> @@ -1324,14 +1328,14 @@
>       typedef bool type;
>     };
>
> -  template <class A, class B >
> +  template <class A>
>     bool
> -  operator()(A a, B b) const
> +  operator()(A a, A b) const
>     { return ::std::prev_permutation(a, b); }
>
> -  template <class A, class B, class C >
> +  template <class A, class C >
>     bool
> -  operator()(A a, B b, C c) const
> +  operator()(A a, A b, C c) const
>     { return ::std::prev_permutation(a, b, c); }
>
>   };
> _______________________________________________
> Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
>