Boucles while en Zero : l'itération dans le langage agent-first

Les bases

while exécute son corps tant qu'une condition bool reste true :

while condition {
    // corps
}

Le compilateur évalue la condition avant chaque itération :

• true — exécute le corps, puis revérifie.
• false — sort de la boucle.

Une illustration triviale tirée des exemples Zero, avec une condition déjà false :

pub fun main(world: World) -> Void raises {
    while false {
        check world.out.write("unreachable\n")
    }
    check world.out.write("countdown done\n")
}

Lancez ça et seul le second write se déclenche. Le corps du while ne s'exécute jamais parce que la condition était false à la première vérification.

La condition est un bool

Comme pour if/else, la condition de boucle doit être un bool. Zero ne convertit pas les entiers, les chaînes ou d'autres valeurs en booléen.

while count {              // erreur de compilation
    // ...
}

while count > 0 {          // OK
    // ...
}

La condition peut être n'importe quoi qui s'évalue à bool : une liaison, une comparaison, une combinaison &&/||, ou un appel de fonction. Les mêmes règles que if s'appliquent.

Boucles comptées

Le motif classique « fais quelque chose N fois » utilise un compteur et un while :

let mut i = 0
while i < 10 {
    // travailler
    i = i + 1
}

Trois pièces : une valeur initiale, une condition qui compare à la borne, et une mise à jour dans le corps. C'est le motif que tout langage impératif possède — Zero ne l'habille simplement pas d'un mot-clé for.

Note sur l'orthographe mut ci-dessus : la façon dont Zero orthographie les liaisons mutables dans votre chaîne d'outils peut différer dans les versions pré-1.0. Lancez zero check --json sur un petit test pour confirmer la syntaxe exacte acceptée par votre compilateur. Le motif conceptuel (compteur + condition + mise à jour) est la partie stable.

Boucles infinies

Un while dont la condition est toujours true tourne indéfiniment :

while true {
    // attendre du travail, le traiter, recommencer
}

C'est la bonne forme pour une boucle d'événements, un REPL ou un serveur de longue durée. Pour en sortir, vous terminez le processus, faites remonter une erreur depuis le corps, ou restructurez pour casser la condition.

Quand recourir à une boucle

Les boucles sont un outil à utiliser avec parcimonie. Ce qui ressemble à une boucle dans d'autres langages a souvent une forme plus propre en Zero :

• Itérer sur une collection fixe : préférez une fonction exposée par la bibliothèque standard ou par votre shape — un utilitaire de style forEach, un folder, ou un parcours récursif.
• Lire jusqu'à la fin de l'entrée : bouclez sur une lecture faillible, mais utilisez check et raises pour gérer la limite proprement plutôt que d'imbriquer des drapeaux de statut.
• Sondage d'une condition : demandez-vous si la conception devrait plutôt vous fournir un signal. Les boucles de sondage sont un signe douteux dans n'importe quel langage système.

Le même instinct vaut pour les agents : une forme déclarative et compacte est plus facile à raisonner qu'une boucle à compteur écrite à la main, autant pour les humains que pour les générateurs de code.

Boucles et effets

Un corps de while, comme tout autre bloc, peut faire des E/S — mais seulement s'il a accès à une capacité World (ou à une tranche de celle-ci). Une fonction dont la signature ne mentionne pas World peut boucler autant qu'elle veut, mais ne peut rien écrire vers l'extérieur. Cette propriété tient aussi à l'intérieur du corps de la boucle ; la boucle n'accorde aucune nouvelle capacité.

Ça paraît évident, mais c'est la raison pour laquelle vous pouvez mettre un while dans une fonction de calcul « pure » et savoir — depuis la signature seule — qu'elle ne peut rien afficher ni écrire sur le disque.

Notes de style

Quelques petites habitudes qui paient :

• Gardez la condition évidente. Si la condition fait du vrai travail, isolez-la dans une fonction ou une liaison nommée pour que la boucle se lise clairement.
• Mettez à jour le compteur en bas du corps, pas éparpillé partout. C'est plus facile de repérer les bugs de off-by-one.
• Préférez les conditions de sortie anticipée que vous pouvez exprimer comme la condition même de la boucle, plutôt que des drapeaux qui basculent en plein milieu de l'itération. Moins de pièces mobiles.

La suite : les shapes

Vous avez maintenant vu le cœur du contrôle de flux en Zero. Le prochain chapitre porte sur la modélisation des données — en commençant par les shapes, les types produit façon struct de Zero.