Enums no Zero: enumerações simples sem payloads

Declarando um enum

enum declara um tipo cujos valores são um conjunto fixo de variantes nomeadas:

enum Status {
    ready,
    failed,
}

Agora Status é um tipo com exatamente dois valores: Status.ready e Status.failed. Nada mais pode ser um Status.

A gramática é minúscula de propósito:

• enum Nome { abre a declaração.
• Cada linha lista um nome de variante, separado por vírgula.
• } fecha.

Sem payloads, sem valores discriminadores, sem métodos derivados — é isso que mantém enum como "o tipo soma pequeno" no Zero.

Usando um enum

Você nomeia uma variante qualificando com o tipo do enum:

let state: Status = Status.ready

A anotação : Status é opcional se o lado direito já fixa o tipo; na maioria dos casos você pode escrever:

let state = Status.ready

e o compilador vai inferir o tipo como Status.

Comparando valores de enum

Dois valores de enum são iguais quando são a mesma variante:

if state == Status.ready {
    check world.out.write("ready\n")
} else {
    check world.out.write("not ready\n")
}

Essa é a forma mais simples de ramificar sobre um enum. Para análise exaustiva — tratando cada variante explicitamente — vá de match:

match state {
    .ready  => { check world.out.write("ready\n") }
    .failed => { check world.out.write("failed\n") }
}

As vantagens do match sobre if/else if aparecem quando você adiciona uma terceira variante depois. O compilador vai te dizer todo match que está sem o caso novo; uma cadeia if/else vai cair silenciosamente no ramo default.

Choice e match cobre match em mais detalhe. Funciona tanto para enum quanto para choice.

Um exemplo prático

A amostra oficial do Zero coloca enum e choice lado a lado no mesmo arquivo:

choice Result {
    ok: i32,
    err: String,
}

enum Status {
    ready,
    failed,
}

pub fun main(world: World) -> Void raises {
    let result: Result = Result.ok(42)
    match result {
        .ok => value {
            if value == 42 {
                check world.out.write("choice ok\n")
            }
        }
        .err => message {
            check world.out.write("choice err\n")
        }
    }
}

Status não faz nada nesse trecho — está aí para mostrar o contraste. Uma variante de choice vincula um payload (value, message) quando casa; uma variante de enum não vincula nada porque não há nada para vincular.

Enum vs. choice: uma árvore de decisão rápida

Uma regra curta:

• As variantes são só rótulos → enum.
• As variantes têm que carregar dado → choice.

Se você está modelando estados de ciclo de vida e em algum momento precisa anexar uma mensagem de erro ao estado "failed", troque o tipo de enum para choice. As variantes ganham cada uma um tipo de payload, e os braços match que processam o tipo ganham uma ligação para esse payload. É um refactor que o compilador conduz para você.

Concretamente:

// Antes — enum, sem payloads
enum Status {
    ready,
    failed,
}

// Depois — choice com payloads em cada variante
choice Status {
    ready: Void,
    failed: String,
}

As variantes cujo payload é Void são só rótulos na forma choice. Você pode usar enum e choice para os mesmos estados lógicos; escolha enum quando realmente não precisa de dado anexado.

Casos de uso

Alguns exemplos do dia a dia em que enum é a resposta certa:

• Ciclo de vida sem metadados. Loading, Ready, Empty — estados puros, sem payloads.
• Modos. Read, Write, Append para um modo de abrir arquivo.
• Direção. North, South, East, West.
• Nível de log. Trace, Debug, Info, Warn, Error. (Você pode adicionar depois uma mensagem, momento em que mudaria para choice.)
• Dia da semana. Um exemplo canônico.

Sempre que você iria recorrer a uma constante inteira mágica (0 = pendente, 1 = ativo, 2 = feito), um enum é quase sempre mais claro.

Notas de estilo

• Nomes de variante em minúsculas combinam com o estilo do Zero para identificadores no resto da linguagem.
• Uma vírgula após a última variante é OK (e recomendada para diffs amigáveis — adicionar uma nova variante não mexe na linha anterior).
• Mantenha as listas de enum pequenas. Se você tem uma dúzia de variantes e muitas querem payloads, talvez esteja olhando para um choice — ou um redesenho — em vez de um enum maior.

A seguir: choice e match

O próximo passo natural é o parente mais rico: choice e match — o tipo união marcada do Zero e a construção de pattern matching que vem junto.