Programmer avec Rust

Table of contents

1. Couverture
2. Programmer avec Rust - pour une programmation système rapide et sûre - collection O'Reilly
3. Copyright
4. Introduction
   1. À qui s’adresse ce livre ?
   2. Intention des auteurs
   3. Structure du livre
   4. Conventions typographiques
   5. Code source des exemples
   6. Terminologie française
   7. Remerciements du traducteur
   8. Pour nous contacter
5. CHAPITRE 1. Pourquoi Rust ?
   1. Sûreté du typage
6. CHAPITRE 2. Brève visite guidée de Rust
   1. Téléchargement et installation de Rust
   2. Une première fonction Rust
      1. Rédaction et exécution des tests unitaires
      2. Exploitation de paramètres de ligne de commande
   3. Un serveur Web minimal
   4. Traitements concurrents
      1. Calcul d’une fractale Mandelbrot
      2. Analyse des paramètres de ligne de commande par paires
      3. Conversion de pixels vers nombres complexes
      4. Génération de l’image de l’ensemble
      5. Écriture du fichier image
      6. La fonction principale main()
      7. Traitement multiexétron
      8. Essai du traceur Mandelbrot
      9. La sécurité invisible
7. CHAPITRE 3. Types fondamentaux
   1. Types de données machine
      1. Types numériques entiers (integer)
      2. Types numériques à virgule flottante
      3. Type booléen (bool)
      4. Type caractère (char)
   2. Les types tuples
   3. Les types pointeurs
      1. Références
      2. Boîtes (Box)
      3. Pointeurs bruts ou risqués
   4. Tableaux, vecteurs et tranches
      1. Tableaux (array)
      2. Vecteurs
      3. Tranches (slices)
   5. Les types chaînes (string)
      1. Littéraux chaînes de caractères
      2. Chaînes octets
      3. Implantation des chaînes en mémoire
      4. Type String
      5. Utilisation des chaînes
      6. Autres types apparentés aux chaînes
   6. Des types d’un autre type
8. CHAPITRE 4. Posséder, léguer et emprunter
   1. Appartenance ou possession
   2. Transfert de propriété (move)
      1. Autres opérations à transfert de possession
         1. Renvoi d’une valeur depuis une fonction
         2. Construction d’une nouvelle valeur
         3. Passage de paramètres à une fonction
      2. Transfert et flux d’exécution
      3. Transfert de possession et contenu géré par indice
      4. Types copiants : possessions inaliénables
   3. Rc et Arc : possessions partagées
9. CHAPITRE 5. Références
   1. Références en tant que valeurs de pointeurs
      1. Références Rust et références C++
      2. Affectation d’une variable à une référence
      3. Références en cascade
      4. Comparaison de références
      5. Impossibilité des références nulles
      6. Emprunt de références sur expressions arbitraires
      7. Références à des tranches et à des objets traits
   2. Sûreté des références
      1. Emprunter une variable locale
      2. Réception d’une référence en paramètre d’entrée
      3. Passage de références en paramètres
      4. Renvoi d’une référence
      5. Structures contenant des références
      6. Paramètres de durée de vie multiples
      7. Omission des paramètres de durée de vie
      8. Partage ou mutation
   3. Sus à la jungle d’objets !
10. CHAPITRE 6. Expressions
    1. Un langage d’expressions
    2. Blocs et points-virgules
    3. Déclarations
    4. if et match
       1. La tournure if let
    5. Les boucles
    6. Expressions de valeurs renvoyées return
    7. Pourquoi des boucles en Rust ?
    8. Appels de fonction et de méthode
    9. Champs et éléments
    10. Opérateurs de références
    11. Opérateurs arithmétiques, sur bits, de comparaison et logiques
    12. Opérations d’affectation
    13. Transtypages
    14. Clôtures
    15. Priorité et associativité des expressions
    16. Pour aller plus loin
11. CHAPITRE 7. Gestion des erreurs
    1. Panique à bord
       1. Dépilement (unwinding)
       2. Abandon
    2. Result
       1. Capture des erreurs
       2. Alias du type Result
       3. Affichage des erreurs
       4. Propagation des erreurs
       5. Gestion de types d’erreurs multiples
       6. Gestion des erreurs totalement improbables
       7. Ignorer les erreurs
       8. Gestion des erreurs dans la fonction main()
       9. Déclaration d’un type erreur spécifique
       10. Avantages de Result
12. CHAPITRE 8. Caisses et modules
    1. Le concept de caisse (crate)
       1. Profil de production (build)
    2. Modules
       1. Fichiers distincts pour les modules
       2. Chemin d’accès et imports
       3. Le prélude standard
       4. Éléments ou blocs fondamentaux de Rust
    3. Convertir un programme en librairie
       1. Le sous-répertoire src/bin
    4. Attributs de compilation
    5. Test et documentation
       1. Tests unitaires
       2. Tests d’intégration
       3. Documentation automatique et docomments
       4. Doc-tests
    6. Contrôle des dépendances
       1. Contrôle des versions
       2. Le fichier Cargo.lock
    7. Publication d’une caisse sur crates.io
    8. Espaces de travail
    9. Encore d’autres bénéfices
13. CHAPITRE 9. Structures struct
    1. Structures à champs nommés
    2. Structures de style tuple
    3. Structures unité
    4. Organisation mémoire d’une structure
    5. Définition des méthodes d’une structure avec impl
    6. Structures génériques
    7. Structure avec paramètres de durées de vie
    8. Types structures et traits prédéfinis
    9. Mutabilité intérieure
       1. RefCell<T>
14. CHAPITRE 10. Énumérations et motifs
    1. Énumérations (énumes)
       1. Énumes avec données
       2. Implantation d’une énume en mémoire
       3. Énumes et structures de données complexes
       4. Énumes génériques
    2. Motifs d’accès (pattern)
       1. Littéraux, variables et génériques dans les motifs
       2. Motifs tuple et struct
       3. Motifs références
       4. Sélections multiples
       5. Gardien de motifs
       6. Motif @
       7. Autres utilisations des motifs de sélection
       8. Peuplement d’un arbre binaire
    3. Pour conclure sur les énumes
15. CHAPITRE 11. Traits et génériques
    1. Utilisation des traits
       1. Objets traits
       2. Implémentation mémoire d’un objet trait
       3. Fonctions génériques
       4. Choix entre objets traits et génériques
    2. Définition et implémentation d’un trait
       1. Méthodes par défaut
       2. Traits et types complémentaires
       3. Types self et traits
       4. Sous-traits
       5. Méthodes statiques
    3. Appels de méthodes totalement qualifiés
    4. Traits définissant des relations entre types
       1. Types associés (comment fonctionnent les itérateurs)
       2. Traits génériques (fonctionnement de la surcharge d’opérateur)
       3. Traits compagnons (fonctionnement de rand: :random)
    5. Rétro-ingénierie des liaisons
    6. Conclusion
16. CHAPITRE 12. Surcharge des opérateurs
    1. Opérateurs arithmétiques et sur bits
       1. Opérateurs unaires
       2. Opérateurs binaires
       3. Opérateurs d’affectation combinée
    2. Tests d’égalité
    3. Comparaisons ordonnées
    4. Index et IndexMut
    5. Autres opérateurs
17. CHAPITRE 13. Traits utilitaires
    1. Drop (largage)
    2. Sized (taille fixée ou non fixée)
    3. Clone
    4. Copy
    5. Deref et DerefMut
       1. Default
    6. AsRef et AsMut
    7. Borrow et BorrowMut
    8. From et Into
    9. ToOwned
    10. Borrow et ToOwned se combinent dans Cow
18. CHAPITRE 14. Clôtures
    1. Capture de variables
       1. Clôtures qui empruntent
       2. Clôtures qui dérobent
    2. Type des fonctions et des clôtures
    3. Performances des clôtures
    4. Clôtures et sûreté
       1. Clôtures qui tuent
       2. FnOnce
       3. FnMut
    5. Fonctions ou clôtures de rappel (callbacks)
    6. Utilisation efficace des clôtures
19. CHAPITRE 15. Itérateurs
    1. Les traits Iterator et IntoIterator
    2. Création d’un itérateur
       1. Les méthodes iter et iter_mut
       2. Implémentation de IntoIterator
       3. Les méthodes drain
       4. Autres sources d’itérateurs
    3. Adaptateurs d’itérateurs
       1. map et filter
       2. filter_map et flat_map
       3. scan
       4. take et take_while
       5. skip et skip_while
       6. Peekable (consultable)
       7. fuse
       8. Itérateurs réversibles et rev
       9. inspect
       10. chain
       11. enumerate
       12. zip
       13. by_ref
       14. cloned
       15. cycle
    4. Consommation des itérateurs
       1. Accumulation simple : count, sum, product
       2. min et max
       3. min_by et max_by
       4. max_by_key, min_by_key
    5. Comparaison de séquences d’éléments
       1. any et all
       2. position, rposition et ExactSizeIterator
       3. fold
       4. nth
       5. last
       6. find
       7. Construction d’une collection avec collect et FromIterator
       8. Le trait Extend
       9. partition
    6. Implémentation de vos propres itérateurs
20. CHAPITRE 16. Collections
    1. Aperçu global
    2. Vec<T>
       1. Accès aux éléments d’un vecteur
       2. Itérations
       3. Contrôle de la taille des vecteurs
       4. Jointures
       5. Distribution (split)
       6. Permutations (swap)
       7. Tris
       8. Recherches
       9. Comparaison de tranches
       10. Traitements aléatoires
       11. Interdiction des erreurs d’invalidation
    3. VecDeque<T>
    4. LinkedList<T>
    5. BinaryHeap<T>
    6. HashMap<K, V> et BTreeMap<K, V>
       1. Entrées d’une mappe
       2. Itérations dans une mappe
    7. HashSet<T> et BTreeSet<T>
       1. Itérations dans un ensemble
       2. Valeurs égales mais différentes
       3. Opérations globales sur les ensembles
    8. Types hachables
       1. Utilisation d’un algorithme de hachage spécifique
    9. Au-delà des collections standard
21. CHAPITRE 17. Chaînes et textes
    1. Quelques rappels sur Unicode
       1. ASCII, Latin-1 et Unicode
       2. UTF-8
       3. Sens d’écriture des textes
    2. Caractère (char)
       1. Catégories de caractères
       2. Gestion des chiffres
       3. Conversion Maj/Min des caractères
       4. Conversions de et vers les entiers
    3. Chaînes String et str
       1. Création de valeurs chaînes
       2. Inspection d’une chaîne
       3. Ajout et insertion de texte
       4. Suppression de texte
       5. Conventions pour les recherches et les itérations
       6. Motifs de recherche de texte
       7. Recherches et remplacements
       8. Itération ou balayage de texte
       9. Raccourcissements (trim)
       10. Changement de casse dans les chaînes
       11. Analyse d’autres types de chaînes
       12. Conversion d’autres types vers les chaînes
       13. Emprunt de chaînes comme autres types de style texte
       14. Accès à du texte en tant que UTF-8
       15. Production de texte à partir de données UTF-8
       16. Contrôle de l’allocation et Cow
       17. String et collections génériques
    4. Formatage de valeurs
       1. Formatage de valeurs textes
       2. Contrôle des formats numériques
       3. Formatage d’autres types
       4. Formatage pour le débogage
       5. Formatage des pointeurs pour le débogage
       6. Références aux paramètres par index ou par nom
       7. Largeur et précision dynamiques
       8. Formatage de vos types programmeur
       9. Utilisation du langage de formatage dans votre code
    5. Expressions régulières (regex)
       1. Utilisation générale de Regex
       2. Production de valeurs Regex optimisées
    6. Normalisation et Unicode
       1. Formes Unicode normalisées
       2. La caisse unicode-normalization
22. CHAPITRE 18. Entrées/sorties
    1. Lecteurs et scripteurs
       1. Lecteurs (readers)
       2. Lecteurs tamponnés
       3. Lecture de plusieurs lignes
       4. Collecte de plusieurs lignes
       5. Scripteurs (writers)
       6. Accès fichiers
       7. Recherches
       8. Autres types lecteurs et scripteurs
       9. Données binaires, compression et sérialisation
    2. Fichiers et répertoires
       1. OsStr et Path
       2. Méthodes de Path et PathBuf
       3. Fonctions d’accès au système de fichiers
       4. Lecture d’un répertoire
       5. Particularités des plates-formes
    3. Fonctions réseau
23. CHAPITRE 19. Concurrence et exétrons
    1. Le parallélisme Fork-Join
       1. spawn et join
       2. Gestion des erreurs entre exétrons
       3. Partage de données immutables entre exétrons
       4. La librairie Rayon
       5. Retour sur les fractales de Mandelbrot
    2. Canaux (channels)
       1. Émission d’une valeur
       2. Réception de valeurs
       3. Fusion des index (étapes 3 à 5)
       4. Caractéristiques et performances des canaux
       5. Sécurité des exétrons avec Send et Sync
       6. Itérateurs, pipelines et canaux
       7. Au-delà des pipelines
    3. États mutables partagés (mutex)
       1. Qu’est-ce qu’un verrou mutex ?
       2. Mutex<T>
       3. mut et Mutex
       4. Les mutex ne sont pas toujours une bonne idée
       5. Autoblocage (dead lock)
       6. Verrous mutex empoisonnés
       7. Canaux multirécepteurs avec mutex
       8. Verrous en lecture/écriture (RwLock<T>)
       9. Variables de condition (Condvar)
       10. Atomiques
       11. Variables globales
    4. Rust, le compagnon de la parallélisation
24. CHAPITRE 20. Macros
    1. Principe des macros
       1. Principe de déploiement d’une macro
       2. Conséquences inattendues
       3. Répétition d’expressions
    2. Macros incorporées
    3. Débogage des macros
    4. La macro json!
       1. Types de fragments de macro
       2. Récursion dans les macros
          1. Utilisation de traits dans les macros
       3. Portée et hygiène
       4. Exportation et importation de macros
    5. Erreurs de syntaxe dans les patrons
    6. Au-delà de macro_rules!
25. CHAPITRE 21. Code non sûr (unsafe)
    1. Non sûr de quoi ?
    2. Blocs unsafe
       1. Un exemple : un type String ASCII efficace
    3. Fonctions non sûres
    4. Blocs non sûrs ou fonctions non sûres ?
    5. Comportement incertain ou indéfini
    6. Traits non sûrs
    7. Pointeurs bruts (raw)
       1. Déréférencement sûr d’un pointeur brut
       2. Exemple : RefWithFlag
       3. Pointeurs annulables
       4. Taille de types et alignements
       5. Arithmétique sur les pointeurs
       6. Lectures/écritures mémoire manuelles et possession
       7. Exemple : GapBuffer
       8. Gestion des paniques dans le code non sûr
    8. Fonctions étrangères : appels de C et C++ depuis Rust
       1. Recherche des représentations de données correspondantes
       2. Déclaration d’une fonction ou d’une variable étrangère
       3. Utilisation d’une fonction de librairie
          1. En pratique
       4. Une interface brute vers libgit2
       5. Une interface libgit2 sûre
          1. Rédaction de git/mod.rs
    9. Conclusion
26. Sommaire