Suponha que eu tenha uma interface genérica:

interface MyComparable<T extends Comparable<T>>  {
    public int compare(T obj1, T obj2);
}

E um métodosort:

public static <T extends Comparable<T>> 
       void sort(List<T> list, MyComparable<T> comp) {
    // sort the list
}

Eu posso invocar esse método e passar uma expressão lambda como argumento:

List<String> list = Arrays.asList("a", "b", "c");
sort(list, (a, b) -> a.compareTo(b));

Isso vai funcionar bem.

Mas agora, se eu tornar a interface não genérica e o método genérico:

interface MyComparable {
    public <T extends Comparable<T>> int compare(T obj1, T obj2);
}

public static <T extends Comparable<T>> 
       void sort(List<T> list, MyComparable comp) {
}

E depois invoque isso como:

List<String> list = Arrays.asList("a", "b", "c");
sort(list, (a, b) -> a.compareTo(b));

Não compila. Ele mostra erro na expressão lambda dizendo:

"O método de destino é genérico"

OK, quando eu compilei usandojavac, mostra o seguinte erro:

SO.java:20: error: incompatible types: cannot infer type-variable(s) T#1
        sort(list, (a, b) -> a.compareTo(b));
            ^
    (argument mismatch; invalid functional descriptor for lambda expression
      method <T#2>(T#2,T#2)int in interface MyComparable is generic)
  where T#1,T#2 are type-variables:
    T#1 extends Comparable<T#1> declared in method <T#1>sort(List<T#1>,MyComparable)
    T#2 extends Comparable<T#2> declared in method <T#2>compare(T#2,T#2)
1 error

A partir dessa mensagem de erro, parece que o compilador não pode inferir os argumentos de tipo. É esse o caso? Se sim, então por que está acontecendo assim?

Tentei de várias maneiras, procurei pela internet. Então eu acheieste artigo JavaCodeGeeks, que mostra um caminho, então tentei:

sort(list, <T extends Comparable<T>>(a, b) -> a.compareTo(b));

o que novamente não funciona, ao contrário do que esse artigo afirma que funciona. Pode ser possível que ele funcionasse em algumas construções iniciais.

Então, minha pergunta é: existe alguma maneira de criar expressão lambda para um método genérico? Eu posso fazer isso usando uma referência de método, criando um método:

public static <T extends Comparable<T>> int compare(T obj1, T obj2) {
    return obj1.compareTo(obj2);
}

em alguma classe dizemSOe passe como:

sort(list, SO::compare);