Laços while em Zero: iteração na linguagem agent-first

O básico

while roda o corpo enquanto uma condição bool se mantiver true:

while condição {
    // corpo
}

O compilador avalia a condição antes de cada iteração:

• true — roda o corpo e checa de novo.
• false — sai do laço.

Uma ilustração trivial dos exemplos do Zero, com uma condição que já é false:

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

Rode isso e só o segundo write dispara. O corpo do while nunca executa porque a condição era false na primeira vez que foi checada.

A condição é um bool

Como em if/else, a condição do laço precisa ser um bool. Zero não converte inteiros, strings ou outros valores em booleanos.

while count {              // erro de compilação
    // ...
}

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

A condição pode ser qualquer coisa que avalie para bool: uma ligação, uma comparação, uma combinação &&/|| ou uma chamada de função. Valem as mesmas regras do if.

Laços contados

O clássico "faça algo N vezes" usa um contador e um while:

let mut i = 0
while i < 10 {
    // faça trabalho
    i = i + 1
}

Três peças: um valor inicial, uma condição que compara contra um limite e uma atualização no corpo. É o padrão que toda linguagem imperativa tem — Zero só não enfeita com uma palavra-chave for.

Uma nota sobre o mut acima: como o Zero escreve ligações mutáveis na sua versão da toolchain pode variar em versões pré-1.0. Rode zero check --json contra um teste pequeno para confirmar a sintaxe exata que o seu compilador aceita. O padrão conceitual (contador + condição + atualização) é a parte que é estável.

Laços infinitos

Um while cuja condição é sempre true roda para sempre:

while true {
    // espera trabalho, trata, volta a iterar
}

Essa é a forma certa para um loop de eventos, um REPL ou um servidor de longa duração. Para sair, você termina o processo, lança um erro a partir do corpo ou reestrutura para quebrar a condição.

Quando recorrer a um laço

Laços são uma ferramenta para usar com parcimônia. Coisas que parecem laços em outras linguagens muitas vezes têm uma forma mais limpa em Zero:

• Iterar sobre uma coleção fixa: prefira uma função que a biblioteca padrão ou o seu shape exponha — um helper estilo forEach, um folder ou uma travessia recursiva.
• Ler até o fim da entrada: itere sobre uma leitura falível, mas use check e raises para tratar a fronteira de forma limpa em vez de aninhar flags de status.
• Pollar por uma condição: considere se o design deveria te entregar um sinal. Laços de polling são um cheiro ruim em qualquer linguagem de sistemas.

O mesmo instinto vale para agentes: uma forma compacta e declarativa é mais fácil de raciocinar do que um laço com contador escrito à mão, tanto para humanos quanto para geradores de código.

Laços e efeitos

O corpo de um while, como qualquer outro bloco, pode fazer I/O — mas só se tiver acesso a uma capacidade World (ou a uma fatia dela). Uma função cuja assinatura não menciona World pode iterar à vontade mas não consegue escrever nada para fora. Essa propriedade vale dentro do corpo do laço também; o laço não concede nenhuma capacidade nova.

Soa óbvio, mas é por isso que você pode colocar um while dentro de uma função de computação "pura" e ainda saber — só pela assinatura — que ela não pode imprimir nada nem escrever em disco.

Notas de estilo

Alguns hábitos pequenos que compensam:

• Mantenha a condição óbvia. Se a condição está fazendo trabalho de verdade, mova para uma função ou ligação nomeada para o laço ler de forma limpa.
• Atualize o contador no final do corpo, não espalhado por ele. Bugs de off-by-one são mais fáceis de achar assim.
• Prefira condições de saída antecipada que você consegue expressar como a própria condição do laço, em vez de flags que mudam no meio da iteração. Menos peças móveis.

A seguir: shapes

Você já viu o controle de fluxo básico do Zero. O próximo capítulo é sobre modelagem de dados — começando pelos shapes, os tipos produto do Zero, parecidos com structs.