Iterator 如何递归传递函数指针？

我想编写一个

迭代器

适配器，将函数递归地应用于其底层

迭代器

。递归，因为变量

IR:：Loop

包含一个

Vec

，其中的迭代器也应该传递给函数

函数应该使用一个

&mut迭代器

，并使用它来计算迭代器的下一个值（如）

使用std:：iter:：Peekable；
#[衍生（克隆）]
枚举IR{
手术，
操作B，
循环（Vec），
}
pub-trait-MyItertools：迭代器{
fn应用\u递归选项>(
自己
f:f，
)->ApplyRecursive
哪里
自我：大小，
Self：：项：克隆，
{
应用执行{
iter:self.peek（），
f:f，
}
}
}
针对T的impl MyItertools
哪里
T:迭代器，
{
}
//将函数递归应用于Item=IR的某个迭代器
#[衍生（克隆）]
结构ApplyRecursive
哪里
I：迭代器，
I：：项目：克隆，
{
iter：可窥视，
f:f，
}
ApplyRecursive的impl迭代器
哪里
F:Fn（可查看和可变）
->选项，
{
类型Item=I:：Item；
fn下一步（&mut self）->选项{
match self.iter.peek（）{
一些（&IR:：循环（代码））=>{
self.iter.next（）；//推进迭代器
让code:Vec=code.into_iter（）.apply_recursive（self.f）.collect（）；
一些（IR:：Loop（代码））
}
一些（x）=>（self.f）（&mut self.iter），
无=>无，
}
}
fn大小提示（&self）->（使用，选项）{
self.iter.size_hint（）
}
}
fn main（）{}

我做错了什么？我甚至不理解错误信息：

错误[E0277]：绑定为的特征不满足
-->src/main.rs:54:54
|
54 | let code:Vec=code.into_iter（）.apply_recursive（self.f）.collect（）；
|^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^没有为`F'实现特性`for``
|
=帮助：考虑为绑定添加一个“哪里”
错误[E0277]：绑定为的特性未满足
-->src/main.rs:54:54
|
54 | let code:Vec=code.into_iter（）.apply_recursive（self.f）.collect（）；
|^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^没有为`F'实现特性`for``
|
=帮助：考虑为绑定添加一个“哪里”
错误：在当前作用域中找不到类型为“ApplyRecursive”的名为“collect”的方法
-->src/main.rs:54:78
|
54 | let code:Vec=code.into_iter（）.apply_recursive（self.f）.collect（）；
|                                                                              ^^^^^^^
|
=注意：方法'collect'存在，但未满足以下特征边界：'F:std:：ops:：Fn'，'ApplyRecursive:std:：iter:：Iterator'`
=帮助：trait中的项目只有在trait已实现且在范围内时才能使用；以下特性定义了一个“collect”项，您可能需要实现它：
=帮助：候选者#1:`std:：iter:：Iterator`

最后一个错误表明您没有

迭代器<代码>迭代器

仅在某些条件下为您的结构实现，您没有满足这些条件。第二个错误解释了原因

对于类型

F

那么，为什么编译器认为这不起作用呢？让我们看看您的约束条件：

impl<I, F> Iterator for ApplyRecursive<I, F>
where
    I: Iterator<Item = IR>
    F: Fn(&mut Peekable<I>) -> Option<I::Item>,

这打开了一系列关于可变性、访问私有字段和导出私有类型的错误，但我认为它克服了这个困难

或者，我们可以将

F

更改为接受特征对象，而不必担心对其进行专门化：

pub trait CustomIter: Iterator {
    fn apply_recursive<F>(self, f: F) -> ApplyRecursive<Self, F>
    where
        F: Fn(&mut Iterator<Item = Self::Item>) -> Option<Self::Item>,
        Self: Sized,
        Self::Item: Clone,
    {
        ApplyRecursive { iter: self.peekable(), f: f }
    }
}

impl<I, F> Iterator for ApplyRecursive<I, F>
where
    I: Iterator<Item = IR>,
    F: Fn(&mut Iterator<Item = IR>) -> Option<IR>,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<IR> {

pub-trait-CustomIter:迭代器{
fn apply_recursive（self，f:f）->ApplyRecursive
哪里
F:Fn（&mut迭代器）->选项，
自我：大小，
Self：：项：克隆，
{
ApplyRecursive{iter:self.peekable（），f:f}
}
}
ApplyRecursive的impl迭代器
哪里
I：迭代器，
F:Fn（&mut迭代器）->选项，
{
类型Item=I:：Item；
fn下一步（&mut self）->选项{

出于可读性的考虑，我强烈建议不要将内联特征约束

与

where

子句混合使用。一旦它很长或很复杂，就全部转到

where

子句。我的偏好是始终使用

where

子句。非常感谢！您可以比编译器更好地解释这一点哈；）对我来说，仿制药是生锈最难的部分，但多亏了你，我今天学到了很多！

impl<F> Iterator for ApplyRecursive<vec::IntoIter<IR>, F>
where
    F: Fn(&mut vec::IntoIter<IR>) -> Option<IR>,
{
    type Item = IR;

    fn next(&mut self) -> Option<IR> {

pub trait CustomIter: Iterator {
    fn apply_recursive<F>(self, f: F) -> ApplyRecursive<Self, F>
    where
        F: Fn(&mut Iterator<Item = Self::Item>) -> Option<Self::Item>,
        Self: Sized,
        Self::Item: Clone,
    {
        ApplyRecursive { iter: self.peekable(), f: f }
    }
}

impl<I, F> Iterator for ApplyRecursive<I, F>
where
    I: Iterator<Item = IR>,
    F: Fn(&mut Iterator<Item = IR>) -> Option<IR>,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<IR> {