如何将动态分配与以迭代器作为参数的方法一起使用？

问题描述

我正在编写一个用于生锈的命令行应用程序，用于处理来自传感器的音频。我希望用户能够从多个选项中选择要应用的算法或过滤器。我希望使用动态调度来切换出一个在运行时实现我的过滤器特征的结构。但是，编译器不允许这样做，因为其中一种trait方法采用通用参数。

如何在不引起任何编译器麻烦的情况下实现相同的功能？我知道一个简单的解决方案是将process方法的参数更改为数组或向量，但这是我的最后选择，因为我更喜欢采用Iterator或IntoIterator，因为它更通用，更适合我的具体需求。

这是一些说明问题的代码。

trait SensorFilter {
    fn process(&self,sig: &mut impl Iterator<Item = f32>) -> Vec<f32>;
}

struct Alg1 {
    mul: f32,}

struct Alg2 {
    add: f32,}

impl SensorFilter for Alg1 {
    fn process(&self,sig: &mut impl Iterator<Item = f32>) -> Vec<f32> {
        sig.map(|x| x * self.mul).collect()
    }
}

impl SensorFilter for Alg2 {
    fn process(&self,sig: &mut impl Iterator<Item = f32>) -> Vec<f32> {
        sig.map(|x| x * self.add).collect()
    }
}

enum AlgChoice {
    Alg1,Alg2
}

fn main() {
    let choice = AlgChoice::Alg1; // user chooses via command-line.
    let mut sig = vec![0.,1.,2.,3.,4.,5.,6.].into_iter(); // iterator gets data from sensor.

    // This doesn't work,because my trait cannot be made into an object.
    let alg: &dyn SensorFilter = match choice {
        AlgChoice::Alg1 => Alg1{mul:0.3},_ => Alg2{add:1.2},};

    let result = alg.process(&mut sig);
    println!("{:?}",result);
}

谢谢：）

解决方法

这里的技巧是将泛型函数参数更改为泛型特征参数：

// Make the generic param into a type argument w/ constraints
trait SensorFilter<I> where I: Iterator<Item = f32> {
    fn process(&self,sig: &mut I) -> Vec<f32>;
}

struct Alg1 {
    mul: f32,}

struct Alg2 {
    add: f32,}

// Implement trait for all I that match the iterator constraint
impl<I: Iterator<Item = f32>> SensorFilter<I> for Alg1 {
    fn process(&self,sig: &mut I) -> Vec<f32> {
        sig.map(|x| x * self.mul).collect()
    }
}

impl<I: Iterator<Item = f32>> SensorFilter<I> for Alg2 {
    fn process(&self,sig: &mut I) -> Vec<f32> {
        sig.map(|x| x * self.add).collect()
    }
}

enum AlgChoice {
    Alg1,Alg2
}

fn main() {
    let choice = AlgChoice::Alg1; // user chooses via command-line.
    let mut sig = vec![0.,1.,2.,3.,4.,5.,6.].into_iter(); // iterator gets data from sensor.

    // Specify the type argument of your trait.
    let alg: &dyn SensorFilter<std::vec::IntoIter<f32>> = match choice {
        AlgChoice::Alg1 => &Alg1{mul:0.3},_ => &Alg2{add:1.2},};

    let result = alg.process(&mut sig);
    println!("{:?}",result);
}

使SensorFilter对象安全的最简单方法是简单地将process更改为接受dyn Iterator而不是impl Iterator：

trait SensorFilter {
    fn process(&self,sig: &mut dyn Iterator<Item = f32>) -> Vec<f32>;
}

如果您不能这样做，例如因为Iterator实际上是非对象安全的，则可以将公共的，非对象安全的部分提取到第二个特征中，并自动将其实现为SensorFilter的所有内容：

// This trait is object-safe.
trait SensorFilter {
    fn filter(&self,x: f32) -> f32;
}

// This trait will not be object-safe because it uses generics.
trait Process {
    fn process<I: IntoIterator<Item = f32>>(&self,sig: I) -> Vec<f32>;
}

// The `?Sized` bound allows you to call `.process()` on `dyn SensorFilter`.
impl<T: ?Sized + SensorFilter> Process for T {
    fn process<I: IntoIterator<Item = f32>>(&self,sig: I) -> Vec<f32> {
        sig.into_iter().map(|x| self.filter(x)).collect()
    }
}

// ...

impl SensorFilter for Alg1 {
    fn filter(&self,x: f32) -> f32 {
        x * self.mul
    }
}

impl SensorFilter for Alg2 {
    fn filter(&self,x: f32) -> f32 {
        x * self.add
    }
}

Playground

请注意，我使用的是Iterator，而不是IntoIterator，严格来说，它是更通用的。

当您无法轻松地从SensorFilter中删除通用性时，此想法的一种变体是使用双重调度：将SensorFilter写入dyn Iterator而不是{{1} }，然后编写便利特征，将其包装为特定类型：

impl Iterator

dynamic-dispatch iterator rust