function - patron - recorrer arraylist java foreach

¿Cómo escribir una función Rust que tome un iterador?

Question

Me gustaría escribir una función que acepte un iterador y devuelva los resultados de algunas operaciones en él. Específicamente, estoy tratando de iterar sobre los valores de un HashMap :

use std::collections::HashMap;
fn find_min<''a>(vals: Iterator<Item=&''a u32>) -> Option<&''a u32> {
vals.min()
}
fn main() {
let mut map = HashMap::new();
map.insert("zero", 0u32);
map.insert("one", 1u32);
println!("Min value {:?}", find_min(map.values()));
}

Pero Ay:

error: the `min` method cannot be invoked on a trait object
--> src/main.rs:4:10
|
4 | vals.min()
| ^^^
error[E0277]: the trait bound `std::iter::Iterator<Item=&''a u32> + ''static: std::marker::Sized` is not satisfied
--> src/main.rs:3:17
|
3 | fn find_min<''a>(vals: Iterator<Item = &''a u32>) -> Option<&''a u32> {
| ^^^^ `std::iter::Iterator<Item=&''a u32> + ''static` does not have a constant size known at compile-time
|
= help: the trait `std::marker::Sized` is not implemented for `std::iter::Iterator<Item=&''a u32> + ''static`
= note: all local variables must have a statically known size
error[E0308]: mismatched types
--> src/main.rs:11:41
|
11 | println!("Min value {:?}", find_min(map.values()));
| ^^^^^^^^^^^^ expected trait std::iter::Iterator, found struct `std::collections::hash_map::Values`
|
= note: expected type `std::iter::Iterator<Item=&u32> + ''static`
found type `std::collections::hash_map::Values<''_, &str, u32>`

Me sale el mismo error si trato de pasar por referencia; si utilizo un Box , recibo errores de por vida.

Answer 1

Desea utilizar los genéricos aquí:

fn find_min<''a, I>(vals: I) -> Option<&''a u32>
where
I: Iterator<Item = &''a u32>,
{
vals.min()
}

Los rasgos se pueden usar de dos maneras: como límites en los parámetros de tipo y como objetos de rasgo. El libro The Rust Programming Language tiene un capítulo sobre los traits y un capítulo sobre los objetos de rasgo que explican estos dos casos de uso.

Además, a menudo desea tomar algo que implemente IntoIterator ya que esto puede hacer que el código llame mejor a su función:

fn find_min<''a, I>(vals: I) -> Option<&''a u32>
where
I: IntoIterator<Item = &''a u32>,
{
vals.into_iter().min()
}

Answer 2

Este comportamiento es un poco intuitivo de aquellos con un fondo de Python en lugar de, por ejemplo, un fondo C ++, así que déjenme aclarar un poco.

En Rust, los valores se almacenan conceptualmente dentro del nombre que los une. Por lo tanto, si escribes

let mut x = Foo { t: 10 };
let mut y = x;
x.t = 999;

y todavía será 10 .

Entonces cuando escribes

let x: Iterator<Item=&''a u32>;

(o lo mismo en la lista de parámetros de función), Rust necesita asignar suficiente espacio para cualquier valor de tipo Iterator<Item=&''a u32> . Incluso si esto fuera posible, no sería eficiente.

Entonces, lo que hace Rust es ofrecerle la opción de

• Pon el valor en el montón, ej. con Box , que proporciona semántica al estilo de Python. Luego puede tomar genéricamente con &mut Iterator<Item=&''a u32> .

• Especialice cada invocación de función para cada tipo posible para satisfacer el límite. Esto es más flexible, ya que una referencia de rasgo es una especialización posible, y le da al compilador más oportunidades de especialización, pero significa que no puede tener despacho dinámico (donde el tipo puede variar dependiendo de los parámetros de tiempo de ejecución).