Les instructions (statements)

• Une instruction est une commande effectuant une action mais ne retournant aucune valeur.

• Exemple:

  let x = 1; // une instruction

• On ne peut pas assigner une instruction let

    fn main() {
        let y = (let x = 1);
    }

Les expressions

• Une expression est une combinaison de variables, d’opérations, … retournant une valeur.

• Exemple:

  3 + 5

• La plupart du code rust est une expression.

• N’importe quel bloc peut effectuer des opérations et retourner une valeur.

fn main() {
    let y = {
        let x = 5 + 3;
        x - 9
    };
    println!("5 + 3 - 9 = {}", y);
}

• Important: Une expression sans ; dans un bloc retourne la valeur evaluée de l’expression.

Généralités

• Les fonctions s’écrivent en snake_case (le compilateur vous avertiras…).
• La définition d’une fonction commence par un fn.
• La définition des fonctions peut se faire avant ou après l’endroit où elle est appelée.
• Une fonction contient des instructions et se termine parfois avec une expression.

fn main() {
    println!("La fonction main est une fonction.");

    fonction_fonction();
}

fn fonction_fonction() {
    println!("La fonction fonction_fonction est une fonction.");
}

Paramètres de fonctions

• Une fonction peut prendre des arguments séparés par des “,”.

• Le type des arguments doit toujours être explicitement déclaré.

  
    fn main() {
        affiche_entier(1024);
  }
  
  fn affiche_entier(x: i32) {
        println!("Affiche l'entier {}.", x);
  }
    

Valeur de retour de fonctions

• On déclare le type de retour d’une fonction avec -> Type.

  
    fn main() {
        println!("La réponse est {}.", la_reponse());
  }
  
  fn la_reponse() -> i32 {
      42
  }
  

• Important: La valeur de retour d’une fonction n’est pas suivie d’un “;”.

• Les instructions ne retournent pas de valeur et sont représentées par le type () (le type vide). D’où

  
    fn main() {
        println!("La réponse est {}.", la_reponse());
  }
  
  fn la_reponse() -> i32 {
      42;
  }