Métodos genéricos

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 25 de 61.

Una estructura genérica puede contener cualquier tipo, pero no resulta muy útil sin métodos para interactuar con sus datos. Para definir métodos para una estructura genérica, necesitas una sintaxis especial en el bloque impl.

La clave es declarar el parámetro genérico en el propio impl:

struct Wrapper<T> {
    value: T,
}

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

Observa el impl<T> antes de Wrapper<T>. Esto indica a Rust que T es un parámetro de tipo genérico para todo el bloque de implementación. Sin esta declaración, Rust buscaría un tipo concreto llamado T y no lo encontraría.

El método get devuelve &T: una referencia al tipo que contenga el contenedor. Esto funciona tanto si T es un entero como si es una cadena u otro tipo cualquiera:

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

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

La misma definición de método funciona para ambos, porque el T genérico se adapta a cada tipo concreto en tiempo de compilación.

Desafío

Fácil

¡Ampliemos tu contenedor genérico con métodos! Construirás una estructura Box (que no debe confundirse con el Box estándar de Rust) que puede contener cualquier tipo y proporciona métodos para interactuar con su contenido.

Organizarás tu código en dos archivos:

mybox.rs: Define una estructura genérica pública llamada MyBox<T> con un campo privado contents de tipo T. Implementa métodos para esta estructura:
- Una función asociada new que crea un nuevo MyBox con el valor indicado
- Un método peek que devuelve una referencia al contenido (usando &self)
- Un método replace que recibe un valor nuevo y reemplaza el contenido actual (usando &mut self)
main.rs: Incluye tu módulo y demuestra cómo funcionan los métodos genéricos con distintos tipos. Crearás cajas, consultarás su contenido y reemplazarás valores para mostrar los métodos en acción.

Recuerda la sintaxis clave para implementar métodos en una estructura genérica: necesitas impl<T> antes de MyBox<T> para indicar a Rust que T es un parámetro genérico para todo el bloque de implementación.

En tu archivo principal, demuestra tu MyBox haciendo lo siguiente:

Crear una caja con un entero (la primera entrada, analizada como i32)
Consultar su contenido e imprimir el valor
Reemplazar el contenido con un entero nuevo (la segunda entrada, analizada como i32)
Volver a consultar el contenido para mostrar el valor actualizado
Crear una segunda caja con una cadena (la tercera entrada)
Consultar el contenido de la caja de cadena

Tu salida debe seguir este formato:

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

Por ejemplo, con las entradas 10, 25 y Rust:

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

Recibirás tres entradas: un entero inicial, un entero de reemplazo y un valor de cadena.

Pruébalo tú mismo

mod mybox;

use mybox::MyBox;

fn main() {
    // Leer 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: Crea un MyBox con el entero inicial
    
    // TODO: Peek at its contents and print: "Integer box contains: {value}"
    
    // TODO: Reemplaza el contenido con el entero de reemplazo
    
    // TODO: Peek again and print: "After replace: {value}"
    
    // TODO: Crea un segundo MyBox con el valor de cadena
    
    // TODO: Peek at the string box and print: "String box contains: {value}"
}