Khớp nhiều lớp trường hợp trong scala

Tôi đang đối sánh với một số lớp trường hợp và muốn xử lý hai trong số các trường hợp theo cùng một cách. Một cái gì đó như thế này:

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"
  }
}

Nhưng khi tôi làm điều này, tôi gặp lỗi:

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

Tôi có thể làm cho nó hoạt động Tôi xóa các tham số khỏi định nghĩa của B và C nhưng làm thế nào tôi có thể khớp với các tham số?

Có vẻ như bạn không quan tâm đến giá trị của các tham số Chuỗi và muốn xử lý B và C giống nhau, vì vậy:

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

Nếu bạn phải, phải, phải trích xuất tham số và xử lý chúng trong cùng một khối mã, bạn có thể:

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"
  }
}

Mặc dù tôi cảm thấy sẽ sạch hơn nhiều nếu đưa điều đó vào một phương pháp:

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"
  }
}

Có một số cách mà tôi có thể thấy để đạt được những gì bạn đang có, nếu bạn có một số điểm chung giữa các lớp trường hợp. Đầu tiên là để các lớp trường hợp mở rộng một đặc điểm khai báo tính chung, thứ hai là sử dụng kiểu cấu trúc loại bỏ nhu cầu mở rộng các lớp trường hợp của bạn.

 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))
   }
 }

Phương thức loại cấu trúc tạo ra một cảnh báo về việc tẩy xóa, hiện tại tôi không chắc chắn về cách loại bỏ.

Chà, nó không thực sự có ý nghĩa, phải không? B và C loại trừ lẫn nhau, do đó, sb hoặc sc đều bị ràng buộc, nhưng bạn không biết cái nào, vì vậy bạn cần logic lựa chọn thêm để quyết định cái nào sẽ sử dụng (vì chúng bị ràng buộc với một Tùy chọn [Chuỗi], không một chuỗi). Vì vậy, không thu được gì về điều này:

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

Hoặc cái này:

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