Genéricos e Funções

Genéricos permitem escrever código flexível e reutilizável, evitando a duplicação de lógica para diferentes tipos de dados. Em vez de definir múltiplas funções ou estruturas para tipos diferentes (como i32, f64 ou String), podemos usar um parâmetro de tipo genérico, convencionalmente representado pela letra T.

O compilador Rust gerencia genéricos usando um processo chamado monomorfização: durante a compilação, ele gera uma cópia do código genérico para cada tipo concreto que é realmente usado. Isso significa que não há sobrecarga de desempenho em tempo de execução.

Funções genéricas

Para definir uma função genérica, inserimos o parâmetro de tipo <T> logo após o nome da função e antes da lista de argumentos:

fn print_value<T: std::fmt::Debug>(value: T) {
    println!("Value: {:?}", value);
}

Em funções genéricas, podemos usar o tipo genérico T para tipos de argumento e tipos de retorno:

fn identity<T>(value: T) -> T {
    value
}

Estruturas genéricas

Também podemos usar parâmetros de tipo genérico dentro de estruturas (struct) para definir campos flexíveis:

struct KeyValuePair<K, V> {
    key: K,
    value: V,
}

fn main() {
    let pair = KeyValuePair {
        key: String::from("age"),
        value: 30,
    };
}

Em um bloco impl para uma estrutura genérica, devemos declarar o parâmetro de tipo <T> imediatamente após a palavra-chave impl para indicar que estamos implementando métodos em uma estrutura genérica:

struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    fn new(value: T) -> Self {
        Container { value }
    }

    fn value(&self) -> &T {
        &self.value
    }
}

Experimente você mesmo

Exercício 1: A estrutura de pontos

Exercício 2: Revertendo uma Tupla com troca

Exercício 3: A estrutura do contêiner