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

From: Jim Apple (japple_at_[hidden])
Date: 2003-12-08 19:35:52

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

My Q's and A's

Q: Should all constant reference parameters in standard algorithms be 
constant int BLL clones?

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); }

  };