Vereinfachen der Option-Behandlung in Rust mit Map

RustRustBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab untersuchen wir die Verwendung des map()-Kombinatoren in Rust, um die Kontrollstruktur zu vereinfachen und Option-Typen auf eine präzise und modulare Weise zu verarbeiten.

Hinweis: Wenn das Lab keinen Dateinamen angibt, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) rust(("Rust")) -.-> rust/ErrorHandlingandDebuggingGroup(["Error Handling and Debugging"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/MemorySafetyandManagementGroup -.-> rust/lifetime_specifiers("Lifetime Specifiers") rust/DataStructuresandEnumsGroup -.-> rust/method_syntax("Method Syntax") rust/ErrorHandlingandDebuggingGroup -.-> rust/error_propagation("Error Propagation") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} rust/function_syntax -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} rust/expressions_statements -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} rust/lifetime_specifiers -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} rust/method_syntax -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} rust/error_propagation -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} rust/operator_overloading -.-> lab-99236{{"Vereinfachen der Option-Behandlung in Rust mit Map"}} end

Kombinatoren: map

match ist eine gültige Methode zur Behandlung von Options. Allerdings können Sie sich schließlich daran gewöhnen, dass häufige Verwendung lästig ist, insbesondere bei Operationen, die nur mit einer Eingabe gültig sind. In diesen Fällen können Kombinatoren verwendet werden, um die Kontrollstruktur auf modulare Weise zu verwalten.

Option hat eine integrierte Methode namens map(), ein Kombinator zur einfachen Zuordnung von Some -> Some und None -> None. Mehrere map()-Aufrufe können miteinander verkettet werden, um noch mehr Flexibilität zu erzielen.

Im folgenden Beispiel ersetzt process() alle vorherigen Funktionen, bleibt dabei aber kompakt.

#![allow(dead_code)]

#[derive(Debug)] enum Food { Apple, Carrot, Potato }

#[derive(Debug)] struct Peeled(Food);
#[derive(Debug)] struct Chopped(Food);
#[derive(Debug)] struct Cooked(Food);

// Das Entschälen von Lebensmitteln. Wenn es keines gibt, dann geben wir `None` zurück.
// Andernfalls geben wir das entschälte Lebensmittel zurück.
fn peel(food: Option<Food>) -> Option<Peeled> {
    match food {
        Some(food) => Some(Peeled(food)),
        None       => None,
    }
}

// Das Zerkleinern von Lebensmitteln. Wenn es keines gibt, dann geben wir `None` zurück.
// Andernfalls geben wir das zerkleinerte Lebensmittel zurück.
fn chop(peeled: Option<Peeled>) -> Option<Chopped> {
    match peeled {
        Some(Peeled(food)) => Some(Chopped(food)),
        None               => None,
    }
}

// Das Kochen von Lebensmitteln. Hier demonstrieren wir `map()` anstelle von `match` für den Fallunterschied.
fn cook(chopped: Option<Chopped>) -> Option<Cooked> {
    chopped.map(|Chopped(food)| Cooked(food))
}

// Eine Funktion, um Lebensmittel nacheinander zu schälen, zu zerkleinern und zu kochen.
// Wir verkettieren mehrere Verwendung von `map()`, um den Code zu vereinfachen.
fn process(food: Option<Food>) -> Option<Cooked> {
    food.map(|f| Peeled(f))
     .map(|Peeled(f)| Chopped(f))
     .map(|Chopped(f)| Cooked(f))
}

// Überprüfen, ob es Lebensmittel gibt, bevor wir es versuchen zu essen!
fn eat(food: Option<Cooked>) {
    match food {
        Some(food) => println!("Mmm. I love {:?}", food),
        None       => println!("Oh no! It wasn't edible."),
    }
}

fn main() {
    let apple = Some(Food::Apple);
    let carrot = Some(Food::Carrot);
    let potato = None;

    let cooked_apple = cook(chop(peel(apple)));
    let cooked_carrot = cook(chop(peel(carrot)));
    // Probieren wir jetzt die einfacher aussehende `process()` aus.
    let cooked_potato = process(potato);

    eat(cooked_apple);
    eat(cooked_carrot);
    eat(cooked_potato);
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab "Kombinatoren: Map" abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.