Por que este lambda Java 8 falha ao compilar?

O seguinte código Java falha ao compilar:

@FunctionalInterface
private interface BiConsumer<A, B> {
    void accept(A a, B b);
}

private static void takeBiConsumer(BiConsumer<String, String> bc) { }

public static void main(String[] args) {
    takeBiConsumer((String s1, String s2) -> new String("hi")); // OK
    takeBiConsumer((String s1, String s2) -> "hi"); // Error
}

Os relatórios do compilador:

Error:(31, 58) java: incompatible types: bad return type in lambda expression
    java.lang.String cannot be converted to void

O estranho é que a linha marcada "OK" compila bem, mas a linha marcada "Erro" falha. Eles parecem essencialmente idênticos.

Seu lambda precisa ser congruente com BiConsumer<String, String>. Se você se referir a JLS # 15.27.3 (Tipo de Lambda) :

Uma expressão lambda é congruente com um tipo de função se todas as opções a seguir forem verdadeiras:

• [...]
• Se o resultado do tipo de função for nulo, o corpo lambda é uma expressão de instrução (§14.8) ou um bloco compatível com nulo.

Portanto, o lambda deve ser uma expressão de instrução ou um bloco compatível com void:

• Uma invocação de construtor é uma expressão de instrução, portanto, é compilada.
• Um literal de string não é uma expressão de instrução e não é compatível com o void ( consulte os exemplos em 15.27.2 ), portanto, não é compilado.

Basicamente, new String("hi")é um trecho de código executável que realmente faz algo (ele cria uma nova String e a retorna). O valor retornado pode ser ignorado e new String("hi")ainda pode ser usado em lambda void-return para criar uma nova String.

No entanto, "hi"é apenas uma constante que não faz nada por conta própria. A única coisa razoável a fazer com ele no corpo lambda é devolvê- lo. Mas o método lambda teria que ter um tipo de retorno Stringou Object, mas ele retorna void, daí o String cannot be casted to voiderro.

O primeiro caso está ok porque você está invocando um método "especial" (um construtor) e não está realmente pegando o objeto criado. Só para deixar mais claro, colocarei as chaves opcionais em seus lambdas:

takeBiConsumer((String s1, String s2) -> {new String("hi");}); // OK
takeBiConsumer((String s1, String s2) -> {"hi"}); // Error

E mais claro, vou traduzir isso para a notação mais antiga:

takeBiConsumer(new BiConsumer<String, String>(String s1, String s2) {
    public void accept(String s, String s2) {
        new String("hi"); // OK
    }
});

takeBiConsumer(new BiConsumer<String, String>(String s1, String s2) {
    public void accept(String s, String s2) {
        "hi"; // Here, the compiler will attempt to add a "return"
              // keyword before the "hi", but then it will fail
              // with "compiler error ... bla bla ...
              //  java.lang.String cannot be converted to void"
    }
});

No primeiro caso, você está executando um construtor, mas NÃO está retornando o objeto criado; no segundo caso, você está tentando retornar um valor String, mas seu método em sua interface BiConsumerretorna void, daí o erro do compilador.

O JLS especifica que

Se o resultado do tipo de função for nulo, o corpo lambda é uma expressão de instrução (§14.8) ou um bloco compatível com nulo.

Agora vamos ver isso em detalhes,

Uma vez que seu takeBiConsumermétodo é do tipo void, o receptor lambda new String("hi")irá interpretá-lo como um bloco como

{
    new String("hi");
}

que é válido em um vazio, daí a primeira compilação de caso.

No entanto, no caso em que o lambda é -> "hi", um bloco como

{
    "hi";
}

não é uma sintaxe válida em java. Portanto, a única coisa a fazer com "oi" é tentar devolvê-lo.

{
    return "hi";
}

que não é válido em um vazio e explica a mensagem de erro

incompatible types: bad return type in lambda expression
    java.lang.String cannot be converted to void

Para um melhor entendimento, note que se você alterar o tipo de takeBiConsumerpara String, -> "hi"será válido pois simplesmente tentará retornar diretamente a string.

Observe que, a princípio, achei que o erro era causado pelo lambda estar em um contexto de invocação incorreto, portanto, compartilharei essa possibilidade com a comunidade:

JLS 15.27

É um erro em tempo de compilação se uma expressão lambda ocorre em um programa em algum lugar diferente de um contexto de atribuição (§5.2), um contexto de invocação (§5.3) ou um contexto de lançamento (§5.5).

No entanto, em nosso caso, estamos em um contexto de invocação correto.