Métodos Genéricos

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 25 de 61.

Uma struct genérica pode armazenar qualquer tipo, mas não é muito útil sem métodos para interagir com seus dados. Para definir métodos para uma struct genérica, você precisa de uma sintaxe especial no bloco impl.

O ponto principal é declarar o parâmetro genérico no próprio impl:

struct Wrapper<T> {
    value: T,
}

impl<T> Wrapper<T> {
    fn get(&self) -> &T {
        &self.value
    }
}

Observe o impl<T> antes de Wrapper<T>. Isso informa ao Rust que T é um parâmetro de tipo genérico para todo o bloco de implementação. Sem essa declaração, o Rust procuraria um tipo concreto chamado T e não conseguiria encontrá-lo.

O método get retorna &T: uma referência ao tipo que quer que o wrapper contenha. Isso funciona independentemente de T ser um inteiro, uma string ou qualquer outro tipo:

let num_wrapper = Wrapper { value: 100 };
let text_wrapper = Wrapper { value: "Rust" };

println!("{}", num_wrapper.get());  // 100
println!("{}", text_wrapper.get()); // Rust

A mesma definição de método funciona para ambos, porque o tipo genérico T se adapta a cada tipo concreto em tempo de compilação.

Desafio

Fácil

Vamos estender seu contêiner genérico com métodos! Você criará uma estrutura Box (não confunda com a Box padrão do Rust) que pode armazenar qualquer tipo e fornece métodos para interagir com seu conteúdo.

Você organizará seu código em dois arquivos:

mybox.rs: Defina uma estrutura genérica pública chamada MyBox<T> com um campo privado contents do tipo T. Implemente métodos para essa estrutura:
- Uma função associada new que cria uma nova MyBox com o valor fornecido
- Um método peek que retorna uma referência ao conteúdo (usando &self)
- Um método replace que recebe um novo valor e substitui o conteúdo atual (usando &mut self)
main.rs: Inclua seu módulo e demonstre os métodos genéricos funcionando com diferentes tipos. Você criará caixas, consultará seus conteúdos e substituirá valores para mostrar os métodos em ação.

Lembre-se da sintaxe fundamental para implementar métodos em uma estrutura genérica: você precisa de impl<T> antes de MyBox<T> para informar ao Rust que T é um parâmetro genérico para todo o bloco de implementação.

Em seu arquivo principal, demonstre seu MyBox fazendo o seguinte:

Criar uma caixa com um inteiro (primeira entrada, analisada como i32)
Consultar seu conteúdo e imprimir o valor
Substituir o conteúdo por um novo inteiro (segunda entrada, analisada como i32)
Consultar novamente para mostrar o valor atualizado
Criar uma segunda caixa com uma string (terceira entrada)
Consultar o conteúdo da caixa de string

Sua saída deve seguir este formato:

Integer box contains: {value}
After replace: {value}
String box contains: {value}

Por exemplo, com as entradas 10, 25 e Rust:

Integer box contains: 10
After replace: 25
String box contains: Rust

Você receberá três entradas: um inteiro inicial, um inteiro de substituição e um valor de string.

Experimente você mesmo

mod mybox;

use mybox::MyBox;

fn main() {
    // Ler entradas
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let initial_int: i32 = input1.trim().parse().expect("Invalid integer");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let replacement_int: i32 = input2.trim().parse().expect("Invalid integer");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let string_value = input3.trim().to_string();

    // TODO: Criar um MyBox com o inteiro inicial
    
    // TODO: Peek at its contents and print: "Integer box contains: {value}"
    
    // TODO: Substituir o conteúdo pelo inteiro de substituição
    
    // TODO: Peek again and print: "After replace: {value}"
    
    // TODO: Criar um segundo MyBox com o valor da string
    
    // TODO: Peek at the string box and print: "String box contains: {value}"
}