Generics 如何从函数返回过滤器迭代器？

我想要这样的东西：

fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> ??? {
    input.iter().filter(|&x| x == Int::one())
}

fn过滤器\u一个？？？{
input.iter（）.filter（|&x | x==Int:：one（））
}

那个函数的返回类型是什么？（我想返回迭代器）

（我希望这不是太明显，我已经试了半个小时了，现在才开始感到沮丧：p）

编辑：

我试图按照=>

编译器给了我以下错误：

<anon>:5:1: 7:2 error: the trait `core::kinds::Sized` is not implemented for the type `for<'r> core::ops::Fn(&'r T) -> bool + 'a`
<anon>:5 fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> Filter<&T, Iter<'a, T>, Fn(&T) -> bool>{
<anon>:6     input.iter().filter(|&x| x == Int::one())
<anon>:7 }
<anon>:5:1: 7:2 note: required by `core::iter::Filter`
<anon>:5 fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> Filter<&T, Iter<'a, T>, Fn(&T) -> bool>{
<anon>:6     input.iter().filter(|&x| x == Int::one())
<anon>:7 }
<anon>:5:1: 7:2 error: the trait `for<'r> core::ops::Fn(&'r &'a T) -> bool` is not implemented for the type `for<'r> core::ops::Fn(&'r T) -> bool + 'a`
<anon>:5 fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> Filter<&T, Iter<'a, T>, Fn(&T) -> bool>{
<anon>:6     input.iter().filter(|&x| x == Int::one())
<anon>:7 }
<anon>:5:1: 7:2 note: required by `core::iter::Filter`
<anon>:5 fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> Filter<&T, Iter<'a, T>, Fn(&T) -> bool>{
<anon>:6     input.iter().filter(|&x| x == Int::one())
<anon>:7 }
error: aborting due to 2 previous errors
playpen: application terminated with error code 101

：5:1:7:2错误：未为类型“for bool+”实现特性“core:：gends:：Sized”`
：5 fn filter\u一个过滤器（输入：&'a Vec）->过滤器核心：：ops：：fn（&'r&'a T）->bool`未为'for bool+'a类型实现`
：5 fn filter\u one filter（输入：&'a Vec）->filter不幸的是，不可能返回依赖闭包的迭代器（特别是闭包，函数可以正常工作；请参见下文），例如由
filter（）
或
map（）
适配器返回的迭代器。原因如下

这是
filter（）
迭代器扩展方法的签名：

fn filter<P>(self, predicate: P) -> Filter<A, Self, P> where P: FnMut(&A) -> bool

然后，在这个特定调用的单组化之后，
p
将成为编译器生成的某种匿名未命名类型。因为它是未命名的，自然，您不能在类型签名中指定它，因此，您也不能指定依赖于unboxed闭包的迭代器类型-您只是不知道作为
过滤器的第三个参数要写什么

您可以通过使用函数而不是闭包来解决此问题，闭包对于您的用例来说应该足够了：

use std::slice::Items;
use std::iter::Filter;
use std::num::Int;

fn filter_one<T: Int>(input: &[T]) -> Filter<&T, Items<T>, fn(&&T) -> bool> {
    fn equal_to_one<U: Int>(&&x: &&U) -> bool { x == Int::one() }
    input.iter().filter(equal_to_one::<T>)
}

fn main() {
    let v = [1i, 2, 3];
    let r: Vec<int> = filter_one(v.as_slice()).map(|x| *x).collect();
    println!("{}", r);
}

使用std:：slice:：Items；
使用std:：iter:：Filter；
使用std:：num:：Int；
fn过滤器（输入：&[T]）->过滤器布尔>{
fn等于一（&&x:&&U）->bool{x==Int:：one（）}
input.iter（）.filter（等于1:）
}
fn main（）{
设v=[1i，2，3]；
设r:Vec=filter_one（v.as_slice（））.map（|x |*x.collect（）；
println！（“{}”，r）；
}

请注意，我还将
&Vec
更改为
&T]
——您不应该使用
&Vec
，因为它不必要地限制了代码的灵活性

但是，对于更一般的闭包情况，如果没有抽象返回类型，就不可能做到这一点。有人提议添加它们，但被推迟到1.0之后。
1.26
fn filter\u one（输入：&[u8]）->impl迭代器{
input.iter（）.filter（|&x | x==1）
}
fn main（）{
设nums=vec！[1,2,3,1,2,3]；
let other:Vec=filter_one（&nums）.collect（）；
println！（“{：？}”，其他）；
}

锈1.0
fn过滤器\u一个盒子{
Box:：new（input.iter（）.filter（|&x | x==1））
}
fn main（）{
设nums=vec！[1,2,3,1,2,3]；
let other:Vec=filter_one（&nums）.collect（）；
println！（“{：？}”，其他）；
}

此解决方案需要额外的分配。我们创建一个装箱的trait对象。在这里，对象的大小总是已知的（它只是一两个指针），但是堆中对象的大小不需要知道

同样，如果谓词逻辑不需要来自环境的任何信息，则可以使用函数而不是闭包：

use std::{iter::Filter, slice::Iter};

fn filter_one<'a>(input: &'a [u8]) -> Filter<Iter<u8>, fn(&&u8) -> bool> {
    fn is_one(a: &&u8) -> bool {
        **a == 1
    }

    input.iter().filter(is_one)
}

fn main() {
    let nums = vec![1, 2, 3, 1, 2, 3];
    let other: Vec<_> = filter_one(&nums).collect();
    println!("{:?}", other);
}

使用std:{iter:：Filter，slice:：iter}；
fn过滤器\一个过滤器布尔>{
fn是一个（a:&u8）->bool{
**a==1
}
input.iter（）过滤器（是一个）
}
fn main（）{
设nums=vec！[1,2,3,1,2,3]；
let other:Vec=filter_one（&nums）.collect（）；
println！（“{：？}”，其他）；
}

另见：



可能是的，但编译器没有足够的指导，我会编辑！在这种情况下，它可能是一个副本，非常感谢您的详细解释，我理解这个问题！：）谢谢你的回答。
框
对这种情况有帮助吗？或者这在出现关闭时没有帮助吗？是的，
Box
也有帮助。事实上，trait对象目前是返回闭包的一般问题的解决方案。你可以在Shepmaster的回答中看到这是如何做到的。谢谢！！我现在将使用此解决方法，直到rust获得将泛型表示为fn返回类型的能力！我非常肯定，在这种情况下，在结构上显式实现闭包特性是一种过分的做法。常规函数也实现所有相关的特性，您不需要定义自定义结构并自己实现这些特性。此外，一旦您开始使用稳定的Rust版本，这将打破（因为它们不允许使用门控特性，并且未绑定闭包特性的自定义实现将保持门控）。当然，如果您确实需要闭包来捕获其环境，那么这是目前为止唯一的选择…如果
impl
或
trait
定义中的函数是什么呢？@DrSensor您自己尝试过这两种方法吗？您可以从类型的固有方法返回一个
impl Trait
。你一点也不介意。
fn filter_one(input: &[u8]) -> impl Iterator<Item = &u8> {
    input.iter().filter(|&&x| x == 1)
}

fn main() {
    let nums = vec![1, 2, 3, 1, 2, 3];
    let other: Vec<_> = filter_one(&nums).collect();
    println!("{:?}", other);
}

fn filter_one<'a>(input: &'a [u8]) -> Box<Iterator<Item = &'a u8> + 'a> {
    Box::new(input.iter().filter(|&&x| x == 1))
}

fn main() {
    let nums = vec![1, 2, 3, 1, 2, 3];
    let other: Vec<_> = filter_one(&nums).collect();
    println!("{:?}", other);
}

use std::{iter::Filter, slice::Iter};

fn filter_one<'a>(input: &'a [u8]) -> Filter<Iter<u8>, fn(&&u8) -> bool> {
    fn is_one(a: &&u8) -> bool {
        **a == 1
    }

    input.iter().filter(is_one)
}

fn main() {
    let nums = vec![1, 2, 3, 1, 2, 3];
    let other: Vec<_> = filter_one(&nums).collect();
    println!("{:?}", other);
}