Lazy val y secuencias infinitas en Scala

Vals y Lazy vals están presentes en Scala. La palabra clave perezosa cambia el valor para que se inicialice de forma perezosa. La inicialización diferida significa que siempre que la creación de un objeto parezca costosa, la palabra clave perezosa se puede colocar antes de val. Esto le da la ventaja de que se inicializa en el primer uso, es decir, la expresión de entrada no se evalúa inmediatamente sino una vez en el primer acceso.

Ejemplo:

// Scala program of Lazy val
  
// Creating object 
object GFG 
{ 
    // Main method 
    def main(args:Array[String]) 
    { 
        lazy val geek = {
               
            println ("Initialization for the first time")
            12
        }
        // Part 1
        println(geek)
           
        // Part 2
        print(geek)
    } 
}     
     

Producción :

Initialization for the first time
12
12

En el código anterior, ‘geek’ era un valor perezoso y, por lo tanto, para la primera vez que se accedió, devolvió

Initialization for the first time
12

Pero por segunda vez cuando se imprime, solo devolvió

12

porque es un resultado en caché.

Cuando usamos la palabra clave perezosa antes de una palabra clave val, se usa una expresión de bloque para inicializar la variable: «geek». Para usar el bloque en Scala, la secuencia de expresiones está encerrada entre { } . Entonces, el valor «12» es el valor del bloque y el valor de la expresión de asignación es Unidad, que en realidad es un tipo vacío en Java.

Secuencias Infinitas

Las listas de Scala son secuencias. Además, estas listas son secuencias estrictas, lo que significa que los elementos de la lista se construyen por adelantado. Pero también hay secuencias no estrictas en las que los elementos se construyen según el requisito. Se crea una lista conectando las celdas contras.

Hay 2 casos de este tipo:

• 12 ::Nil

  Aquí, la celda con tiene un valor y una cola vacía. Y la lista aquí como un solo elemento.

  List[Int] = List(12)

• 12 : 22 : Nil

  Aquí, la celda de contras tiene un valor y otra lista como cola.

  List[Int] = List(22)

El símbolo :: es el operador contras (construcción). Invocamos el operador contras y Nil es una lista. Así crece la lista.

Hay 3 formas de crear una lista de este tipo:

• Código 1:

  val geek = 6 ::23 ::45 ::Nil        print(geek)

  Producción :

  List(6, 23, 45)

• Código 2:

  val geek = (6 ::(23 ::(45 ::Nil)))        print(geek)

  Producción :

  List(6, 23, 45)

• Código 3:

  val geek = (((Nil.::(45)).::(23)).::(6))        print(geek)

  Producción :

  List(6, 23, 45)

Ejemplo :

// Scala program to merge lists 
  
// Creating object 
object GFG 
{ 
    // Main method 
    def main(args:Array[String]) 
    { 
        var a = 5
           
        def fun() = { 
            a += 1; 
            a 
        }
           
        lazy val geek = Stream.continually( fun() )
           
        (geek take 10) foreach {
            x => println(x)
        }
    } 
}     
     

Producción :

6
7
8
9
10
11
12
13
14
15

El método fun() se convierte en una función. Un flujo infinito es creado por el método Stream.continually() . Toma la función y cada vez que se accede a cada elemento, se llama a la función fun() solo en ese momento para calcular ese elemento. Esta ejecución de la función a pedido se conoce como Thunk y, una vez que se calcula, va a la memoria caché para su uso posterior, lo que se denomina memoización .