intro aux types produits

essential_rust.tex

@@ -444,6 +444,8 @@ fn somme(vect: &Vec<usize>) -> usize {
 }
 \end{lstlisting}
 
+La forme complète d'une référence est \texttt{\&'lft Type} ou \texttt{\&'lft mut Type} :
+voir \Cref{advancedLifetimes} pour plus de détails.
 
 
 
@@ -527,43 +529,68 @@ Il se trouve que les boucles et tests sont des expressions: voir \Cref{expressio
 
 \section{Structures, Enums et Pattern matching}
 
-Dans l'exemple ci-dessous, nous allons créer deux utilisateurs, Anthony et Luc.
+\subsection{Types produits}
 
-Chaque utilisateur a :
-\begin{itemize}
-  \item un identifiant
-  \item un prénom
-  \item potentiellement, un surnom
-\end{itemize}
+Il y a trois formes pour déclarer un type qui est la concaténation de
+valeurs de plusieurs types.
+Tous peuvent être déstructurés similairement.
 
+Ici on veut que le type \texttt{T} ait trois valeurs de types \texttt{u8}, \texttt{char},
+\texttt{String}.
+
+Tuples:
 \begin{lstlisting}[style=Rust, language=Rust]
-enum MaybeNickname {     // L'enum \textbf{MaybeNickname} se compose :
-    Nickname(String),    //  - soit d'un élément, qui est la chaîne de caractère.
-    NoNickname,          //  - soit d'aucun élément.
+type T = (u8, char, String);
+
+fn main() {
+    let t = (1, 'a', "un".to_string());
+    let (n, c, s) = t;
+    let n = t.0;
 }
+// avantages: peut être créé à la volée
+// inconvénients: long à écrire si il y a beaucoup de valeurs, on risque d'oublier des valeurs
+// utilisation: pour des types qui n'ont pas particulièrement de signification dans le programme
+\end{lstlisting}
+~\\
 
-struct User {
-    id: i32,
-    name: String,
-    nickname: MaybeNickname,
+Tuple struct:
+\begin{lstlisting}[style=Rust, language=Rust]
+struct T(u8, char, String);
+
+fn main() {
+    let t = T(1, 'a', "un".to_string());
+    let T(n, c, s) = t;
+    let n = t.0;
+}
+// avantages: ne peut pas être confondu avec d'autres types qui ont les mêmes éléments
+// inconvénients: on peut oublier l'ordre des éléments
+// utilisation: pour des types qui contiennent peu de valeurs
+\end{lstlisting}
+Voir \Cref{patternNewtype} pour une utilisation fréquente de cette forme
+~\\
+
+Struct:
+\begin{lstlisting}[style=Rust, language=Rust]
+struct T {
+    num: u8,
+    chr: char,
+    str: String,
 }
 
 fn main() {
-    let user_one: User = User {
-        id: 1,
-        name: "Anthony".to_string(),
-        nickname: MaybeNickname::Nickname("Antho".to_string()),
-    };
-    
-    let user_two: User = User {
-        id: 2,
-        name: "Luc".to_string(),
-        nickname: MaybeNickname::NoNickname,
+    let t = T {
+        num: 1,
+        chr: 'a',
+        str: "un".to_string(),
     };
-   
-    print_user(user_one);   // "1: Anthony aka Antho"
-    print_user(user_two);   // "2: Luc"
+    let T { num: n, chr: c, str: s } = t;
+    let n = t.num;
 }
+// avantages: on ne risque pas d'oublier la signification de chaque champ
+// inconvénients: long à écrire
+// utilisation: pour des types qui ont soit beaucoup de valeurs,
+//              soit plusieurs valeurs qu'on risque de confondre
+\end{lstlisting}
 
 fn print_user(user: User) {
     // Afin de comparer l'enum, on utilise un pattern matching