Ordnen Sie mehrere Fallklassen in Scala zu

Ich mache Matching gegen einige Fallklassen und möchte zwei der Fälle auf die gleiche Weise behandeln. Etwas wie das:

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

Aber wenn ich das mache, bekomme ich den Fehler:

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

Ich kann es zum Laufen bringen, indem ich die Parameter aus der Definition von B und C entferne, aber wie kann ich mit den Parametern übereinstimmen?

Sieht so aus, als ob Sie sich nicht um die Werte der String-Parameter kümmern und B und C gleich behandeln möchten.

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

Wenn Sie den Parameter extrahieren und im selben Codeblock behandeln müssen, können Sie:

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

Obwohl ich der Meinung bin, dass es viel sauberer wäre, dies in eine Methode einzubeziehen:

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

Es gibt mehrere Möglichkeiten, wie ich sehen kann, was Sie suchen, wenn Sie Gemeinsamkeiten zwischen Fallklassen haben. Die erste besteht darin, dass die Fallklassen ein Merkmal erweitern, das die Gemeinsamkeit deklariert, und die zweite darin, einen Strukturtyp zu verwenden, der die Notwendigkeit beseitigt, Ihre Fallklassen zu erweitern.

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

Die strukturelle Typmethode generiert eine Warnung vor dem Löschen, die ich derzeit nicht sicher beseitigen kann.

Nun, es macht nicht wirklich Sinn, oder? B und C schließen sich gegenseitig aus, sodass entweder sb oder sc gebunden werden, aber Sie wissen nicht, welche. Daher benötigen Sie eine weitere Auswahllogik, um zu entscheiden, welche verwendet werden soll (vorausgesetzt, sie sind an eine Option [String] gebunden, nicht ein Faden). Daraus wird also nichts gewonnen:

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

Oder dieses:

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