Unapply ve unapplySeq arasındaki fark nedir?

Question

Scala neden hem unapply hem de unapplySeq kullanıyor? İkisi arasındaki fark nedir? Ne zaman diğerini tercih etmeliyim?

Answer 1

:

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 @ _*) => ... } 

İkinci durumda, tekrarlanan parametrelerin Seq ve A* ve _* arasındaki benzerlik gibi ele alındığını unutmayın.

Doğal olarak çeşitli tek değerler içeren bir şeyi yapılandırmak isterseniz, unapply'u kullanın. Seq içeren bir öğeyi yapılandırmak isterseniz, unapplySeq'u kullanın.

Answer 2

Sabit ve değişken değişkenlik. Pattern Matching in Scala (pdf), aynalama örnekleri ile iyi açıklar. Ayrıca this answer'da da yansıtma örnekleri var.

Kısaca: Yani

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 

, aşağıdaki örnekte sergilenmektedir düşünüyorsunuz? Tekrarlanan parametreler için

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 yapılar ve unapplySeq de-yapıları: Düzenli parametreleri apply yapılar ve unapply de-yapılar için

: biraz detaya gidiyor ve basitleştirilmesi olmadan

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