Annoter le type des variables

let is_rust_cool: bool = true;

// let mon_float: f64 = 5.0; // Annotation simple
// let mon_integer = 5i32; // Annotation via suffixe 

// Ou inférence de type:
let mon_autre_float = 5.0; // f64
let mon_autre_integer = 5; // i32

Le type de variable ne peut pas être changé


Tableau de taille fixe et type connu

let petit_tableau: [i8; 5] = [1, 2, 3, 4, 5];

Tableau de taille fixe, type connu et initialisé à 0

let petit_tableau2: [i8; 20] = [0; 20];

Retourner le nombre d’éléments d’un tableau

println!("petit_tableau2 contient {} éléments", petit_tableau2.len());

Retourner la taille occupée en mémoire par un tableau

use std::mem;
fn main() {
  let petit_tableau2: [i8; 20] = [0; 20];
  println!("petit_tableau2 occupe {} bytes", mem::size_of_val(&petit_tableau2));
  // petit_tableau2 occupe 20 bytes
  let petit_tableau2: [i16; 20] = [0; 20];
  println!("petit_tableau2 occupe {} bytes", mem::size_of_val(&petit_tableau2));
  // petit_tableau2 occupe 20 bytes
  // i8 <-> 8 bits <-> 1 byte
  // i16 <-> 16 bits <-> 2 bytes
}

Slicer des tableaux

fn describe_slice(slice: &[i16]) {
    println!("Slice[0]: {}", slice[0]);
    println!("Slice length: {}", slice.len());
}

fn main() {
  let petit_tableau2: [i16; 20] = [0; 20];
  describe_slice(&petit_tableau2);
  //Slice[0]: 0
  //Slice length: 20
  describe_slice(&petit_tableau2[0..2]);
  //Slice[0]: 0
  //Slice length: 2
}

Retourner l’élément N d’un tuple

let mon_tuple = (1u8, 2u16, 3u32, 4u64, 5u32, 6u16, -1i8, -2i16, -3i32, -4i64, 0.1f32, 0.2f64, false, 'a', 'b');
println!("Premier element dans mon_tuple: {}", mon_tuple.0);
println!("Deuxième element dans mon_tuple: {}", mon_tuple.1);

Un tuple dans un tuple

let mon_tuple_dans_tuple = ((1u8, 2u16, 2u32), (3u32, 5u8), -2i16);
println!("Print tuple dans tuples: {:?}", mon_tuple_dans_tuple);
//Print tuple dans tuples: ((1, 2, 2), (3, 5), -2)
println!("Premier tuple dans tuples: {:?}", mon_tuple_dans_tuple.0);
//Premier tuple dans tuples: (1, 2, 2)

Attention les tuples trop longs ne peuvent pas être “printés”


Renverser un tuple de 2 éléments/ une paire

Comme en Python les tuples peuvent être passés ou retournés dans les fonctions

fn reverse(pair: (i32, bool)) -> (bool, i32) {
    let (integer, boolean) = pair;
    (boolean, integer)
}

let mon_tuple = (1, true);
println!("mon_tuple = {:?}", mon_tuple);
//mon_tuple = (1, true)
println!("mon_tuple reversed = {:?}", reverse(mon_tuple));
//mon_tuple reversed = (true, 1)

Comme en Python, les tuples contenant 1 élement, s’écrivent ("titi",)


Destructuration

let mon_tuple = (1, "titi", 0.5, true);
let (a, b, c, d) = mon_tuple;
println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
//1, "titi", 0.5, true

Structures

#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

let ma_matrice = Matrix(0.1, 0.2, 1.1, 2.2);
println!("{:?}", ma_matrice);
Matrix(0.1, 0.2, 1.1, 2.2)