Rust notas de estudio 6.1 rasgos y genéricos (Trait && generics)

6.1 Rasgo && genéricos

Rasgos

• Similar a interfaces y clases abstractas.
• Agregar comportamiento definido a la estructura

impl trait_demo for struct_demo

struct Steve {
    
    
    name: String,
}

impl Person for Steve {
    
    
    fn new(name_str: String) -> Self {
    
    
        Steve {
    
     name: name_str }
    }

    fn language(&self) -> &str {
    
    
        "Steve"
    }
}

struct Alex {
    
    
    name: String,
}

impl Person for Alex {
    
    
    fn new(name_str: String) -> Self {
    
    
        Alex {
    
     name: name_str }
    }

    fn language(&self) -> &str {
    
    
        "Alex"
    }
    fn eat_food(&self) {
    
    
        println!("Eat fish!");
    }
}

trait Person {
    
    
    fn new(name_str: String) -> Self;
    fn language(&self) -> &str;
    fn eat_food(&self) {
    
    
        println!("Eat food");
    }
}

fn main() {
    
    
    let a = Steve::new("Star_tears".to_string());
    let b = Alex::new("T_dream".to_string());
    a.eat_food();
    b.eat_food();
}

• enumeración de retorno

  • fn get_trait -> Box<dyn trait_name>
    

genérico

• La programación genérica ( generic programming) es un estilo o paradigma de un lenguaje de programación
• Los genéricos permiten a los programadores escribir código en un lenguaje de programación fuertemente tipado utilizando algunos tipos especificados más tarde, especificando estos tipos como parámetros al instanciar

trait Bark {
    
    
    fn bark(&self) -> String;
}

struct Dog {
    
    
    species: String,
}

struct Cat {
    
    
    color: String,
}

impl Bark for Dog {
    
    
    fn bark(&self) -> String {
    
    
        format!("{} barking", self.species)
    }
}

fn bark<T: Bark>(b: T) {
    
    
    println!("{}", b.bark());
}

fn main() {
    
    
    let dog = Dog {
    
    
        species: "white dog".to_string(),
    };
    bark(dog);
}