这个 Rust 函数返回的迭代器类型是什么？

Question

所以我这里有这个示例代码：

use std::iter::Filter;
use std::slice::Iter;

fn main() {
    let numbers = vec![12i32, 26, 31, 56, 33, 16, 81];

    for number in ends_in_six(numbers) {
        println!("{}", number);
    }
}

fn ends_in_six(numbers: Vec<i32>) /* -> ??? */ {
    numbers.iter().filter(|&n| *n % 10 == 6)
}

我正在尝试 return 一个迭代器，从我收集到的信息来看，它在 Rust 中一直很毛茸茸。运行代码 here 给我这个错误：

<anon>:13:5: 13:45 error: mismatched types:
 expected `()`,
    found `core::iter::Filter<core::slice::Iter<'_, i32>, [closure <anon>:13:27: 13:44]>`
(expected (),
    found struct `core::iter::Filter`) [E0308]
<anon>:13     numbers.iter().filter(|&n| *n % 10 == 6)
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

现在，解决这个问题（基于我对这一切如何运作的相对有限的了解），看来我应该做如下事情：

fn ends_in_six<'a>(numbers: Vec<i32>) -> Filter<Iter<'a, i32>, /* ??? */> {

但现在我又卡住了，因为我得到的是 [closure <anon>:13:27: 13:44] 而不是实际类型。即使当我尝试使用函数 here 来尝试找出类型时，我也得到了：

core::iter::Filter<core::slice::Iter<i32>, [closure((&&i32,)) -> bool]>

所以，我试图自己弄清楚，并基于上一行，我尝试了：

fn ends_in_six<'a>(numbers: Vec<i32>) -> Filter<Iter<'a, i32>, Fn(&&i32) -> bool> {

并出现更多错误，因为 Fn 在编译时不是常量（即未实现 Sized）。这是有道理的，但我有点不知所措。

编辑：我只是 tried:

fn ends_in_six<'a, F>(numbers: Vec<i32>) -> Filter<Iter<'a, i32>, F>
  where F: Fn(&&i32) -> bool {

现在我收到了这些错误：

<anon>:7:19: 7:30 error: unable to infer enough type information about `_`; type annotations required [E0282]
<anon>:7     for number in ends_in_six(numbers) {
                           ^~~~~~~~~~~
<anon>:14:32: 14:34 error: the type of this value must be known in this context
<anon>:14     numbers.iter().filter(|&n| *n % 10 == 6)
                                         ^~
<anon>:14:27: 14:44 error: mismatched types:
 expected `F`,
    found `[closure <anon>:14:27: 14:44]`
(expected type parameter,
    found closure) [E0308]
<anon>:14     numbers.iter().filter(|&n| *n % 10 == 6)
                                    ^~~~~~~~~~~~~~~~~

Answer 1

每个闭包都有自己独特的类型（闭包是结构和 Fn、FnMut 或 FnOnce 实现的糖，具体取决于确定）并且无法编写闭包的类型。

你可以做的一件事是将它写成一个函数，然后将它转换为一个函数指针，如下所示。

另一件事是使用盒装函数 (Box<Fn(&&i32) -> bool>)，例如 Box::new(|&&n| n % 10 == 6)。这涉及堆分配，因此不是最有效的，但在现实生活中你不需要担心性能差异。

您所做的泛型尝试不起作用，因为泛型是关于允许 caller 指定类型，任何类型，在这种情况下您希望 callee 指定单个唯一类型。

use std::iter::Filter;
use std::slice::Iter;

fn main() {
    let numbers = vec![12i32, 26, 31, 56, 33, 16, 81];

    for number in ends_in_six(numbers) {
        println!("{}", number);
    }
}

fn ends_in_six(numbers: Vec<i32>) Filter<Iter<'a, i32>, fn(&&i32) -> bool> {
    fn filterer(&&n: &&i32) -> bool { n % 10 == 6 }
    numbers.iter().filter(filterer as fn(&&i32) -> bool)
}

这个 Rust 函数返回的迭代器类型是什么？

What is the iterator type returned by this Rust function?

types

iterator

type-inference

return-type

rust