Enums en Zero: enumeraciones simples sin payload

Declarar un enum

enum declara un tipo cuyos valores son un conjunto fijo de variantes nombradas:

enum Status {
    ready,
    failed,
}

Ahora Status es un tipo con exactamente dos valores: Status.ready y Status.failed. Nada más puede ser un Status.

La gramática es intencionadamente diminuta:

• enum Name { abre la declaración.
• Cada línea lista el nombre de una variante, separadas por comas.
• } la cierra.

Sin payloads, sin valores discriminantes, sin métodos derivados — eso es lo que mantiene a enum como "el tipo suma pequeño" de Zero.

Usar un enum

Nombras una variante cualificándola con el tipo del enum:

let state: Status = Status.ready

La anotación : Status es opcional una vez que el lado derecho fija el tipo; en la mayoría de los casos puedes escribir:

let state = Status.ready

y el compilador inferirá el tipo como Status.

Comparar valores de enum

Dos valores de enum son iguales cuando son la misma variante:

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

Esa es la forma más simple de ramificar sobre un enum. Para análisis exhaustivo — manejar cada variante explícitamente — recurre a match:

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

Las ventajas de match sobre if/else if se notan cuando añades una tercera variante después. El compilador te dirá cada match al que le falta el nuevo caso; una cadena if/else se irá silenciosamente a su rama por defecto.

Choice y match cubre match con más detalle. Funciona tanto para enum como para choice.

Un ejemplo trabajado

El ejemplo oficial de Zero pone enum y choice lado a lado en el mismo archivo:

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 no hace nada en este fragmento — está ahí para mostrar el contraste. Una variante de choice liga un payload (value, message) al hacer match; una variante de enum no liga nada porque no hay nada que ligar.

Enum vs. choice: un árbol de decisión rápido

Una regla corta:

• Las variantes son solo etiquetas → enum.
• Las variantes tienen que llevar datos → choice.

Si modelas estados de ciclo de vida y al final necesitas adjuntar un mensaje de error al estado "failed", cambia el tipo de enum a choice. Las variantes ganan cada una su tipo de payload, y las ramas match aguas abajo ganan una ligadura para ese payload. Es un refactor por el que te lleva el compilador.

Concretamente:

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

// Después — choice con payloads en cada variante
choice Status {
    ready: Void,
    failed: String,
}

Las variantes cuyo payload es Void son solo etiquetas en forma de choice. Puedes usar enum y choice para los mismos estados lógicos; elige enum cuando de verdad no necesites datos adjuntos.

Casos de uso

Algunos ejemplos cotidianos donde enum es la respuesta correcta:

• Ciclo de vida sin metadatos. Loading, Ready, Empty — estados puros, sin payload.
• Modos. Read, Write, Append para el modo de apertura de un archivo.
• Dirección. North, South, East, West.
• Nivel de log. Trace, Debug, Info, Warn, Error. (Más adelante puedes querer añadir un mensaje, en cuyo punto cambiarías a choice.)
• Día de la semana. Un ejemplo canónico.

Cada vez que ibas a recurrir a una constante entera mágica (0 = pendiente, 1 = activo, 2 = hecho), un enum casi siempre es más claro.

Notas de estilo

• Los nombres de variante en minúsculas coinciden con el estilo de Zero para identificadores en el resto del lenguaje.
• Una coma final tras la última variante es válida (y recomendable para diffs más limpios — añadir una variante nueva no remueve la línea previa).
• Mantén las listas de enum pequeñas. Si tienes una docena de variantes y muchas quieren payload, probablemente estés viendo un choice — o un rediseño — antes que un enum más grande.

Lo siguiente: choice y match

El siguiente paso natural es el primo más rico: choice y match — el tipo unión etiquetada de Zero y el constructo de pattern matching que lo acompaña.