Sintaxis de límites de traits

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

Hasta ahora, has aprendido a definir traits e implementarlos para structs. También has trabajado con genéricos para escribir código flexible. Ahora es el momento de combinar estos conceptos: usar traits para restringir qué tipos puede aceptar una función genérica.

Considera una función genérica que necesita llamar a un método específico de su parámetro. Sin ninguna restricción, Rust no puede garantizar que el tipo T tenga ese método:

fn print_info<T>(item: T) {
    println!("{}", item.summarize());  // ¡Error! T podría no tener summarize()
}

La solución es un límite de trait. Al añadir : TraitName después del parámetro genérico, le indicas a Rust que T debe implementar ese trait:

trait Summary {
    fn summarize(&self) -> String;
}

fn print_info<T: Summary>(item: T) {
    println!("{}", item.summarize());  // Ahora Rust sabe que este método existe
}

La sintaxis <T: Summary> se lee como «T es cualquier tipo que implementa Summary». Ahora la función solo acepta tipos que tienen el comportamiento requerido. Si intentas pasar un tipo que no implementa Summary, el compilador lo rechazará con un error claro.

Este patrón es potente porque te permite escribir código genérico que aún tiene acceso a una funcionalidad específica. Tu función sigue siendo flexible y funciona con cualquier tipo, pero solo con los tipos que proporcionan el comportamiento que necesitas.

Desafío

Fácil

¡Construyamos un sistema de notificaciones que use límites de traits para garantizar que solo se puedan enviar mensajes con el formato adecuado! Crearás una función genérica que acepte cualquier tipo que implemente un trait específico, demostrando cómo los límites de traits restringen los parámetros genéricos.

Organizarás tu código en dos archivos:

notification.rs: Define un trait público Notify con un método llamado message que recibe &self y devuelve un String. Después, crea dos structs públicos que implementen este trait:
- Email: con un campo público subject (String). Su método message debe devolver Email: {subject}
- SMS: con un campo público content (String). Su método message debe devolver SMS: {content}
Finalmente, crea una función genérica pública llamada send_notification que acepte cualquier tipo T que implemente el trait Notify. Esta función debe imprimir el resultado de llamar a message() sobre el elemento.
main.rs: Incluye tu módulo de notificaciones y usa las entradas proporcionadas para crear una instancia de Email y una de SMS. Llama a send_notification con cada una para demostrar que tu función genérica funciona con cualquier tipo que implemente Notify.

La idea clave aquí es que send_notification no conoce el tipo concreto que recibe. Solo sabe que el tipo puede producir un mensaje. El límite del trait T: Notify garantiza esta capacidad.

Tu salida debe mostrar que ambas notificaciones se han enviado:

Email: {subject}
SMS: {content}

Por ejemplo, con las entradas Meeting Tomorrow y On my way!:

Email: Meeting Tomorrow
SMS: On my way!

Recibirás dos entradas: el asunto del correo electrónico y el contenido del SMS.

Pruébalo tú mismo

mod notification;

use notification::{Email, SMS, send_notification};

fn main() {
    // Leer entradas
    let mut subject = String::new();
    std::io::stdin().read_line(&mut subject).expect("Failed to read line");
    let subject = subject.trim().to_string();
    
    let mut content = String::new();
    std::io::stdin().read_line(&mut content).expect("Failed to read line");
    let content = content.trim().to_string();
    
    // TODO: Crea una instancia de Email con el subject
    
    // TODO: Crea una instancia de SMS con el content
    
    // TODO: Llama a send_notification con el email
    
    // TODO: Llama a send_notification con el sms
}