Ausdrucksstarke Rust-Generika mit der where-Klausel

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 lernen wir, dass eine where-Klausel in Rust verwendet werden kann, um die Grenzen für generische Typen getrennt von ihrer Deklaration auszudrücken, was zu einer klareren Syntax führt, und dass es auch möglich ist, Grenzen auf beliebige Typen anzuwenden, nicht nur auf Typparameter. Die where-Klausel ist besonders nützlich, wenn die Grenzen ausdrucksstärker sind als die normale Syntax, wie im Beispiel mit dem PrintInOption-Trait gezeigt.

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/DataTypesGroup(["Data Types"]) 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/AdvancedTopicsGroup(["Advanced Topics"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/type_casting("Type Conversion and Casting") 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/AdvancedTopicsGroup -.-> rust/traits("Traits") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/type_casting -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/function_syntax -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/expressions_statements -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/lifetime_specifiers -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/method_syntax -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/traits -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} rust/operator_overloading -.-> lab-99351{{"Ausdrucksstarke Rust-Generika mit der where-Klausel"}} end

where-Klauseln

Eine Grenze kann auch mithilfe einer where-Klausel direkt vor der öffnenden { ausgedrückt werden, anstatt beim ersten Erwähnung des Typs. Darüber hinaus können where-Klauseln Grenzen auf beliebige Typen anwenden, nicht nur auf Typparameter.

Einige Fälle, in denen eine where-Klausel nützlich ist:

  • Wenn die separate Angabe von generischen Typen und Grenzen klarer ist:
impl <A: TraitB + TraitC, D: TraitE + TraitF> MyTrait<A, D> for YourType {}

// Ausdrücken von Grenzen mit einer `where`-Klausel
impl <A, D> MyTrait<A, D> for YourType where
    A: TraitB + TraitC,
    D: TraitE + TraitF {}
  • Wenn das Verwenden einer where-Klausel ausdrucksstärker ist als das Verwenden der normalen Syntax. Die impl in diesem Beispiel kann ohne eine where-Klausel nicht direkt ausgedrückt werden:
use std::fmt::Debug;

trait PrintInOption {
    fn print_in_option(self);
}

// Da wir andernfalls diese als `T: Debug` ausdrücken müssten oder
// eine andere indirekte Methode verwenden, erfordert dies eine `where`-Klausel:
impl<T> PrintInOption for T where
    Option<T>: Debug {
    // Wir wollen `Option<T>: Debug` als unsere Grenze, weil das, was gedruckt wird. Andernfalls würden wir die falsche Grenze verwenden.
    fn print_in_option(self) {
        println!("{:?}", Some(self));
    }
}

fn main() {
    let vec = vec![1, 2, 3];

    vec.print_in_option();
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab zu den where-Klauseln abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.