Question

我有一个程序，涉及检查复杂的数据结构，看它是否有任何缺陷。（它非常复杂，所以我发布了示例代码。）所有检查都是彼此无关的，并且都有自己的模块和测试。

更重要的是，每个检查都有自己的错误类型，其中包含有关每个数字检查失败方式的不同信息。我是这样做的，而不是只返回错误字符串，以便我可以测试错误（这是Error依赖PartialEq的原因。）

我的代码到目前为止

我有Check和Error的特征：

trait Check {
    type Error;
    fn check_number(&self, number: i32) -> Option<Self::Error>;
}

trait Error: std::fmt::Debug + PartialEq {
    fn description(&self) -> String;
}

两个示例检查，带有错误结构。在此示例中，如果数字为负数或偶数，我想显示错误：


#[derive(PartialEq, Debug)]
struct EvenError {
    number: i32,
}
struct EvenCheck;

impl Check for EvenCheck {
    type Error = EvenError;

    fn check_number(&self, number: i32) -> Option<EvenError> {
        if number < 0 {
            Some(EvenError { number: number })
        } else {
            None
        }
    }
}

impl Error for EvenError {
    fn description(&self) -> String {
        format!("{} is even", self.number)
    }
}

#[derive(PartialEq, Debug)]
struct NegativeError {
    number: i32,
}
struct NegativeCheck;

impl Check for NegativeCheck {
    type Error = NegativeError;

    fn check_number(&self, number: i32) -> Option<NegativeError> {
        if number < 0 {
            Some(NegativeError { number: number })
        } else {
            None
        }
    }
}

impl Error for NegativeError {
    fn description(&self) -> String {
        format!("{} is negative", self.number)
    }
}

我知道在这个例子中，两个结构看起来相同，但在我的代码中，有许多不同的结构，所以我无法合并它们。最后，一个示例main函数，用于说明我想要做的事情：

fn main() {
    let numbers = vec![1, -4, 64, -25];
    let checks = vec![
        Box::new(EvenCheck) as Box<Check<Error = Error>>,
        Box::new(NegativeCheck) as Box<Check<Error = Error>>,
    ]; // What should I put for this Vec's type?

    for number in numbers {
        for check in checks {
            if let Some(error) = check.check_number(number) {
                println!("{:?} - {}", error, error.description())
            }
        }
    }
}

您可以在the Rust playground中看到代码。

我试过的解决方案

我最接近解决方案的方法是删除相关类型并让检查返回Option<Box<Error>>。但是，我得到了这个错误：

error[E0038]: the trait `Error` cannot be made into an object
 --> src/main.rs:4:55
  |
4 |     fn check_number(&self, number: i32) -> Option<Box<Error>>;
  |                                                       ^^^^^ the trait `Error` cannot be made into an object
  |
  = note: the trait cannot use `Self` as a type parameter in the supertraits or where-clauses

因为PartialEq特征中的Error。到目前为止，Rust对我来说很棒，我真的希望我能够将类型系统弯曲成支持这样的东西！

Answer 1

当您编写impl Check并使用具体类型专门化type Error时，您最终会得到不同的类型。

换句话说，Check<Error = NegativeError>和Check<Error = EvenError>是静态不同的类型。虽然您可能希望Check<Error>同时对其进行描述，但请注意，Rust NegativeError和EvenError不是Error的子类型。它们保证实现Error特征定义的所有方法，但是对这些方法的调用将被静态分派给编译器创建的物理上不同的函数（每个函数都有NegativeError的版本，一个用于EvenError）。

因此，您不能将它们放在同一个Vec中，甚至是盒装（如您所发现的）。知道要分配多少空间并不是一个问题，Vec要求其类型是同质的（你也不能有vec![1u8, 'a']，尽管char可以表示作为记忆中的u8。

正如您所发现的那样，Rust的“擦除”某些类型信息并获得子类型的动态调度部分的方法是特征对象。

如果你想再试一下特质对象的方法，你可能会发现它有一些调整更吸引人......

如果您使用std::error中的Error特征而不是您自己的版本，您可能会觉得更容易。

您可能需要impl Display使用动态构建的String创建说明，如下所示：

impl fmt::Display for EvenError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} is even", self.number)
    }
}

impl Error for EvenError {
    fn description(&self) -> &str { "even error" }
}

现在您可以删除关联的类型并让Check返回特征对象：

trait Check  {
    fn check_number(&self, number: i32) -> Option<Box<Error>>;
}

您的Vec现在有一个明确的类型：

let mut checks: Vec<Box<Check>> = vec![
    Box::new(EvenCheck) ,
    Box::new(NegativeCheck) ,
];

使用std::error::Error的最佳部分......

现在您不需要使用PartialEq来了解引发的错误。如果您确实需要从特征对象中检索具体的Error类型，Error会有各种类型的向下转换和类型检查。

for number in numbers {
    for check in &mut checks {
        if let Some(error) = check.check_number(number) {
            println!("{}", error);

            if let Some(s_err)= error.downcast_ref::<EvenError>() {
                println!("custom logic for EvenErr: {} - {}", s_err.number, s_err)                    
            }
        }
    }
}

full example on the playground

Answer 2

我建议你进行一些重构。

首先，我很确定，Rust中的向量应该是同构的，因此无法为它们提供不同类型的元素。此外，你不能低估特质，将它们降低到一个共同的基本特征（我记得，在SO上有一个关于它的问题）。

所以我使用代数类型与此任务的显式匹配，如下所示：

enum Checker {
    Even(EvenCheck),
    Negative(NegativeCheck),
}

let checks = vec![
    Checker::Even(EvenCheck),
    Checker::Negative(NegativeCheck),
];

至于错误处理，请考虑使用FromError框架，这样您就可以在代码中包含try!宏，并将错误类型从一个转换为另一个。

Answer 3

我最终找到了一种方法来做到这一点，我很满意。不是拥有Box<Check<???>>个对象的向量，而是有一个闭包向量，它们都具有相同的类型，抽象出被调用的函数：

fn main() {
    type Probe = Box<Fn(i32) -> Option<Box<Error>>>;

    let numbers: Vec<i32> = vec![ 1, -4, 64, -25 ];
    let checks = vec![
        Box::new(|num| EvenCheck.check_number(num).map(|u| Box::new(u) as Box<Error>)) as Probe,
        Box::new(|num| NegativeCheck.check_number(num).map(|u| Box::new(u) as Box<Error>)) as Probe,
    ];

    for number in numbers {
        for check in checks.iter() {
            if let Some(error) = check(number) {
                println!("{}", error.description());
            }
        }
    }
}

这不仅允许返回Box<Error>个对象的向量，还允许Check个对象提供自己的错误关联类型，而不需要实现{{1} }}。多个PartialEq es看起来有点凌乱，但总的来说

我如何拥有一组由相关类型不同的对象？

我的代码到目前为止

我试过的解决方案

3 个答案: