Bucles while en Zero: iteración en el lenguaje agent-first

Lo básico

while ejecuta su cuerpo mientras una condición bool siga siendo true:

while condition {
    // cuerpo
}

El compilador evalúa la condición antes de cada iteración:

• true — ejecuta el cuerpo y comprueba de nuevo.
• false — sale del bucle.

Una ilustración trivial de los ejemplos de Zero, con una condición que ya es false:

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

Ejecútalo y solo se dispara el segundo write. El cuerpo del while nunca se ejecuta porque la condición era false la primera vez que se comprobó.

La condición es un bool

Como con if/else, la condición del bucle tiene que ser un bool. Zero no convierte enteros, cadenas u otros valores en booleano.

while count {              // error de compilación
    // ...
}

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

La condición puede ser cualquier cosa que evalúe a bool: una ligadura, una comparación, una combinación con &&/|| o una llamada a función. Aplican las mismas reglas que con if.

Bucles contados

El patrón clásico de "haz algo N veces" usa un contador y un while:

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

Tres piezas: un valor inicial, una condición que compara contra el límite y una actualización en el cuerpo. Es el patrón que tiene cualquier lenguaje imperativo — Zero simplemente no lo viste con una palabra clave for.

Una nota sobre el mut de arriba: cómo Zero escribe ligaduras mutables en tu toolchain puede variar en versiones pre-1.0. Ejecuta zero check --json contra un test pequeño para confirmar la sintaxis exacta que acepta tu compilador. El patrón conceptual (contador + condición + actualización) es la parte estable.

Bucles infinitos

Un while cuya condición sea siempre true corre para siempre:

while true {
    // espera trabajo, manéjalo, vuelve a iterar
}

Esa es la forma correcta para un bucle de eventos, un REPL o un servidor de larga vida. Para salir, o terminas el proceso, o levantas un error desde el cuerpo, o reestructuras para romper la condición.

Cuándo recurrir a un bucle

Los bucles son una herramienta que conviene usar con moderación. Cosas que parecen bucles en otros lenguajes a menudo tienen una forma más limpia en Zero:

• Iterar sobre una colección fija: prefiere una función que la biblioteca estándar o tu shape exponga — un helper estilo forEach, un fold o un recorrido recursivo.
• Leer hasta fin de entrada: itera sobre una lectura falible, pero usa check y raises para manejar el límite limpiamente en lugar de anidar flags de estado.
• Sondear una condición: considera si el diseño debería entregarte una señal en su lugar. Los bucles de polling son un mal olor en cualquier lenguaje de sistemas.

El mismo instinto vale para los agentes: una forma compacta y declarativa es más fácil de razonar que un bucle contado escrito a mano, tanto para humanos como para generadores de código.

Bucles y efectos

El cuerpo de un while, como cualquier otro bloque, puede hacer E/S — pero solo si tiene acceso a una capacidad World (o a una porción de ella). Una función cuya firma no mencione World puede iterar todo lo que quiera pero no puede escribir nada al exterior. Esa propiedad también vale dentro del cuerpo del bucle; el bucle no concede capacidades nuevas.

Suena obvio, pero es la razón por la que puedes meter un while dentro de una función de cómputo "pura" y aun así saber — solo por la firma — que no puede imprimir nada ni escribir en disco.

Notas de estilo

Algunos hábitos pequeños que se notan:

• Mantén la condición obvia. Si la condición hace trabajo real, súbela a una función o ligadura con nombre para que el bucle se lea limpio.
• Actualiza el contador al final del cuerpo, no esparcido por todas partes. Más fácil detectar errores de uno más o uno menos.
• Prefiere condiciones de salida temprana que puedas expresar como la propia condición del bucle, antes que flags que se voltean a mitad de la iteración. Menos piezas móviles.

Lo siguiente: shapes

Ya has visto el control de flujo central de Zero. El próximo capítulo trata sobre modelar datos, empezando por shapes, los tipos producto al estilo struct de Zero.