A explicação da avaliação tardia

Em Scala, a maioria dos valores é estrita: eles são calculados no momento em que são definidos. A avaliação tardia inverte essa lógica. Um valor tardio só é calculado quando é necessário pela primeira vez, nunca antes.

Isso é importante quando os cálculos são dispendiosos, podem falhar ou talvez nunca sejam usados. Por que pagar por um trabalho que ninguém solicita?

Um val normal avalia imediatamente o lado direito, mesmo que você nunca o leia novamente.

Execute este código e observe que "computing" é impresso antes de "after". O trabalho acontece no momento da definição.

Prefixe um val com lazy para adiar a avaliação até o primeiro acesso.

Aqui, "after" é impresso primeiro; depois, "computing" é impresso somente quando x é lido. O resultado também é armazenado em cache: o corpo é executado no máximo uma vez.

Um parâmetro declarado como => A é passado por nome: o argumento não é avaliado até ser usado dentro do método.

Esse é o bloco básico da avaliação tardia. LazyList usa parâmetros por nome para que uma cauda nunca seja calculada até ser solicitada.

LazyList é a sequência tardia do Scala (ela substituiu a antiga Stream a partir da versão 2.13). A cabeça é avaliada avidamente, mas a cauda é tardia.

Os elementos são produzidos sob demanda e memorizados depois de calculados, para que a mesma célula nunca seja recalculada.

Uma LazyList permanece não avaliada até que você a force. Chamar toList, foreach ou imprimir cada elemento força as células.

O REPL mostra <not computed> para a cauda tardia. Ao forçá-la, os valores reais são revelados.

Você adiciona um elemento ao início de uma LazyList com #::. Diferentemente de :: de uma lista, o operando direito de #:: é passado por nome; portanto, a cauda não é criada até ser necessária.

Isso permite descrever sequências cuja parte restante é calculada de forma tardia.

Depois que uma célula de uma LazyList é calculada, seu valor é armazenado. Lê-la novamente não tem custo, e a expressão que a produz não é executada duas vezes.

Execute este código: "calc" é impresso somente no primeiro acesso a cada elemento forçado, não nas leituras repetidas.

Como a cauda é tardia, você pode aplicar map a uma LazyList, e somente os elementos acessados serão calculados.

Aqui, "map" é impresso apenas uma vez, embora a lista tenha três elementos, porque somente a cabeça é forçada.

A avaliação tardia permite três coisas: evitar trabalho não utilizado, criar sequências infinitas e separar a descrição de um cálculo da quantidade que será executada.

Você escreve todo o pipeline uma vez; o consumidor decide quantos elementos solicitar.

A avaliação tardia tem custos. Uma LazyList usa memoização; portanto, manter uma referência à cabeça mantém na memória todos os elementos já forçados. Para dados enormes ou infinitos, evite reter a cabeça.

Além disso, efeitos colaterais em código tardio são executados em momentos inesperados, o que pode dificultar a depuração.

Teste sua compreensão da avaliação tardia.

A avaliação estrita executa o trabalho imediatamente; a avaliação tardia o adia até que seja necessário. lazy val e os parâmetros por nome (=> A) são os recursos básicos.

LazyList se baseia neles: cabeça imediata, cauda tardia e memorizada, forçada por meio de toList ou do acesso a um elemento. Em seguida, criaremos LazyLists manualmente.