Liaisons let en Zero : nommer des valeurs avec let

Une seule façon de nommer une valeur

En Zero, vous donnez un nom à une valeur avec let :

let answer = 42

C'est toute la syntaxe. Pas de var, pas de const, pas de auto. Un seul mot-clé de liaison garde le langage petit — agents et humains l'apprennent une fois et l'appliquent partout.

let introduit une liaison locale dans la portée courante. Après cette ligne, answer réfère à 42 jusqu'à la fin du bloc englobant.

Inférence de types

Le compilateur infère le type depuis le côté droit. Le littéral 42 est de type i32 par défaut, donc answer est un i32. Le littéral "hello" est une chaîne, donc :

let greeting = "hello"

lie greeting à une valeur de type chaîne. Si vous appelez une fonction qui retourne un Pair<i32, u8>, la liaison a le type Pair<i32, u8> :

let pair = makePair(40, 2_u8)

Vous n'avez pas à écrire le type sur chaque liaison, ce qui garde le code lisible.

Annotations de type explicites

Quand vous voulez documenter le type — ou en forcer un précis là où l'inférence en choisirait un autre — écrivez le type après deux points :

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

Les annotations servent aussi d'indice au compilateur quand un littéral pourrait être de plusieurs types. Le littéral 10 pourrait être i32, i64, u8, etc. ; l'annotation tranche.

Vous verrez aussi des suffixes de type sur les littéraux comme alternative à l'annotation de la liaison :

let small = 10_u8   // u8 d'après le suffixe du littéral
let big   = 10_i64  // i64 d'après le suffixe du littéral

Les deux formes sont valides ; choisissez celle qui rend l'intention la plus claire sur le site d'appel.

Liaisons en action

Un exemple complet utilisant les deux formes, inférée et explicite — cliquez sur Run pour essayer :

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 est annoté explicitement parce que le côté droit est un littéral de struct. total est inféré — sum est déclaré comme retournant i32, donc la liaison est i32 aussi.

Portée et masquage

Une liaison let est valide depuis la ligne qui la déclare jusqu'à la fin de son bloc englobant. Les blocs imbriqués créent de nouvelles portées :

pub fun main(world: World) -> Void raises {
    let value = 1
    if true {
        let value = 2   // masque le 'value' extérieur à l'intérieur de ce bloc
        // ici, value == 2
    }
    // de retour hors du if, value vaut à nouveau 1
}

Le value intérieur ne mute pas celui de l'extérieur — c'est une liaison distincte qui sort de portée à l'accolade fermante du bloc if. C'est le même modèle que celui de Rust et des langages de la famille ML. C'est particulièrement courant quand vous voulez transformer une valeur à travers une série d'étapes sans inventer un nouveau nom pour chaque résultat intermédiaire.

Ce que let ne fait pas

Quelques choses que vous pourriez attendre d'autres langages et que let ne propose délibérément pas :

• Déclarations de type seules. Il n'y a pas de forme let x: i32; qui introduise une liaison non initialisée. Une liaison doit avoir une valeur au moment de sa déclaration.
• Déstructuration par motifs (pour l'instant). Certains langages permettent d'écrire let (a, b) = pair. Zero est petit par conception et se concentre actuellement sur de simples liaisons de noms — vérifiez la doc actuelle pour savoir si la déstructuration a été ajoutée.
• Plusieurs mots-clés pour des durées de vie différentes. Pas de static, const, let mut séparés, ni de variantes portée-bloc vs. portée-fonction. Un seul mot-clé.

Si votre bagage est JavaScript, l'analogie la plus proche est const — un nom lié à une valeur pour le reste du bloc, avec masquage dans les portées intérieures. Si votre bagage est Rust, let joue ici le même rôle que le let de Rust moins le mot-clé mut explicite.

Un pattern : construire une valeur étape par étape

Les liaisons brillent quand vous voulez écrire un calcul comme une série d'étapes intermédiaires nommées. C'est bon à la fois pour les humains qui lisent et pour les agents qui raisonnent localement sur chaque ligne :

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)
    }
}

Chaque ligne introduit un nouveau fait avec lequel le reste de la fonction peut travailler. Le compilateur produit toujours du code compact — nommer les valeurs intermédiaires n'a aucun coût à l'exécution.

La suite : les types primitifs

let ne sert pas à grand-chose sans quelque chose à lier. Le prochain document parcourt les types primitifs de Zero — les largeurs d'entiers, les flottants, les chaînes et les types Void et Bool que vous croiserez le plus souvent.