¿Cómo convertir este mapa/mapa plano en un para la comprensión en Scala?

Question

Cómo convertir este mapa/flatMap en un para la comprensión, y explica cómo funciona, gracias.

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

Answer 1

El código puede ser traducido a esto:

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

citas de Programming in Scala, Second Edition:

Generalmente, una para la expresión es de la forma:

for (seq) yield expr 

Aquí , seq es una secuencia de generadores, d efinitions, y filters, con punto y coma entre elementos sucesivos.

Esta expresión contiene un generador, una definición, y un filtro:

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

Traslación de expresiones con un generador

En primer lugar, se supone que tiene un sencillo para la expresión:

for (x <- expr1) yield expr2 

donde x es una variable. Tal expresión se traduce a:

expr1.map(x => expr2) 

Traslación de expresiones, comenzando con un generador y un filtro

Ahora, considere por expresiones que combinan un generador líder con algunos otros elementos. Una para la expresión de la forma:

for (x <- expr1 if expr2) yield expr3 

se traduce a:

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

Traslación de expresiones, comenzando con dos generadores

El siguiente caso se encarga de expresiones que comienzan con dos generadores, como en:

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

La expresión anterior se traduce a una solicitud de flatMap:

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