如何编写一个带有迭代器的 Rust 函数？

Question

我想写一个函数，它接受一个迭代器并返回一些操作的结果。具体来说，我正在尝试遍历 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()));
}

可惜：

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>`

如果我尝试通过引用传递，我会得到同样的错误；如果我使用Box，我会得到终身错误。

Answer 1

你想在这里使用泛型：

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

Traits 可以以两种方式使用：作为类型参数的边界和作为 trait 对象。 Rust 编程语言这本书有一个关于 traits 的章节和一个关于 trait objects 的章节来解释这两个用例。

此外，您通常希望采用实现 IntoIterator 的东西，因为这可以使调用您的函数的代码更好：

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

Answer 2

由于 Rust 1.26 impl Trait 可用。一个不太冗长的版本。

use std::collections::HashMap;

fn find_min<'a>(vals: impl 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()));
}

playground

Answer 3

对于那些有 Python 背景而不是 C++ 背景的人来说，这种行为有点不直观，所以让我稍微澄清一下。

在 Rust 中，值在概念上存储在绑定它们的名称中。因此，如果你写

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

y.t 仍将是 10。

所以当你写的时候

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

（或在函数参数列表中相同），Rust 需要为 Iterator<Item=&'a u32> 类型的 any 值分配足够的空间。即使这可能，也不会有效。

因此，Rust 所做的就是为您提供选择

• 将值放在堆上，例如。 Box，它提供了 Python 风格的语义。然后你可以用&mut Iterator<Item=&'a u32> 通用。

• 为每个可能的类型专门化每个函数调用以满足界限。这更灵活，因为特征引用是一种可能的特化，并为编译器提供了更多特化的机会，但这意味着您不能有 dynamic 调度（其中类型可以根据运行时参数而变化） .