Implementación de Traits

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy. Lección 30 de 61.

Ahora que sabes cómo definir un trait, veamos cómo hacer que un struct cumpla ese contrato. Implementar un trait conecta el requisito abstracto con un comportamiento concreto.

La sintaxis usa impl TraitName for StructName:

trait Speak {
    fn speak(&self) -> String;
}

struct Dog {
    name: String,
}

impl Speak for Dog {
    fn speak(&self) -> String {
        format!("{} says: Woof!", self.name)
    }
}

El bloque impl Speak for Dog indica a Rust que Dog está implementando el trait Speak. Dentro, proporcionas el cuerpo real del método. Aquí es donde defines cómo habla un perro.

El poder de los traits queda claro cuando varios tipos implementan el mismo:

struct Cat {
    name: String,
}

impl Speak for Cat {
    fn speak(&self) -> String {
        format!("{} says: Meow!", self.name)
    }
}

Tanto Dog como Cat ahora comparten la capacidad Speak, pero cada uno proporciona su propia implementación única. Puedes llamar a .speak() en cualquiera de los dos tipos:

let dog = Dog { name: String::from("Rex") };
let cat = Cat { name: String::from("Whiskers") };

println!("{}", dog.speak());  // Rex dice: ¡Guau!
println!("{}", cat.speak());  // Whiskers dice: ¡Miau!

Esta es la base del polimorfismo en Rust: distintos tipos, la misma interfaz, comportamientos únicos.

Desafío

Fácil

¡Demos vida a los traits implementándolos para diferentes tipos! Crearás un trait Describable y lo implementarás para dos structs diferentes, cada uno proporcionando su propia descripción única.

Organizarás tu código en tres archivos:

describable.rs: Define un trait público Describable con un método describe(&self) -> String.
items.rs: Crea dos structs públicos que implementen tu trait:
- Book con un campo público title (String)
- Movie con un campo público name (String)
Cada struct debería implementar Describable con su propio formato de descripción único.
main.rs: Reúne tus módulos, crea instancias de ambos structs y llama a sus métodos describe para mostrar cómo el mismo trait produce diferentes salidas para distintos tipos.

Tu Book debería describirse como Book: {title} y tu Movie debería describirse como Film: {name}. ¡Observa cómo cada tipo cumple el mismo contrato, pero con su propio comportamiento!

En tu archivo principal, crea un book y un movie usando las dos entradas proporcionadas y después imprime sus descripciones en líneas separadas.

Tu salida debería seguir este formato:

Book: {title}
Film: {name}

Por ejemplo, con las entradas 1984 e Inception:

Book: 1984
Film: Inception

Recibirás dos entradas: el título de un book y el nombre de un movie.

REQUIRED OUTPUT FORMAT: [Your translated content here]

Pruébalo tú mismo

mod describable;
mod items;

use describable::Describable;
use items::{Book, Movie};

fn main() {
    // Lee las entradas
    let mut title = String::new();
    std::io::stdin().read_line(&mut title).expect("Failed to read line");
    let title = title.trim().to_string();
    
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    // TODO: Crea una instancia de Book con el title
    
    // TODO: Crea una instancia de Movie con el name
    
    // TODO: Imprime la descripción del libro
    
    // TODO: Imprime la descripción de la película
}