Perché ottengo un errore di deduzione tipo per un lambda ritorno lambda con percorsi di ritorno multipli?

Question

Ho il seguente codice:

int main() { 
    auto f = [] { 
     if (1) return [] { return 1; }; 
     else return [] { return 2; }; 
    }; 
    return f()(); 
} 

che solleva il seguente errore del compilatore GCC 5.2.1 utilizzando:

error: inconsistent types ‘main()::<lambda()>::<lambda()>’ and 
     ‘main()::<lambda()>::<lambda()>’ deduced for lambda 
     return type else return [] { return 2; }; 

Ora, ovviamente, questi due tipi sembrano essere lo stesso, quindi non sono sicuro se questo è GCC con un messaggio di errore fuorviante o se in realtà è un bug. Secondo la mia conoscenza questo dovrebbe essere compilato; il tipo di ritorno lambda deve essere dedotto di essere std::function<int()>. È interessante notare che se pre-dichiaro il ritorno lambda e restituisco la stessa variabile due volte, funziona.

chiunque può fare luce su ciò che sta accadendo? Ho trovato domande simili, molte attribuite a bug di GCC, ma questo sembra diverso.

Answer 1

Ora, ovviamente, questi due tipi sono gli stessi,

No, non lo sono. Il tipo di ogni espressione lambda è un tipo unico e distinto.

Da [expr.prim.lambda]/3:

Il tipo di lambda-espressione (che è anche il tipo dell'oggetto chiusura) è una classe unica, senza nome mancata unione tipo - chiamato il tipo chiusura - le cui proprietà sono descritte di seguito.

Pertanto, tipo di ritorno detrazione per ffallisce e non si traduca in std::function<int()>. Quest'ultimo è un tipo di libreria non correlato che non è in qualche modo magicamente il "tipo comune" di qualsiasi tipo di chiusura.

Naturalmente ognuno dei tipi di chiusura unico può essere convertito-std::function<int()>, quindi se si fornisce il tipo di ritorno, tutto funziona:

auto f = []() -> std::function<int()> { 
    return 1 ? []() { return 1; } 
      : []() { return 2; }; 
}; 

Oppure, come una funzione semplice:

std::function<int()> f() { 
    return 1 ? []() { return 1; } 
      : []() { return 2; }; 
} 

Answer 2

Ogni lambda ha un suo tipo unico:

Th espressione e lambda crea un oggetto temporaneo prvalue senza nome unico tipo anonimo mancata unione non aggregata [...].

Da here, sottolineare il mio.

Inoltre, lambda non hanno nulla a che fare con std::function, che è un altro tipo diverso.In particolare,

[] { return 1; } 

e

[] { return 2; } 

hanno tipi differenti. Questo è il motivo per cui la deduzione fallisce.

Answer 3

Questi tipi sono non lo stesso. Ogni lambda è un'istanza di un tipo unico, senza nome. std::function è un modello che può essere convertito implicitamente da oggetti callable appropriati compresi lambda, ma nessuna istanziazione di std::function è di tipo o tipo padre di qualsiasi lambda, quindi non può essere dedotta.

Tuttavia, si può dire al compilatore che si desidera per tornare std::function e funzionerà:

auto f = []() -> std::function<int()> { 
    if (1) return [] { return 1; }; 
    else return [] { return 2; }; 
}