Combine várias classes de casos em scala

Estou fazendo correspondência com algumas classes de caso e gostaria de tratar dois dos casos da mesma maneira. Algo assim:

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

Mas quando faço isso, recebo o erro:

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

Posso fazê-lo funcionar removendo os parâmetros da definição de B e C, mas como posso combinar com os parâmetros?

Parece que você não se importa com os valores dos parâmetros String e deseja tratar B e C da mesma forma, então:

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

Se você deve, deve, deve extrair o parâmetro e tratá-los no mesmo bloco de código, você pode:

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

Embora eu ache que seria muito mais limpo fatorar isso em um método:

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

Existem algumas maneiras que posso ver de alcançar o que você procura, se houver alguma semelhança entre as classes de caso. O primeiro é fazer com que as classes de caso estendam um traço que declara a comunalidade, o segundo é usar um tipo estrutural que remove a necessidade de estender suas classes de caso.

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

O método do tipo estrutural gera um aviso de apagamento que, no momento, não tenho certeza de como eliminar.

Bem, isso realmente não faz sentido, não é? B e C são mutuamente exclusivos, então sb ou sc são vinculados, mas você não sabe quais, então você precisaria de mais lógica de seleção para decidir qual usar (dado que eles foram vinculados a uma Option [String], não uma linha). Portanto, não há nada a ganhar com isso:

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

Ou isto:

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