Types avancés

# Tableaux statiques

---
## Type `array`

- Collection d'éléments du même type.
- Taille fixe connue à la compilation.
- Syntaxe: `[T; N]` où `T` est le type des éléments et `N` la taille (constante).

```rust [2,4|]
fn main() {
    let entiers = [1, 2, 3, 4, 5];
    println!("Les 5 premiers entiers naturels: {:?}.", entiers); 
    let zeros: [i32; 10] = [0; 10]; // déclaration explicite du type
    println!("Dix zéros: {:?}.", zeros); 
}
```

---
## Problème?

```rust compile_fail
fn main() {
    let entiers = [1, 2.0, 3, 4, 5];
}
```

---
## Accès aux éléments

- Indices en `0` à `size-1`.
- Syntaxe: `array[index]`.

```rust [2-3|4-5|]
fn main() {
    let jours = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi",
                   "Samedi", "Dimanche"];
    let premier = jours[0]; // [index]
    let dernier = jours[6]; // index in [0, size-1]
    println!("Le premier jour de la semaine est 
        le {} et le dernier {}.", premier, dernier); 
}
```

---
## Dépassement de capacité

- Panique à l'exécution.

```rust compile_fail
fn main() {
    let jours = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi",
                   "Samedi", "Dimanche"];
    let _oups = jours[7]; // dépassement de capacité
}
```

---
## Modification des éléments: erreur

```rust compile_fail
fn main() {
    let entiers = [1, 2, 3, 4, 5];
    entiers[0] = -4; // immutable => erreur
}
```

---
## Modification des éléments: ok

```rust
fn main() {
    let mut entiers = [1, 2, 3, 4, 5];
    entiers[0] = -4; // immutable => ok
    println!("Les 5 entiers : {:?}.", entiers); 
}
```

---
# `N`-uplets

---
## `Tuples`

- *Collection* de `n` objets: `n`-tuplet.
- Les éléments peuvent être de types différents.
- Syntaxe `(V1, V2, ..., Vn)` où `Vi` est la valeur de l'élément `i`.
- Syntaxe `(T1, T2, ..., Tn)` où `Ti` est le type de l'élément `i`.

```rust
fn main() {
    let triple = (1.0, 'c', 18usize);                // type inféré
    println!("Un tuple {:?}", triple);
    let tuple: (i32, char)  = (666, 'a'); // type explicite
    println!("Un autre tuple {:?}", tuple);
}
```

---
## Exemple

```rust [1-3|4-6|7-12|]
fn area(w: usize, h: usize) -> usize {
    w * h
}
fn area_t(r: (usize, usize)) -> usize {
    r.0 * r.1 // sélecteur
}
fn main() {
    let w = 10; 
    let h = 20;
    println!("Area = {}.", area(w,h));
    println!("Area with tuple = {}.", area_t((w,h)));
}
```

---
## Destructuration

```rust [3|5-7|]
fn main() {
    let tuple = (1.0, 'c', 18usize);
    let (fl, ch, us) = tuple;
    println!("Le tuple destructuré: {fl}, {ch}, {us}");
    let fl_ind = tuple.0;
    let ch_ind = tuple.1;
    let us_ind = tuple.2;
    println!("Le tuple re-destructuré: {fl_ind}, {ch_ind}, {us_ind}"); 
}
```

---
# Structures

---
## `struct`: initialisation

```rust [1-4|6-8|]
struct Etudiant {
    nom: String,
    actif: bool,
}
fn main() {
    let etu = Etudiant {
        nom: String::from("Jean-Paul Dax"), 
        actif: true,
    };
}
```

---
## `struct`: sélecteur

```rust [10|]
struct Etudiant {
    nom: String,
    actif: bool,
}
fn main() {
    let etu = Etudiant {
        nom: String::from("Jean-Paul Dax"), 
        actif: true,
    };
    println!("Nom: {}", etu.nom);
}
```

---
## `struct`: mutabilité

```rust [6|10|]
struct Etudiant {
    nom: String,
    actif: bool,
}
fn main() {
    let mut etu = Etudiant {
        nom: String::from("Jean-Paul Dax"), 
        actif: true,
    };
    etu.actif = false;
}
```

---
## `tuple struct`

```rust [2|3|]
fn main() {
  struct Point2d(i32, i32);
  let origine = Point2d(0,0);
  println!("L'origine est le point ({}, {}).", origine.0, origine.1);
}
```

---
# Types énumérés

---
## `Enum`: déclaration / instantiation

```rust [1-5|7-9|]
enum StatusEtudiant {
    Immatricule,
    Exmatricule,
    InscriptionEnCours,
}
fn main() {
    let status1 = StatusEtudiant::Immatricule;
    let status2 = StatusEtudiant::Exmatricule;
    let status3 = StatusEtudiant::InscriptionEnCours;
}
```

- **Question**: Quel est le type de `status1`, `status2`, et `status3`?

---
## `Enum`: exemple

```rust [7-8|5|]
enum StatusEtudiant {
    Immatricule,
    Exmatricule,
    InscriptionEnCours,
}
fn foo(enum_type: TypeEnum) { }
fn main() {
    changer_status(StatusEtudiant::Immatricule); // appel valide
    changer_status(StatusEtudiant::Exmatricule); // appel également valide
}
```

---
## `Enum`: types associés

```rust [2-6|8-10|]
enum AnimalMythique {
    Chupacabra,
    Dahu,
}
fn main() {
    let animal1 = AnimalMythique::Chupacabra;
    let animal2 = AnimalMythique::Dahu;
}
```

---
# Pattern matching

---
## `match`

```rust [9-13|]
enum AnimalMythique {
    Chupacabra,
    Dahu,
}
fn main() {
    let animal1 = AnimalMythique::Chupacabra;
    let animal2 = AnimalMythique::Dahu;
}
fn main() {
    let data = AnimalMythique::Chupacabra;
    let pays = 
        match data {
            AnimalMythique::Chupacabra => "Mexique",
            AnimalMythique::Dahu => "Suisse",
        };
    println!("Pays associé: {pays}");
}
```

---
## `match`: bras manquant

```rust compile_fail [8-10|]
enum AnimalMythique {
    Chupacabra,
    Dahu,
}
fn main() {
    let animal = AnimalMythique::Chupacabra;
    let pays = 
        match animal {
            AnimalMythique::Chupacabra => "Mexique",
        };
    println!("Pays associé: {pays}");
}
```

---
## `match`: défaut

```rust [11|9-12|]
enum AnimalMythique {
    Chupacabra,
    Dahu,
    ChevalAile,
}
fn main() {
    let animal = AnimalMythique::ChevalAile;
    let pays = 
        match animal {
            AnimalMythique::Chupacabra => "Mexique",
            _ => "Inconnu"
        };
    println!("Pays associé: {pays}");
}
```

---
## `Enum`: types associés

```rust [2-6|8-10|]
enum AnimalMythique {
    Chupacabra,
    Dahu,
    ChevalAile(String), // ChevalAile a un type associé
}
fn main() {
    let animal1 = AnimalMythique::Chupacabra;
    let animal2 = AnimalMythique::Dahu;
    let animal3 = AnimalMythique::ChevalAile("Grèce".to_string());
    let animal4 = AnimalMythique::ChevalAile("Éthiopie".to_string());
}
```

---
## `match`: lier une valeur

```rust [4|10|] no_run
enum AnimalMythique {
    Chupacabra,
    Dahu,
    ChevalAile(String),
}
fn pays_dorigine(animal: AnimalMythique) {
    match animal {
        AnimalMythique::Chupacabra => println!("Mexique"),
        AnimalMythique::Dahu => println!("Suisse"),
        AnimalMythique::ChevalAile(pays) => println!("{}", pays),
    };
}
```

---
# Rustlings

- Faire les exercices Rustlings sur les `srtuct`, `enum`, et `match`.