Traits und Trait Bounds

Traits definieren das Verhalten, das ein bestimmter Typ besitzt und mit anderen Typen teilen kann. Wir können Traits verwenden, um eine Reihe von Methoden zu definieren, die eine bestimmte gemeinsame Funktionalität oder Schnittstelle darstellen, ähnlich wie Interfaces in anderen Programmiersprachen.

Trait Bounds (Trait-Einschränkungen) ermöglichen es zu spezifizieren, dass ein generischer Typ ein bestimmtes Trait implementieren muss. Dadurch wird sichergestellt, dass die erforderlichen Methoden zur Kompilierzeit verfügbar sind.

Definieren und Implementieren eines Traits

Um ein Trait zu definieren, verwenden wir das Schlüsselwort trait, gefolgt von den Signaturen der Methoden, die die Typen implementieren müssen:

pub trait Summary {
    fn summarize(&self) -> String;
}

Um ein Trait für einen konkreten Typ zu implementieren, verwenden wir die Syntax impl TraitName for TypeName:

pub struct NewsArticle {
    pub headline: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}", self.headline)
    }
}

Trait Bounds (Trait-Einschränkungen)

Wenn wir generische Funktionen schreiben, können wir die Typparameter einschränken, um sicherzustellen, dass sie ein bestimmtes Trait implementieren. Die Standard-Syntax lautet <T: Trait>:

pub fn notify<T: Summary>(item: &T) {
    println!("Notifica: {}", item.summarize());
}

Alternativ können wir für komplexere Signaturen die where-Klausel verwenden:

pub fn notify_advanced<T>(item: &T)
where
    T: Summary
{
    println!("Notifica: {}", item.summarize());
}

Probier es aus

Esercizio 1: Das Trait Summary

Esercizio 2: Trait Bounds mit print_summary

Esercizio 3: Flächenberechnung mittels Trait