विशेषता वर्ग बनाम लागू रूपांतरण

Question

मैं मौजूदा प्रकारों में नए कार्यों को जोड़ने की कोशिश कर रहा हूं (इसलिए मैं आईडीई ऑटो उन प्रकारों के लिए प्रासंगिक कार्यों का सुझाव दे सकता हूं जिन पर मेरा नियंत्रण नहीं है, उदाहरण के लिए Future[Option[A]])। मैंने इसे पूरा करने के लिए निहित वर्ग और निहित रूपांतरण दोनों की खोज की है और वे दोनों एक ही व्यवहार की पेशकश करते हैं।

case class Foo(a: Int) 
implicit class EnrichedFoo(foo: Foo) { 
    def beep = "boop" 
} 
Foo(1).beep // "boop" 

एक अंतर्निहित रूपांतरण और का उपयोग कर:

case class Foo(a: Int) 
trait Enriched { 
    def beep: String 
} 
implicit def fooToEnriched(foo: Foo) = new Enriched { 
    def beep = "boop" 
} 
Foo(1).beep // "boop" 

मैं यहाँ एक अंतर हो सकता है कि पहला उदाहरण एक एक- बनाता लगता

वहाँ एक अंतर्निहित वर्ग का उपयोग कर के बीच कोई प्रभावी अंतर है एक विशेषता के बजाय कक्षा से बाहर, लेकिन मैं आसानी से एक सार तत्व का विस्तार करने के लिए निहित वर्ग को अनुकूलित कर सकता हूं, उदाहरण के लिए:

case class Foo(a: Int) 
trait Enriched { 
    def beep: String 
} 
implicit class EnrichedFoo(foo: Foo) extends Enriched { 
    def beep = "boop" 
} 
Foo(1).beep // "boop" 

Answer 1

जहां तक ​​मुझे पता होगा, वे बिल्कुल वही हैं। स्कोपिंग नियम भी दोनों पर समान रूप से लागू होते हैं।

मेरी राय में, मैं आपकी स्थिति के लिए implicit classes का उपयोग करूंगा। वे शायद इस तरह के कुछ के लिए बिल्कुल बनाया गया था।

मेरे लिए लागू रूपांतरण, अधिक उपयुक्त हैं जब आपके पास वास्तव में दो अलग-अलग प्रकार के वर्ग होते हैं और दोनों के बीच परिवर्तित करना चाहते हैं।

एक नई भाषा निर्माण के वर्ग है जो किसी दूसरे प्रकार में विस्तार तरीकों प्रदान के निर्माण को आसान बनाने का प्रस्ताव है:

आप अंतर्निहित कक्षाएं right here. वहाँ यह कहता है के लिए प्रारंभिक प्रस्ताव की जाँच कर सकते हैं।

आप यह भी देख सकते हैं कि यह implicit classes को कैसे बेकार करता है। निम्नलिखित: वरीयता के अपने एक मामले में मेरे लिए अच्छी तरह से

class RichInt(n: Int) extends Ordered[Int] { 
    def min(m: Int): Int = if (n <= m) n else m 
    ... 
} 
implicit final def RichInt(n: Int): RichInt = new RichInt(n) 

Answer 2

:

implicit class RichInt(n: Int) extends Ordered[Int] { 
    def min(m: Int): Int = if (n <= m) n else m 
    ... 
} 

में desugar होगा। असल में implicit classes कक्षाओं के निर्माण को कम करने के लिए आया है जो किसी अन्य प्रकार के विस्तार विधियां प्रदान करता है। लागू कक्षाएं value classes पर बहुत अधिक मूल्य जोड़ती हैं।