为动态分派扩展Iterator trait时的对象安全问题咨询

问题背景 #

想要为Iterator trait扩展一个便利函数，定义了如下BetterIterator trait：

trait BetterIterator: Iterator { 
    fn skip_bad(&mut self); 
}

最初通过动态分派返回Box<dyn BetterIterator>的实现可以正常运行：

struct Iter {}

impl Iterator for Iter {
    type Item = ();
    fn next(&mut self) -> Option<()> { None }
}

impl BetterIterator for Iter {
    fn skip_bad(&mut self) {}
}

fn make_iter() -> Box<dyn BetterIterator<Item=()>> {
    Box::new( Iter {} )
}

fn main() 
{
    let mut iter = make_iter();
    iter.skip_bad();
    for _item in iter {
        // ...
    }
}

修改后的问题 #

为了支持链式调用（例如for _item in make_iter().skip_bad()），将BetterIterator修改为：

trait BetterIterator: Iterator { 
    fn skip_bad(&mut self) -> &mut Self; 
}

impl BetterIterator for Iter {
    fn skip_bad(&mut self) -> &mut Self { self }
}

此时编译器报错：the trait BetterIterator cannot be made into an object。

问题解答 #

是否违反对象安全规则？ #

是的，这完全违反了Rust的对象安全规则。对象安全要求：trait中的方法除了作为接收者类型（比如&mut self里的self）外，不能在其他位置使用Self类型。修改后的skip_bad方法返回了&mut Self，这里的Self指代具体的实现类型（比如Iter），但动态分派的dyn BetterIterator是经过类型擦除的trait对象，编译器在运行时无法确定Self的具体类型，因此无法满足返回&mut Self的要求，导致trait失去对象安全性。

解决办法 #

有三种常见方案可以兼顾对象安全和链式调用需求：

1. 修改返回类型为trait对象引用

调整trait方法的返回类型，从&mut Self改为trait对象引用，这样既保持对象安全，又支持链式调用：

trait BetterIterator: Iterator { 
    fn skip_bad(&mut self) -> &mut dyn BetterIterator<Item = Self::Item>; 
}

impl BetterIterator for Iter {
    fn skip_bad(&mut self) -> &mut dyn BetterIterator<Item = ()> { self }
}

2. 使用泛型包装结构体

如果不需要动态分派，可以用泛型包装器包裹迭代器，在包装器上实现链式方法：

struct BetterIter<I: Iterator>(I);

impl<I: Iterator> BetterIter<I> {
    fn skip_bad(&mut self) -> &mut Self {
        // 在这里实现skip_bad的具体逻辑
        self
    }
}

impl<I: Iterator> Iterator for BetterIter<I> {
    type Item = I::Item;
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}

fn make_iter() -> BetterIter<Iter> {
    BetterIter(Iter {})
}

fn main() {
    for _item in make_iter().skip_bad() {
        // ...
    }
}

这种方式通过泛型保留了具体类型信息，避免了类型擦除，同时支持链式调用。

3. 使用impl Trait返回类型（Rust 1.26+）

如果不需要动态分派的trait对象，可以用impl Trait直接返回实现了trait的具体类型：

trait BetterIterator: Iterator { 
    fn skip_bad(&mut self) -> &mut Self; 
}

impl BetterIterator for Iter {
    fn skip_bad(&mut self) -> &mut Self { self }
}

fn make_iter() -> impl BetterIterator<Item=()> {
    Iter {}
}

fn main() {
    for _item in make_iter().skip_bad() {
        // ...
    }
}

该方案无需使用Box<dyn ...>，直接返回匿名的实现类型，既支持链式调用，又不会触发对象安全问题，但缺点是返回类型无法在需要动态分派的场景中使用。

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