Enums en Zero : énumérations simples sans charge utile

Déclarer un enum

enum déclare un type dont les valeurs sont un ensemble fixe de variantes nommées :

enum Status {
    ready,
    failed,
}

Maintenant Status est un type avec exactement deux valeurs : Status.ready et Status.failed. Rien d'autre ne peut être un Status.

La grammaire est intentionnellement minuscule :

• enum Name { ouvre la déclaration.
• Chaque ligne liste un nom de variante, séparées par des virgules.
• } la ferme.

Pas de charges utiles, pas de valeurs de discriminant, pas de méthodes dérivées — c'est ce qui garde enum comme « le petit type somme » en Zero.

Utiliser un enum

Vous nommez une variante en la qualifiant avec le type de l'enum :

let state: Status = Status.ready

L'annotation : Status est optionnelle dès que le côté droit fixe le type ; dans la plupart des cas, vous pouvez écrire :

let state = Status.ready

et le compilateur inférera le type à Status.

Comparer des valeurs d'enum

Deux valeurs d'enum sont égales quand elles sont la même variante :

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

C'est la façon la plus simple de brancher sur un enum. Pour une analyse exhaustive — traiter chaque variante explicitement — recourez à match :

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

Les avantages de match sur if/else if apparaissent quand vous ajoutez une troisième variante plus tard. Le compilateur vous signalera chaque match auquel manque le nouveau cas ; une chaîne if/else passera silencieusement dans sa branche par défaut.

Choice et match couvre match plus en détail. Il fonctionne aussi bien pour enum que pour choice.

Un exemple complet

L'exemple officiel de Zero met enum et choice côte à côte dans le même fichier :

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 ne fait rien dans ce snippet — il est là pour montrer le contraste. Une variante de choice lie une charge utile (value, message) au moment du match ; une variante d'enum ne lie rien parce qu'il n'y a rien à lier.

Enum vs. choice : un petit arbre de décision

Une règle courte :

• Les variantes sont juste des étiquettes → enum.
• Les variantes doivent porter des données → choice.

Si vous modélisez des états de cycle de vie et que vous avez besoin un jour d'attacher un message d'erreur à l'état « failed », basculez le type d'enum à choice. Les variantes prennent chacune un type de charge utile, et les branches match en aval gagnent une liaison pour cette charge. C'est une refactorisation que le compilateur vous guide à faire.

Concrètement :

// Avant — enum, pas de charges utiles
enum Status {
    ready,
    failed,
}

// Après — choice avec charges utiles sur chaque variante
choice Status {
    ready: Void,
    failed: String,
}

Les variantes dont la charge utile est Void ne sont que des étiquettes sous forme choice. Vous pouvez utiliser enum et choice pour les mêmes états logiques ; choisissez enum quand vous n'avez réellement pas besoin de données attachées.

Cas d'usage

Quelques exemples courants où enum est la bonne réponse :

• Cycle de vie sans métadonnées. Loading, Ready, Empty — états purs, pas de charges utiles.
• Modes. Read, Write, Append pour un mode d'ouverture de fichier.
• Direction. North, South, East, West.
• Niveau de log. Trace, Debug, Info, Warn, Error. (Vous pourriez plus tard ajouter un message, auquel cas vous basculeriez vers choice.)
• Jour de la semaine. Un exemple canonique.

Chaque fois que vous tendriez sinon vers une constante entière magique (0 = pending, 1 = active, 2 = done), un enum est presque toujours plus clair.

Notes de style

• Des noms de variantes en minuscules collent au style de Zero pour les identifiants dans tout le reste du langage.
• Une virgule traînante après la dernière variante est acceptable (et même recommandée pour la lisibilité des diffs — ajouter une nouvelle variante ne touche pas à la ligne précédente).
• Gardez les listes d'enum petites. Si vous avez une douzaine de variantes et que beaucoup voudraient des charges utiles, vous regardez sans doute un choice — ou une refonte — plutôt qu'un plus gros enum.

La suite : choice et match

L'étape naturelle suivante est le cousin plus riche : choice et match — le type union étiquetée de Zero et la construction de filtrage par motifs qui va avec.