Grundlagen
Alle ansehen- 01 Grundlagen Der Einstieg in Rust — Sprache, Toolchain, erstes Programm
- 02 Was ist Rust? Systemnahe Sprache mit Memory Safety ohne Garbage Collector
- 03 Installation mit rustup rustup als Toolchain-Manager — stable, beta, nightly nebeneinander
- 04 Erstes Programm Hello World mit rustc und Cargo, Anatomie von main.rs
- 05 Cargo-Grundlagen Cargo als Build- und Paketmanager — Projekte, Dependencies, Profile
- 06 Projektstruktur Wie ein Rust-Projekt auf der Festplatte aussieht und warum
- 07 Editionen 2015 / 2018 / 2021 / 2024 Was Editionen sind, was sie ändern und wie du migrierst
- 08 Compiler und Fehlerlesen Wie eine rustc-Diagnose aufgebaut ist und wie man sie nutzt
Variablen & Bindungen
Alle ansehen- 01 Variablen & Bindungen Wie Werte in Rust an Namen kommen — und warum let keine Variable ist
- 02 let-Bindung let bindet einen Namen an einen Wert — keine klassische Variable
- 03 mut und Immutability Default immutable, mit mut explizit veränderbar — drei Ebenen
- 04 Shadowing Eine neue Bindung mit altem Namen — mit oder ohne Typ-Wechsel
- 05 const vs. static Zwei Wege, zur Compile-Zeit feste Werte auszudrücken
- 06 Type Inference Wie der Compiler in 90 % aller Fälle den Typ selbst kennt
- 07 Scoping und Blocks Jede Schweifklammer ist ein Scope — und gleichzeitig eine Expression
Primitive Datentypen
Alle ansehen- 01 Primitive Datentypen Die eingebauten Basistypen — und ihre besonderen Eigenheiten
- 02 Integer-Typen Zehn Integer-Familien, klare Bitbreiten, deterministischer Overflow
- 03 Float-Typen f32 und f64 nach IEEE 754 — mit allen Eigenheiten
- 04 bool Wirklich nur zwei Werte — kein automatisches Casten
- 05 char Vier Bytes Unicode-Scalar — nicht zu verwechseln mit Byte
- 06 Tuple Heterogene Bündel mit fester Größe — ohne Feldnamen
- 07 Array Stack-allokierte, homogene Sequenz mit Compile-Zeit-Länge
- 08 Slice View über zusammenhängenden Speicher — ohne Eigentum
- 09 Unit und Never Die zwei besonderen Typen — () und !
- 10 Numeric Conversions Drei Wege, zwischen Zahlentypen zu konvertieren — mit klaren Trade-offs
Strings & Text
Alle ansehen- 01 Strings & Text Wie Rust mit Text umgeht — UTF-8 strikt, zwei Typen statt einem
- 02 str vs. String Zwei String-Typen, klare Aufgaben — und ein Trick zur API-Wahl
- 03 String-Slicing und Bytes Slicing in UTF-8 — wo Byte- und Zeichen-Indices auseinander gehen
- 04 UTF-8 und char-Iteration Drei Wege durch einen String — bytes, chars, Grapheme
- 05 Das format!-Makro Compile-Time-validierte Formatierung — von Padding bis Hex
- 06 Parsing und Konvertierung Strings in andere Typen — und umgekehrt
- 07 Cow<str> Mal Referenz, mal owned — Allokation nur wenn nötig
Kontrollfluss
Alle ansehen- 01 Kontrollfluss Bedingungen, Schleifen, Pattern-Shortcuts — alle als Expressions
- 02 if als Expression Bedingungen, die Werte liefern — kein ternärer Operator nötig
- 03 loop mit Wert-Rückgabe Endlos-Schleife — und die einzige mit Wert über break
- 04 while Bedingung am Schleifen-Anfang — plus die while let-Variante
- 05 for und Range Die idiomatische Iteration — auf jedem IntoIterator
- 06 break, continue, Labels Schleifen beenden, überspringen, mit Labels gezielt steuern
- 07 if let und let else Pattern-Matches kompakt — und mit garantiertem Ausstieg
Funktionen
Alle ansehen- 01 Funktionen Funktionen in Rust — kompakte Syntax, Expression-orientiert
- 02 fn-Deklaration Funktionen deklarieren — Syntax, Namens-Konventionen, pub
- 03 Expressions vs. Statements Das Semikolon als Bedeutungs-Grenze — Expression oder Anweisung
- 04 Parameter und Rückgabe Wie Werte rein- und rauskommen — Pass-by-Value, Referenzen, Tupel
- 05 Divergierende Funktionen Funktionen, die niemals zurückkehren — Typ !
- 06 Funktions-Pointer und fn-Typen Funktionen als Werte — fn-Pointer und der Vergleich zu Closures
Ownership
Alle ansehen- 01 Ownership Das Kern-Konzept — Memory-Safety durch Compile-Zeit-Beweis
- 02 Ownership-Regeln Drei einfache Regeln — und der Compiler beweist Memory-Safety
- 03 Move-Semantik Was bei einer Zuweisung wirklich passiert — auf Bit-Ebene
- 04 Copy-Trait und Clone Zwei Mechanismen für Wert-Kopie — wann was?
- 05 Drop-Trait Deterministisches Cleanup beim Scope-Ende — das Fundament für RAII
- 06 Funktionsparameter und Ownership Wie Werte durch Funktionen wandern — Move, Borrow, Round-Trip
- 07 Stack vs. Heap Wo Werte leben — Stack (schnell, klein) vs. Heap (flexibel, groß)
References & Borrowing
Alle ansehen- 01 References & Borrowing Werte teilen, ohne Ownership zu übergeben
- 02 Shared vs. Mut References Zwei Reference-Typen, eine Regel: Aliasing XOR Mutability
- 03 Borrow Checker Wie der Compiler die Borrow-Regeln zur Bauzeit prüft
- 04 Reborrowing Wie &mut-Referenzen in Funktions-Calls überleben — implizit
- 05 Dereferenzierung und Auto-Deref Vom Pointer zum Wert — und warum das oft unsichtbar passiert
- 06 Dangling References Pointer auf freigegebenen Speicher — in Safe Rust unmöglich
Slices & Views
Alle ansehen- 01 Slices & Views Universelle Views auf zusammenhängende Daten — ohne Ownership
- 02 String-Slice &str Der String-Slice — UTF-8-validiert, leicht, der API-Standard
- 03 Array-Slices &[T] Der generische Element-Slice — universeller Funktions-Parameter
- 04 Mutable Slices In-Place-Bearbeitung — und der Borrow-Checker-Trick split_at_mut
- 05 Slice-Patterns Pattern-Matching auf Slice-Länge und Elementen — elegant
- 06 windows und chunks Iteratoren über Sub-Slices — gleitend oder feste Blöcke
Structs & Methoden
Alle ansehen- 01 Structs & Methoden Eigene Datentypen mit Verhalten — das Fundament jeder Domäne
- 02 Struct-Grundlagen Field-Structs — die Default-Form für benannte Datenstrukturen
- 03 Tuple-Structs Structs mit positionalen Feldern — und der Newtype-Spezialfall
- 04 Unit-Structs Structs ohne Felder — kostenlose Typ-Marker
- 05 impl-Blocks und Methoden Methoden zu Structs hinzufügen — Receiver-Typen verstehen
- 06 Associated Functions Funktionen, die zum Typ gehören — nicht zur Instanz
- 07 derive-Makro-Grundlagen Standard-Traits automatisch ableiten — eine Zeile spart hunderte
- 08 Builder-Pattern Konfigurierbare Konstruktoren mit Method-Chaining
- 09 Newtype-Pattern Tuple-Structs mit einem Feld — typsichere Wrapper mit Zero-Cost
Enums & Pattern Matching
Alle ansehen- 01 Enums & Pattern Matching Sum-Types und exhaustives match — das Rückgrat sicherer APIs
- 02 Enum-Grundlagen Sum-Types mit drei Varianten-Formen — Unit, Tuple, Struct
- 03 Option Optionale Werte ohne null — typsicher und explizit
- 04 Result Fallible Operationen ohne Exceptions — typsicher und kompositional
- 05 match-Exhaustiveness Der Compiler verlangt, dass du alle Varianten abdeckst
- 06 Patterns-Katalog Das vollständige Pattern-Vokabular der Sprache
- 07 if let und while let Pattern-Match für einen Branch — kompakter als match
- 08 let else Pattern-Match mit divergierendem Else — der Game-Changer
Collections
Alle ansehen- 01 Collections Die wichtigsten Container der Stdlib — wann welcher
- 02 Vec Der wichtigste Container — wachsende Sequenz auf dem Heap
- 03 String als Collection String aus Container-Sicht — Vec<u8> mit UTF-8-Garantie
- 04 HashMap Key-Value-Lookup mit O(1) — die zweitwichtigste Collection
- 05 HashSet Unique-Werte-Sammlung mit O(1)-Membership
- 06 BTreeMap und BTreeSet Sortierte Sammlungen mit O(log n) — und Range-Queries
- 07 VecDeque und LinkedList VecDeque als Ring-Buffer für FIFO/LIFO — LinkedList nur selten
- 08 Kapazität und Reallocation Wie Vec, String, HashMap wachsen — und wie du Reallocations vermeidest
Error Handling
Alle ansehen- 01 Error Handling Fehlerbehandlung ohne Exceptions — typsicher und explizit
- 02 panic vs. recoverable Wann panic, wann Result — die wichtigste Designentscheidung
- 03 Result im Detail Das vollständige Result-API — Kombinatoren, Extraktion, Konvertierung
- 04 ?-Operator Fehler-Propagation in einem Zeichen — das Standard-Werkzeug
- 05 From-Trait für Error-Conversion Wie der ?-Operator verschiedene Fehler-Typen automatisch konvertiert
- 06 Eigene Error-Typen Domain-Errors als Enum mit Error-Trait und Display-Impl
- 07 thiserror-Pattern Das idiomatische Crate für Library-Errors — derive statt Hand-Code
- 08 anyhow-Pattern Das idiomatische Crate für Application-Errors — flexibel und kontextreich
- 09 Error-Strategie Die richtige Wahl: thiserror, anyhow, Stdlib — wann was?
Generics
Alle ansehen- 01 Generics Code, der mit beliebigen Typen funktioniert — ohne Laufzeit-Kosten
- 02 Typ-Parameter Die Syntax für generische Typen — in allen Sprach-Konstrukten
- 03 Trait-Bounds Constraints für Type-Parameter — welche Capabilities sind erforderlich?
- 04 where-Klauseln Bounds übersichtlich auslagern — die where-Syntax
- 05 Turbofish ::<T> — die explizite Form, wenn Type-Inference scheitert
- 06 Monomorphisierung Wie Generics ohne Laufzeit-Kosten funktionieren — Spezialisierung im Compiler
- 07 Const-Generics Typ-Parameter, die konstante Werte statt Typen sind
Traits
Alle ansehen- 01 Traits Das zentrale Polymorphismus-Konstrukt der Sprache
- 02 Trait-Definition Die Syntax eines Traits — wie Verträge in Rust ausgedrückt werden
- 03 Default-Methoden Methoden mit Body, die der Implementierer überschreiben kann
- 04 Trait-Bounds im Detail Trait-Bounds in allen Kontexten — vom einfachen bis zum komplexen Fall
- 05 dyn Trait-Objekte Heterogene Sammlungen und runtime-polymorphe APIs mit dyn Trait
- 06 Static vs. Dynamic Dispatch Wann Generics, wann dyn — der definitive Vergleich
- 07 Associated Types Typen, die zur Trait-Implementation gehören
- 08 Supertraits Traits, die andere Traits voraussetzen
- 09 Orphan-Rule Wer darf welches Trait für welchen Typ implementieren?
- 10 Blanket-Implementations Eine Implementation für ALLE Typen mit bestimmten Eigenschaften
- 11 Marker-Traits: Send, Sync, Sized, Copy, Unpin Traits ohne Methoden, die Eigenschaften eines Typs auszeichnen
- 12 Operator-Overloading-Traits Operator-Verhalten für eigene Typen über Trait-Implementations
Lifetimes
Alle ansehen- 01 Lifetimes – Übersicht Wie Rust ohne Garbage Collector Speicher-Sicherheit garantiert
- 02 Was sind Lifetimes Lifetimes konkret: wie der Borrow-Checker arbeitet
- 03 Lifetime-Annotations Die Syntax der expliziten Lifetime-Annotations
- 04 Lifetimes in Funktionen Funktions-Signaturen mit Lifetimes — Input, Output, Mehrfach-Refs
- 05 Lifetimes in Structs Structs, die Referenzen halten — Lifetime-Parameter und Konsequenzen
- 06 Lifetime-Elision Wann der Compiler Lifetimes von selbst ableitet
- 07 Static-Lifetime Die Lifetime, die so lange lebt wie das Programm
- 08 Lifetime-Bounds Lifetime-Constraints an Type-Parametern und Lifetime-Parametern
- 09 Higher-Ranked Trait Bounds (HRTB) for<'a>-Syntax für Lifetime-quantifizierte Trait-Bounds
- 10 Lifetimes in impl-Blöcken impl-Blöcke für Typen mit Lifetime-Parametern
- 11 Subtyping und Variance Wie Lifetimes sich zueinander konvertieren lassen