Les fonctions en Rust

Syntaxe

• On va déclarer une fonction avec le mot clé fn suivi du nom de la fonction.
• On est obligé d’indiquer le type de chaque paramètre de la fonction.
• Le type de retour de la fonction est indiqué par une flèche après les paramètres de la fonction.
• Les fonctions doivent prendre un nom en snake_case.

// La ligne suivante est ce qu'on appelle
// la signature de la fonction
fn double_number(age: i32) -> u32 {
    return age * 2;
}

Point important, les fonctions peuvent être appelées avant leur déclaration :

fn main() {
    let number: i32 = 144;
    double_number(number);
    // On appelle double_number
    // alors qu'elle est défini
    // plus tard dans le code
}

fn double_number(age: i32) -> u32 {
    return age * 2;
}

Déclaration et Expression

En Rust il existe 2 types d’instructions :

• Les déclarations : ce sont des instructions qui ne retournent PAS de valeur, on les reconnait par le ; qui les suit
• Les expressions : ce sont des instructions qui sont évaluées à une valeur de retour, on les reconnait par l’absence de ;

Un petit exemple :

fn main() {
    let x = 5; // Une déclaration, pas de valeur de retour
    x + 1 // Une expression, ici on ajoute 1 à x et on retourne cette valeur
    // Ainsi la fonction main() va retourner x+1 car c'est une expression
    // on a donc pas besoin du return lorsqu'on utilise une expression
}

On peut donc se passer de return simplement en omettant le ; après une expression.

On peut même créer des blocs qui ont leur propre porté grâce aux accolades :

fn main() {
    let x = 5; // Une déclaration, car il n'y a pas de valeur de retour
    let y = {
        let x = 3; // Ici on crée une variable x dans la portée du bloc
        x + 1 // C'est une expression, donc le bloc retourne la valeur x+1
        // Et ainsi y prend cette valeur de retour
    };
}

Et voilà, c’est tout ce qu’il y a à savoir sur les fonctions en Rust :)