क्या स्कैला में "test-if-match" ऑपरेटर है?

Question

संभव डुप्लिकेट:
Scala: short form of pattern matching that returns Boolean

मेरी स्केला कोड में मैं खोजने कर रहा हूँ अपने आप को अक्सर निम्न तरह बातें लिख:

x match{ 
    case Type(params) => doStuffWith(params) 
    case _ => /* do nothing*/ 
} 

वहाँ पहले से ही करने के लिए कुछ पूर्वनिर्धारित ऑपरेटर है यह करो? मुझे लगता है कि अगर मैं चीजों को लिख सकता हूं तो यह बहुत स्पष्ट होगा:

if(x match Type(params)) { 
    doStuffWith(params) 
} 

अनिवार्य रूप से अजीब अन्यथा मामले से परहेज करना। मेरे पास अन्य स्थितियां भी हैं जहां यह सत्यापित करने में सक्षम होना चाहिए कि किसी इनलाइन फैशन में पैटर्न से मेल खाने से मुझे ब्रेसिज़ की अतिरिक्त जोड़ी मिल जाएगी।

मुझे पता है कि इस तरह की चीज अधिक पुनरावृत्त कोड लिखते समय और अधिक उपयोगी हो सकती है, लेकिन स्कैला में इतनी सारी छिपी हुई विशेषताएं दिखाई देती हैं कि मैं सोच रहा था कि किसी के पास इसका आसान समाधान है या नहीं।

Answer 1

आप lift सकता है एक आंशिक Any से Option[A] करने के लिए एक समारोह में A को Any से कार्य करते हैं। तब

def lifted[A](pf: PartialFunction[Any,A]) = pf.lift 

, बनाने के लाभ:

वाक्य रचना अच्छा पहले एक सहायक समारोह को परिभाषित करने के लिए

val f = lifted { 
    case Type(i) => doStuff(i) 
} 

scala> f(2) 
res15: Option[Int] = None 

scala> f(Type(4)) 
res16: Option[Int] = Some(8) 

doStuff विधि केवल यदि तर्क से मेल खाता है बुलाया जाएगा। और आपके पास कई केस क्लॉज हो सकते हैं।

Answer 2

सबसे छोटा रास्ता मैं के बारे में सोच सकते हैं एक विकल्प में मूल्य लपेट और कलेक्ट विधि का उपयोग करने के लिए है:

Option(x).collect { case Type(params) => doStuffWith(params) } 

Answer 3

यह उल्लेख करने के लिए, लिंक है कि @ phant0m दिया का उपयोग करना:

import PartialFunction.condOpt 

condOpt(x){ case Type(params) => doStuffWith(params) } 

Answer 4

इस पैटर्न अपने कोड में अक्सर दिखाई देता है, तो आप Type की एक विधि में doSomeStuff मोड़ पर विचार करना चाहिए। स्कैला में केस क्लास सामान्य कक्षाएं हैं, और जब आप समझ में आते हैं तो आपको ऑब्जेक्ट उन्मुख सुविधाओं का उपयोग करना चाहिए।

अन्यथा, आप अपने पदानुक्रम के शीर्ष पर एक विधि जोड़ सकते हैं, मानते हैं कि आपके सभी केस क्लास एक सामान्य विशेषता का विस्तार करते हैं। उदाहरण के लिए:

class Base { 
    def whenType(f: (T1, T2) => Unit): Unit = this match { 
    case Type(t1, t2) => f(t1, t2) 
    case _ =>() 
    } 
} 

और फिर आप उपयोग कर सकते हैं x whenType doSomeStuff