1. Die Programmiersprache Rust
2. Vorwort
3. Einführung
4. 1. Erste Schritte
5. 1. 1.1. Installation
   2. 1.2. Hallo Welt
   3. 1.3. Hallo Cargo
6. 2. Ein Ratespiel programmieren
7. 3. Allgemeine Programmierkonzepte
8. 1. 3.1. Variablen und Veränderbarkeit
   2. 3.2. Datentypen
   3. 3.3. Funktionen
   4. 3.4. Kommentare
   5. 3.5. Kontrollfluss
9. 4. Eigentümerschaft (ownership) verstehen
10. 1. 4.1. Was ist Eigentümerschaft (ownership)?
    2. 4.2. Referenzen und Ausleihen (borrowing)
    3. 4.3. Der Anteilstyp (slice)
11. 5. Strukturen (structs) für zusammenhängende Daten verwenden
12. 1. 5.1. Strukturen (structs) definieren und instanziieren
    2. 5.2. Beispielprogramm mit Strukturen (structs)
    3. 5.3. Methodensyntax
13. 6. Aufzählungen (enums) und Musterabgleich (pattern matching)
14. 1. 6.1. Eine Aufzählung (enum) definieren
    2. 6.2. Das Kontrollflusskonstrukt match
    3. 6.3. Prägnanter Kontrollfluss mit if let
15. 7. Wachsende Projekte verwalten mit Paketen (packages), Kisten (crates) und Modulen
16. 1. 7.1. Pakete (packages) und Kisten (crates)
    2. 7.2. Mit Modulen den Kontrollumfang und Datenschutz steuern
    3. 7.3. Mit Pfaden auf ein Element im Modulbaum verweisen
    4. 7.4. Pfade in den Gültigkeitsbereich bringen mit dem Schlüsselwort use
    5. 7.5. Module in verschiedene Dateien aufteilen
17. 8. Allgemeine Kollektionen
18. 1. 8.1. Wertlisten in Vektoren ablegen
    2. 8.2. UTF-8-kodierten Text in Zeichenketten (strings) ablegen
    3. 8.3. Schlüssel mit zugehörigen Werten in Hashtabellen ablegen
19. 9. Fehlerbehandlung
20. 1. 9.1. Nicht behebbare Fehler mit panic!
    2. 9.2. Behebbare Fehler mit Result
    3. 9.3. Wann panic! aufrufen und wann nicht?
21. 10. Generische Typen, Merkmale (traits) und Lebensdauer
22. 1. 10.1. Generische Datentypen
    2. 10.2. Merkmale (traits): Gemeinsames Verhalten definieren
    3. 10.3. Referenzen validieren mit Lebensdauern
23. 11. Automatisierte Tests schreiben
24. 1. 11.1. Tests schreiben
    2. 11.2. Steuern wie Tests ausgeführt werden
    3. 11.3. Testverwaltung
25. 12. Ein E/A-Projekt: Ein Kommandozeilenprogramm erstellen
26. 1. 12.1. Kommandozeilenargumente entgegennehmen
    2. 12.2. Eine Datei einlesen
    3. 12.3. Refaktorierung um die Modularität und Fehlerbehandlung zu verbessern
    4. 12.4. Bibliotheksfunktionalität mit testgetriebener Entwicklung erstellen
    5. 12.5. Mit Umgebungsvariablen arbeiten
    6. 12.6. Fehlermeldungen in die Standardfehlerausgabe anstatt der Standardausgabe schreiben
27. 13. Funktionale Sprachelemente: Iteratoren und Funktionsabschlüsse (closures)
28. 1. 13.1. Funktionsabschlüsse (closures): Anonyme Funktionen, die ihre Umgebung erfassen
    2. 13.2. Eine Reihe von Elementen verarbeiten mit Iteratoren
    3. 13.3. Unser E/A-Projekt verbessern
    4. 13.4. Performanzvergleich: Schleifen vs. Iteratoren
29. 14. Mehr über Cargo und Crates.io
30. 1. 14.1. Bauvorgang anpassen mit Freigabeprofilen (release profiles)
    2. 14.2. Kisten (crate) auf crates.io veröffentlichen
    3. 14.3. Cargo-Arbeitsbereiche
    4. 14.4. Installieren von Binärdateien mit cargo install
    5. 14.5. Cargo um benutzerdefinierte Befehle erweitern
31. 15. Intelligente Zeiger
32. 1. 15.1. Mit Box<T> auf Daten im Haldenspeicher zeigen
    2. 15.2. Intelligente Zeiger wie normale Referenzen behandeln mit dem Merkmal (trait) Deref
    3. 15.3. Programmcode beim Aufräumen ausführen mit dem Merkmal (trait) Drop
    4. 15.4. Der referenzzählende intelligente Zeiger Rc<T>
    5. 15.5. RefCell<T> und das innere Veränderbarkeitsmuster
    6. 15.6. Referenzzyklen können zu einem Speicherleck führen
33. 16. Furchtlose Nebenläufigkeit
34. 1. 16.1. Mit Strängen (threads) Programmcode gleichzeitig ausführen
    2. 16.2. Nachrichtenaustausch zwischen Strängen (threads)
    3. 16.3. Nebenläufigkeit mit gemeinsamem Zustand
    4. 16.4. Erweiterbare Nebenläufigkeit mit den Merkmalen (traits) Sync und Send
35. 17. Async und Await
36. 1. 17.1. Futures und die asynchrone Syntax
    2. 17.2. Nebenläufigkeit mit async
    3. 17.3. Arbeiten mit einer beliebigen Anzahl von Futures
    4. 17.4. Ströme (streams)
    5. 17.5. Merkmale für async
    6. 17.6. Futures, Aufgaben und Stränge
37. 18. Objektorientierte Sprachelemente von Rust
38. 1. 18.1. Charakteristiken objektorientierter Sprachen
    2. 18.2. Merkmalsobjekte (trait objects) die Werte unterschiedlicher Typen erlauben
    3. 18.3. Ein objektorientiertes Entwurfsmuster implementieren
39. 19. Muster (patterns) und Abgleich (matching)
40. 1. 19.1. Alle Stellen an denen Muster (patterns) verwendet werden können
    2. 19.2. Abweisbarkeit: Falls ein Muster (pattern) mal nicht passt
    3. 19.3. Mustersyntax
41. 20. Fortgeschrittene Sprachelemente
42. 1. 20.1. Unsicheres (unsafe) Rust
    2. 20.2. Fortgeschrittene Merkmale (traits)
    3. 20.3. Fortgeschrittene Typen
    4. 20.4. Erweiterte Funktionen und Funktionsabschlüsse (closures)
    5. 20.5. Makros
43. 21. Abschlussprojekt: Einen mehrsträngigen (multi-threaded) Webserver erstellen
44. 1. 21.1. Einen einsträngigen (single-threaded) Webserver erstellen
    2. 21.2. Unseren einsträngigen (single-threaded) Webserver in einen mehrsträngigen (multi-threaded) Webserver verwandeln
    3. 21.3. Kontrolliertes Beenden und Aufräumen
45. 22. Anhang
46. 1. 22.1. A - Schlüsselwörter
    2. 22.2. B - Operatoren und Symbole
    3. 22.3. C - Ableitbare Merkmale (traits)
    4. 22.4. D - Nützliche Entwicklungswerkzeuge
    5. 22.5. E - Ausgaben
    6. 22.6. F - Übersetzungen des Buchs
    7. 22.7. G - Wie Rust erstellt wird und „nächtliches Rust“