Cocokkan beberapa kelas kasus dalam skala

Saya melakukan pencocokan terhadap beberapa kelas kasus dan ingin menangani dua kasus dengan cara yang sama. Sesuatu seperti ini:

abstract class Foo
case class A extends Foo
case class B(s:String) extends Foo
case class C(s:String) extends Foo


def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(sb) | C(sc) => "B"
    case _ => "default"
  }
}

Tetapi ketika saya melakukan ini saya mendapatkan kesalahan:

(fragment of test.scala):10: error: illegal variable in pattern alternative
    case B(sb) | C(sc) => "B"

Saya bisa membuatnya berfungsi dengan menghapus parameter dari definisi B dan C tetapi bagaimana saya bisa mencocokkan dengan parameter?

Sepertinya Anda tidak peduli dengan nilai parameter String, dan ingin memperlakukan B dan C sama, jadi:

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(_) | C(_) => "B"
    case _ => "default"
  }
}

Jika Anda harus, harus, mengekstrak parameter dan memperlakukannya dalam blok kode yang sama, Anda dapat:

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case bOrC @ (B(_) | C(_)) => {
      val s = bOrC.asInstanceOf[{def s: String}].s // ugly, ugly
      "B(" + s + ")"
    }
    case _ => "default"
  }
}

Meskipun saya merasa akan jauh lebih bersih untuk memfaktorkannya menjadi sebuah metode:

def doB(s: String) = { "B(" + s + ")" }

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(s) => doB(s)
    case C(s) => doB(s)
    case _ => "default"
  }
}

Ada beberapa cara yang dapat saya lihat untuk mencapai apa yang Anda inginkan, jika Anda memiliki kesamaan antara kelas kasus. Yang pertama adalah membuat kelas kasus memperluas sifat yang menyatakan kesamaan, yang kedua adalah menggunakan tipe struktural yang menghilangkan kebutuhan untuk memperluas kelas kasus Anda.

 object MuliCase {
   abstract class Foo
   case object A extends Foo

   trait SupportsS {val s: String}

   type Stype = Foo {val s: String}

   case class B(s:String) extends Foo
   case class C(s:String) extends Foo

   case class D(s:String) extends Foo with SupportsS
   case class E(s:String) extends Foo with SupportsS

   def matcher1(l: Foo): String = {
     l match {
       case A        => "A"
       case s: Stype => println(s.s); "B"
       case _        => "default"
     }
   }

   def matcher2(l: Foo): String = {
     l match {
       case A            => "A"
       case s: SupportsS => println(s.s); "B"
       case _            => "default"
     }
   }

   def main(args: Array[String]) {
     val a = A
     val b = B("B's s value")
     val c = C("C's s value")

     println(matcher1(a))
     println(matcher1(b))
     println(matcher1(c))

     val d = D("D's s value")
     val e = E("E's s value")

     println(matcher2(d))
     println(matcher2(e))
   }
 }

Metode tipe struktural menghasilkan peringatan tentang penghapusan yang, saat ini saya tidak yakin bagaimana cara menghilangkannya.

Yah, itu tidak masuk akal, bukan? B dan C saling eksklusif, jadi sb atau sc terikat, tetapi Anda tidak tahu yang mana, jadi Anda memerlukan logika seleksi lebih lanjut untuk memutuskan mana yang akan digunakan (mengingat bahwa keduanya terikat ke Opsi [String], bukan Sebuah benang). Jadi tidak ada yang didapat dari ini:

  l match {
    case A() => "A"
    case B(sb) => "B(" + sb + ")"
    case C(sc) => "C(" + sc + ")"
    case _ => "default"
  }

Atau ini:

  l match {
    case A() => "A"
    case _: B => "B"
    case _: C => "C"
    case _ => "default"
  }