How to require a trait in another trait correctly?

Question

I tried to write two traits where one requires another to be implemented and got this error:

error[E0277]: the trait bound `T: ValTrait` is not satisfied
  --> src/main.rs:20:1
   |
20 | / fn get<T: ValRequireTrait + std::fmt::Debug>(_t: T) {
21 | |     println!("{:?}", T::VAL);
22 | | }
   | |_^ the trait `ValTrait` is not implemented for `T`
   |
   = help: consider adding a `where T: ValTrait` bound
   = note: required by `ValRequireTrait`

The code:

trait ValTrait<T = Self> {
    const VAL: T;
}

trait ValRequireTrait<T: ValTrait = Self> {}

#[derive(Debug, Copy, Clone)]
struct A {
    field: u64,
}

impl ValTrait for A {
    const VAL: A = A {
        field: 0u64
    };
}
impl ValRequireTrait for A {}


fn get<T: ValRequireTrait + std::fmt::Debug>(_t: T) {
    println!("{:?}", T::VAL);
}

fn main() {
    let a = A { field: 6u64 };
    get(a);
}

How to do this correctly? If I do what the compiler says I will not need the ValRequireTrait because it will be useless. I wanted ValRequireTrait to be a mark that the structure implements enough methods as I need.

In other words, I expect such a requirement be transitive so when in get() function I require one trait (ValRequireTrait), others (ValTrait) will be required automatically without any specification in the code as compiler wants.

Answer 1

It sounds like you want ValTrait to be a supertrait of ValRequireTrait. A good introduction can be found in the Rust book (2nd edition):

Sometimes, we may want a trait to be able to rely on another trait also being implemented wherever our trait is implemented, so that our trait can use the other trait’s functionality. The required trait is a supertrait of the trait we’re implementing.

If you change this line:

trait ValRequireTrait<T: ValTrait = Self> {}

to this, it compiles fine:

trait ValRequireTrait<T: ValTrait = Self>: ValTrait<T> {}