स्काला के पैटर्न मिलान प्रणाली में तुलना ऑपरेटरों का उपयोग करना

Question

क्या स्काला में पैटर्न मिलान प्रणाली के उपयोग से तुलना संभव है? उदाहरण के लिए:

a match {
    case 10 => println("ten")
    case _ > 10 => println("greater than ten")
    case _ => println("less than ten")
}

दूसरा मामला बयान अवैध है, लेकिन मैं "जब एक से अधिक है" निर्दिष्ट करने में सक्षम होना चाहूंगा।

Comments

इसका उपयोग यह जांचने के लिए भी किया जा सकता है कि क्या कोई फ़ंक्शन सही का मूल्यांकन करता है, उदाहरण के लिएcase x if x.size > 2 => ...

— टेंटनर

समझने के लिए महत्वपूर्ण बात यह है कि => ऑपरेटर के बाईं ओर "पैटर्न" वास्तव में "पैटर्न" हैं। आपके पास पहले मामले की अभिव्यक्ति में 10 पूर्णांक शाब्दिक नहीं है। इसलिए, आप ऑपरेशन नहीं कर सकते हैं (जैसे> चेक करें या कहें कि फ़ंक्शन एप्लिकेशन isOdd (_)) बाईं ओर है।

— उस्मान संगट

Answer 1

आप ifपैटर्न के बाद एक गार्ड, और एक बूलियन अभिव्यक्ति जोड़ सकते हैं :

a match {
    case 10 => println("ten")
    case x if x > 10 => println("greater than ten")
    case _ => println("less than ten")
}

संपादित करें: ध्यान दें कि यह एक से अधिक अल्पज्ञता एक डाल करने के लिए अलग है if के बाद=> , क्योंकि एक पैटर्न नहीं होगा अगर गार्ड सच नहीं है से मेल खाते हैं।

Comments

बेन, अच्छा जवाब, यह वास्तव में पैटर्न गार्ड के महत्व को दर्शाता है।

— जेएफवी

Answer 2

प्रश्न की भावना के गैर-उत्तर के रूप में, जिसने पूछा कि कैसे एक मैच क्लॉज में विधेय को शामिल किया जाए, इस मामले में विधेय को इससे पहले ही स्पष्ट किया जा सकता है match:

def assess(n: Int) {
  println(
    n compare 10 match {
      case 0 => "ten"
      case 1 => "greater than ten"
      case -1 => "less than ten"
    })
}

अब, केवल वादे के लिए प्रलेखनscala.math.Ordering.compare(T, T) कि गैर-समान परिणाम शून्य से अधिक या कम होंगे । जावा का Comparable#compareTo(T)स्केल के समान ही निर्दिष्ट किया गया है। यह सकारात्मक और नकारात्मक मूल्यों के लिए क्रमशः 1 और 1 का उपयोग करने के लिए पारंपरिक रूप से होता है, जैसा कि स्काला का वर्तमान कार्यान्वयन करता है, लेकिन कोई कार्यान्वयन के कुछ जोखिम के बिना इस तरह की धारणा नहीं बना सकता है।

Comments

मुझे यकीन नहीं है कि यदि आप इसे एक वास्तविक समाधान के रूप में सुझा रहे हैं, लेकिन मैं किसी भी चीज के खिलाफ जोरदार सिफारिश करूंगा जो एक अनिर्दिष्ट सम्मेलन या धारणा पर निर्भर है।

— बेन जेम्स

बिल्कुल सही। इसीलिए मैंने लिखा "कोई बिना किसी जोखिम के ऐसी धारणा नहीं बना सकता", और मेरे जवाब को "गैर-उत्तर" के रूप में योग्य बनाया। यह दिलचस्प है कि क्यों compare() और compareTo()उनके कोडोमैन के रूप में 0, 1 और -1 निर्दिष्ट न करें।

— सेह

Math.signum (n 10 की तुलना करें) -1, 0 या 1. की गारंटी देगा

— रिचज

आज सुबह मैंने पुष्टि की कि मेरा मूल उत्तर लिखने के लगभग छह साल बाद, भले ही प्रश्न का कार्यान्वयन एक प्रकार से दूसरे में चला गया हो, स्काला अभी भी -1, 0 या 1 लौटने के विख्यात व्यवहार को बनाए रखती है

— seh

एक मान्य उत्तर, लेकिन व्यक्तिगत रूप से मुझे यह पसंद नहीं है। यह भूल जाना बहुत आसान है कि 0,1, और -1 का क्या मतलब है।

— DanGordon

Answer 3

एक उपाय जो मेरी राय में गार्ड जोड़ने से बहुत अधिक पठनीय है:

(n compare 10).signum match {
    case -1 => "less than ten"
    case  0 => "ten"
    case  1 => "greater than ten"
}

टिप्पणियाँ:

• Ordered.compareएक नकारात्मक पूर्णांक लौटाता है अगर यह उससे कम है, सकारात्मक यदि अधिक है, और 0यदि बराबर है।
• Int.signumसे उत्पादन को संपीड़ित compareकरने के लिए -1एक नकारात्मक संख्या (10 से कम) के लिए, 1सकारात्मक के लिए (10 से अधिक), या 0शून्य के लिए (10 के बराबर)।

Answer 4

यद्यपि उपरोक्त सभी और बलो उत्तर मूल प्रश्न का पूरी तरह से उत्तर देते हैं, कुछ अतिरिक्त जानकारी दस्तावेज़ीकरण https://docs.scala-lang.org/tour/pattern-matching.html पर देखी जा सकती है , वे मेरे मामले में फिट नहीं हुए लेकिन चूँकि यह स्टैकओवरफ़्लो उत्तर Google में पहला सुझाव है, मैं अपने उत्तर को पोस्ट करना चाहूँगा जो कि उपरोक्त प्रश्न का एक कोना है।
मेरा सवाल यह है कि:

• किसी फ़ंक्शन के तर्क के साथ मैच अभिव्यक्ति में गार्ड का उपयोग कैसे करें?

जो पैराफ्रेस्ड हो सकता है:

• किसी फ़ंक्शन के तर्क के साथ मैच अभिव्यक्ति में एक बयान का उपयोग कैसे करें?

जवाब नीचे दिए गए कोड का उदाहरण है:

    def drop[A](l: List[A], n: Int): List[A] = l match {
      case Nil => sys.error("drop on empty list")
      case xs if n <= 0 => xs
      case _ :: xs => drop(xs, n-1)
    }

scala fiddle का लिंक: https://scalafiddle.io/sf/G37THif/2 जैसा कि आप देख सकते हैं कि case xs if n <= 0 => xsस्टेटमेंट गार्ड (यदि) स्टेटमेंट के साथ n (किसी फ़ंक्शन का तर्क) का उपयोग करने में सक्षम है।

मुझे उम्मीद है कि इससे मेरे जैसे किसी को मदद मिलेगी।