0Pricing
Scala for Backend Engineering & Functional Programming · Lección

Crear una LazyList

Construya secuencias perezosas

Crear una LazyList es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Conceptos básicos de construcción

Hay varias formas de construir una LazyList. La más sencilla es la fábrica apply, igual que al construir una lista.

Pero la verdadera potencia proviene de los constructores que mantienen perezosa la cola, que exploraremos en esta lección.

val ll = LazyList(10, 20, 30)
println(ll.head)

La LazyList vacía

LazyList.empty es el terminador, el equivalente perezoso de Nil. Toda LazyList finita termina en él.

Se utiliza como caso base al anteponer elementos con #::.

object Demo extends App {
  val empty = LazyList.empty[Int]
  println(empty.isEmpty)
  println(empty.toList)
}

Anteponer con #::

El operador #:: añade una cabeza a una cola pasada por nombre. Construya la lista de derecha a izquierda y termine con LazyList.empty.

Como #:: recibe la cola de forma perezosa, no se construye nada después de la cabeza hasta que se fuerza.

object Demo extends App {
  val ll = 1 #:: 2 #:: 3 #:: LazyList.empty
  println(ll.toList)
}

Observar la evaluación perezosa

Coloque un efecto secundario en la cola para observar cuándo se ejecuta. Solo forzar la cola lo activa.

Ejecute esto: "building tail" se imprime únicamente después de acceder al segundo elemento, no cuando se define la LazyList.

object Demo extends App {
  val ll = 1 #:: { println("building tail"); 2 #:: LazyList.empty }
  println("defined")
  println(ll.head)
  println(ll(1))
}

cons explícitamente

Internamente, #:: es LazyList.cons. Tanto la cabeza como la cola se pasan por nombre en cons, lo que proporciona un control total sobre la evaluación.

Esto resulta útil al definir generadores recursivos.

val ll = LazyList.cons(1, LazyList.cons(2, LazyList.empty))
println(ll.head)

Generadores recursivos

Una LazyList puede referirse a sí misma. Defina una función que produzca una cabeza y se llame recursivamente para generar la cola.

Como la cola se pasa por nombre, la recursión no se ejecuta indefinidamente: se pausa hasta que se solicita cada celda.

def countFrom(n: Int): LazyList[Int] =
  n #:: countFrom(n + 1)

println(countFrom(5).take(3).toList)

Ejecutar un generador

Ejecutemos un generador autorreferente y obtengamos algunos valores. take limita cuántas celdas se fuerzan.

Sin take, esto entraría en un bucle infinito, así que debe limitar siempre un generador infinito antes de forzarlo.

object Demo extends App {
  def countFrom(n: Int): LazyList[Int] =
    n #:: countFrom(n + 1)
  println(countFrom(1).take(5).toList)
}

A partir de un iterador

Puede envolver una colección o un iterador existentes. LazyList.from(start) construye una cuenta infinita y someList.to(LazyList) convierte datos que ya se conocen de forma estricta.

Estas opciones proporcionan una vista perezosa sobre datos que ya tiene o que puede describir.

object Demo extends App {
  val ll = List(1, 2, 3).to(LazyList)
  println(ll.map(_ * 2).toList)
}

LazyList.iterate

LazyList.iterate(seed)(f) aplica repetidamente f para construir cada elemento a partir del anterior.

Es una forma clara de expresar secuencias definidas por una regla de paso, como las potencias de dos.

object Demo extends App {
  val powers = LazyList.iterate(1)(_ * 2)
  println(powers.take(6).toList)
}

LazyList.continually

LazyList.continually(expr) repite una expresión indefinidamente y la vuelve a evaluar para cada elemento. Resulta útil para flujos constantes o aleatorios.

Combínelo con take para obtener una sección finita.

object Demo extends App {
  val zeros = LazyList.continually(0)
  println(zeros.take(4).toList)
}

Elegir un constructor

Use apply para listas pequeñas y fijas, #:: o cons para la recursión escrita manualmente, iterate para reglas de paso, from para contar y continually para repetir.

Todos mantienen perezosa la cola, por lo que la elección depende de qué expresión resulte más clara.

Comprobación rápida

Compruebe su comprensión de la construcción de LazyList.

Resumen

Ha construido LazyList con apply, empty, #::/cons, iterate, from y continually.

La cola pasada por nombre permite definir de forma segura generadores autorreferentes y potencialmente infinitos. A continuación, aprovecharemos esto para crear flujos realmente infinitos.

Preguntas frecuentes

¿La lección «Crear una LazyList» es gratis?

Sí — el texto completo de «Crear una LazyList» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Crear una LazyList»?

Construya secuencias perezosas Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Crear una LazyList»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. La evaluación perezosa
  2. Crear una LazyList
  3. Streams infinitos
  4. Tomar y filtrar de forma perezosa
← Volver a Scala for Backend Engineering & Functional Programming