From e585a06c888037c339197ee5b813094eec5d2bf4 Mon Sep 17 00:00:00 2001
From: Orestis Malaspinas <orestis.malaspinas@hesge.ch>
Date: Thu, 27 Sep 2018 10:00:26 +0200
Subject: [PATCH] modifications pour types avances et modules
---
modules.md | 33 ++++++-
types_avances.md | 244 ++++++++++++++++++++++++++++-------------------
2 files changed, 175 insertions(+), 102 deletions(-)
diff --git a/modules.md b/modules.md
index a1d7bf4..97e7681 100644
--- a/modules.md
+++ b/modules.md
@@ -38,6 +38,7 @@ sansfont: Sans Serif
## La définition d'un module
- Dans le fichier `lib.rs` on peut à présent créer un/deux/... modules contenant une fonction
+
```{.lang-rust}
mod mon_module { // on peut même insérer d'autres modules à l'intérieur
fn ma_fonction() {
@@ -54,7 +55,7 @@ sansfont: Sans Serif
- Les fonctions `mon_module::ma_fonction()`{.lang-rust}, `mon_autre_module::ma_fonction()`{.lang-rust} auront une signification (et une fonctionalité différente).
-## Fichiers (1/2)
+## Fichiers (1/3)
- Avoir tous ses modules dans un fichier: pas pratique.
- On *déclare* les modules dans `src/lib.rs`, on met le contenu dans `src/mon_module.rs`
@@ -83,7 +84,7 @@ sansfont: Sans Serif
}
```
-## Fichiers (2/2)
+## Fichiers (2/3)
- On peut aller encore plus loin: `src/lib.rs`
@@ -94,7 +95,7 @@ sansfont: Sans Serif
}
mod mon_autre_module {
- fn ma_fonction() {
+ fn ma_fonction() {
unimplemented!(); // macro très pratique!
}
}
@@ -125,3 +126,29 @@ sansfont: Sans Serif
unimplemented!(); // macro très pratique!
}
```
+
+## Fichiers (2/3)
+
+- Avec la structure de module suivante
+
+ ```{.lang-rust}
+ mod mon_module {
+ fn ma_fonction() {
+ unimplemented!(); // macro très pratique!
+ }
+
+ mod mon_autre_module {
+ fn ma_fonction() {
+ unimplemented!(); // macro très pratique!
+ }
+ }
+ }
+
+ ```
+
+- On accède aux deux `ma_fonction()` avec
+
+ ```{.lang-rust}
+ mon_module::ma_fonction();
+ mon_module::mon_autre_module::ma_fonction();
+ ```
\ No newline at end of file
diff --git a/types_avances.md b/types_avances.md
index bee5f67..b3d1272 100644
--- a/types_avances.md
+++ b/types_avances.md
@@ -6,52 +6,6 @@ author: Orestis Malaspinas
sansfont: Sans Serif
---
-# $N$-uplets
-
-## `Tuples`{.rust}
-
-- Un $n-$tuplet est une *collection* ordonnée de $n$ objets.
-- Permet de regrouper plusieurs valeurs avec différents types dans un type composé.
-
- <pre><code data-trim="hljs rust" class="lang-rust">
- fn main() {
- let tuple: (f64, char, usize) = (1.0, 'c', 18usize); // type pas nécessaire
-
- println!("Un tuple {:?}", tuple); // affichage Debug
-
- let sans_type_tuple = (666, "abcdef"); // type inféré
-
- println!("Un autre tuple {:?}", sans_type_tuple); // affichage Debug
- }
- </code></pre>
-
-## Destructuration
-
-- Les $n$ objets d'un $n$-uple n'ont pas d'identifiant, juste un numéro.
-- On peut destructurer un $n$-uplet avec la notation
-
- `let (a,b,c,...) = tuple;`{.rust}
-
-- Les champs sont accessibles avec la notation
-
- `
- let a = tuple.0;
- let b = tuple.1;
- `{.rust}
-
-<pre><code data-trim="hljs rust" class="lang-rust">
-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);
-}
-</code></pre>
-
# Vecteurs statiques
## `array`{.rust}
@@ -59,7 +13,7 @@ fn main() {
- Collection d'objet de **même** type dont le nombre est connu à la compilation.
- Ne peuvent pas changer de taille au cours de l'exécution (les éléments peuvent changer de valeur).
- Éléments alloués contigument dans la mémoire. <!-- Ajouter image -->
-- Alloués sur la pile.
+- Alloués sur la pile (en général).
<pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
@@ -109,6 +63,77 @@ fn main() {
}
</code></pre>
+# $N$-uplets
+
+## `Tuples` {.rust}
+
+- Un $n-$tuplet est une *collection* ordonnée de $n$ objets.
+
+ ```
+ let tuple: (type1, type2, ...) = (val1, val2, ...); // le type peut être inféré
+ ```
+- Permet de regrouper plusieurs valeurs avec différents types dans un type composé.
+
+ <pre><code data-trim="hljs rust" class="lang-rust">
+ fn main() {
+ let tuple: (f64, char, usize) = (1.0, 'c', 18usize); // type pas nécessaire
+
+ println!("Un tuple {:?}", tuple); // affichage Debug
+
+ let sans_type_tuple = (666, "abcdef"); // type inféré
+
+ println!("Un autre tuple {:?}", sans_type_tuple); // affichage Debug
+ }
+ </code></pre>
+- Pas forcément toujours pratique: on a pas d'identifiant pour les champs.
+
+## Exemple
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn area(w: usize, h: usize) -> usize {
+ w * h
+}
+
+fn area_t(r: (usize, usize)) -> usize {
+ r.0 * r.1
+}
+
+fn main() {
+ let w = 10;
+ let h = 20;
+
+ println!("Area = {}.", area(w,h));
+ println!("Area with tuple = {}.", area_t((w,h)));
+}
+</code></pre>
+
+## Destructuration
+
+- Les $n$ objets d'un $n$-uple n'ont pas d'identifiant, juste un numéro.
+- On peut destructurer un $n$-uplet avec la notation
+
+ `let (a,b,c,...) = tuple;`{.rust}
+
+- Les champs sont accessibles avec la notation
+
+ `
+ let a = tuple.0;
+ let b = tuple.1;
+ `{.rust}
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+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);
+}
+</code></pre>
+
# Structures
## `struct`{.rust} (1/3)
@@ -217,73 +242,94 @@ let ins2 = TypeEnum::id2;
## `Enum`{.rust} (2/2)
-- On peut également associées avec n'importe quel variante de l'enum.
+- On peut également associer des valeurs avec n'importe quel variante de l'enum.
- <pre><code data-trim="hljs rust">
- struct TypeStruct {
- // détails pas importants
- };
+<pre><code data-trim="hljs rust">
+struct TypeStruct {
+ // détails pas importants
+};
- enum TypeEnum {
- id1(char, char), // deux char
- id2{x: usize}, // struct anonyme
- id3(TypeStruct), // struct
- }
+enum TypeEnum {
+ id1(char, char), // deux char
+ id2{x: usize}, // struct anonyme
+ id3(TypeStruct), // struct
+}
- let ins1 = TypeEnum::id1('a','b');
- let ins2 = TypeEnum::id2({x: 12usize});
- let ins2 = TypeEnum::id3(TypeStruct::new());
- </code></pre>
+let ins1 = TypeEnum::id1('a','b');
+let ins2 = TypeEnum::id2({x: 12usize});
+let ins2 = TypeEnum::id3(TypeStruct::new());
+</code></pre>
+
+# Pattern matching
-## Pattern matching, `match`{.rust}
+## `match`{.rust} (1/3)
- Structure de contrôle extrêmement puissante.
-- Comparaison entre une valeurs et une série de *patterns* <!-- TODO traduire -->
-afin de décider d'une action à effectuer.
+- Comparaison entre une valeurs et une série de *patterns* afin de décider d'une action à effectuer.
- Toutes les possibilités sont obligatoirement traitées.
- <pre><code data-trim="hljs rust" class="lang-rust">
- enum TypeEnum {
- id1,
- id2,
- id3,
- }
+<pre><code data-trim="hljs rust" class="lang-rust">
+enum TypeEnum {
+ id1,
+ id2,
+ id3,
+}
- fn main() {
- let data = TypeEnum::id1;
- let num =
- match data {
- TypeEnum::id1 => 1,
- TypeEnum::id2 => 2,
- TypeEnum::id3 => 3,
- };
- println!("num = {}", num);
- }
- </code></pre>
+fn main() {
+ let data = TypeEnum::id1;
+ let num =
+ match data {
+ TypeEnum::id1 => 1,
+ TypeEnum::id2 => 2,
+ TypeEnum::id3 => 3,
+ };
+ println!("num = {}", num);
+}
+</code></pre>
-## Pattern matching, `match`{.rust}
+## `match`{.rust} (2/3)
- Dans certains cas, on veut le même comportement pour plusieurs `patterns`.
- <pre><code data-trim="hljs rust" class="lang-rust">
- enum TypeEnum {
- id1,
- id2,
- id3,
- }
+<pre><code data-trim="hljs rust" class="lang-rust">
+enum TypeEnum {
+ id1,
+ id2,
+ id3,
+}
- fn main() {
- let data = TypeEnum::id3;
- let num =
- match data {
- TypeEnum::id1 => 1,
- _ => 2,
- };
- println!("num = {}", num);
- }
- </code></pre>
+fn main() {
+ let data = TypeEnum::id3;
+ let num =
+ match data {
+ TypeEnum::id1 => 1,
+ _ => 2,
+ };
+ println!("num = {}", num);
+}
+</code></pre>
+
+## `match`{.rust} (3/3)
+
+- Pour lier une valeur stockée dans un `Enum`{.rust}
+
+<pre><code data-trim="hljs rust">
+enum AnimalMythique {
+ Chupacabra,
+ Dahu,
+ ChevalAile(Pays), // Le type Pays est défini avant
+}
+
+fn pays_dorigine(animal: AnimalMythique) {
+ match animal {
+ AnimalMythique::Chpacabra => println!("Mexique", pays),
+ AnimalMythique::Dahu => println!("Suisse", pays), // Oui il Suisse.
+ AnimalMythique::ChevalAile(pays) => println!("{}", pays);
+ },
+}
+</code></pre>
-## Options
+# Options
- Un type énuméré particulièrement utile est le type `Option`{.rust}
```{.lang-rust}
--
GitLab