scala - software - Match "fallthrough": ¿se ejecuta el mismo código para más de un caso?

scala vs java

Question

¿Cuál es la forma de la Scala de escribir el siguiente código?

 int i;

 switch(i) {
   case 1:  
         a();
         break;

   case 2:
   case 15:
        b();
        c();
        break;

   default: foo()        
 } 

Es decir, ¿cuál es la forma idiomática de ejecutar el mismo código basado en múltiples valores de casos?

 i match {
   case 1  => a    
   case 2  =>
   case 15 => { b
                c }
   case _ => foo        
 } 

No parece ser el truco, ya que Scala evalúa el valor de coincidencia en función del primer caso coincidente, es decir, si i = 2, el código no arrojará nada.

¡Gracias por la ayuda!

Answer 1

De acuerdo con esta conversación, no hay caída, pero puedes hacer uso de | .

Esto debería funcionar:

i match {
  case 1  => a    
  case 2 | 15 => b
                 c
  case _ => foo        
} 

Answer 2

Las declaraciones de casos realmente pueden incluir protecciones lógicas adicionales usando una declaración if estándar. Entonces podrías hacer algo como:

i match {
  case x if x == 1 => a
  case x if (x == 2 | x == 15) => b; c;
  case _ => foo
}

Las guardias de coincidencia pueden ser cualquier función booleana o composición de funciones, por lo que le da mucha más potencia que la declaración de conmutación estándar en Java.

Answer 3

Si bien no es aplicable aquí, para problemas más complejos, puede ''descifrar'' en cierto sentido utilizando la función y luego función parcial.

 def do_function_a() { println("a"); }
 def do_function_b() { println("b"); }
 val run_function:PartialFunction[String, String] = { 
       case "a" => do_function_a(); "b"
       case "b" => do_function_b(); "c"
 }

 (run_function andThen run_function)("a") // a/nb

Answer 4

Si está tratando con clases reales (en lugar de cadenas o ints), necesita _: antes de cada clase para convertirlas en un patrón antes de unirlas a | .

sealed trait ShipCondition
case class ShipOnFire() extends ShipCondition
case class FoodSucks() extends ShipCondition
case class MateySnoresTooLoud() extends ShipCondition
case class Ok() extends ShipCondition

val condition = ShipOnFire()

def checkCondition(cond: ShipCondition): Unit = {
  cond match {
    case c @ (_: ShipOnFire | _: FoodSucks) => println("Abandon Ship!") // can also use `c` for something. It has the type ShipCondition
    case (_: MateySnoresTooLoud | _: Ok) => println("Deal with it!")
  }
}

checkCondition(condition) // Abandon Ship!

¡Obtienes un buen control exhaustivo también! Tenga en cuenta que no se puede desestructurar la clase de caso cuando se usa una coincidencia de patrón alternativa (por ejemplo, case (MateySnoresTooLoud(str) | _: Ok) => no se compilará.