En mi proyecto, con frecuencia estoy iterando a través de un vector de estructuras para encontrar un objeto por algún valor de campo, luego uso alguna función de rasgo en ese objeto:

pub struct Person{
    name: String,
    age: u32,
    id: u32,
}

impl Person{
    pub fn new(name: String, id_num: u32, age: u32)->Self{
        let p = Person{
            name: name,
            id: id_num,
            age: age,
        };
        p
    }
}

trait PersonTrait{
    fn printname();
    fn get_name()->String; 
    fn get_age()->u32;
    fn set_age(age: u32);
}


impl PersonTrait for Person{
    fn printname(){
        dbg!(self.name)
    }
    fn get_name()->String{
        self.name
    }
    fn get_id()->u32{
        self.id;
    }
    fn set_age(age: u32){
        self.age = age;
    }
}


fn main(){
    let my_people = vec![Person::new("Rakim".to_string(), 1, 56), Person::new("Ghostface".to_string(), 2, 56), Person::new("RZA".to_string(), 3, 56)];
    //frequently repeating this pattern of finding struct in array of structs, then doing something to that found struct

    for person in my_people.clone(){
        if person.get_id() == 1 {
            person.set_age(100);
        }
    }

    for person in my_people.clone(){
        if person.get_id() == "Rakim".to_string(){
            person.printname();
        }
    }
    
}

Entonces, el patrón general que estoy usando aquí es:

for x in my_objects{
    if x.id() == some_id{
        x.do_some_trait_function()
    }
}

Me gustaría crear una función más general para simplificar esta sintaxis, algo como:

//not sure what the correct syntax would be here, or how you might pass a trait function as an argument
fn find_then_do_trait_function(obj_list: Vec<Person>, id: u32, trait_function: my_trait_function()){ 
    for x in obj_list(){
        if x.get_id() == id {
            //use my trait function on x
        }
    }
}

¿Cómo puedo hacer esto? Sé que podría crear una enum para cada función de rasgo, luego match esa enumeración, pero eso también parece bastante detallado.

1
ANimator120 23 ene. 2021 a las 05:21

1 respuesta

La mejor respuesta

No hay nada único en las funciones de los rasgos. Ha identificado un patrón muy común que se puede dividir en dos partes: queremos filtrar un vector y luego realizar alguna operación en cada elemento coincidente. Podemos definir una función que tome dos argumentos de cierre para hacer esto por nosotros.

fn search_and_call<T>(obj_list: &mut Vec<T>,
                      mut condition: impl FnMut(&mut T) -> bool,
                      mut func: impl FnMut(&mut T) -> ()) {
    for x in obj_list {
        if condition(x) {
          func(x);
        }
    }
}

func puede ser cualquier cierre. Ese cierre podría llamar a una función de rasgo, o podría imprimir en la pantalla, o hacer cualquier cantidad de cosas. Al escritor de la función anterior no le importa; es lo mismo en lo que a nosotros respecta. Uso de muestra:

let mut v = vec!(1, 2, 3, 4);
search_and_call(&mut v, |x| *x % 2 == 0, |x| println!("{}", *x));

Sin embargo, vale la pena señalar que el excelente Iterator rasgo define un montón de funciones útiles, y podemos obtener este comportamiento gratis, sin siquiera tocar un bucle for.

let mut v = vec!(1, 2, 3, 4);
v.iter().filter(|x| *x % 2 == 0).for_each(|x| println!("{}", *x));

.iter() obtiene un iterador sobre nuestro vector, .filter(...) produce un nuevo iterador que selecciona ciertos elementos basados ​​en nuestra condición, y .for_each(...) llama a una función en todos los elementos que quedan después del filtro.

2
Silvio Mayolo 23 ene. 2021 a las 02:42