स्कैला "<-" समझ के लिए

Question

मुझे पता चला है कि स्कैला के पास हमेशा कुछ भी "प्राकृतिक स्पष्टीकरण" होता है। हमेशा कुछ "ओह," लेकिन यह सिर्फ इस पर एक समारोह कहा जाता है और उस वस्तु के साथ और उस पैरामीटर "। एक मायने में, वास्तव में कुछ भी कंपाइलर-जादू नहीं है क्योंकि हम इसे अन्य भाषाओं से जानते हैं।

0.to(10).foreach((i:Int)=>println(i)) 

:

for(i <- 0 to 10) println(i) 

इस उदाहरण मैं देख सकता हूँ यह की तरह कुछ करने के लिए फिर से लिखा जा रहा है: के रूप में निम्न कोड में इस्तेमाल किया ऑपरेटर -

मेरा प्रश्न < पर है लेकिन यह व्याख्या नहीं करता है कि i को एनन में ले जाया गया foreach समारोह के अंदर ymous समारोह। उस बिंदु पर जहां आप i लिखते हैं, यह एक ऑब्जेक्ट नहीं है, और अभी तक घोषित चर नहीं है। तो यह क्या है, और यह कैसे foreach के अंदर ले जाया जा रहा है?

मेरा अनुमान है कि मैं अंत में कुछ है जो इस तथ्य संकलक जादू

अपने समय के लिए धन्यवाद में है की खोज की है।

स्पष्ट करने के लिए, मेरे सवाल यह है: कैसे < है - कोड के 1 लाइन में ऑपरेटर काम के बाद से मैं एक वस्तु है जिस पर वह एक समारोह के रूप कहा जा सकता है नहीं है।

Answer 1

<- एक भाषा है परिभाषित कीवर्ड प्रतीक, जैसा कि => है लेकिन -> (जो परिभाषित प्रतीक है) के विपरीत इसके विपरीत है। चूंकि यह मूल स्कैला व्याकरण का हिस्सा है, इसका उपयोग बाइंडिंग बनाने के लिए किया जा सकता है (आपके उदाहरण में i के लिए) जो कुछ ऐसा है जो उपयोगकर्ता द्वारा परिभाषित संरचनाओं द्वारा नहीं किया जा सकता है।

Answer 2

इस मामले में, यह वास्तव में संकलक जादू का थोड़ा सा है। फ़िल्टर/मानचित्र/फ्लैटमैप फॉर्म के लिए समझ के लिए अनुवाद desugaring का एक विशेष बिट है, अद्यतन के विशेष रूपों के रूपांतरण और लागू विधियों की तरह।

Answer 3

डेव जवाब बढ़ाने के लिए, यहाँ के लिए एक अनुवाद स्कीमा है स्काला भाषा विनिर्देश से '-comprehensions के लिए':

एक समझ for (enums) yield e प्रत्येक प्रगणक enums द्वारा उत्पन्न बंधन के लिए अभिव्यक्ति e मूल्यांकन करता है। एक जनरेटर अनुक्रम हमेशा जनरेटर के साथ शुरू होता है; इसके बाद आगे जनरेटर, मूल्य परिभाषाएं, या गार्ड का अनुसरण किया जा सकता है।

एक जनरेटर p <- ee अभिव्यक्ति से बाइंडिंग का उत्पादन करता है जो पैटर्न p पैटर्न के विरुद्ध किसी तरह से मेल खाता है। एक मूल्य परिभाषा val p = e अभिव्यक्ति का मूल्यांकन करने के परिणामस्वरूप मूल्य नाम p (या पैटर्न p में कई नाम) को बांधता है। एक गार्ड if e में एक बुलियन अभिव्यक्ति है जो गणना की बाध्यकारी को प्रतिबंधित करती है। map, filter, flatMap, और foreach:

जनरेटर और गार्ड की सटीक अर्थ आमंत्रण चार विधियों का को अनुवाद द्वारा परिभाषित किया गया है। इन तरीकों को विभिन्न वाहक प्रकारों के विभिन्न तरीकों से लागू किया जा सकता है।

अनुवाद योजना निम्नानुसार है। पहले चरण में, प्रत्येक जनरेटर p <- e, जहां पी अचूक नहीं है (§8।1) e के प्रकार के लिए द्वारा

p <- e.filter { case p => true; case _ => false } 

फिर बदल दिया जाता है, निम्न नियमों को बार-बार आवेदन किया है जब तक सभी comprehensions सफाया किया गया है कर रहे हैं। के लिए-समझ for (p <- e) yield e0

• एक e.map { case p => e0 } लिए अनुवाद किया है।

• ए-समझ के लिए for (p <- e) e0 का अनुवाद e.foreach { case p => e0 } पर किया गया है।

• ए-समझ के लिए for (p <- e; p0 <- e0 . . .) yield e00, जहां। । । जेनरेटर या गार्ड के एक (संभवतः खाली) अनुक्रम है, का अनुवाद से किया गया है:
  e.flatMap { case p => for (p0 <- e0 . . .) yield e00 }।

• ए-समझ के लिए for (p <- e; p0 <- e0 . . .) e00 कहां है। । । जेनरेटर या गार्ड के एक (संभावित रूप से खाली) अनुक्रम है, का अनुवाद किया गया है:
  e.foreach { case p => for (p0 <- e0 . . .) e00 }।

• एक जनरेटर p <- e एक गार्ड if g के बाद एक भी जनरेटर के लिए अनुवाद किया है:
  p <- e.filter((x1, . . . , xn) => g)
  जहां x1,। । । , xnp के के निशुल्क चर हैं।

• एक जनरेटर p <- e एक मूल्य परिभाषा val p0 = e0 के बाद मूल्यों, जहां x और x0 ताजा नाम हैं के जोड़े की निम्न जनरेटर से अनुवाद किया है:

  val (p, p0) <- 
      for(x@p <- e) yield { val x0@p0 = e0; (x, x0) }