Uygulama İçiçe Özellikleri

Question

I (fonksiyonları ve bazı parametre kabartmak kaldırdıktan sonra) gibi bakmak bazı özellikleri var: sonra bir muktedir

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

U Eğer FooveUBoo uygular uygulayan bazı T için Bar<T> uygular olduğu için Baz'un bir uygulamasını türetmek için. Ancak, bunu yaparken geçerli bir Rust kodu yazamadım.

birkaç denemeden edildi:

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

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

verir

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

ise verir

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

Biri/nasıl biri (sabit) Rust'ta (herhangi bir dinamik gönderim olmadan umarım) bunu yapabilir?

Düzenleme: Bazı insanlar bazı benzer soruların ima kendisi için esasen iki yaklaşım vardı (ve benim durum için her ikisi de uygun bulmayacağı):

1. ilişkili türlerini kullanma. Bunu yapmak istemiyorum çünkü T, örn. U ve V'un T için fn bla<T: Foo, U: Bar<T>, V: Bar<T>>() gibi bir imzası olan bazı işlevleri yazmak istiyorum. (Ya da ilişkili türleri ile bunu yapmanın bir yolu var mı?)
2. Bir yapıda U ve T'u koyarak bir çeşit sargı kullanarak. Bunu kullanmak istemiyorum, çünkü bu tür "özellik bağımlılıkları" gibi bir çok seviyem var, bu yüzden her seviyede bir şeyler sarmak kodu çok şişirirdi.

Güncelleştirilmiş soru şu şekilde olurdu: İlişkilendirilen türleri veya sarmalayıcıları kullanmadan bu soruna bir çözüm var mı?

Answer 1

Bunu T yapım ilişkilendirilmiş bir türü yapabilirsiniz:

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?)

Evet, ilişkili türleri ile yapabilirsiniz:

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