Zero Enums: Einfache Aufzählungen ohne Payloads

Ein Enum deklarieren

enum deklariert einen Typ, dessen Werte eine feste Menge benannter Varianten sind:

enum Status {
    ready,
    failed,
}

Jetzt ist Status ein Typ mit genau zwei Werten: Status.ready und Status.failed. Nichts anderes kann ein Status sein.

Die Grammatik ist absichtlich winzig:

• enum Name { öffnet die Deklaration.
• Jede Zeile listet einen Variantennamen, kommagetrennt.
• } schließt sie.

Keine Payloads, keine Diskriminator-Werte, keine abgeleiteten Methoden – das hält enum zum „kleinen Summentyp" in Zero.

Ein Enum verwenden

Du benennst eine Variante, indem du sie mit dem Enum-Typ qualifizierst:

let state: Status = Status.ready

Die Annotation : Status ist optional, sobald die rechte Seite den Typ festnagelt; in den meisten Fällen kannst du schreiben:

let state = Status.ready

und der Compiler inferiert den Typ als Status.

Enum-Werte vergleichen

Zwei Enum-Werte sind gleich, wenn sie dieselbe Variante sind:

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

Das ist der einfachste Weg, auf einem Enum zu verzweigen. Für erschöpfende Analyse – jede Variante explizit behandeln – greif zu match:

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

Die Vorteile von match gegenüber if/else if zeigen sich, sobald du später eine dritte Variante hinzufügst. Der Compiler sagt dir jedes match, dem der neue Fall fehlt; eine if/else-Kette fällt stillschweigend in ihren Default-Zweig.

Choice und match behandelt match ausführlicher. Es funktioniert sowohl für enum als auch für choice.

Ein durchgespieltes Beispiel

Das offizielle Zero-Sample stellt enum und choice nebeneinander in derselben Datei vor:

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 tut in diesem Snippet nichts – es ist nur da, um den Kontrast zu zeigen. Eine choice-Variante bindet beim Matchen einen Payload (value, message); eine enum-Variante bindet nichts, weil es nichts zu binden gibt.

Enum vs. Choice: ein kurzer Entscheidungsbaum

Eine kurze Regel:

• Die Varianten sind nur Labels → enum.
• Die Varianten müssen Daten tragen → choice.

Modellierst du Lebenszyklus-Zustände und musst irgendwann eine Fehlermeldung an den „failed"-Zustand hängen, wechsle den Typ von enum zu choice. Die Varianten bekommen je einen Payload-Typ, und die nachgelagerten match-Zweige gewinnen ein Binding für diesen Payload. Es ist ein Refactor, durch den der Compiler dich führt.

Konkret:

// Vorher – enum, keine Payloads
enum Status {
    ready,
    failed,
}

// Nachher – choice mit Payloads auf jeder Variante
choice Status {
    ready: Void,
    failed: String,
}

Varianten mit Payload Void sind in der choice-Form auch nur Labels. Du kannst enum und choice für dieselben logischen Zustände nutzen; nimm enum, wenn du wirklich keine Daten dranhängen willst.

Einsatzfälle

Ein paar alltägliche Beispiele, wo enum die richtige Antwort ist:

• Lebenszyklus ohne Metadaten. Loading, Ready, Empty – reine Zustände, keine Payloads.
• Modi. Read, Write, Append für einen Datei-Öffnungs-Modus.
• Richtung. North, South, East, West.
• Log-Level. Trace, Debug, Info, Warn, Error. (Vielleicht hängst du später eine Nachricht dran, und dann wechselst du zu choice.)
• Wochentag. Ein kanonisches Beispiel.

Immer wenn du sonst zu einer magischen Integer-Konstante greifen würdest (0 = pending, 1 = active, 2 = done), ist ein enum fast immer klarer.

Stil-Hinweise

• Kleingeschriebene Variantennamen passen zu Zeros Stil für Bezeichner im Rest der Sprache.
• Ein abschließendes Komma nach der letzten Variante ist okay (und empfohlen für diff-Freundlichkeit – eine neue Variante hinzuzufügen rührt die vorherige Zeile nicht an).
• Halte Enum-Listen klein. Hast du ein Dutzend Varianten und viele davon wollen Payloads, schaust du eher auf eine choice – oder ein Redesign – statt auf ein größeres enum.

Als Nächstes: Choice und Match

Der natürliche nächste Schritt ist der reichhaltigere Verwandte: choice und match – Zeros Tagged-Union-Typ und das dazugehörige Pattern-Matching-Konstrukt.