Les lasagnes délicieuses de Lucian

En Rust, affecter une valeur à un nom s'appelle une liaison. Les liaisons sont immuables, sauf si elles sont déclarées avec le mot-clé mut. Rust étant un langage typé statiquement, chaque liaison possède un type connu à la compilation.

Les liaisons sont le plus souvent définies avec le mot-clé let. Pour la plupart d'entre elles, préciser le type est facultatif, car l'inférence de type de Rust sait généralement déduire le type à partir de la valeur. Une liaison ressemble à ceci :

// Automatically inferred type
let fingers = 10;

Les fonctions sont des éléments. Alors que les liaisons font généralement référence à une valeur particulière, les éléments désignent une unité d'organisation du code, généralement une fonction ou un module, disponible pendant toute la durée de vie du programme. Une fonction renvoie automatiquement le résultat de sa dernière expression. Une fonction peut prendre zéro ou plusieurs paramètres, qui sont des liaisons dont la durée de vie correspond à l'appel de la fonction.

L'inférence de type est théoriquement possible pour les fonctions, mais elle est désactivée : c'est un choix délibéré de conception du langage. Cela signifie qu'on passe un peu plus de temps, à l'écriture, à préciser les types d'entrée et de sortie d'une fonction, mais qu'on gagne ce temps à la lecture du code, car tous les types d'entrée et de sortie sont définis explicitement.

fn add(x: i32, y: i32) -> i32 {
  x + y
}

Pour appeler une fonction, on écrit son nom suivi de parenthèses. Si la fonction attend des paramètres, il faut fournir un argument pour chacun, entre les parenthèses.

let five = add(2, 3);

Si le type d'une liaison ne peut pas être déduit, le compilateur signale une erreur. Pour corriger cela, ajoute une annotation de type explicite à la liaison.

// Explicit type annotation
let fingers: i32 = 10;

En Rust, les éléments peuvent être utilisés avant ou après leur définition, car ils ont une durée de vie statique. Les liaisons, en revanche, ne peuvent être utilisées qu'après leur définition. Utiliser une liaison avant sa définition provoque une erreur de compilation.

fn main() {
    // `fn add` hasn't yet been defined, but that's perfectly ok
    dbg!(add(3, 4));
}

fn add(x: i32, y: i32) -> i32 {
  x + y
}

// this won't compile; `a` is used before its binding is defined
let b = a;
let a = x + y;

Rust utilise des accolades ({}) pour définir une portée. Une liaison définie dans une portée ne peut pas en sortir.

let a = 1;
dbg!(a); // 1
{
    // Here, we re-bind `a` to a new value, which is still immutable.
    // This technique is called _shadowing_. The new binding is constrained to
    // this anonymous scope. Outside this scope, the previous binding still
    // applies.
    let a = 2;
    let b = 3;
    dbg!(a, b); // 2, 3
}
// can't use `b` anymore because it is out of scope
// dbg!(b);

// The shadowed `a` in the inner scope above has fallen out of scope,
// leaving us with our original binding.
dbg!(a); // 1

Les éléments Rust sont souvent organisés en modules. Chaque crate est implicitement un module, mais elle peut définir des sous-modules internes d'une profondeur arbitraire. Un module regroupe des fonctionnalités liées et se définit avec le mot-clé mod.

mod calc_i32 {
    fn add(a: i32, b: i32) -> i32 { a + b }
    fn sub(a: i32, b: i32) -> i32 { a - b }
    fn mul(a: i32, b: i32) -> i32 { a * b }
    fn div(a: i32, b: i32) -> i32 { a / b }
}

Rust prend en charge deux types de commentaires. Le mot-clé // indique un commentaire sur une seule ligne ; tout ce qui suit jusqu'à la fin de la ligne est ignoré. Les mots-clés /* et */ indiquent un commentaire multiligne ; tout ce qui se trouve entre ces deux mots-clés est ignoré. Il est idiomatique et de bonne pratique de préférer les commentaires sur une seule ligne.

Rust prend aussi en charge les commentaires de documentation, qui apparaissent dans la documentation générée par cargo doc. Les commentaires de documentation externes sont formés avec le mot-clé ///, qui se comporte exactement comme le mot-clé //. Ils s'appliquent à l'élément qui les suit, par exemple une fonction :

/// The `add` function produces the sum of its arguments.
fn add(x: i32, y: i32) -> i32 { x + y }

Les commentaires de documentation internes sont formés avec le mot-clé //!, qui se comporte exactement comme le mot-clé //. Ils s'appliquent à l'élément qui les englobe, par exemple un module :

mod my_cool_module {
    //! This module is the bee's knees.
}

Les commentaires de documentation peuvent être de longueur arbitraire et contenir du markdown, qui est rendu dans la documentation générée.