Как я могу иметь коллекцию объектов, которые отличаются по их связанному типу?

Ответ 1

В конце концов я нашел способ сделать это, и я доволен. Вместо того, чтобы иметь вектор объектов 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 предоставлять свой собственный связанный с ошибкой тип, который не требуется реализовать PartialEq. Несколько as es выглядят немного грязно, но в целом это не так уж плохо.

Ответ 2

Когда вы пишете impl Check и специализируете свой type Error на конкретном типе, вы получаете разные типы.

Другими словами, Check<Error = NegativeError> и Check<Error = EvenError> являются статически разными типами. Хотя вы можете ожидать, что Check<Error> описывает оба, обратите внимание, что в Rust NegativeError и EvenError не являются EvenError Error. Они гарантированно реализуют все методы, определенные свойством Error, но тогда вызовы этих методов будут статически отправляться физически различным функциям, которые создает компилятор (у каждой будет версия для NegativeError, одна для EvenError).

Следовательно, вы не можете поместить их в тот же Vec, даже в штучной упаковке (как вы обнаружили). Это не столько вопрос знания, сколько места нужно выделить, это то, что Vec требует, чтобы его типы были однородными (у вас также не может быть vec![1u8, 'a'], хотя char может быть представлен как u8 в объем памяти).

Простой способ "стереть" некоторую информацию о типе и получить динамическую диспетчеризирующую часть подтипирования - это, как вы обнаружили, черты объектов.

Если вы хотите еще раз попробовать подход к объекту черты, вы можете найти его более привлекательным с помощью нескольких настроек...

1. Возможно, вам будет гораздо проще, если вы используете черту Error в std::error вместо своей собственной версии.

   Возможно, вам потребуется impl Display для создания описания с динамически 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" }
   }
   

2. Теперь вы можете отбросить связанный тип и заставить 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) ,
   ];
   

3. Лучшая часть использования std::error::Error...

   в том, что теперь вам не нужно использовать PartialEq чтобы понять, какая ошибка была PartialEq. Error имеет различные типы downcast и проверки типов, если вам нужно извлечь конкретный тип 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)                    
               }
           }
       }
   }
   

полный пример на детской площадке

Ответ 3

Я бы предложил вам несколько рефакторингов.

Во-первых, я уверен, что векторы должны быть однородными в Rust, поэтому нет возможности поставлять для них элементы разных типов. Кроме того, вы не можете понижать черты, чтобы свести их к общей базовой чертой (как я помню, был вопрос об этом на SO).

Поэтому я бы использовал алгебраический тип с явным соответствием для этой задачи, например:

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

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

Что касается обработки ошибок, рассмотрите возможность использования FromError, поэтому вы сможете привлечь try! в вашем коде и для преобразования типов ошибок из одного в другой.