将泛型方法转换为 trait object 安全方法

Question

我想制作一个删除通用参数（以生成特征对象）的适配器，如下例所示。

use std::ops::Deref;

fn make_dyn_box<I, S>(iter_in: I)
where
    I: Iterator<Item = S>,
    S: Deref<Target = u8>,
{
    let mut iter_out = iter_in.map(
        |s| -> Box<dyn Deref<Target = u8>> {Box::new(s)}
    );
    take_dyn_box(&mut iter_out)
}

fn take_dyn_box<'a: 'b, 'b>(
    iter: &'a mut (dyn 'a + Iterator<Item = Box<dyn 'b + Deref<Target = u8>>>),
) { }

有没有办法在没有堆分配、只使用安全代码且没有外部依赖项的情况下完成此任务？

以下是我想要的想法，但借用检查器不允许这样做。

use std::ops::Deref;

fn make_dyn<I, S>(iter_in: I)
where
    I: Iterator<Item = S>,
    S: Deref<Target = u8>,
{
    let mut item = None;
    let item = &mut item;
    let mut iter_out = iter_in.map(|s| -> &dyn Deref<Target = u8> {
        item.replace(s);
        Option::as_ref(item).unwrap()
    });
    take_dyn(&mut iter_out)
}

fn take_dyn<'a: 'b, 'b>(
    iter: &'a mut (dyn 'a + Iterator<Item = &'b (dyn 'b + Deref<Target = u8>)>),
) { }

Answer 1

一种简单的方法是要求输入迭代器返回引用。 这编译：

fn make_dyn<'b, I, S>(iter_in: I)
where
    I: Iterator<Item = &'b S>,
    S: Deref<Target = u8> + 'b,
{
    let mut iter_out = iter_in.map(|s| -> &dyn Deref<Target = u8> {
        s as _
    });
    
    take_dyn(&mut iter_out)
}

fn take_dyn<'a: 'b, 'b>(
    _iter: &'a mut (dyn 'a + Iterator<Item = &'b (dyn 'b + Deref<Target = u8>)>),
) { }

请注意，让迭代器适配器返回可以进一步操作的迭代器是一种很好的方式：

fn make_dyn_<'b, I, S>(iter_in: I) -> impl Iterator<Item = &'b (dyn 'b + Deref<Target = u8>)>
where
    I: Iterator<Item = &'b S>,
    S: Deref<Target = u8> + 'b,
{
    iter_in.map(|s| -> &dyn Deref<Target = u8> {
        s as _
    })
}

（您也可以将其定义为实现Iterator特征的通用结构。）

现在：如果您不想要求输入迭代器返回引用，那么就没有办法返回您的新迭代器。

您在示例代码中所做的是在迭代器中创建一个小缓冲区，并返回对它的引用。

如果该缓冲区存储在您的迭代器结构中，则您尝试创建的内容称为流式迭代器，目前无法实现。 这篇极长的博文解释了原因； 本质上，它需要对 Rust 的类型系统进行大量而繁琐的扩展。

如果您重新排列代码以让用户将闭包传递给您的函数，您可以这样做。 然后，您可以控制何时调用闭包，这样您就可以将返回的值存储到缓冲区中，并将对缓冲区的引用传递给闭包。 但这不像通常的Iterator界面那样符合人体工程学。

这就是您对示例代码所做的事情......我不确定为什么它不起作用。 如果您将take_dyn更改为采用单个&'b (dyn 'b + Deref<Target = u8>)>并反复调用它，它应该可以工作。