अनुपयोगी और अनुपयोगी के बीच क्या अंतर है?

Question

स्कैला में unapply और unapplySeq दोनों क्यों हैं? दोनों के बीच क्या अंतर है? मुझे दूसरे पर कब पसंद करना चाहिए?

Answer 1

विवरण में जा रहा है और एक सा सरल बनाने के बिना:

object S { 
    def apply(a: A):S = ... // makes a S from an A 
    def unapply(s: S): Option[A] = ... // retrieve the A from the S 
} 
val s = S(a) 
s match { case S(a) => a } 

दोहराया पैरामीटर के लिए, apply निर्माणों और unapplySeq de-संरचनाओं: नियमित मापदंडों apply निर्माणों और unapply de-संरचनाओं के लिए

:

object M { 
    def apply(a: A*): M = ......... // makes a M from an As. 
    def unapplySeq(m: M): Option[Seq[A]] = ... // retrieve the As from the M 
} 
val m = M(a1, a2, a3) 
m match { case M(a1, a2, a3) => ... } 
m match { case M(a, as @ _*) => ... } 

ध्यान दें कि उस दूसरे मामले में, दोहराए गए मानकों को Seq और A* और _* के बीच समानता के समान माना जाता है।

तो यदि आप कुछ ऐसी चीजों को डि-स्ट्रक्चर करना चाहते हैं जो स्वाभाविक रूप से विभिन्न एकल मान हैं, तो unapply का उपयोग करें। यदि आप Seq वाले किसी चीज़ को डि-स्ट्रक्चर करना चाहते हैं, तो unapplySeq का उपयोग करें।

Answer 2

फिक्स्ड-एरीटी बनाम परिवर्तनीय धैर्य। Pattern Matching in Scala (pdf) मिररिंग उदाहरणों के साथ, इसे अच्छी तरह से समझाता है। मेरे पास this answer में मिररिंग उदाहरण भी हैं।

संक्षेप में:

object Sorted { 
    def unapply(xs: Seq[Int]) = 
    if (xs == xs.sortWith(_ < _)) Some(xs) else None 
} 

object SortedSeq { 
    def unapplySeq(xs: Seq[Int]) = 
    if (xs == xs.sortWith(_ < _)) Some(xs) else None 
} 

scala> List(1,2,3,4) match { case Sorted(xs) => xs } 
res0: Seq[Int] = List(1, 2, 3, 4) 
scala> List(1,2,3,4) match { case SortedSeq(a, b, c, d) => List(a, b, c, d) } 
res1: List[Int] = List(1, 2, 3, 4) 
scala> List(1) match { case SortedSeq(a) => a } 
res2: Int = 1 

तो, जो आपको लगता है कि निम्न उदाहरण में प्रदर्शित किया जाता है?

scala> List(1) match { case List(x) => x } 
res3: Int = 1