मैच "गिरावट": एक से अधिक मामलों के लिए कोड के समान टुकड़े को निष्पादित करना?

Question

क्या निम्नलिखित कोड लिखने के लिए स्काला का तरीका है:

int i; 

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

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

    default: foo()   
} 

अर्थात एकाधिक केस मानों के आधार पर कोड के समान टुकड़े को निष्पादित करने का बेवकूफ तरीका क्या है?

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

काफी, चाल करना प्रतीत नहीं करता है के बाद से स्काला पहले मिलान के मामले पर आधारित मैच मूल्य है, यानी अगर मैं = 2 कोड कुछ भी नहीं वापस आ जाएगी मूल्यांकन करता है।

मदद के लिए धन्यवाद!

Answer 1

this conversation के अनुसार कोई गिरावट नहीं है, लेकिन आप | का उपयोग कर सकते हैं।

इस चाल करना चाहिए:

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

Answer 2

प्रकरण बयान वास्तव में एक मानक है, तो कथन का उपयोग अतिरिक्त तर्क गार्ड शामिल कर सकते हैं। तो अगर आप की तरह कुछ कर सकता है: मिलान गार्ड किसी भी बूलियन समारोह या कार्यों की रचना हो सकती है

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

, तो यह यह जावा में मानक स्विच बयान तुलना में बहुत अधिक शक्ति देता है।

Answer 3

हालांकि लागू नहीं होने पर, अधिक जटिल समस्याओं के लिए आप आंशिक कार्यों पर और फिर फ़ंक्शन का उपयोग करके एक अर्थ में 'गिरावट' कर सकते हैं।

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

आप वास्तविक वर्गों (तार या ints के बजाय) के साथ काम कर रहे हैं, तो आप उन्हें | साथ शामिल होने से पहले एक पैटर्न में बनाने के लिए प्रत्येक वर्ग के पहले _: की जरूरत है।

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! 

आपको अच्छी तरह से जांच भी मिलती है! ध्यान दें कि आप मामले वर्ग destructuring जब वैकल्पिक पैटर्न मिलान का उपयोग कर ऐसा नहीं कर सकते (जैसे case (MateySnoresTooLoud(str) | _: Ok) => संकलित करने के लिए असफल हो जायेगी।