Rust

Materialien zum Buch . . . 18
1. Über dieses Buch . . . 19

1. 1 . . . Was Sie in diesem Buch lernen werden . . . 20
1. 2 . . . Was dieses Buch Ihnen zeigen möchte . . . 21
1. 3 . . . Noch mehr Informationen und Guides . . . 22
1. 4 . . . Danksagung . . . 24

2. Die Installation, die IDE und »Hallo Rust« . . . 25

2. 1 . . . Wie Sie Rust installieren . . . 25
2. 2 . . . Eine Entwicklungsumgebung wählen . . . 28
2. 3 . . . Das erste Programm . . . 30
2. 4 . . . Wie es weitergeht . . . 33

3. Variablen und Datentypen . . . 35

3. 1 . . . Prelude: Die Standardimporte . . . 35
3. 2 . . . Variablen . . . 36
3. 3 . . . Konstanten . . . 56
3. 4 . . . Skalare Datentypen . . . 60
3. 5 . . . Wie Rust mit »Option< T> « auf null verzichtet . . . 81
3. 6 . . . Zusammenfassung . . . 84

4. Speichernutzung und Referenzen . . . 87

4. 1 . . . Wichtige Speicherbereiche . . . 87
4. 2 . . . Eigentumsverhältnisse im Speicher . . . 89
4. 3 . . . Referenzen und der leihweise Zugriff . . . 98
4. 4 . . . Mit Box Objekte im Heap ablegen . . . 111
4. 5 . . . Zusammenfassung . . . 121

5. Strings . . . 123

5. 1 . . . Der String-Slice . . . 123
5. 2 . . . Der String . . . 134
5. 3 . . . Wie Sie Strings formatieren . . . 147
5. 4 . . . Zusammenfassung . . . 154

6. Collections . . . 157

6. 1 . . . Tupel . . . 157
6. 2 . . . Arrays . . . 166
6. 3 . . . Elementbereiche . . . 173
6. 4 . . . Vektoren . . . 182
6. 5 . . . Slices . . . 214
6. 6 . . . HashMap und BTreeMap . . . 231
6. 7 . . . Hashes . . . 245
6. 8 . . . Mengen verwalten . . . 248
6. 9 . . . Die Entry API . . . 251
6. 10 . . . Elemente verschiedener Datentypen in eine Collection einfügen . . . 257
6. 11 . . . Zusammenfassung . . . 260

7. Funktionen . . . 263

7. 1 . . . Der Aufbau einer Funktion . . . 264
7. 2 . . . Funktionszeiger . . . 268
7. 3 . . . Referenzen und Lebenszeiten in Funktionen . . . 271
7. 4 . . . Konstante Funktionen . . . 280
7. 5 . . . Anonyme Funktionen und Closures . . . 285
7. 6 . . . Funktions-Traits . . . 302
7. 7 . . . Zusammenfassung . . . 311

8. Anweisungen, Ausdrücke und Muster . . . 313

8. 1 . . . Von der Anweisung zum Ausdruck und Muster . . . 313
8. 2 . . . Die Zuweisung im Detail . . . 316
8. 3 . . . Speicherausdrücke . . . 319
8. 4 . . . Operatoren . . . 325
8. 5 . . . Konditionale Ausdrücke . . . 330
8. 6 . . . Schleifen . . . 342
8. 7 . . . Muster . . . 350
8. 8 . . . Zusammenfassung . . . 364

9. Fehlerbehandlung . . . 367

9. 1 . . . Fehler, von denen sich das Programm nicht erholen kann . . . 367
9. 2 . . . Erwartbare Fehler behandeln . . . 381
9. 3 . . . Zusammenfassung . . . 418

10. Strukturen . . . 421

10. 1 . . . Daten zusammenhängend ablegen . . . 422
10. 2 . . . Records: Der Struktur-Urtyp . . . 423
10. 3 . . . Strukturen und Instanzen . . . 426
10. 4 . . . Lebenszeiten: Wenn Felder Referenzen enthalten . . . 441
10. 5 . . . Wie Sie dem Compiler mit PhantomData wichtige Typinformationen übergeben . . . 449
10. 6 . . . Eine Datenstruktur ohne feste Größe . . . 460
10. 7 . . . Die drei Strukturen . . . 462
10. 8 . . . Muster . . . 466
10. 9 . . . Daten und Verhalten sind getrennt . . . 468
10. 10 . . . Strukturen in der Praxis: Das Bestellsystem überarbeiten . . . 475
10. 11 . . . Assoziierte Funktionen und die new-Konvention . . . 480
10. 12 . . . Methoden . . . 486
10. 13 . . . Referenzen in assoziierten Funktionen und Methoden . . . 501
10. 14 . . . Praxisbeispiel: Simulationsfähigkeiten im Restaurant-System . . . 503
10. 15 . . . Rekursion in Strukturen . . . 507
10. 16 . . . Typ-Aliasse . . . 510
10. 17 . . . Zusammenfassung . . . 512

11. Traits . . . 515

11. 1 . . . Marker-Traits . . . 516
11. 2 . . . Trait-Implementierungsblöcke . . . 517
11. 3 . . . Sie können ein Trait jeweils für T und & T implementieren . . . 541
11. 4 . . . Super-Traits . . . 546
11. 5 . . . Trait-Objekte . . . 549
11. 6 . . . Beispielprojekt: Trait-Objekte von »Form« . . . 564
11. 7 . . . Undurchsichtige Datentypen zurückgeben . . . 574
11. 8 . . . Traits in der Praxis . . . 578
11. 9 . . . Zusammenfassung . . . 627

12. Enumerationen . . . 631

12. 1 . . . Die Eigenschaften einer Enumeration . . . 632
12. 2 . . . Verschiedene Variant-Typen . . . 644
12. 3 . . . Enumerationen und Muster . . . 656
12. 4 . . . Implementierungsblöcke und Verhalten . . . 660
12. 5 . . . Zusammenfassung . . . 667

13. Module, Pfade und Crates . . . 669

13. 1 . . . Das Modul . . . 669
13. 2 . . . Pfade . . . 697
13. 3 . . . Vom Crate zum Paket, vom Paket zum Workspace . . . 721
13. 4 . . . Zusammenfassung . . . 777

14. Generische Programmierung . . . 781

14. 1 . . . Von der Vorlage zur Konkretisierung: Monomorphisierung . . . 781
14. 2 . . . Typparameter, generische Konstanten und Lebenszeiten . . . 783
14. 3 . . . Syntaktische Elemente, die generisch sein können . . . 785
14. 4 . . . Mehr zu Trait-Grenzen . . . 789
14. 5 . . . Zusammenfassung . . . 794

15. Iteratoren . . . 797

15. 1 . . . Wie Sie einen Iterator beziehen . . . 798
15. 2 . . . Iterator-Adapter . . . 805
15. 3 . . . Einen Iterator konsumieren . . . 816
15. 4 . . . Zusammenfassung . . . 822

16. Nebenläufige und asynchrone Programmierung . . . 823

16. 1 . . . Nebenläufige Programmierung . . . 824
16. 2 . . . Smart Pointer . . . 876
16. 3 . . . Asynchrone Programmierung . . . 893
16. 4 . . . Zusammenfassung . . . 915

17. Makros . . . 917

17. 1 . . . Deklarative Makros . . . 917
17. 2 . . . Prozedurale Makros . . . 939
17. 3 . . . Zusammenfassung . . . 950

18. Automatische Tests und Dokumentation . . . 953

18. 1 . . . Tests . . . 954
18. 2 . . . Rust-Projekte dokumentieren . . . 966
18. 3 . . . Zusammenfassung . . . 979

19. Unsafe Rust und das Foreign Function Interface . . . 981

19. 1 . . . Unsafe Rust . . . 981
19. 2 . . . Primitive Zeiger . . . 987
19. 3 . . . Union . . . 998
19. 4 . . . Foreign Function Interface . . . 1001
19. 5 . . . Zusammenfassung . . . 1005

Index . . . 1007