स्काला को पैटर्न वेरिएबल को रैखिक होने की आवश्यकता होती है, अर्थात पैटर्न चर एक पैटर्न में एक से अधिक बार नहीं हो सकता है। इस प्रकार, यह उदाहरण संकलित नहीं करता है:
def tupleTest(tuple: (Int, Int)) = tuple match {
case (a, a) => a
case _ => -1
}
लेकिन आप समानता की जांच करने के लिए दो पैटर्न चर और एक गार्ड का उपयोग कर सकते हैं:
def tupleTest(tuple: (Int, Int)) = tuple match {
case (a, b) if a == b => a
case _ => -1
}
तो स्केल को रैखिक होने के लिए पैटर्न चर की आवश्यकता क्यों है? क्या ऐसे कोई मामले हैं जिन्हें इस तरह से रूपांतरित नहीं किया जा सकता है?
पहले उदाहरण को दूसरे (स्काला से स्काला) में बदलना आसान है। एक चर की सभी घटनाओं में से v पैटर्न में उन भावों को लें जिन्हें पहले मूल्यांकित किया गया है और इसे चर पर नियत किया गया है v। एक दूसरे की घटना के लिए एक नया चर नाम के साथ पेश किया जाता है जिसे वर्तमान दायरे में उपयोग नहीं किया जाता है। उनमें से प्रत्येक चर के लिए v" एक गार्ड जोड़ें v == v"। यह उसी तरह है जैसे एक प्रोग्रामर (=> समान दक्षता) जाएगा। क्या इस दृष्टिकोण से कोई समस्या है? मैं एक ऐसा उदाहरण देखना चाहता हूं जिसे इस तरह से रूपांतरित नहीं किया जा सकता।
उत्तर:
जवाब के लिए 0 № 1इसलिये case (a, b) मूल रूप से काम कर रहा है val a सेवा मेरे _._1 तथा val b सेवा मेरे _._2 (कम से कम आप इसे उस तरह देख सकते हैं)। के मामले में case (a, a), आप असाइन नहीं कर सकते val a दोनों को _._1 तथा _._2.
वास्तव में आप जिस चीज को करना चाहते हैं, वह ऐसी दिखती होगी
case (a, `a`) => ???
स्कैला एक पहचानकर्ता से मिलान करने के लिए बैकटिक का उपयोग करती है। लेकिन दुर्भाग्य से यह अभी भी दृश्यता के रूप में काम नहीं करता है a के बाद ही दिया जाता है => (हालांकि मज़ा आया होगा, मुझे लेखन से भी नफरत है case (a, b) if a = b =>)। और इसका कारण शायद सिर्फ इसलिए है कि ऐसा कंपाइलर लिखना कठिन है जो इसका समर्थन करता है