Scala Language Abbinamento di più pattern contemporaneamente


Esempio

Il | può essere utilizzato per avere una singola istruzione di dichiarazione del caso contro più input per ottenere lo stesso risultato:

def f(str: String): String = str match {
  case "foo" | "bar" => "Matched!"
  case _ => "No match."
}

f("foo")  // res0: String = Matched!
f("bar")  // res1: String = Matched!
f("fubar")  // res2: String = No match.

Si noti che mentre la corrispondenza dei valori in questo modo funziona bene, la seguente corrispondenza dei tipi causerà problemi:

sealed class FooBar
case class Foo(s: String) extends FooBar
case class Bar(s: String) extends FooBar

val d = Foo("Diana")
val h = Bar("Hadas")

// This matcher WILL NOT work.
def matcher(g: FooBar):String = {
  g match {
    case Foo(s) | Bar(s) => print(s)  // Won't work: s cannot be resolved
    case Foo(_) | Bar(_) => _         // Won't work: _ is an unbound placeholder
    case _ => "Could not match"
  }
}

Se nel secondo caso (con _ ) non hai bisogno del valore della variabile non associata e vuoi solo fare qualcos'altro, stai bene:

def matcher(g: FooBar):String = {
  g match {
    case Foo(_) | Bar(_) => "Is either Foo or Bar."  // Works fine
    case _ => "Could not match"
  }
}

Altrimenti, hai lasciato a spaccare i tuoi casi:

def matcher(g: FooBar):String = {
  g match {
    case Foo(s) => s 
    case Bar(s) => s
    case _ => "Could not match"
  }
}