Zero Let-Bindings: Werten mit let einen Namen geben

Ein Weg, einem Wert einen Namen zu geben

In Zero gibst du einem Wert mit let einen Namen:

let answer = 42

Das ist die ganze Syntax. Kein var, kein const, kein auto. Ein einziges Binding-Schlüsselwort hält die Sprache klein – Agenten und Menschen lernen es einmal und wenden es überall an.

let führt ein lokales Binding im aktuellen Scope ein. Nach dieser Zeile verweist answer bis zum Ende des umschließenden Blocks auf 42.

Typinferenz

Der Compiler inferiert den Typ aus der rechten Seite. Das Literal 42 hat per Default Typ i32, also ist answer ein i32. Das Literal "hello" ist ein String, also:

let greeting = "hello"

bindet greeting an einen String-Wert. Wenn du eine Funktion aufrufst, die ein Pair<i32, u8> zurückgibt, hat das Binding den Typ Pair<i32, u8>:

let pair = makePair(40, 2_u8)

Du musst nicht an jedes Binding den Typ schreiben, was den Code lesbar hält.

Explizite Typannotationen

Wenn du den Typ dokumentieren willst – oder einen bestimmten erzwingen, wenn die Inferenz etwas anderes wählen würde – schreib den Typ nach einem Doppelpunkt:

let count: u8 = 10
let pair:  Pair<i32, u8> = makePair(40, 2_u8)

Annotationen sind außerdem ein Hinweis für den Compiler, wenn ein Literal mehrere Typen haben könnte. Das Literal 10 könnte i32, i64, u8 und so weiter sein; die Annotation legt es fest.

Du wirst auch typisierte Suffixe an Literalen sehen, als Alternative zum Annotieren des Bindings:

let small = 10_u8   // u8 durch das Literal-Suffix
let big   = 10_i64  // i64 durch das Literal-Suffix

Beide Formen sind gültig; nimm die, die die Absicht an der Aufrufstelle klarer macht.

Bindings in Aktion

Ein durchgespieltes Beispiel mit inferierter und expliziter Form – klick Run, um es auszuprobieren:

shape Point {
    x: i32,
    y: i32,
}

fun sum(point: Point) -> i32 {
    return point.x + point.y
}

pub fun main(world: World) -> Void raises {
    let point: Point = Point { x: 40, y: 2 }
    let total = sum(point)
    if total == 42 {
        check world.out.write("point works\n")
    }
}

point ist explizit annotiert, weil die rechte Seite ein Struct-Literal ist. total ist inferiert – sum ist als Rückgabe i32 deklariert, also ist auch das Binding i32.

Scope und Shadowing

Ein let-Binding gilt von der Zeile, die es deklariert, bis zum Ende seines umschließenden Blocks. Verschachtelte Blöcke schaffen neue Scopes:

pub fun main(world: World) -> Void raises {
    let value = 1
    if true {
        let value = 2   // überdeckt das äußere 'value' innerhalb dieses Blocks
        // hier ist value == 2
    }
    // außerhalb des if ist value wieder == 1
}

Das innere value mutiert das äußere nicht – es ist ein eigenes Binding, das beim schließenden } des if-Blocks aus dem Scope läuft. Dasselbe Modell wie in Rust und ML-artigen Sprachen. Besonders praktisch, wenn du einen Wert in einer Folge von Schritten transformieren willst, ohne für jedes Zwischenergebnis einen neuen Namen zu erfinden.

Was let nicht macht

Ein paar Dinge, die du aus anderen Sprachen erwarten könntest, die let bewusst nicht enthält:

• Reine Typdeklarationen. Es gibt keine Form let x: i32;, die ein uninitialisiertes Binding einführt. Ein Binding muss an der Stelle, an der es deklariert wird, einen Wert haben.
• Pattern-Destrukturierung (noch nicht). Manche Sprachen erlauben let (a, b) = pair. Zero ist bewusst klein und konzentriert sich derzeit auf reine Namens-Bindings – schau in die aktuelle Doku, ob Destrukturierung schon gelandet ist.
• Mehrere Schlüsselwörter für unterschiedliche Lebensdauern. Kein eigenes static, const, let mut oder Varianten für Block- vs. Funktions-Scope. Ein Schlüsselwort.

Wenn dein Sprachhintergrund JavaScript ist, ist die nächste Entsprechung const – ein Name, der für den Rest des Blocks an einen Wert gebunden ist, mit Shadowing in inneren Scopes. Kommst du aus Rust, übernimmt let hier dieselbe Rolle wie Rusts let ohne das explizite mut-Schlüsselwort.

Ein Muster: einen Wert Schritt für Schritt aufbauen

Bindings glänzen, wenn du eine Berechnung als Folge benannter Zwischenschritte schreiben willst. Das ist gut für Menschen, die lesen, und für Agenten, die lokal über jede Zeile nachdenken:

pub fun main(world: World) -> Void raises {
    let raw     = 21
    let doubled = raw * 2
    let label   = "result\n"
    if doubled == 42 {
        check world.out.write(label)
    }
}

Jede Zeile führt eine neue Tatsache ein, mit der der Rest der Funktion arbeiten kann. Der Compiler erzeugt trotzdem kompakten Code – Zwischenwerten Namen zu geben kostet zur Laufzeit nichts.

Als Nächstes: Primitive Typen

let ist wenig wert, ohne dass es etwas zu binden gibt. Das nächste Dokument geht durch Zeros primitive Typen – die Integer-Breiten, Floats, Strings sowie die Typen Void und Bool, die du am häufigsten sehen wirst.