Implementando Traits

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

Agora que você sabe como definir um trait, vamos ver como fazer uma struct cumprir esse contrato. Implementar um trait conecta o requisito abstrato ao comportamento concreto.

A sintaxe 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)
    }
}

O bloco impl Speak for Dog informa ao Rust que Dog está implementando o trait Speak. Dentro dele, você fornece o corpo real do método. É aqui que você define como um cachorro fala.

O poder dos traits fica claro quando vários tipos implementam o mesmo trait:

struct Cat {
    name: String,
}

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

Dog e Cat agora compartilham a capacidade Speak, mas cada um fornece sua própria implementação exclusiva. Você pode chamar .speak() em qualquer um dos tipos:

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

println!("{}", dog.speak());  // Rex diz: Au au!
println!("{}", cat.speak());  // Whiskers diz: Miau!

Esta é a base do polimorfismo em Rust: tipos diferentes, mesma interface, comportamentos únicos.

Desafio

Fácil

Vamos dar vida às traits implementando-as para diferentes tipos! Você criará uma trait Describable e a implementará para duas structs diferentes, cada uma fornecendo sua própria descrição exclusiva.

Você organizará seu código em três arquivos:

describable.rs: Defina uma trait pública Describable com um método describe(&self) -> String.
items.rs: Crie duas structs públicas que implementem sua trait:
- Book com um campo público title (String)
- Movie com um campo público name (String)
Cada struct deve implementar Describable com seu próprio formato de descrição exclusivo.
main.rs: Reúna seus módulos, crie instâncias de ambas as structs e chame seus métodos describe para mostrar como a mesma trait produz saídas diferentes para tipos diferentes.

Sua Book deve se descrever como Book: {title} e seu Movie deve se descrever como Film: {name}. Observe como cada tipo cumpre o mesmo contrato, mas com seu próprio comportamento!

Em seu arquivo principal, crie um livro e um filme usando as duas entradas fornecidas e, em seguida, imprima suas descrições em linhas separadas.

Sua saída deve seguir este formato:

Book: {title}
Film: {name}

Por exemplo, com as entradas 1984 e Inception:

Book: 1984
Film: Inception

Você receberá duas entradas: o título de um livro e o nome de um filme.

Experimente você mesmo

mod describable;
mod items;

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

fn main() {
    // Ler 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: Crie uma instância de Book com o title
    
    // TODO: Crie uma instância de Movie com o name
    
    // TODO: Imprima a descrição do livro
    
    // TODO: Imprima a descrição do filme
}