दिलचस्प पोस्ट
एंड्रॉइड हैलो, गैलरी ट्यूटोरियल – "आर। स्टोलेबल का समाधान नहीं किया जा सकता" वेब फॉर्म फ़ील्ड / इनपुट टैग पर आप ब्राउज़र आटोकॉम्पलेट को अक्षम कैसे करते हैं? गतिशील रूप से LINQ ग्रुपिंग 64-बिट के साथ एक 32-बिट लूप गिनती चर को बदलकर पागल प्रदर्शन विचलन का परिचय दिया गया है आयात लाइब्रेरी कैसे काम करती है? विवरण? थोड़ी देर के अंदर बाश में इनपुट पढ़ें जावास्क्रिप्ट से PHP पर JSON डेटा भेजें? PHP में मशीन का आईपी पता है :: 1 लेकिन क्यों? किटकैट के लिए Android 5.0 सामग्री डिज़ाइन शैली नेविगेशन ड्रॉवर कैसे सी में नैन और inf का उपयोग करें? मैं एक Windows सेवा स्थापित करने के लिए एक InstallShield LE प्रोजेक्ट कैसे बनाऊँ? mysql – तारीख की तारीख सीमाओं में दर्ज करें अगर तिथियां मौजूदा लोगों के साथ ओवरलैप नहीं करती हैं सर्वर पक्ष पेजिंग के साथ jqgrid क्लाइंट साइड सॉर्टिंग – डेटा गायब हो जाता है .NET में एक स्ट्रिंग के लिए मैं एक डिफ़ॉल्ट कन्स्ट्रक्टर को परिभाषित क्यों नहीं कर सकता? मनोहर संग्रह: गिनती और खाली पता लगाता है

समझ के लिए स्कला पर बेमेल टाइप करें

यह निर्माण स्काला में एक प्रकार बेमेल त्रुटि क्यों पैदा करता है?

for (first <- Some(1); second <- List(1,2,3)) yield (first,second) <console>:6: error: type mismatch; found : List[(Int, Int)] required: Option[?] for (first <- Some(1); second <- List(1,2,3)) yield (first,second) 

अगर मैं सूची के साथ कुछ स्विच करता हूँ तो यह ठीक संकलित करता है:

 for (first <- List(1,2,3); second <- Some(1)) yield (first,second) res41: List[(Int, Int)] = List((1,1), (2,1), (3,1)) 

यह भी ठीक काम करता है:

 for (first <- Some(1); second <- Some(2)) yield (first,second) 

वेब के समाधान से एकत्रित समाधान "समझ के लिए स्कला पर बेमेल टाइप करें"

समझने के लिए map या flatMap विधि को कॉल में परिवर्तित किया जाता है। उदाहरण के लिए यह एक:

 for(x <- List(1) ; y <- List(1,2,3)) yield (x,y) 

यह हो जाता है:

 List(1).flatMap(x => List(1,2,3).map(y => (x,y))) 

इसलिए, पहले लूप मूल्य (इस मामले में, List(1) ) को flatMap विधि कॉल प्राप्त होगा। चूंकि List पर flatMap दूसरी List देता है, समझने के लिए इसका परिणाम निश्चित रूप से एक List । (यह मेरे लिए नया था: समझ के लिए हमेशा धाराओं का परिणाम नहीं होता है, यह भी जरूरी नहीं कि Seq s।)

अब, देखें कि कैसे flatMap को Option में घोषित किया गया है:

 def flatMap [B] (f: (A) ⇒ Option[B]) : Option[B] 

इसे ध्यान में रखो। आइए देखते हैं समझने के लिए कितने गलत ( Some(1) साथ एक नक्शे के अनुक्रम में बदल जाता है:

 Some(1).flatMap(x => List(1,2,3).map(y => (x, y))) 

अब, यह देखना आसान है कि flatMap कॉल का पैरामीटर कुछ ऐसा होता है जो एक List देता है, लेकिन एक Option नहीं, जैसा कि आवश्यक है

इस बात को ठीक करने के लिए, आप निम्न कार्य कर सकते हैं:

 for(x <- Some(1).toSeq ; y <- List(1,2,3)) yield (x, y) 

यह सिर्फ ठीक है संकलन। यह ध्यान देने योग्य है कि Option Seq का एक उपप्रकार नहीं है, जैसा कि अक्सर माना जाता है।

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

यदि आप सूची प्रकार का परिणाम चाहते हैं, तो आपको एक सूची जनरेटर के साथ शुरू करना चाहिए।

यह प्रतिबंध क्यों नहीं मानता है कि आप हमेशा किसी क्रम के अनुक्रम चाहते हैं? आप ऐसी स्थिति बना सकते हैं जहां Option वापस करने में समझ में आता है। शायद आपके पास एक Option[Int] जिसे आप Option[List[Int]] प्राप्त करने के लिए कुछ के साथ जोड़ना चाहते हैं, निम्न फ़ंक्शन के साथ कहें: (i:Int) => if (i > 0) List.range(0, i) else None ; तब आप इसे लिख सकते हैं और कोई नहीं प्राप्त कर सकते हैं जब चीजें "भावना" नहीं करती हैं:

 val f = (i:Int) => if (i > 0) Some(List.range(0, i)) else None for (i <- Some(5); j <- f(i)) yield j // returns: Option[List[Int]] = Some(List(0, 1, 2, 3, 4)) for (i <- None; j <- f(i)) yield j // returns: Option[List[Int]] = None for (i <- Some(-3); j <- f(i)) yield j // returns: Option[List[Int]] = None 

सामान्य मामलों में समझ के लिए कैसे विस्तारित किया जाता है, वास्तव में एक प्रकार की वस्तु M[T] उद्देश्य M[T] (T) => M[U] के साथ एक प्रकार के M[U] प्रकार के ऑब्जेक्ट को प्राप्त करने के लिए एक सामान्य सामान्य तंत्र है। आपके उदाहरण में, एम विकल्प या सूची हो सकती है। सामान्य तौर पर इसे एक ही प्रकार M होना चाहिए। तो आप सूची के साथ विकल्प को जोड़ नहीं सकते अन्य चीजों के उदाहरणों के लिए, जो M , इस विशेषता के उप-वर्गों को देखें

List[T] संयोजन क्यों किया (T) => Option[T] काम करते हुए भी जब आपने सूची से शुरुआत की? इस मामले में लाइब्रेरी एक अधिक सामान्य प्रकार का उपयोग करती है जहां यह समझ में आता है। तो आप ट्रैवर्सबल के साथ सूची को जोड़ सकते हैं और ऑप्शन से ट्रेवर्सबल तक एक अंतर्निहित रूपांतरण है।

निचली रेखा यह है: इस बारे में सोचें कि किस तरह आप वापस आने के लिए अभिव्यक्ति चाहते हैं और उस प्रकार से पहले जनरेटर के रूप में शुरू करें यदि आवश्यक हो तो उसे उस प्रकार लपेटें

संभवत: विकल्प के साथ कुछ ऐसा करने का विकल्प होता है, जो एक योग्य नहीं है निहित Option.option2IterableOption.option2Iterable ऐसे मामले को संभाल लेंगे जहां कंपाइलर द्वितीय होने की उम्मीद कर रहा है Iterable मुझे उम्मीद है कि संकलक जादू लूप चर के प्रकार के आधार पर अलग है।