Flux infinis
Modélisez des données sans fin en toute sécurité.
Flux infinis est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
L’infini en toute sécurité
Une LazyList peut décrire une séquence infinie, car sa fin n’est jamais calculée avant d’être demandée. Vous ne matérialisez que le préfixe que vous consommez.
Cela permet de modéliser les nombres naturels, les nombres premiers ou les relevés de capteurs sans leur imposer de limite initiale.
Tous les nombres naturels
LazyList.from(1) est la séquence infinie 1, 2, 3, ... Vous pouvez en prendre n’importe quel préfixe fini.
Forcer la séquence entière ne se terminerait jamais ; découpez-la donc toujours avec take ou arrêtez-la avec un prédicat.
object Demo extends App {
val nats = LazyList.from(1)
println(nats.take(5).toList)
}from avec un pas
LazyList.from(start, step) compte selon un intervalle. Utilisez-le pour les nombres pairs, les impulsions ou toute progression arithmétique.
La séquence est infinie, mais chaque appel à take ne force que ce que vous demandez.
object Demo extends App {
val evens = LazyList.from(0, 2)
println(evens.take(5).toList)
}Flux autoréférentiels
Une astuce célèbre consiste à définir une LazyList en fonction d’elle-même. La suite de Fibonacci peut s’écrire en associant le flux à sa propre fin.
Cela fonctionne uniquement parce que la fin reste non évaluée jusqu’à ce que chaque cellule soit extraite.
lazy val fibs: LazyList[Int] =
0 #:: 1 #:: fibs.zip(fibs.tail).map { case (a, b) => a + b }
// fibs(0)=0, fibs(1)=1, fibs(2)=1 ...Exécuter Fibonacci
Forçons un préfixe de ce flux de Fibonacci autoréférentiel.
Chaque nouvel élément est calculé à partir d’éléments précédents déjà mémorisés ; l’ensemble reste donc efficace à mesure que vous récupérez d’autres valeurs.
object Demo extends App {
lazy val fibs: LazyList[Int] =
0 #:: 1 #:: fibs.zip(fibs.tail).map { case (a, b) => a + b }
println(fibs.take(10).toList)
}iterate pour les séquences
LazyList.iterate génère une séquence infinie à l’aide d’une fonction d’évolution. Les puissances, la croissance géométrique et les machines à états s’y prêtent naturellement.
Ici, chaque élément est le triple du précédent, indéfiniment.
object Demo extends App {
val triples = LazyList.iterate(1)(_ * 3)
println(triples.take(6).toList)
}Un crible de nombres premiers
Les flux infinis sont parfaits pour le crible d’Ératosthène. Prenez un nombre premier en tête, filtrez ses multiples dans le reste, puis recommencez.
Le filtre est paresseux : les nombres premiers sont produits un par un à mesure que vous les consommez.
def sieve(s: LazyList[Int]): LazyList[Int] =
s.head #:: sieve(s.tail.filter(_ % s.head != 0))
val primes = sieve(LazyList.from(2))Exécuter le crible
Récupérons maintenant les dix premiers nombres premiers de ce crible infini.
Seule la quantité nécessaire du flux de nombres sous-jacent est forcée pour produire dix nombres premiers, ce qui illustre un calcul piloté par la demande.
object Demo extends App {
def sieve(s: LazyList[Int]): LazyList[Int] =
s.head #:: sieve(s.tail.filter(_ % s.head != 0))
val primes = sieve(LazyList.from(2))
println(primes.take(10).toList)
}Ne forcez jamais toute la séquence
Les méthodes qui ont besoin de la séquence entière, comme length, toList sur un flux non borné ou foreach sans arrêt, resteront bloquées sur une LazyList infinie.
Commencez toujours par la limiter avec take, takeWhile ou find.
// DON'T: LazyList.from(1).toList // hangs forever
val ok = LazyList.from(1).take(3).toListLe piège de la conservation du premier élément
Si un val conserve le premier élément d’une LazyList infinie et mémorisée et que vous la parcourez très loin, chaque cellule forcée reste en mémoire, ce qui provoque une fuite de mémoire.
Pour les parcours longs, consommez-la via une méthode sans conserver le premier élément, ou utilisez un Iterator.
Pourquoi les flux infinis sont importants
Les flux infinis permettent de séparer la génération de la consommation. Le producteur décrit une règle sans fin ; le consommateur décide de la quantité à réaliser.
C’est un puissant modèle fonctionnel pour les pipelines, les simulations et les sources de données paresseuses.
Vérification rapide
Testez votre compréhension des LazyLists infinies.
Récapitulatif
Les LazyLists infinies fonctionnent parce que leur fin est pilotée par la demande : from, iterate, fibs autoréférentiel et le crible de nombres premiers génèrent des éléments indéfiniment, mais ne réalisent que ceux que vous consommez.
Évitez les opérations portant sur toute la séquence et la conservation du premier élément. Ensuite, nous maîtriserons la prise d’éléments et le filtrage paresseux.
Questions Fréquemment Posées
La leçon « Flux infinis » est-elle gratuite ?
Oui — le texte complet de « Flux infinis » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Flux infinis » ?
Modélisez des données sans fin en toute sécurité. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Flux infinis » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.