Nested generic impl

Question

I don't understand why rust don't allow to use a generic inside an other generic constraint.

It's difficult to explain with normal words but for example this simple code don't work

trait GenericTraitA<T1> {}

trait GenericTraitB<T2> {}

impl<T1, T2: GenericTraitA<T1>> dyn GenericTraitB<T2> {}

It says that:

the type parameter T1 is not constrained by the impl trait, self type, or predicates

But i don't see why this is not constrained, i don't understand the ambiguity inside this code.

Answer 1

What that compiler error is saying is, with that impl block definition, it would not be able to determine the appropriate type to substitute in for T1 . Let's look at a concrete example to demonstrate this:

pub trait Trait<T> {
    fn foo(&self);
}

struct Bar;

impl Trait<u32> for Bar {
    fn foo(&self) {
        println!("u32 impl");
    }
}

impl Trait<u64> for Bar {
    fn foo(&self) {
        println!("u64 impl");
    }
}

impl<T, U> U
where
    U: Trait<T>,
{
    fn call_foo(&self) {
        self.foo();
    }
}

fn main() {
    let bar = Bar;
    bar.call_foo();
}

Trying to compile this program yields the following error:

error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
  --> src/main.rs:19:6
   |
19 | impl<T, U> U
   |      ^ unconstrained type parameter

The reason why this error exists is that bar.call_foo() has ambiguous behavior if we were to allow that impl block to be well-formed. Bar implements both Trait<u32> and Trait<u64> , but how do we know which version of foo we're supposed to call? The answer is that we don't, which is why this program doesn't compile.