कार्यान्वयन नेस्टेड लक्षण

Question

मैं है कुछ लक्षण जो (कार्य करता है और कुछ पैरामीटर ब्लोट हटाने के बाद) की तरह लग रहे:

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

तो U कुछ T को लागू करने FooऔरU लागू करता Boo के लिए Bar<T> लागू करता है, तो एक में सक्षम है U के लिए Baz के कार्यान्वयन को प्राप्त करने के लिए। हालांकि, मैं ऐसा करने के लिए वैध जंग कोड लिखने में सक्षम नहीं था।

कुछ की कोशिश करता थे:

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

जो

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

जबकि

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

पैदावार देता है

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

क्या कोई इसे (स्थिर) जंग में कर सकता है (उम्मीद है कि बिना किसी गतिशील प्रेषण के)?

संपादित: कुछ लोग कुछ इसी तरह के सवाल की ओर संकेत किया जिसके लिए वहाँ अनिवार्य रूप से दो दृष्टिकोण थे (और मैं उन दोनों को मेरी स्थिति के लिए अनुपयुक्त):

1. संबद्ध प्रकार का उपयोग करना। मैं ऐसा नहीं करना चाहता क्योंकि मैं T का ट्रैक रखना चाहता हूं, उदा। मैं जो fn bla<T: Foo, U: Bar<T>, V: Bar<T>>() की तरह एक हस्ताक्षर है जहां मैं जानना चाहता हूँ कि U और V लागू हीT के लिए Bar<T> चाहते कुछ कार्यों लिखना चाहते हैं। (या संबंधित प्रकारों के साथ ऐसा करने का कोई तरीका है?)
2. किसी संरचना में U और T डालकर किसी प्रकार की रैपिंग का उपयोग करना। मैं इसका उपयोग नहीं करना चाहता क्योंकि मेरे पास ऐसी "विशेषता निर्भरता" के कई स्तर हैं, इसलिए प्रत्येक स्तर पर चीजों को लपेटने से कोड बहुत अधिक हो जाएगा।

तो अद्यतन प्रश्न यह होगा: क्या संबंधित प्रकार या रैपर का उपयोग किए बिना इस समस्या का समाधान है?

Answer 1

आप एक संबद्ध प्रकार यह T बनाने कर सकते हैं:

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

हाँ, आप इसे संबद्ध प्रकार के साथ कर सकते हैं:

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