Rust：如何为捕获函数参数的闭包正确标注类型

我尝试为Iterator扩展Until trait，让until方法返回TakeWhile迭代器，但闭包捕获参数f后，无论是强制转换为fn指针还是直接使用闭包，都出现编译错误（E0605、E0308）。要求不使用Box与dyn Trait，仅通过纯泛型正确指定TakeWhile返回类型中的函数类型。

带强制转换的代码及错误 #

use std::iter::TakeWhile;

pub trait Until<T, P>: Iterator<Item = T>
where
    P: FnMut(&T) -> bool,
    Self: Sized,
{
    fn until<'a>(self, f: P) -> TakeWhile<Self, fn(&'a T) -> bool> {
        self.take_while((move |item| !f(item)) as fn(&'a T) -> bool)
    }
}

impl<T, P, I> Until<T, P> for I
where
    P: FnMut(&T) -> bool,
    I: Iterator<Item = T>,
{
}

编译错误：

Compiling until v0.1.0 (/home/rne/until)
error[E0605]: non-primitive cast: `[closure@src/lib.rs:9:26: 9:37]` as `fn(&'a T) -> bool`
 --> src/lib.rs:9:25
  |
9 |         self.take_while((move |item| !f(item)) as fn(&'a T) -> bool)
  |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ invalid cast

For more information about this error, try `rustc --explain E0605`.
error: could not compile `until` due to previous error

移除强制转换的代码及错误 #

use std::iter::TakeWhile;

pub trait Until<T, P>: Iterator<Item = T>
where
    P: FnMut(&T) -> bool,
    Self: Sized,
{
    fn until<'a>(self, f: P) -> TakeWhile<Self, fn(&'a T) -> bool> {
        self.take_while(move |item| !f(item))
    }
}

impl<T, P, I> Until<T, P> for I
where
    P: FnMut(&T) -> bool,
    I: Iterator<Item = T>,
{
}

编译错误：

error[E0308]: mismatched types
    --> src/lib.rs:9:25
     |
9    |         self.take_while(move |item| !f(item))
     |              ---------- ^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found closure
     |              |
     |              arguments to this function are incorrect
     |
     = note: expected fn pointer `fn(&T) -> bool`
                   found closure `[closure@src/lib.rs:9:25: 9:36]`
note: closures can only be coerced to `fn` types if they do not capture any variables
    --> src/lib.rs:9:38
     |
9    |         self.take_while(move |item| !f(item))
     |                                      ^ `f` captured here
note: associated function defined here
    --> /usr/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:1204:8
     |
1204 |     fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
     |        ^^^^^^^^^^

For more information about this error, try `rustc --explain E0308`.
error: could not compile `until` due to previous error

核心问题是：捕获外部变量的闭包无法被强制转换为fn指针（fn指针无状态，闭包捕获变量后带有状态），且每个闭包都是唯一的匿名类型，不能用fn指针来表示。

以下是纯泛型的正确实现方式，无需Box或dyn Trait：

use std::iter::TakeWhile;

pub trait Until: Iterator {
    fn until<P>(self, predicate: P) -> TakeWhile<Self, impl FnMut(&Self::Item) -> bool>
    where
        P: FnMut(&Self::Item) -> bool,
    {
        self.take_while(move |item| !predicate(item))
    }
}

impl<I: Iterator> Until for I {}

实现说明 #

1. 简化Trait定义：去掉Trait上的泛型参数，直接利用Iterator的关联类型Self::Item获取迭代器元素类型，更符合Rust设计习惯。
2. 利用impl Trait推导类型：返回类型中的闭包部分用impl FnMut(&Self::Item) -> bool让编译器自动推导捕获变量的闭包类型，无需手动指定泛型或强制转换。
3. 闭包逻辑正确传递：通过move关键字转移predicate的所有权，确保闭包可以捕获并使用该参数，同时反转判断逻辑实现"until"的语义（迭代到满足predicate的元素为止）。

如果不想使用impl Trait，也可以通过新增泛型参数明确闭包类型：

use std::iter::TakeWhile;

pub trait Until: Iterator {
    fn until<P, F>(self, predicate: P) -> TakeWhile<Self, F>
    where
        P: FnMut(&Self::Item) -> bool,
        F: FnMut(&Self::Item) -> bool,
    {
        self.take_while(move |item| !predicate(item))
    }
}

impl<I: Iterator> Until for I {}

第一种写法更简洁，且完全满足纯泛型的要求。

内容的提问来源于stack exchange，提问作者user3515670