Explorando la función any del iterador de Rust

Introducción

En este laboratorio, se discute la función Iterator::any, que es una función que toma un iterador como entrada y devuelve true si algún elemento del iterador satisface una predicado dado, y false en caso contrario. La función está definida como un método de trato en la biblioteca estándar de Rust y se puede utilizar en cualquier tipo que implemente el trato Iterator. La función toma una clausura como argumento, que determina el predicado que se aplicará a cada elemento del iterador. La clausura está definida con el trato FnMut, lo que significa que puede modificar las variables capturadas pero no consumirlas. La función any devuelve un valor booleano que indica si el predicado es satisfecho por algún elemento del iterador.

Nota: Si el laboratorio no especifica un nombre de archivo, puede utilizar cualquier nombre de archivo que desee. Por ejemplo, puede utilizar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.

Skills Graph

Iterator::any

Iterator::any es una función que, cuando se le pasa un iterador, devolverá true si algún elemento satisface el predicado. En caso contrario, devolverá false. Su firma es la siguiente:

pub trait Iterator {
    // El tipo sobre el que se está iterando.
    type Item;

    // `any` toma `&mut self`, lo que significa que el llamador puede ser prestado
    // y modificado, pero no consumido.
    fn any<F>(&mut self, f: F) -> bool where
        // `FnMut` significa que cualquier variable capturada puede ser, como
        // máximo, modificada, no consumida. `Self::Item` indica que toma
        // argumentos para la clausura por valor.
        F: FnMut(Self::Item) -> bool;
}

fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];

    // `iter()` para vectores produce `&i32`. Desestructura a `i32`.
    println!("2 en vec1: {}", vec1.iter()    .any(|&x| x == 2));
    // `into_iter()` para vectores produce `i32`. No es necesario desestructurar.
    println!("2 en vec2: {}", vec2.into_iter().any(|x| x == 2));

    // `iter()` solo presta `vec1` y sus elementos, por lo que se pueden usar de nuevo
    println!("Longitud de vec1: {}", vec1.len());
    println!("El primer elemento de vec1 es: {}", vec1[0]);
    // `into_iter()` mueve `vec2` y sus elementos, por lo que ya no se pueden usar
    // println!("El primer elemento de vec2 es: {}", vec2[0]);
    // println!("Longitud de vec2: {}", vec2.len());
    // TODO: descomenta las dos líneas anteriores y observa los errores del compilador.

    let array1 = [1, 2, 3];
    let array2 = [4, 5, 6];

    // `iter()` para arrays produce `&i32`.
    println!("2 en array1: {}", array1.iter()    .any(|&x| x == 2));
    // `into_iter()` para arrays produce `i32`.
    println!("2 en array2: {}", array2.into_iter().any(|x| x == 2));
}

Resumen

¡Felicitaciones! Has completado el laboratorio de Iterator::any. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.