Óxido - Iterador y cierre

En este capítulo, aprenderemos cómo funcionan los iteradores y cierres en RUST.

Iteradores

Un iterador ayuda a iterar sobre una colección de valores como matrices, vectores, mapas, etc. Los iteradores implementan el rasgo Iterator que se define en la biblioteca estándar de Rust. El método iter () devuelve un objeto iterador de la colección. Los valores de un objeto iterador se denominan elementos. El método next () del iterador se puede utilizar para recorrer los elementos. El método next () devuelve un valor None cuando llega al final de la colección.

El siguiente ejemplo usa un iterador para leer valores de una matriz.

fn main() {
   //declare an array
   let a = [10,20,30];

   let mut iter = a.iter(); 
   // fetch an iterator object for the array
   println!("{:?}",iter);

   //fetch individual values from the iterator object
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
}

Salida

Iter([10, 20, 30])
Some(10)
Some(20)
Some(30)
None

Si una colección como matriz o Vector implementa el rasgo Iterator, entonces se puede recorrer usando la sintaxis for ... como se muestra a continuación-

fn main() {
   let a = [10,20,30];
   let iter = a.iter();
   for data in iter{
      print!("{}\t",data);
   }
}

Salida

10 20 30

Los siguientes 3 métodos devuelven un objeto iterador de una colección, donde T representa los elementos de una colección.

No Señor	Métodos y descripción
1	iter() da un iterador sobre & T (referencia a T)
2	into_iter() da un iterador sobre T
3	iter_mut() da un iterador sobre & mut T

Ilustración: iter ()

La función iter () usa el concepto de préstamo. Devuelve una referencia a cada elemento de la colección, dejando la colección intacta y disponible para su reutilización después del ciclo.

fn main() {
   let names = vec!["Kannan", "Mohtashim", "Kiran"];
   for name in names.iter() {
      match name {
         &"Mohtashim" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   println!("{:?}",names); 
   // reusing the collection after iteration
}

Salida

Hello Kannan
There is a rustacean among us!
Hello Kiran
["Kannan", "Mohtashim", "Kiran"]

Ilustración - into_iter ()

Esta función utiliza el concepto de propiedad. Mueve los valores de la colección a un objeto iter, es decir, la colección se consume y ya no está disponible para su reutilización.

fn main(){
   let names = vec!["Kannan", "Mohtashim", "Kiran"];
   for name in names.into_iter() {
      match name {
         "Mohtashim" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   // cannot reuse the collection after iteration
   //println!("{:?}",names); 
   //Error:Cannot access after ownership move
}

Salida

Hello Kannan
There is a rustacean among us!
Hello Kiran

Ilustración - for e iter_mut ()

Esta función es como la función iter () . Sin embargo, esta función puede modificar elementos dentro de la colección.

fn main() {
   let mut names = vec!["Kannan", "Mohtashim", "Kiran"];
   for name in names.iter_mut() {
      match name {
         &mut "Mohtashim" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   println!("{:?}",names);
   //// reusing the collection after iteration
}

Salida

Hello Kannan
There is a rustacean among us!
Hello Kiran
["Kannan", "Mohtashim", "Kiran"]

Cierre

El cierre se refiere a una función dentro de otra función. Estas son funciones anónimas, funciones sin nombre. El cierre se puede utilizar para asignar una función a una variable. Esto permite que un programa pase una función como parámetro a otras funciones. El cierre también se conoce como función en línea. Se puede acceder a las variables de la función externa mediante funciones en línea.

Sintaxis: Definición de un cierre

Una definición de cierre puede tener opcionalmente parámetros. Los parámetros están dentro de dos barras verticales.

let closure_function = |parameter| {
   //logic
}

La sintaxis que invoca un cierre implementa Fnrasgos. Entonces, se puede invocar con() sintaxis.

closure_function(parameter);    //invoking

Ilustración

El siguiente ejemplo define un cierre is_even dentro de la función main () . El cierre devuelve verdadero si un número es par y devuelve falso si el número es impar.

fn main(){
   let is_even = |x| {
      x%2==0
   };
   let no = 13;
   println!("{} is even ? {}",no,is_even(no));
}

Salida

13 is even ? false

Ilustración

fn main(){
   let val = 10; 
   // declared outside
   let closure2 = |x| {
      x + val //inner function accessing outer fn variable
   };
   println!("{}",closure2(2));
}

La función main () declara una variable val y un cierre. El cierre accede a la variable declarada en la función externa main () .

Salida

12