Scala para comprensiones

Las comprensiones tienen la estructura for (enumerators) yield e, donde los enumeradores se refieren a una lista de enumeradores separados por punto y coma. Enumerator es un generador que introduce nuevas variables o es un filtro . Una comprensión evalúa el cuerpo e para cada enlace generado por los enumeradores y devuelve una secuencia de esos valores.

Estas definiciones nos llevan a las ideas de comprensión de generadores, filtros y definiciones. Una Scala para comprensión contendrá las siguientes 3 expresiones:

• Generadores
• filtros
• Definiciones

Sintaxis:

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

 
Generadores –
Los generadores tienen el siguiente formulario:

pattern <- expression

Por ejemplo b <- libros En esta expresión, el valor b itera sobre todos los elementos contenidos en los libros.
A continuación hay dos cosas más sobre los generadores:

• Cada uno para la comprensión comienza con un generador.
• para las comprensiones habrá múltiples generadores.

Definiciones –

Para la comprensión, las definiciones tienen la siguiente sintaxis:

pattern = expression

Por ejemplo n = b.name, la variable n está vinculada al valor b.name. Esa declaración tiene un resultado similar a escribir este código fuera de una comprensión.val n = b.name

filtros –

Para la comprensión, los filtros tienen el siguiente formulario:

if (expression)

La expresión tiene el tipo booleano. Los filtros eliminan todos los elementos de la iteración cuya expresión devuelve falso, como un código dado. Por ejemplo if (n startsWith "Ca"), cualquier valor n que no comience con la string Ca se eliminará durante el proceso de iteración.

Analicemos algunos ejemplos.

Ejemplo #1: Con rendimiento

// Scala program of for comprehensions
  
// Creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // Creating case class    
        case class Language(name: String, article: Int)
          
        val LanguageBase = List(Language("Scala", 26),
                                Language("Csharp", 32),
                                Language("Perl", 42),
                                Language("Java", 22))
          
        // Applying for comprehensions
        // Generator
        // Definition
        val MoreThanTwenty = for (language <- LanguageBase
        if (language.article >=20 && language.article < 30))// Filters
          
         // i.e. add this to a list
          yield language.name 
          
        // Print more than twenty 
        MoreThanTwenty.foreach(name => println(name))
      
    } 
} 

Producción :

Scala
Java

En el ejemplo anterior, el bucle for utilizado con una declaración de rendimiento en realidad crea una Lista. Porque dijimos yield language.name, es un List[String]. language <- LanguageBase es nuestro generador y if (language.article >=20 && language.article < 30)podría ser un protector que filtra los artículos que no parecen estar entre 20 y 30.
 
Ejemplo #2: Sin rendimiento

Podemos omitir rendimiento en comprensión. En ese caso, la comprensión devolverá Unidad. Esto puede ser útil en caso de que nos gustaría realizar efectos secundarios. Aquí hay un programa como el anterior, sin usar yield.

// Scala program to print Hello, Geeks! 
// by using object-oriented approach 
  
// creating object 
object Geeks { 
  
// Main method 
def main(args: Array[String]) 
{ 
      
def check(a: Int) =
   for (i <- 0 until 4;
        j <- 0 until 4 if i * j >= a)
   println(s"($i, $j)")
  
check(4)
} 
} 

Producción:

(2, 2)
(2, 3)
(3, 2)
(3, 3)

En el ejemplo anterior, a = 4 . En la primera iteración, i = 0 y j = 0 , por lo que i * j no es mayor que igual a a y, por lo tanto, no se obtiene nada. j se incrementa 3 veces más antes de que i se incremente a 1.