Ce support sur le langage Rust s'adresse en premier lieu aux développeurs connaisseurs du C/C++, voire de langages comme Python ou C#, désireux d'apprendre ce langage adapté à la programmation système sécurisée.

Les premiers chapitres permettent de rendre accessible le propos, non seulement à un public issu du monde C++, mais également à un public connaisseur du développement logiciel via un langage plus éloigné. Ainsi, les concepts fondamentaux du langage sont étudiés, notamment la gestion de la mémoire impliquant le tas (heap) et la pile (stack). Les notions centrales en Rust que sont la propriété et l'emprunt font également l'objet de larges développements. La gestion de la mémoire est également abordée du point de vue de l'usage du multithreading.

Puis, au fil de la lecture, vous explorez également les notions de modules et de caisses (crates), de structures, d’énumérations et de filtrage par motif ainsi que les traits, les closures et les principales collections utilisées en Rust. Un chapitre est également consacré à la notion de WebAssembly, ainsi qu'un autre aux notions avancées en Rust.

Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.

Téléchargements

• Des fichiers complémentaires (31 870 Ko)

Comment et pourquoi Rust ?

1. 1. Introduction
2. 2. Contexte d'invention et nature du langage Rust
3. 3. Pourquoi le langage Rust ?
   1. 3.1 La question de la gestion de la mémoire
      1. 3.1.1 La pile
      2. 3.1.2 Le tas
      3. 3.1.3 Le typage sûr
   2. 3.2 La question de la gestion concurrentielle des threads
      1. 3.2.1 Contexte d'utilisation du parallélisme
      2. 3.2.2 Situation de compétition
      3. 3.2.3 L'enfer de l'exclusion mutuelle
4. 4. Conclusion

Commençons à utiliser concrètement Rust

1. 1. Installation et exploration
   1. 1.1 L'outil rustup
   2. 1.2 L'outil central : cargo
      1. 1.2.1 Versions installées
      2. 1.2.2 Un premier projet
      3. 1.2.3 Analyse et explications relatives au premier projet
      4. 1.2.4 Commandes principales cargo
2. 2. Premiers travaux en Rust
   1. 2.1 Un premier exemple de programme Rust
   2. 2.2 Exécution du programme
   3. 2.3 Compléments apportés au programme
3. 3. Outils complémentaires autour du projet réalisé
   1. 3.1 Un mot sur les tests unitaires en Rust
   2. 3.2 Un mot sur l'organisation par module
   3. 3.3 Un mot sur la ligne de commande
4. 4. Nommons les choses - Un peu de vocabulaire
   1. 4.1 Introduction
   2. 4.2 Petit lexique du langage Rust
      1. 4.2.1 Mutabilité
      2. 4.2.2 Structure (struct)
      3. 4.2.3 Trait et générique
      4. 4.2.4 Caisse (crate) et module
      5. 4.2.5 Propriété et emprunt
5. 5. Conclusion

Types, structures de données en Rust

1. 1. Introduction
2. 2. Les types primitifs simples
   1. 2.1 Types numériques entiers
      1. 2.1.1 Entiers signés
      2. 2.1.2 Entiers non signés
      3. 2.1.3 Entiers codés d'après la taille du processeur
   2. 2.2 Types numériques flottants
   3. 2.3 Le type booléen
   4. 2.4 Le type char
3. 3. Les types primitifs, structures de données
   1. 3.1 Le tuple
   2. 3.2 La structure struct
      1. 3.2.1 Structure, cas général
      2. 3.2.2 Structure et mutabilité
      3. 3.2.3 Le tuple structure
4. 4. Les types pointeurs en Rust
   1. 4.1 Références en Rust
   2. 4.2 Boîte (box) en Rust
   3. 4.3 Pointeurs bruts (raw pointers) en Rust
5. 5. Les types tableaux, vecteurs et tranches
   1. 5.1 Introduction
   2. 5.2 Les tableaux en Rust
   3. 5.3 Les vecteurs en Rust
   4. 5.4 Les tranches en Rust
6. 6. Le type chaîne de caractères (string)
   1. 6.1 Introduction
   2. 6.2 Cas pratique autour de string
7. 7. Conclusion

Possession et emprunt en Rust

1. 1. Introduction
   1. 1.1 Le tas et la pile
   2. 1.2 Utilité de la possession
2. 2. Fonctionnement de la possession
   1. 2.1 Grands principes
   2. 2.2 Exemples relatifs à la propriété
      1. 2.2.1 Propriété dans le tas
      2. 2.2.2 Propriété dans la pile
   3. 2.3 Plus loin avec la propriété : usage avec fonctions
      1. 2.3.1 Passage de valeur à une fonction
      2. 2.3.2 Retour de fonction
   4. 2.4 Conclusion à propos de la possession
3. 3. Fonctionnement de l'emprunt
   1. 3.1 Introduction
   2. 3.2 Exemple : transfert de propriété vs emprunt
      1. 3.2.1 Transfert de propriété
      2. 3.2.2 Emprunt
   3. 3.3 Emprunt à base de références mutables
4. 4. Conclusion

Structures en Rust

1. 1. Premières structures en Rust
   1. 1.1 Introduction
   2. 1.2 Structure à champs nommés
      1. 1.2.1 Syntaxe
      2. 1.2.2 La question de la visibilité
   3. 1.3 Structure - tuple
   4. 1.4 Structure - unité
   5. 1.5 Un mot de l'implantation mémoire d'une structure
2. 2. Les méthodes de structure en Rust
   1. 2.1 Prototype des méthodes
   2. 2.2 Usage du mot-clé self
   3. 2.3 Un exemple d'utilisation des méthodes
   4. 2.4 Vers les méthodes statiques en Rust
3. 3. Structure générique
   1. 3.1 Introduction
   2. 3.2 Exemple support
   3. 3.3 Exemple support augmenté
4. 4. La question des références dans une structure
   1. 4.1 Introduction
   2. 4.2 Mise en évidence du besoin d'annotation de durée de vie
   3. 4.3 Durée de vie basée sur le mot-clé static
5. 5. Notion de traits appliqués aux structures
   1. 5.1 Introduction
   2. 5.2 Les traits prédéfinis appliqués aux structures
6. 6. Conclusion

Énumérations et motifs en Rust

1. 1. Introduction
2. 2. Les énumérations en Rust
   1. 2.1 Premiers exemples
   2. 2.2 Exemple de conversion d'entiers vers une énumération
      1. 2.2.1 Les options dans la librairie standard
      2. 2.2.2 Premiers filtrages par motif
   3. 2.3 Un mot sur les méthodes d'énumération
   4. 2.4 Utiliser des structures dans des énumérations
      1. 2.4.1 Introduction
      2. 2.4.2 Exemple d'utilisation
   5. 2.5 Les énumérations génériques
      1. 2.5.1 Exemple dans la librairie standard
      2. 2.5.2 Arbre binaire avec une énumération générique
3. 3. Filtrage par motif
   1. 3.1 Premier exemple, pour rappel
   2. 3.2 Plus loin avec les motifs

Les traits en Rust

1. 1. Introduction
2. 2. Premier trait en Rust
   1. 2.1 Création d'une caisse et d'un exécutable client
   2. 2.2 Définition d'un trait
3. 3. Utiliser un trait en paramètre
   1. 3.1 Introduction
   2. 3.2 Exemple de trait en paramètre
   3. 3.3 Plusieurs paramètres d'un même trait en paramètre
4. 4. Notion de trait lié
   1. 4.1 Introduction
   2. 4.2 Plusieurs traits liés différents pour un même paramètre
      1. 4.2.1 Introduction
      2. 4.2.2 Le trait prédéfini Display
      3. 4.2.3 Création de la structure Tortue
      4. 4.2.4 Un mot sur la clause where
5. 5. Un trait comme valeur de retour
   1. 5.1 Introduction
   2. 5.2 Exemple support
6. 6. Points d'architecture impliquant les traits
   1. 6.1 Traits, génériques et structures
   2. 6.2 Un mot sur les sous-traits

Les traits prédéfinis en Rust

1. 1. Introduction
2. 2. Des traits prédéfinis essentiels : les itérateurs
3. 3. Notion de surcharge d'opérateurs
   1. 3.1 Introduction
   2. 3.2 Les opérateurs surchargeables
   3. 3.3 Exemple support
      1. 3.3.1 Contexte des nombres complexes
      2. 3.3.2 Premiers éléments de programmation
      3. 3.3.3 Surcharges des opérateurs + et -
      4. 3.3.4 Surcharges de la comparaison
4. 4. Inventaire et usage de quelques traits prédéfinis
   1. 4.1 L'usage de Derive
      1. 4.1.1 Explications
      2. 4.1.2 Exemple support
   2. 4.2 Inventaire des traits
      1. 4.2.1 Introduction
      2. 4.2.2 Le trait Drop
      3. 4.2.3 Les traits Deref et DerefMut
      4. 4.2.4 Le trait Default
      5. 4.2.5 Le trait From

Les chaînes de caractères en Rust

1. 1. Introduction
2. 2. Encodages Unicode et UTF-8 et caractères en Rust
   1. 2.1 Quelques définitions
   2. 2.2 Encodage en Rust
      1. 2.2.1 Le type char et l'Unicode
      2. 2.2.2 Les types String et str et l'UTF-8
3. 3. À la découverte des caractères (char) en Rust
   1. 3.1 Nature des caractères
   2. 3.2 Casse des caractères
   3. 3.3 Conversion vers un entier
4. 4. À la découverte de String et str
   1. 4.1 Introduction
   2. 4.2 Le type str
   3. 4.3 Le type String
      1. 4.3.1 Construction du type
      2. 4.3.2 Création d'un String
      3. 4.3.3 Premiers outils autour de String
      4. 4.3.4 Insertion dans un String
      5. 4.3.5 Suppression avec un String
      6. 4.3.6 Recherche et remplacement dans un String
5. 5. Un mot sur les expressions régulières

Les vecteurs en langage Rust

1. 1. Introduction
2. 2. Le vecteur Vec<T>
   1. 2.1 Introduction
   2. 2.2 Accès aux éléments (référence et copie)
   3. 2.3 Méthodes avancées d'accès
   4. 2.4 Considérations sur la taille et la capacité
   5. 2.5 Ajouts et retraits de valeurs
   6. 2.6 Autres opérations sur vecteurs
   7. 2.7 Un mot sur le tri de vecteurs
   8. 2.8 Un mot sur la recherche dans un vecteur

Autres collections en langage Rust

1. 1. Introduction
2. 2. La collection VecDeque<T>
   1. 2.1 Présentation
   2. 2.2 Utilisation de VecDeque<T>
3. 3. La collection LinkedList<T>
   1. 3.1 Présentation
   2. 3.2 Utilisation simple de LinkedList<T>
4. 4. La collection BinaryHeap<T>
   1. 4.1 Présentation
   2. 4.2 Utilisation de BinaryHeap<T>
5. 5. Table de hachage HashMap<Key, Value>
   1. 5.1 Présentation
   2. 5.2 Utilisation de HashMap<Key, Value>
   3. 5.3 Un mot sur la collection BTreeMap<Key, Value>
6. 6. Approche ensembliste avec HashSet<T>
   1. 6.1 Présentation
   2. 6.2 Utilisation de HashSet<T>
   3. 6.3 Un mot sur la collection BTreeSet<T>
7. 7. Conclusion

Les closures en Rust

1. 1. Introduction
2. 2. Considérations théoriques
3. 3. Première utilisation d'une closure
4. 4. Tri facile avec une closure
5. 5. Les closures, résumé des premières notions
6. 6. Considérations sur les traits FnOnce, FnMut et Fn
   1. 6.1 Explications du fonctionnement général
   2. 6.2 Le mot-clé move

Les threads et le multithreading en Rust

1. 1. Introduction
2. 2. Premiers threads et parallélisme
   1. 2.1 Introduction
   2. 2.2 Usage de spawn
      1. 2.2.1 Introduction
      2. 2.2.2 Premier exemple concret
   3. 2.3 Attendre la fin des threads secondaires (Fork-Join)
   4. 2.4 L'alternative rayon
      1. 2.4.1 Premier exemple
      2. 2.4.2 Un peu de parallélisme
3. 3. Communication entre threads
   1. 3.1 Introduction
   2. 3.2 Usage des canaux en Rust
      1. 3.2.1 Définition
      2. 3.2.2 Première utilisation d'un canal
      3. 3.2.3 Considérations sur la sécurisation du canal
      4. 3.2.4 Envois multiples dans le canal
4. 4. Usage des verrous mutuels exclusifs
   1. 4.1 Présentation et définition
   2. 4.2 Les structures Rc et Arc
      1. 4.2.1 Introduction
      2. 4.2.2 Rc<T>
      3. 4.2.3 Arc<T>
   3. 4.3 Usage de Mutex

Rust et WebAssembly

1. 1. Introduction
   1. 1.1 Première considération
   2. 1.2 Explications de WebAssembly
2. 2. Exemple détaillé de WebAssembly
   1. 2.1 Installation d'outils
   2. 2.2 Exemple détaillé
      1. 2.2.1 Introduction
      2. 2.2.2 Développement côté Rust
      3. 2.2.3 Développement côté JavaScript
3. 3. Pour aller plus loin
   1. 3.1 Quelques caisses utiles
      1. 3.1.1 Caisse wasm-bindgen
      2. 3.1.2 Caisse console_error_panic_hook
      3. 3.1.3 Caisse console_log
   2. 3.2 Le gestionnaire de paquets npm
      1. 3.2.1 Introduction
      2. 3.2.2 Déploiement sur npm

Notions avancées en Rust

1. 1. Introduction
2. 2. Les objets-traits
   1. 2.1 Présentation
   2. 2.2 La surcharge statique
   3. 2.3 La surcharge dynamique
      1. 2.3.1 Introduction
      2. 2.3.2 Contexte de l'exemple
      3. 2.3.3 Définition d'un trait dédiée à la surcharge dynamique
      4. 2.3.4 Usage du mot-clé dyn
3. 3. Le code Rust non sûr
   1. 3.1 Introduction
   2. 3.2 Déréférencer un pointeur brut
   3. 3.3 Modifier une variable statique mutable
   4. 3.4 Implémenter des traits non sécurisés

Projet final : coder et publier une caisse

1. 1. Introduction
2. 2. Périmètre fonctionnel
3. 3. Développement Rust de la librairie
4. 4. Autres aspects et tests de la caisse
5. 5. Publication de la caisse
9. Index