Correspondance "fallthrough": exécuter le même morceau de code pour plusieurs cas?

Question

Quelle est la façon dont Scala écrit le code suivant:

  int i;

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

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

   default: foo()        
 } 
 

C'est-à-dire quelle est la manière idiomatique d'exécuter le même morceau de code basé sur plusieurs valeurs de casse?

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

Il ne semble pas tout à fait faire l'affaire, car Scala évalue la valeur de correspondance en fonction du premier cas correspondant, c'est-à-dire que si i = 2, le code ne renverra rien.

Merci pour l'aide!

Answer 1

Selon cette conversation, il n'y a pas de solution, mais vous pouvez utiliser | .

Cela devrait faire l'affaire:

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

Answer 2

Les instructions de cas peuvent en fait inclure des protecteurs logiques supplémentaires à l'aide d'une instruction if standard. Vous pouvez donc faire quelque chose comme:

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

Les gardes correspondants peuvent être n'importe quelle fonction booléenne ou composition de fonctions, ce qui lui donne beaucoup plus de puissance que l'instruction switch standard en Java.

Answer 3

Bien que cela ne soit pas applicable ici, pour des problèmes plus complexes, vous pouvez «tomber» dans un sens en utilisant la fonction andThen sur des fonctions partielles.

  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