Tipos asociados en Rust

Cuando un trait tiene un tipo por implementador, un tipo asociado gana al parámetro.

trait Parser {
    type Output;

    fn parse(&self, raw: &str) -> Option<Self::Output>;
}

struct Counter;
struct Words;

impl Parser for Counter {
    type Output = usize;

    fn parse(&self, raw: &str) -> Option<usize> {
        Some(raw.len())
    }
}

impl Parser for Words {
    type Output = Vec<String>;

    fn parse(&self, raw: &str) -> Option<Vec<String>> {
        Some(raw.split_whitespace().map(String::from).collect())
    }
}

fn main() {
    println!("{:?}", Counter.parse("four"));
    println!("{:?}", Words.parse("one two"));
}

Cómo funciona

1. El implementador elige el tipo; quien llama, no.
2. Self::Output lo nombra dentro del trait.
3. Iterator::Item es el tipo asociado que ya usas.

Palabras clave y builtins usados aquí

• Option
• Self
• Some
• String
• Vec
• fn
• for
• impl
• self
• str
• struct
• trait
• type
• usize

El intento, en números

Líneas

29

Caracteres a escribir

492

Tokens

161

Ritmo de tres estrellas

100 tpm

Al ritmo de tres estrellas de 100 tokens por minuto, este intento toma unos 97 segundos.

Escribe este fragmento

Paso 3 de 3 en Traits; paso 3 de 19 en Traits y genéricos.

← Anterior Siguiente →