¿Por qué no se compila esta lambda de Java 8?

El siguiente código Java no se puede 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
}

El compilador informa:

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

Lo extraño es que la línea marcada como "OK" se compila bien, pero la línea marcada como "Error" falla. Parecen esencialmente idénticos.

Tu lambda debe ser congruente con BiConsumer<String, String>. Si se refiere a JLS # 15.27.3 (Tipo de Lambda) :

Una expresión lambda es congruente con un tipo de función si todo lo siguiente es verdadero:

• [...]
• Si el resultado del tipo de función es nulo, el cuerpo lambda es una expresión de declaración (§14.8) o un bloque compatible con void.

Entonces, la lambda debe ser una expresión de declaración o un bloque compatible vacío:

• Una invocación de constructor es una expresión de declaración, por lo que se compila.
• Un literal de cadena no es una expresión de declaración y no es compatible con nulos (ver los ejemplos en 15.27.2 ) por lo que no se compila.

Básicamente, new String("hi")es un fragmento de código ejecutable que realmente hace algo (crea una nueva cadena y luego la devuelve). El valor devuelto se puede ignorar ynew String("hi") aún se puede usar en la lambda void-return para crear una nueva cadena.

Sin embargo, "hi"es solo una constante que no hace nada por sí misma. Lo único razonable que se puede hacer con él en el cuerpo lambda es devolverlo . Pero el método lambda debería tener el tipo de retorno Stringo Object, pero devuelve void, de ahí el String cannot be casted to voiderror.

El primer caso está bien porque está invocando un método "especial" (un constructor) y en realidad no está tomando el objeto creado. Para que quede más claro, pondré las llaves opcionales en sus lambdas:

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

Y más claro, lo traduciré a la notación anterior:

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

En el primer caso, está ejecutando un constructor, pero NO está devolviendo el objeto creado, en el segundo caso está intentando devolver un valor de cadena, pero su método en su interfaz BiConsumerdevuelve vacío, de ahí el error del compilador.

El JLS especifica que

Si el resultado del tipo de función es nulo, el cuerpo lambda es una expresión de declaración (§14.8) o un bloque compatible con void.

Ahora veamos eso en detalle,

Dado que su takeBiConsumermétodo es de tipo vacío, la lambda que recibe new String("hi")lo interpretará como un bloque como

{
    new String("hi");
}

que es válido en un vacío, de ahí el primer caso compilado.

Sin embargo, en el caso donde está la lambda -> "hi", un bloque como

{
    "hi";
}

no es una sintaxis válida en java. Por lo tanto, lo único que se puede hacer con "hola" es intentar devolverlo.

{
    return "hi";
}

que no es válido en un vacío y explique el mensaje de error

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

Para una mejor comprensión, tenga en cuenta que si cambia el tipo de takeBiConsumera String, -> "hi"será válido ya que simplemente intentará devolver directamente la cadena.

Tenga en cuenta que al principio pensé que el error se debió a que lambda estaba en un contexto de invocación incorrecto, por lo que compartiré esta posibilidad con la comunidad:

JLS 15.27

Es un error en tiempo de compilación si una expresión lambda ocurre en un programa en algún lugar que no sea un contexto de asignación (§5.2), un contexto de invocación (§5.3) o un contexto de conversión (§5.5).

Sin embargo, en nuestro caso, estamos en un contexto de invocación que es correcto.