Đối sánh nhiều trường hợp với các lớp học trong scala

Question

Tôi đang làm phù hợp với một số trường hợp và muốn xử lý hai 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 nhận được lỗi:

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

tôi có thể lấy nó làm việc của tôi loại bỏ các thông số từ định nghĩa của B và C nhưng làm thế nào tôi có thể kết hợp với các params?

Answer 1

Hình như bạn không quan tâm đến các giá trị của các thông số String, và muốn đối xử với B và C là như nhau, do :

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 các tham số và đối xử với họ trong khối mã tương tự, 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 nó sẽ sạch hơn nhiều đến yếu tố đó ra thành 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" 
    } 
} 

Answer 2

Vâng, nó không thực sự hợp lý, phải không? B và C là loại trừ lẫn nhau, vì vậy sb hoặc sc bị ràng buộc, nhưng bạn không biết cái nào, vì vậy bạn cần thêm logic lựa chọn để quyết định sử dụng (cho rằng chúng bị ràng buộc với một Option [String], không một chuỗi).

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

Hoặc này:: Vậy có gì đạt được trong này là

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

Answer 3

Có một vài cách mà tôi có thể nhìn thấy để đạt được những gì bạn đang sau đó, nếu bạn có một số tương đồng giữa trường hợp các lớp học. Đầu tiên là để các lớp vỏ mở rộng một đặc tính khai báo tính phổ biến, thứ hai là sử dụng một kiểu cấu trúc để loại bỏ sự cần thiết phải mở rộng các lớp chữ hoa 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 pháp kiểu cấu trúc tạo cảnh báo về xóa, hiện tại tôi không biết cách loại bỏ.