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