How can I have a collection of objects that differ by their associated type?
Solution 1:
When you write an impl Check
and specialize your type Error
with a concrete type, you are ending up with different types.
In other words, Check<Error = NegativeError>
and Check<Error = EvenError>
are statically different types. Although you might expect Check<Error>
to describe both, note that in Rust NegativeError
and EvenError
are not sub-types of Error
. They are guaranteed to implement all methods defined by the Error
trait, but then calls to those methods will be statically dispatched to physically different functions that the compiler creates (each will have a version for NegativeError
, one for EvenError
).
Therefore, you can't put them in the same Vec
, even boxed (as you discovered). It's not so much a matter of knowing how much space to allocate, it's that Vec
requires its types to be homogeneous (you can't have a vec![1u8, 'a']
either, although a char
is representable as a u8
in memory).
Rust's way to "erase" some of the type information and gain the dynamic dispatch part of subtyping is, as you discovered, trait objects.
If you want to give another try to the trait object approach, you might find it more appealing with a few tweaks...
-
You might find it much easier if you used the
Error
trait instd::error
instead of your own version of it.You may need to
impl Display
to create a description with a dynamically builtString
, like so: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" } }
-
Now you can drop the associated type and have
Check
return a trait object:trait Check { fn check_number(&self, number: i32) -> Option<Box<Error>>; }
your
Vec
now has an expressible type:let mut checks: Vec<Box<Check>> = vec![ Box::new(EvenCheck) , Box::new(NegativeCheck) , ];
-
The best part of using
std::error::Error
...is that now you don't need to use
PartialEq
to understand what error was thrown.Error
has various types of downcasts and type checks if you do need to retrieve the concreteError
type out of your trait object.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
Solution 2:
I'd suggest you some refactoring.
First, I'm pretty sure, that vectors should be homogeneous in Rust, so there is no way to supply elements of different types for them. Also you cannot downcast traits to reduce them to a common base trait (as I remember, there was a question about it on SO).
So I'd use algebraic type with explicit match for this task, like this:
enum Checker {
Even(EvenCheck),
Negative(NegativeCheck),
}
let checks = vec![
Checker::Even(EvenCheck),
Checker::Negative(NegativeCheck),
];
As for error handling, consider use FromError framework, so you will able to involve try! macro in your code and to convert error types from one to another.