I have difficulty reason about how trait bounds work in this following examples. Would appreciate any hints on what's going on, why is that, or if some of these are just bugs.
Let's say we have this taxonomy:
pub trait Partial: Copy {
fn foo() -> Option<Self>;
}
pub trait Complete where Self: Partial + Default {
fn foo() -> Self;
}
impl<T> Partial for T where T: Complete {
fn foo() -> Option<Self> {
Some(<Self as Complete>::foo())
}
}
pub trait Orthogonal: Partial {}
Now, here's one usage of the taxonomy, defining a Partial type:
#[derive(Clone, Copy)]
enum TypeA {
A,
}
impl Partial for TypeA {
fn foo() -> Option<Self> {
None
}
}
And there's another one, defining a Complete type:
enum TypeB {
B,
}
impl Default for TypeB {
fn default() -> Self {
TypeB::B
}
}
impl Complete for TypeB {
fn foo() -> Self {
TypeB::B
}
}
These compile without error.
Question 1
Why TypeB works here even though it has not implemented Copy, which is required by Partial? Not having Copy implemented for TypeA results in a compile error.
Question 2
Now let's try to define another with Orthogonal implementation:
enum TypeC {}
impl Orthogonal for TypeC {}
I would get this error:
error[E0277]: the trait bound `traits::TypeC: traits::Complete` is not satisfied
--> src/traits.rs:61:6
|
61 | impl Orthogonal for TypeC {}
| ^^^^^^^^^^ the trait `traits::Complete` is not implemented for `traits::TypeC`
|
= note: required because of the requirements on the impl of `traits::Partial` for `traits::TypeC`
= note: required by `traits::Orthogonal`
Which is not accurate, because implementing Partial is just enough here and Complete is not required.
What do you think?
