आंशिक रूप से लागू करने के प्रकार पैरामीटर

Question

मैं सख्त निम्नलिखित हल करने के लिए कोशिश कर रहा हूँ:

trait Access[Res[_]] { def access[C]: Res[C] } 

trait CList[C1, A] extends Access[CList[_, A]] // ?! 

def test[C1, C2, A](c: CList[C1, A]): CList[C2, A] = c.access[C2] 

scalac बस का कहना है: "error: illegal cyclic reference involving trait CList"। मैं यह संकलन कैसे कर सकता हूं?

Answer 1

आप प्रकार lambdas में रुचि हो सकती आंशिक आवेदन आप अपने जवाब में इस्तेमाल किया वास्तव में implemented in scalaz है चूंकि कोड कम पठनीय हो जाता है, हालांकि, उन्होंने इसके बजाय प्रकार lambdas का उपयोग शुरू किया। प्रश्न में टाइप

({type λ[α] = CList[α,A]})#λ 

के रूप में लिखा जा सकता है

यह पैरामीटर प्रकार λ पर संरचनात्मक प्रकार के अंदर एक प्रकार प्रक्षेपण बनाकर काम करता है जिससे बाहरी प्रकार पैरामीटर (इस मामले में A) को कैप्चर किया जाता है।

आपके उत्तर में वर्णित भिन्नता से संबंधित अन्य समस्या Access कोविरिएट में Res पैरामीटर बनाकर हल की जा सकती है।

इन परिवर्तनों को आपके कोड इस तरह दिखना चाहिए के बाद:

trait Access[+Res[_]] { def access[C] : Res[C]} 

trait CList[C, +A] extends Access[({type λ[α] = CList[α,A]})#λ] 

Answer 2

"आंशिक प्रकार आवेदन" के लिए googling मैं इस समाधान जेम्स Iry द्वारा स्केला बहस सूची पर तैनात पाया (http://scala-programming-language.1934581.n4.nabble.com/Partial-type-inference-td2007311.html; अनुकूलित इतना आर्ग क्रम बदल जाता है):

type Partial2[T[_,_], B] = { 
    type Apply[A] = T[A,B] 
} 
trait CList[C1, A] extends Access[Partial2[CList, A]#Apply] 

पनीर लुईस, है यह वास्तव में 2011 में स्कैला में ऐसा करने का एकमात्र तरीका? !!

संपादित करें:

यह A में सहप्रसरण के साथ विफल:।।, - (

trait Access[Res[_]] { def access[C]: Res[C] } 

type Partial2[T[_,_], B] = { 
    type Apply[A] = T[A,B] 
} 
trait CList[C1, +A] extends Access[Partial2[CList, A]#Apply] 

"covariant type A occurs in invariant position" 

Answer 3

मैं जानता हूँ कि यह एक बहुत पुराना सवाल है, लेकिन वैसे भी:

trait AnyAccess { 
    type Res[X] 
    def access[Z]: Res[Z] 
} 

trait AnyCList extends AnyAccess { me => 
    type C 
    type A 
    // this could be a subtype bound instead, if needed 
    type Res[X] = AnyCList { type C = X; type A = me.A } 
} 
case object AnyCList { 
    type of[C0, +A0] = AnyCList { type C = C0; type A <: A0 } 
} 

case object buh { 

    def test[C1, C2, A](c: AnyCList.of[C1, A]): AnyCList.of[C2, A] = c.access[C2] 
}