Scala for Backend Engineering & Functional Programming · Aula

Construindo uma LazyList

Construa sequências avaliadas tardiamente.

Construindo uma LazyList é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Noções básicas de construção

Há várias maneiras de criar uma LazyList. A mais simples é a fábrica apply, assim como na criação de uma List.

Mas o verdadeiro poder vem dos construtores que mantêm a cauda tardia, os quais exploraremos nesta lição.

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

A LazyList vazia

LazyList.empty é o terminador, o equivalente tardio de Nil. Toda LazyList finita termina nele.

Você o usa como caso base ao adicionar elementos ao início com #::.

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

Adicionando ao início com #::

O operador #:: adiciona uma cabeça a uma cauda passada por nome. Crie a lista da direita para a esquerda, terminando com LazyList.empty.

Como #:: recebe a cauda de forma tardia, nada além da cabeça é criado até ser forçado.

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

Observando a avaliação tardia

Coloque um efeito colateral na cauda para ver quando ele é executado. Somente forçar a cauda o dispara.

Execute este código: "building tail" é impresso somente depois que você acessa o segundo elemento, não quando a LazyList é definida.

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

Usando cons explicitamente

Internamente, #:: é LazyList.cons. Tanto a cabeça quanto a cauda são passadas por nome em cons, proporcionando controle total sobre a avaliação.

Isso é útil ao definir geradores recursivos.

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

Geradores recursivos

Uma LazyList pode referir-se a si mesma. Defina uma função que produza uma cabeça e chame a si mesma recursivamente para produzir a cauda.

Como a cauda é passada por nome, a recursão não é executada indefinidamente; ela pausa até que cada célula seja solicitada.

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

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

Executando um gerador

Vamos executar um gerador autorreferente e obter alguns valores. take limita quantas células são forçadas.

Sem take, isso entraria em um laço infinito; portanto, sempre limite um gerador infinito antes de forçá-lo.

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

A partir de um iterador

Você pode encapsular uma coleção ou um iterador existente. LazyList.from(start) cria uma contagem infinita, e someList.to(LazyList) converte dados já conhecidos de forma imediata.

Esses recursos fornecem uma visão tardia sobre dados que você já possui ou consegue descrever.

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 criar cada elemento seguinte a partir do anterior.

É uma forma clara de expressar sequências definidas por uma regra de passo, como potências de dois.

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

LazyList.continually

LazyList.continually(expr) repete uma expressão indefinidamente, reavaliando-a para cada elemento. É útil para fluxos constantes ou aleatórios.

Combine-o com take para obter uma fatia finita.

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

Escolhendo um construtor

Use apply para listas pequenas e fixas, #:: ou cons para recursão escrita manualmente, iterate para regras de passo, from para contagens e continually para repetições.

Todos mantêm a cauda tardia; portanto, a escolha depende da expressividade.

Verificação rápida

Verifique sua compreensão da construção de LazyList.

Recapitulação

Você criou LazyLists com apply, empty, #::/cons, iterate, from e continually.

A cauda passada por nome torna seguros de definir os geradores autorreferentes e potencialmente infinitos. Em seguida, usaremos isso para criar fluxos realmente infinitos.

Perguntas Frequentes

A aula “Construindo uma LazyList” é grátis?

Sim — o texto completo de “Construindo uma LazyList” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Construindo uma LazyList”?

Construa sequências avaliadas tardiamente. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Construindo uma LazyList”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming