दिलचस्प पोस्ट
स्विफ्ट का इस्तेमाल करते हुए तालिका दृश्य में छवियों के आलसी लोडिंग को कैसे लागू किया जाए उत्पादन बफरिंग क्या है? क्यू में वादों की एक चर संख्या को कैसे क्रमबद्ध करना है? एडीबी का उपयोग करते समय मुझे डेटा फ़ोल्डर से प्रवेश का खंडन क्यों मिलता है? अनाम तरीकों (सी # 2.0) और लैम्ब्डा भाव (सी # 3.0) के बीच अंतर क्या है? पायथन: यूआरएलआरआर: <urlopen त्रुटि कैसे एक रैक कार्य के लिए कमांड लाइन तर्क को पारित करने के लिए पायथन 3 प्रकार त्रुटि: sys.stdout.write () के साथ बाइट नहीं होना चाहिए। Aptana स्टूडियो 3 में jQuery का समर्थन कैसे सक्षम करें जाओ और Node.js HTTP सर्वर के साथ एक एकल कुकी सेट करें OnItemClickListener चेकबॉक्स के साथ काम नहीं कर रहा था? Regex के साथ केवल कुछ समूह बदलें अजगर का समर्थन करता है multithreading? क्या यह निष्पादन समय गति कर सकता है? यदि वादा में दूसरा प्रवाह (ब्लूबर्ड) त्रुटि जाँच के लिए रूपांतरण समारोह अच्छा माना जाता है?

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

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

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) 

Solutions Collecting From Web of "समझ के लिए स्कला पर बेमेल टाइप करें"

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