Come convertire questa mappa/flatMap in a per comprensione in Scala?

Question

Come convertire questa mappa/flatMap in una comprensione, e per favore spiega come funziona, grazie.

def compute2(maybeFoo: Option[Foo]): Option[Int] = 
     maybeFoo.flatMap { foo => 
     foo.bar.flatMap { bar => 
      bar.baz.map { baz => 
      baz.compute 
     } 
    } 
    } 

Answer 1

Il codice può essere tradotto in questo modo:

def compute2(maybeFoo: Option[Foo]): Option[Int] = 
    for { 
    foo <- maybeFoo 
    bar <- foo.bar 
    baz <- bar.baz 
    } yield baz.compute 

Citazioni da Programming in Scala, Second Edition:

In generale, una per l'espressione è della forma:

for (seq) yield expr 

Qui , seq è una sequenza di generatori, d efinizioni e filtri, con punto e virgola tra gli elementi successivi.

Questo per l'espressione contiene un generatore, una definizione, e un filtro:

for { 
p <- persons // a generator 
n = p.name // a definition 
if (n startsWith "To") // a filter 
} yield n 

Traducendo per le espressioni con un generatore

In primo luogo, supponiamo che abbiate una semplice espressione:

for (x <- expr1) yield expr2 

dove x è una variabile. tale espressione è tradotta a:

expr1.map(x => expr2) 

traslazionale per espressioni che iniziano con un generatore e un filtro

Ora, non per le espressioni che combinano un generatore leader con alcuni altri elementi. A per l'espressione della forma:

for (x <- expr1 if expr2) yield expr3 

è tradotta a:

expr1 withFilter (x => expr2) map (x => expr3) 

traslazionale per espressioni iniziano con due generatori

Il prossimo caso maniglie per espressioni che iniziano con due generatori, come in:

for (x <- expr1; y <- expr2) yield expr3 

Il per l'espressione di cui sopra si traduce a un'applicazione di flatMap:

expr1.flatMap(x => for (y <- expr2) yield expr3)