दिलचस्प पोस्ट
जैक्सन JSON के साथ किसी स्ट्रिंग, स्ट्रिंग> को JSON स्ट्रिंग को मैप में कनवर्ट कैसे करें सी में तार करने के लिए enum नाम कन्वर्ट करने के लिए कैसे XCode में EXC_BAD_ACCESS को तोड़ दिया? रैंडम कैसे है System.Guid.NewGuid ()? क्या यह सी फ़िशर-येट्स फेरबदल सही है? Regex का उपयोग कर अवांछित पात्रों के लिए स्ट्रिंग फ़िल्टर कैसे करें? एक ही समाधान में log4net के 2 अलग-अलग संस्करणों का संदर्भ देता है क्या मैं विजुअल स्टूडियो में डिबगिंग करते समय लौटने से पहले रिटर्न वेल्यू का पता लगा सकता हूँ? एक स्थानांतरित पैटर्न के लिए एक स्ट्रिंग से बचें मैं Excel में कैसे निर्यात करूं? IEnumerable में कोई गणना विधि नहीं है कैसे घटाएँ / दिन से / दिन से जोड़ें? छवि के पहलू अनुपात को बनाए रखते हुए आप <div> को भरने के लिए एक छवि कैसे बढ़ाएं? git-svn: `svn स्विच –relocate` के समतुल्य क्या है? एंड्रॉइड 4.4 में वास्तविक पथ में कन्वर्ट सामग्री: // यूआरआई

स्काला में एक मैनिफ़ेस्ट क्या है और आपको इसकी आवश्यकता कब है?

स्कला 2.7.2 के बाद से Manifest नाम की कुछ चीज है जो जावा के प्रकार के विलोपन के लिए एक वैकल्पिक हल है। लेकिन वास्तव में कार्य कैसे Manifest होता है और आपको इसका उपयोग कब करने की आवश्यकता है?

ब्लॉग पोस्ट मैनिफेस्ट्स: जॉर्ज ऑर्टिज़ द्वारा रिफ़ीर्ड टाइप्स में से कुछ बताते हैं, लेकिन यह संदर्भ सीमा के साथ इसका उपयोग कैसे करें इसका वर्णन नहीं करता है।

इसके अलावा, ClassManifest क्या है, ClassManifest में क्या अंतर है?

मेरे पास कुछ कोड है (एक बड़ा प्रोग्राम का हिस्सा, इसमें आसानी से शामिल नहीं किया जा सकता है) जिसमें कुछ चेतावनियां टाइप की गई हैं जो कि मिटाए हुए हैं; मुझे संदेह है कि मैं मैनिफ़ेस्ट्स का उपयोग करके इन्हें हल कर सकता हूं, लेकिन मुझे यकीन नहीं है कि वास्तव में कैसे।

वेब के समाधान से एकत्रित समाधान "स्काला में एक मैनिफ़ेस्ट क्या है और आपको इसकी आवश्यकता कब है?"

कंपाइलर के बारे में अधिक जानकारी के बारे में अधिक जानकारी JVM runtime आसानी से प्रतिनिधित्व कर सकती है। एक मैनिफ़ेस्ट संकलक के लिए रन-टाइम पर कोड को इंटर-डायमेंटल संदेश भेजने के लिए एक रास्ता है जो कि प्रकार की जानकारी खो गया था।

यह कैप्टनियन लोगों ने जीवाश्म रिकॉर्ड और मनुष्यों के "जंक" डीएनए में एन्कोडेड संदेशों को छोड़ दिया है, रोशनी वाले और गुरुत्वाकर्षण अनुनाद क्षेत्रों की सीमाओं के कारण, वे सीधे संपर्क करने में असमर्थ हैं। लेकिन, यदि आप अपने सिग्नल में कैसे ट्यून करते हैं, तो आप उन तरीकों से लाभ उठा सकते हैं जिनसे आप कल्पना नहीं कर सकते, यह तय करने से कि दोपहर के भोजन के लिए क्या खाना है या कौन से लोट्टो नंबर खेलना है।

यह स्पष्ट नहीं है कि अगर कोई मैनिफेस्ट आपको अधिक विवरणों के बिना देखे हुए त्रुटियों का लाभ उठाएगा।

मैनिफेस्ट्स का एक सामान्य उपयोग यह है कि आपका कोड संग्रह के स्थिर प्रकार के आधार पर अलग तरह से व्यवहार करता है। उदाहरण के लिए, यदि आप एक सूची [स्ट्रिंग] को अन्य प्रकार की सूची से अलग तरह से व्यवहार करना चाहते हैं:

  def foo[T](x: List[T])(implicit m: Manifest[T]) = { if (m <:< manifest[String]) println("Hey, this list is full of strings") else println("Non-stringy list") } foo(List("one", "two")) // Hey, this list is full of strings foo(List(1, 2)) // Non-stringy list foo(List("one", 2)) // Non-stringy list 

इसके लिए एक प्रतिबिंब-आधारित समाधान शायद सूची के प्रत्येक तत्व का निरीक्षण करना शामिल होगा।

एक संदर्भ बाक्स स्काला में टाइप-क्लासेस का उपयोग करने के लिए सबसे अनुकूल लगता है, और इसे डेबिश घोष द्वारा समझाया गया है: http://debasishg.blogspot.com/2010/06/scala-implicits-type-classes-here-i.html

संदर्भ सीमा भी केवल विधि हस्ताक्षर को और भी पठनीय बना सकते हैं। उदाहरण के लिए, उपर्युक्त कार्य को इस तरह से संदर्भ सीमा का उपयोग करके फिर से लिखा जा सकता है:

  def foo[T: Manifest](x: List[T]) = { if (manifest[T] <:< manifest[String]) println("Hey, this list is full of strings") else println("Non-stringy list") } 

पूरा जवाब नहीं है, लेकिन Manifest और ClassManifest बीच के अंतर के बारे में, आप स्काला 2.8 Array पेपर में एक उदाहरण पा सकते हैं:

केवल शेष प्रश्न यह है कि कैसे सामान्य सरणी निर्माण को कार्यान्वित किया जाए। जावा के विपरीत, स्काला एक उदाहरण सृजन को नए Array[T] अनुमति देता है जहां T एक प्रकार का पैरामीटर है। यह कैसे लागू किया जा सकता है, तथ्य यह है कि जावा में एक समान सरणी प्रस्तुति मौजूद नहीं है?

ऐसा करने का एकमात्र तरीका है अतिरिक्त रनटाइम जानकारी की आवश्यकता है जो टाइप T वर्णन करता है स्काला 2.8 में इसके लिए एक नई तंत्र है, जिसे मैनिफेस कहा जाता है। प्रकार की एक वस्तु Manifest[T] प्रकार T बारे में पूरी जानकारी प्रदान करता है
Manifest मान आम तौर पर अंतर्निहित पैरामीटर में पारित किए जाते हैं; और संकलक जानता है कि कैसे उन्हें स्थैतिक रूप से ज्ञात प्रकार T लिए निर्माण करना है

ClassManifest नाम का एक कमजोर रूप भी मौजूद है, जिसे बिना किसी प्रकार के शीर्ष-स्तरीय वर्ग को जानने से भी बनाया जा सकता है, बिना सभी प्रकार के तर्कों को जानने के
यह ऐसी क्रम प्रकार की जानकारी है जो सरणी निर्माण के लिए आवश्यक है।

उदाहरण:

किसी को एक ClassManifest[T] को एक अन्तर्निहित पैरामीटर के रूप में विधि में पास करके यह जानकारी प्रदान करने की आवश्यकता है:

 def tabulate[T](len:Int, f:Int=>T)(implicit m:ClassManifest[T]) = { val xs = new Array[T](len) for (i <- 0 until len) xs(i) = f(i) xs } 

एक लघुकथा रूप के रूप में, संदर्भ बाउंड 1 का इस्तेमाल इसके बजाय पैरामीटर T पर किया जा सकता है,

( चित्रण के लिए इस तरह के प्रश्न देखें)

, दे:

 def tabulate[T: ClassManifest](len:Int, f:Int=>T) = { val xs = new Array[T](len) for (i <- 0 until len) xs(i) = f(i) xs } 

जब एक प्रकार जैसे Int , या String , या List[T] पर टेब्लेट को कॉल करता है, तो स्काला कंपाइलर एक क्लास मैनिफेस्ट बना सकता है जो टैबलेट के लिए अंतर्निहित तर्क को पारित करता है।

एक मैनिफ़ेस्ट जेनेरिक प्रकारों को संशोधित करने का इरादा था जो कि जेवीएम (जो जेनेटिक्स का समर्थन नहीं करता) पर चलने के लिए टाइप-मिटे गए हैं। हालांकि, उनके पास कुछ गंभीर समस्याएं थीं: वे बहुत सरल थे, और स्काला के प्रकार प्रणाली को पूरी तरह से समर्थन करने में असमर्थ थे। इस प्रकार उन्हें स्काला 2.10 में पदावनत किया गया था, और TypeTag एस के साथ प्रतिस्थापित किया गया TypeTag (जो अनिवार्य रूप से स्कला संकलक ही प्रकार के प्रतिनिधित्व करने के लिए उपयोग करता है, और इसलिए पूर्ण रूप से स्काला प्रकारों का समर्थन करता है)। अंतर के बारे में अधिक जानकारी के लिए, देखें:

  • स्कला: टाइपटैग क्या है और मैं इसका उपयोग कैसे करूं?
  • नए स्कला टाइपटैग (नापसंद) मैनिफेस्ट्स में सुधार कैसे करते हैं?

दूसरे शब्दों में

आपको इसकी आवश्यकता कब होती है?

2013-01-04 से पहले, जब स्काला 2.10 जारी किया गया था ।

चलो भी scala स्रोतों ( Manifest.scala . scala ) में Manifest.scala , हम देखते हैं:

 Manifest.scala: def manifest[T](implicit m: Manifest[T]) = m 

तो निम्नलिखित उदाहरण कोड के संबंध में:

 def foo[A](somelist: List[A])(implicit m: Manifest[A]): String = { if (m <:< manifest[String]) { "its a string" } else { "its not a string" } } 

हम देख सकते हैं कि manifest function एक अन्तर्निहित m: Manifest[T] लिए खोज function m: Manifest[T] जो आपके type parameter उदाहरण प्रदान करता है जो हमारे उदाहरण कोड में प्रदान करता है, यह manifest[String] इसलिए जब आप कुछ ऐसे कॉल करते हैं:

 if (m <:< manifest[String]) { 

आप जांच रहे हैं कि वर्तमान implicit m जो आपने अपने फ़ंक्शन में परिभाषित किया है, प्रकार का manifest[String] और जैसा कि manifest एक प्रकार का manifest[T] यह एक विशिष्ट manifest[String] लिए खोज करेगा और इसे वहां मिलेगा ऐसा निहित है