Scoping und Blocks

Was ein Scope ist

Ein Scope ist der Bereich im Programm, in dem ein Name (eine Bindung, ein Parameter, ein Modul-Item) sichtbar und verwendbar ist. In Rust ist Scoping lexikalisch — es ergibt sich aus der Position im Quellcode, nicht aus dem Ausführungspfad.

Jede Schweifklammer-Klausel öffnet einen neuen Scope:

fn main() {
    let aussen = 1;             // Scope: ganze Funktion

    {
        let innen = 2;          // Scope: dieser innere Block
        println!("{aussen} {innen}");
    }

    // innen ist hier nicht mehr sichtbar — Compile-Fehler:
    // println!("{innen}");
}

Beim Verlassen des Scopes:

• Bindungen werden ungültig (Name nicht mehr aufrufbar).
• Werte werden gedroppt (siehe Drop-Reihenfolge unten).

Funktionen, if-Branches, match-Arme, for-Bodies — alle eröffnen je einen Scope.

Blocks als Expressions

Hier wird es interessant: ein Block in Rust ist nicht nur eine Anweisungs-Sequenz — er ist auch eine Expression.

fn main() {
    let wert = {
        let a = 3;
        let b = 4;
        a * a + b * b           // Letzte Zeile, kein Semikolon → Rückgabewert
    };
    println!("{wert}");          // 25
}

Die Regel: die letzte Zeile in einem Block ohne abschließendes Semikolon ist die Rückgabe-Expression des Blocks. Mit Semikolon wäre es ein Statement, und der Block hätte den Wert () (Unit).

Das hat eine wichtige Konsequenz: viele Konstrukte, die in anderen Sprachen Anweisungen sind, sind in Rust Expressions.

if als Expression

fn main() {
    let score = 75;
    let note = if score >= 90 { "A" }
               else if score >= 80 { "B" }
               else if score >= 70 { "C" }
               else { "D" };
    println!("Note: {note}");
}

Wichtig: alle Branches müssen den gleichen Typ liefern. else ist Pflicht, wenn der if als Expression genutzt wird (sonst gäbe es einen Pfad ohne Wert).

match als Expression

fn beschreibung(zahl: i32) -> &'static str {
    match zahl {
        0 => "null",
        1..=9 => "einstellig",
        10..=99 => "zweistellig",
        _ => "groß",
    }
}

Der ganze match ist ein Wert; die Funktion gibt ihn direkt zurück (keine return-Anweisung nötig, weil match die letzte Expression der Funktion ist).

loop mit break-Wert

loop ist die einzige Schleife in Rust, die als Expression einen Wert über break zurückgeben kann:

fn main() {
    let mut zaehler = 0;

    let endwert = loop {
        zaehler += 1;
        if zaehler == 10 {
            break zaehler * 2;
        }
    };

    println!("{endwert}");     // 20
}

while und for haben keine break-mit-Wert-Form — sie sind immer vom Typ (). Wer einen Wert per Schleife sammeln will, nutzt entweder loop mit break <wert> oder einen Iterator-Adapter (.fold(...), .find(...)).

Statement vs. Expression — der entscheidende Punkt

Rust unterscheidet streng zwischen Statements und Expressions:

• Statement: tut etwas, hat keinen Wert (genauer: hat Wert ()).
• Expression: liefert einen Wert.

Die Trennlinie ist das Semikolon: ein Semikolon hinter einer Expression macht sie zum Statement.

fn main() {
    let a = 1 + 2;             // Statement (let), enthält Expression (1+2)
    let b = { 1 + 2 };          // Block-Expression als Initialisierer
    let c = { 1 + 2; };          // Block, der () zurückgibt — c ist ()
}

c ist hier vom Typ () (Unit), weil das Semikolon den 1 + 2-Ausdruck zu einem Statement gemacht hat und der Block keinen weiteren Wert hatte. Das ist eine der ersten Stolperfallen für Einsteiger.

Gleiche Falle bei Funktions-Bodys:

fn quadrat(x: i32) -> i32 {
    x * x;                     // Semikolon! → expression statement → ()
    // Fehler: expected i32, found ()
}

Lösung: Semikolon weglassen. Die rustc-Fehlermeldung „implicitly returns () as its body has no tail expression" weist genau darauf hin.

Drop-Reihenfolge am Scope-Ende

Wenn ein Wert seinen Scope verlässt, ruft Rust deterministisch seine Drop::drop-Methode auf. Die Reihenfolge ist LIFO (Last In, First Out): zuletzt deklarierte Bindungen werden zuerst gedroppt.

struct Laut(&'static str);
impl Drop for Laut {
    fn drop(&mut self) {
        println!("Drop: {}", self.0);
    }
}

fn main() {
    let a = Laut("a");
    let b = Laut("b");
    let c = Laut("c");
    println!("--- Ende der Funktion ---");
}

Ausgabe:

--- Ende der Funktion ---
Drop: c
Drop: b
Drop: a

Diese deterministische Drop-Reihenfolge ist die Grundlage für RAII-Patterns: ein File-Handle wird beim Scope-Ende garantiert geschlossen, ein Mutex-Guard freigegeben, eine Datenbank-Transaktion entweder committed oder rollbacked. Anders als bei GC-Sprachen passiert das deterministisch — keine Magic, keine Verzögerung.

Drop in verschachtelten Scopes

fn main() {
    let aussen = Laut("aussen");

    {
        let innen = Laut("innen");
    }   // innen wird hier gedroppt

    println!("--- weiterer Code ---");
}   // aussen wird hier gedroppt

Ausgabe:

Drop: innen
--- weiterer Code ---
Drop: aussen

Das ist das Werkzeug, mit dem du Scope-gebundene Ressourcen explizit über Block-Klammern verwaltest:

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(0);

    {
        let mut guard = m.lock().unwrap();
        *guard += 1;
    }   // guard wird hier gedroppt → Mutex freigegeben

    // Hier ist der Lock wieder frei.
}

Idiomatisch: einen Block einfügen, um die Lebensdauer eines MutexGuard (oder eines anderen RAII-Wrappers) zu begrenzen.

Drop in komplexen Expressions

Bei temporären Werten in komplexen Expressions ist die Drop-Reihenfolge nicht immer intuitiv:

struct Loud(&'static str);
impl Drop for Loud {
    fn drop(&mut self) {
        println!("Drop: {}", self.0);
    }
}

fn id<T>(x: T) -> T { x }

fn main() {
    let _ = id(Loud("a")).0;
    println!("---");
    let _ = (Loud("b"), Loud("c"));
}

Die Regel ist im Wesentlichen: Temporäre Werte einer Expression leben bis zum Ende der umschließenden Anweisung. Bei Tupel-Konstruktion werden Elemente in Reverse-Reihenfolge gedroppt (letztes zuerst). Diese Details werden im Drop-Trait-Artikel (Kapitel 7) genauer beleuchtet — hier reicht das Wissen, dass Reihenfolge garantiert ist und im Compiler dokumentiert ist.

Scope und Lifetimes

Scopes sind die Basis, auf der Lifetimes funktionieren. Eine Lifetime einer Referenz endet spätestens am Ende des Scopes, in dem der gebundene Wert lebt.

fn main() {
    let r;
    {
        let x = 5;
        r = &x;                 // Fehler: x lebt nur in diesem inneren Scope
    }
    // println!("{r}");          // r würde auf einen gedroppten Wert zeigen
}

Der Borrow Checker verfolgt diese Scope-Grenzen exakt. Eine Referenz darf nicht über die Lebensdauer ihres Ziels hinaus existieren — und Scopes definieren diese Lebensdauer.

Non-Lexical Lifetimes (NLL)

Seit Edition 2018 sind die Lifetimes nicht-lexikalisch: der Compiler erkennt, dass eine Referenz nach ihrer letzten Verwendung effektiv tot ist, auch wenn sie syntaktisch im Scope noch existiert.

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    println!("{first}");        // letzte Verwendung von first
    v.push(4);                  // ok — first ist effektiv tot
}

Vor 2018 wäre das ein Borrow-Konflikt gewesen (shared + mutable Borrow gleichzeitig). NLL erkennt, dass first nach println! nicht mehr genutzt wird — sie wird intern beendet, bevor v.push(4) läuft.

Im Lifetime-Kapitel gibt es dazu mehr Detail.

Labels — break/continue gezielt ansprechen

Bei verschachtelten Schleifen kannst du Labels verwenden, um gezielt eine äußere Schleife zu beenden oder fortzusetzen:

fn main() {
    'aussen: for i in 0..5 {
        for j in 0..5 {
            if i * j > 6 {
                break 'aussen;       // beendet die äußere Schleife
            }
            println!("{i} {j}");
        }
    }
}

Labels werden mit 'name: markiert (gleiche Syntax wie Lifetimes — nicht zufällig). Sie sind nur für loop/while/for-Konstrukte sinnvoll.

Auch Block-Labels gibt es seit Rust 1.65:

fn main() {
    let wert = 'block: {
        if false {
            break 'block 5;
        }
        10
    };
    println!("{wert}");        // 10
}

Praktisch für „frühen Ausstieg" aus einem Block, ohne dass die ganze Funktion zurückkehren muss.

Weiterführende Ressourcen

Externe Quellen

• Rust Reference – Blocks
• Rust Reference – Drop Scopes
• The Rust Book – Control Flow
• The Rust Book – Lifetimes
• The Rust Book – Non-Lexical Lifetimes (NLL)
• Rust Reference – Statements

Verwandte Artikel

• let-Bindung
• Shadowing
• mut und Immutability
• Variablen & Bindungen – Übersicht
• Compiler und Fehlerlesen