여러 사례 클래스를 스칼라로 일치

Question

일부 사례 클래스와의 비교를 수행하고 있으며 두 가지 사례를 동일한 방식으로 처리하려고합니다. 이런 식으로 뭔가 :

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

하지만이 작업을 수행 할 때 오류 얻을 :

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

나는 그것이 내가의 작업을 진행 B와 C의 정의에서 매개 변수를 제거하지만 난 어떻게 일치시킬 수 있습니다 매개 변수는?

Answer 1

이 보이는 그래서, 그래서이를 통해 얻은 아무것도 없다 :

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

당신이해야하는 경우, 매개 변수를 추출하고 동일한 코드 블록을 취급해야한다, 그럴 수 :

나는이 방법으로 그을 고려하는 것이 훨씬 청소기 될 것이다 느낌이 있지만

:

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

음, 실제로 이해가되지 않습니까? B와 C는 상호 배타적이므로 sb 또는 sc가 바인딩되지만 어느 것을 모를 것인지를 결정하기 위해 추가 선택 논리가 필요합니다 (Option [String]에 바인드 된 경우). String).

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

또는이 : 당신이 동일한 문자열 매개 변수의 값을 걱정하고, B를 치료하고 싶은 C없는 것

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

Answer 3

난 당신이 몇 가지 공통점 사이에있는 경우, 이후에 무슨 달성하기 위해 볼 수있는 몇 가지 방법이 있습니다 사례 클래스. 첫 번째는 사례 클래스가 공통성을 선언하는 특성을 확장하도록하는 것이고 두 번째는 사례 클래스를 확장 할 필요를 제거하는 구조적 형식을 사용하는 것입니다.

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

구조적 유형의 방법은 현재 내가 제거하는 방법을 잘 모르겠어요, 삭제에 대한 경고를 생성합니다.