1. Die Programmiersprache Rust
2. Vorwort
3. Einführung
4. 1. Erste Schritte
   1. 1.1. Installation
   2. 1.2. Hallo Welt
   3. 1.3. Hallo Cargo
5. 2. Ein Ratespiel programmieren
6. 3. Allgemeine Programmierkonzepte
   1. 3.1. Variablen und Veränderbarkeit
   2. 3.2. Datentypen
   3. 3.3. Funktionen
   4. 3.4. Kommentare
   5. 3.5. Kontrollfluss
7. 4. Eigentümerschaft verstehen
   1. 4.1. Was ist Eigentümerschaft?
   2. 4.2. Referenzen und Borrowing
   3. 4.3. Der Slice-Typ
8. 5. Strukturen für zusammenhängende Daten verwenden
   1. 5.1. Strukturen definieren und instanziieren
   2. 5.2. Beispielprogramm mit Strukturen
   3. 5.3. Methoden
9. 6. Aufzählungen und Pattern Matching
   1. 6.1. Eine Aufzählung definieren
   2. 6.2. Das Kontrollflusskonstrukt match
   3. 6.3. Prägnanter Kontrollfluss mit if let und let...else
10. 7. Pakete, Crates und Module
    1. 7.1. Pakete und Crates
    2. 7.2. Gültigkeitsbereich und Sichtbarkeit mit Modulen 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
11. 8. Allgemeine Kollektionen
    1. 8.1. Wertlisten in Vektoren ablegen
    2. 8.2. UTF-8-kodierten Text in Strings ablegen
    3. 8.3. Schlüssel mit zugehörigen Werten in Hashtabellen ablegen
12. 9. Fehlerbehandlung
    1. 9.1. Nicht behebbare Fehler mit panic!
    2. 9.2. Behebbare Fehler mit Result
    3. 9.3. Wann panic! aufrufen und wann nicht?
13. 10. Generische Typen, Traits und Lebensdauer
    1. 10.1. Generische Datentypen
    2. 10.2. Gemeinsames Verhalten definieren mit Traits
    3. 10.3. Referenzen validieren mit Lebensdauern
14. 11. Automatisierte Tests schreiben
    1. 11.1. Tests schreiben
    2. 11.2. Steuern, wie Tests ausgeführt werden
    3. 11.3. Testverwaltung
15. 12. Ein E/A-Projekt: Ein Kommandozeilenprogramm erstellen
    1. 12.1. Kommandozeilenargumente entgegennehmen
    2. 12.2. Eine Datei einlesen
    3. 12.3. Refactoring zum Verbessern der Modularität und Fehlerbehandlung
    4. 12.4. Funktionalität mit testgetriebener Entwicklung hinzufügen
    5. 12.5. Mit Umgebungsvariablen arbeiten
    6. 12.6. Fehler zur Standardfehlerausgabe umleiten
16. 13. Funktionale Sprachelemente: Iteratoren und Closures
    1. 13.1. Closures
    2. 13.2. Eine Reihe von Elementen mit Iteratoren verarbeiten
    3. 13.3. Unser E/A-Projekt verbessern
    4. 13.4. Performanz von Schleifen vs. Iteratoren
17. 14. Mehr über Cargo und Crates.io
    1. 14.1. Bauvorgang anpassen mit Freigabeprofilen
    2. 14.2. Crates 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
18. 15. Intelligente Zeiger
    1. 15.1. Mit Box<T> auf Daten im Heap zeigen
    2. 15.2. Intelligente Zeiger wie normale Referenzen behandeln
    3. 15.3. Programmcode beim Aufräumen ausführen mit dem 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
19. 16. Furchtlose Nebenläufigkeit
    1. 16.1. Programmcode mit Threads gleichzeitig ausführen
    2. 16.2. Nachrichtenaustausch zwischen Threads
    3. 16.3. Nebenläufigkeit mit gemeinsamem Zustand
    4. 16.4. Erweiterbare Nebenläufigkeit mit Send und Sync
20. 17. Grundlagen der asynchronen Programmierung: Async, Await, Futures und Streams
    1. 17.1. Futures und die asynchrone Syntax
    2. 17.2. Anwenden von Nebenläufigkeit mit async
    3. 17.3. Kontrolle an die Laufzeitumgebung abgeben
    4. 17.4. Streams: Sequenz von Futures
    5. 17.5. Ein genauerer Blick auf die Traits für Async
    6. 17.6. Futures, Aufgaben und Threads
21. 18. Objektorientierte Sprachelemente
    1. 18.1. Charakteristiken objektorientierter Sprachen
    2. 18.2. Verwendung von Trait-Objekten zur Abstraktion über gemeinsames Verhalten
    3. 18.3. Ein objektorientiertes Entwurfsmuster implementieren
22. 19. Muster und Pattern Matching
    1. 19.1. Stellen, an denen Muster verwendet werden können
    2. 19.2. Abweisbarkeit: Falls ein Muster mal nicht passt
    3. 19.3. Mustersyntax
23. 20. Fortgeschrittene Sprachelemente
    1. 20.1. Unsafe Rust
    2. 20.2. Fortgeschrittene Traits
    3. 20.3. Fortgeschrittene Typen
    4. 20.4. Erweiterte Funktionen und Closures
    5. 20.5. Makros
24. 21. Abschlussprojekt: Einen multi-threaded Webserver erstellen
    1. 21.1. Einen single-threaded Webserver erstellen
    2. 21.2. Von einem single-threaded zu einem multi-threaded Webserver
    3. 21.3. Kontrolliertes Beenden und Aufräumen
25. 22. Anhang
    1. 22.1. A - Schlüsselwörter
    2. 22.2. B - Operatoren und Symbole
    3. 22.3. C - Ableitbare Traits
    4. 22.4. D - Nützliche Entwicklungswerkzeuge
    5. 22.5. E - Editionen
    6. 22.6. F - Übersetzungen des Buches
    7. 22.7. G - Wie Rust erstellt wird und „nightly Rust“