Perché questo Java 8 lambda non riesce a compilare?

Question

Il seguente codice Java non riesce a compilare:

@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 
} 

Le relazioni del compilatore:

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

La cosa strana è che la linea marcata "OK" compila bene, ma la linea marcata "errore" non riesce . Sembrano essenzialmente identici.

Answer 1

Il lambda deve essere congruente con BiConsumer<String, String>. Se si fa riferimento a JLS #15.27.3 (Type of a Lambda):

un'espressione lambda è congruente con un tipo di funzione se tutte le seguenti sono vere:

• [...]
• Se il risultato della tipo di funzione è vuoto , il corpo lambda è un'espressione di dichiarazione (§14.8) o un blocco compatibile con il vuoto.

Così il lambda deve essere sia un'espressione un'istruzione o un blocco compatibile vuoto:

• Un'invocazione costruttore è a statement expression quindi compila.
• Una stringa letterale non è un'espressione di dichiarazione e non è nullo compatibile (vedere the examples in 15.27.2) quindi non viene compilata.

Answer 2

Il JLS specificare che

Se il risultato della funzione è di tipo vuoto, il corpo lambda è sia un'espressione dichiarazione (§14.8) o di un blocco di vuoto-compatibili.

Ora vediamo che nel dettaglio,

Dal momento che il metodo takeBiConsumer è di tipo void, il Lambda riceve new String("hi") lo interpreterà come un blocco come

{ 
    new String("hi"); 
} 

che è valido in un vuoto , quindi il primo caso compilato.

Tuttavia, nel caso in cui il lambda è -> "hi", un blocco come

{ 
    "hi"; 
} 

non è valido per la sintassi Java. Quindi l'unica cosa da fare con "ciao" è provare e restituirlo.

{ 
    return "hi"; 
} 

che non è valido in un vuoto e spiegare il messaggio di errore

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

Per una migliore comprensione, si noti che se si cambia il tipo di takeBiConsumer in una stringa, -> "hi" sarà valida come proverà semplicemente a restituire direttamente la stringa.

---

Si noti che in un primo momento ho insegnato l'errore è stato causato dal lambda essere in un contesto invocazione sbagliato, così io condividere questa possibilità con la comunità:

JLS 15.27

E ' è un errore in fase di compilazione se si verifica un'espressione lambda in un programma in un contesto diverso da un contesto di assegnazione (§5.2), un contesto di invocazione (§5.3) o un contesto di fusione (§5.5).

Tuttavia nel nostro caso, siamo in un invocation context che è corretto.

Answer 3

Il primo caso è ok perché si sta invocando un metodo "speciale" (un costruttore) e non si sta effettivamente prendendo l'oggetto creato.Giusto per renderlo più chiaro, io metterò le parentesi graffe opzionali nel lambda:

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

E più chiaro, io traduco che per la vecchia notazione:

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

Nel primo caso stai eseguendo un costruttore, ma NON stai restituendo l'oggetto creato, nel secondo caso stai tentando di restituire un valore String, ma il tuo metodo nell'interfaccia BiConsumer restituisce nulla, quindi l'errore del compilatore.

Answer 4

In linea di principio, new String("hi") è una parte di codice eseguibile che esegue effettivamente qualcosa (crea una nuova stringa e quindi la restituisce). Il valore restituito può essere ignorato e new String("hi") può ancora essere utilizzato in lambda void-return per creare una nuova stringa.

Tuttavia, "hi" è solo una costante che non fa nulla per conto proprio. L'unica cosa ragionevole da fare con il corpo lambda è restituire it. Ma il metodo lambda dovrebbe avere il tipo di ritorno String o Object, ma restituisce void, quindi l'errore String cannot be casted to void.