स्कैला प्रकार प्रणाली में ऑक्स पैटर्न को समझना

Question

इस प्रश्न से पहले पूछा जा सकता है और उत्तर दिया जा सकता है, लेकिन मैं इसे एक उदाहरण के साथ समझना चाहता हूं और मैं यह नहीं कह सकता कि ऑक्स पैटर्न सहायक हो सकता है! तो यहां विशेषता है:

trait Foo[A] { 
    type B 
    def value: B 
} 

मेरे पास ऐसा प्रकार क्यों है जो मूल्य फ़ंक्शन के रिटर्न प्रकार के लिए बाध्य है? मैं यह करने में क्या हासिल करूं? विशेष रूप से, मैं ऐसे पैटर्न का उपयोग कहां करूंगा?

Answer 1

किसी भी टुपल का अंतिम तत्व प्राप्त करने के लिए एक टाइपक्लास की कल्पना करें।

trait Last[A] { 
    type B 
    def last(a: A): B 
} 

object Last { 
    type Aux[A,B0] = Last[A] { type B = B0 } 

    implicit def tuple1Last[A]: Aux[Tuple1[A],A] = new Last[Tuple1[A]] { 
    type B = A 
    def last(a: Tuple1[A]) = a._1 
    } 

    implicit def tuple2Last[A,C]: Aux[(A,C),C] = new Last[(A,C)] { 
    type B = C 
    def last(a: (A,C)) = a._2 
    } 

    ... 
} 

प्रकार B हमेशा प्रकार A पर निर्भर करता है, क्यों A typeclass की एक इनपुट प्रकार है और B एक आउटपुट प्रकार है कि है।

अब यदि आप एक ऐसा फ़ंक्शन चाहते हैं जो अंतिम तत्व के आधार पर टुपल्स की किसी भी सूची को सॉर्ट कर सकता है तो आपको B तक पहुंच की आवश्यकता है, उसी तर्क सूची में टाइप करें। स्कैला की वर्तमान स्थिति में, यही कारण है कि आपको Aux पैटर्न की आवश्यकता क्यों है: वर्तमान में last.B को उसी पैरामीटर सूची में टाइप करना संभव नहीं है, जहां last परिभाषित किया गया है, न ही यह एकाधिक अंतर्निहित पैरामीटर सूचियां संभव है ।

def sort[A,B](l: List[A])(implicit last: Last.Aux[A,B], ord: Ordering[B]) = ??? 

बेशक

आप हमेशा पूरी तरह से बाहर Last[A] { type B = B0 } लिख सकते हैं, लेकिन स्पष्ट रूप से है कि बहुत जल्दी बहुत अव्यावहारिक हो जाता है (निर्भर प्रकार के साथ कुछ और अंतर्निहित पैरामीटर जोड़कर कल्पना, कुछ निराकार के साथ बहुत आम है कि); यही वह जगह है जहां Aux टाइप उपनाम आता है।