दिलचस्प पोस्ट
थोड़े से स्वैप () के उदाहरण जब एक बुरा विचार है? स्विफ्ट में NS_OPTIONS- शैली बिटमैस्क एन्यूमरेशन कैसे बनाएं? html एक समूह में केवल एक चेकबॉक्स का चयन करें संघ, एकत्रीकरण और संरचना के बीच अंतर क्या है? WPF के साथ एक लॉग दर्शक लागू करना कोणीय – वादे बनाम अवलोकन खारिज करें ModalViewController और पास डेटा वापस क्या मुझे std :: function या C ++ में फ़ंक्शन पॉइंटर का उपयोग करना चाहिए? मैं एएसपी.नेट एमवीसी में अपना वेबएप का मूल यूआरएल कैसे प्राप्त करूं? मैं टच सक्षम ब्राउज़र में एक स्पर्श के साथ एक मंडराना कैसे अनुकरण करूं? User_id के साथ Google+ प्रोफ़ाइल चित्र url प्राप्त करना अजगर बाध्य और अनबाउंड विधि ऑब्जेक्ट कैसे एसडी कार्ड पर निर्देशिका स्वचालित रूप से बनाने के लिए जांचें कि पंक्ति mysql के साथ मौजूद है या नहीं स्व संदर्भित संरचना परिभाषा?

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

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

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 मुझे उम्मीद है कि संकलक जादू लूप चर के प्रकार के आधार पर अलग है।