在scala中匹配多个案例类

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

看起来您并不关心 String 参数的值，并且希望将 B 和 C 视为相同，因此：

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

如果您必须、必须、必须提取参数并在同一代码块中处理它们，您可以

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

：我觉得将其分解为方法会更清晰：

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

如果案例类之间有一些共性，我可以看到几种方法来实现您所追求的目标。第一个是让案例类扩展一个声明通用性的特征，第二个是使用结构类型，这样就无需扩展案例类。

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

结构类型方法会生成有关擦除的警告，目前我不确定如何消除。

Answer 3

嗯，这确实没有意义，不是吗？ B 和 C 是互斥的，因此 sb 或 sc 被绑定，但您不知道哪个，因此您需要进一步的选择逻辑来决定使用哪个（假设它们绑定到 Option[String]，而不是一个字符串）。所以没有任何收获：

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

或者这个：

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