Sorting and comparator

[Remi Forax]

I may be wrong but I think we haven't discuss about the method sort,

Currently the idiom to sort a stream of Person by name is to call:
   people.sorted(Comparators.comparing(Person::getName))

This idiom as two problems in my opinion,
first you have to call the static method comparing which make the code ugly
and hard to produce with an IDE if the only keys you know on your keyboard
is 'dot' and 'CTRL SPACE'.
Moreover, while Person::getName is a constant lambda, the result
of Comparator.comparing is not a constant lambda, so the code has
to allocate a new lambda (in the code of Comparator.comparing at each call).

I think it's better to have two methods, sorted and sortedBy with sortedBy
taking a new functional interface Ordered (put a better name here)
defined like this:

interface Ordered<T, U extends Comparable<? super U>> extends 
Comparator<T,T>, Mapper<T, U> {
   public default int compare(T o1, T o2) {
     return apply(o1).compareTo(apply(o2));
   }
}

this doesn't solve all the use cases, so some methods of Comparators for 
by example
sorting in reverse order are still needed but  instead of
   people.sorted(Comparators.comparing(Person::getName))

one can write
   people.sortedBy(Person::getName)
with sortedBy defined like this:

   public default Stream<U> sortedBy(Ordered<? super T, ? extends U> 
ordered) {
      return sorted(ordered);  // no conversion here because an Ordered 
is a Comparator
   }                                        // so the lambda is still 
constant

cheers,
Rémi