wykonawczymi zagnieżdżone Cechy

Question

Mam pewne cechy, które (po usunięciu funkcji i jakiś parametr uwędzić) wyglądać tak:

trait Foo { } 
trait Boo { } 
trait Bar<T: Foo> { } 
trait Baz { } 

Jeśli U realizuje Bar<T> jakiegoś T wykonawczego FooiU realizuje Boo, a następnie z nich jest w stanie w celu uzyskania implementacji Baz dla U. Jednak nie udało mi się napisać prawidłowego kodu Rusta.

kilku próbach były:

impl<T: Foo, U: Bar<T> + Boo> Baz for U { } 

co daje

error: the type parameter T is not constrained by the impl trait, self type, or predicates [E0207]

natomiast

impl<U: Bar<T> + Boo> Baz for U { } 

daje

error: type name T is undefined or not in scope [E0412]

Czy ktoś/jak można to zrobić w (stabilnej) rdzy (mam nadzieję, że bez dynamicznej wysyłki)?

Edit: Niektórzy ludzie zasugerował niektórych podobnych pytań, na które nie były zasadniczo dwa podejścia (i uważam, obaj nadają się do mojej sytuacji):

1. Korzystanie powiązanych typów. Nie chcę tego robić, ponieważ chcę śledzić numer T, np. Chcę napisać kilka funkcji, które mają podpis jak fn bla<T: Foo, U: Bar<T>, V: Bar<T>>() gdzie chcę wiedzieć, że U i V implementują Bar<T> dla sameT. (Lub czy jest sposób na to z powiązanymi typami?)
2. Używanie pewnego rodzaju zawijania poprzez wstawianie U iw struct. Nie chcę tego używać, ponieważ mam kilka poziomów takich "zależności cech", więc owijanie rzeczy na każdym poziomie znacznie zwiększyłoby kod.

Zaktualizowane pytanie brzmi: Czy istnieje rozwiązanie tego problemu bez korzystania z powiązanych typów lub opakowań?

Answer 1

Można zrobić to co T przypisany typ:

trait Foo { } 
trait Boo { } 
trait Bar { 
    type T: Foo; 
} 
trait Baz { } 

impl<U: Bar + Boo> Baz for U 
    // this where clause is not necessary (this bound is already true) 
    // where U::T: Foo 
{ } 

I don't want to do this because I want to keep track of T , e.g. I want to write some functions which have a signature like fn bla<T: Foo, U: Bar<T>, V: Bar<T>>() where I want to know that U and V implement Bar<T> for the sameT . (Or is there way of doing this with associated types?)

Tak, można to zrobić z powiązanych typów:

fn bla<U: Bar, V: Bar<T = U::T>>() { }