Remove algo duplication

[Marc Glisse]

On Sun, 15 Sep 2013, Christopher Jefferson wrote:

> I have not looked carefully at predefined_ops.h, but I can show you
> some of the previous code which I know has caused problems for this
> kind of simplification. I attach it below.
>
> I agree with Marc, I think templated member functions are the way to
> go. For example, I would use objects like this:
>
> struct __less {
> template<typename T, typename U>
> bool operator()(T& t, U& u) { return t < u; }
> };
>
> Note the missing 'const' on T& and U& is intentional.

That doesn't work for input iterators that return prvalues, does it? (and 
please let's not rely on the fact that only input iterators can return 
prvalues)

> Francois:I assume it is these kinds of problems which made we want to
> change all the predicates to take iterators directly, and do the
> de-referencing in-predicate. However, that does radically change
> almost every algorithm. Do you have any examples of where my suggested
> __less above does not work, and your redirection does? While I'm not
> 100% opposed to such a big change, I would want it to have excellent
> justification!

One good point about the iterator thing is that you know it does the same 
thing as using operator< directly, since that's what it does. An example 
where you can notice a difference is for instance with an input iterator 
whose operator* returns a prvalue and an operator< that takes its 
arguments by value. Then with *i<*j you get copy elision, whereas 
std::less<void>(*i,*j) has to perform 2 moves. We may decide to ignore 
this difference, I am just giving an example where using __less would be a 
detectable change for users.

Maybe having 2 copies of the algos isn't bad enough to deserve so much 
effort...

Using the preprocessor would be another way to remove duplication.

-- 
Marc Glisse