दिलचस्प पोस्ट
$ (दस्तावेज़) .click () iPhone पर सही ढंग से काम नहीं कर रहा है jquery MySQL: ALTER IGNORE TABLE "अखंडता बाधा उल्लंघन" देता है PHP में ऑपरेटर के साथ त्रुटि दबाएं पायथन में युग (यूनिक्स टाइम) के बाद से मैं डेटेट ऑब्जेक्ट को मिलीसेकंड में कैसे रूपांतरित कर सकता हूं? एचटीएमएल – पेज को रिफ्रेश किए बिना \ पेज पेज अपडेट करें \ पेज पुनः लोड हो रहा है कैसे जाँचें कि क्या स्ट्रिंग में केवल जावा में अंक होते हैं छवि को ग्रेस्केल में कनवर्ट करें UITextView के अंदर UIScrollView AutoLayout के साथ .पीआईडी ​​फ़ाइल क्या है और इसमें क्या शामिल है? UITableViewCell का UITextField उपविजेता, सेल का सूचकांक प्राप्त करें यादृच्छिक संख्या लेकिन दोहराएं मत Excel फ़ाइलों के साथ काम करने के लिए एक साधारण और विश्वसनीय सी पुस्तकालय क्या है? UIView नीचे सीमा? क्या आप यह निर्धारित कर सकते हैं कि क्रोम एक स्क्रिप्ट के माध्यम से गुप्त मोड में है? मूल्यों के बीच रिक्त स्थान के बिना चर को कैसे मुद्रित करें

स्काला में किस प्रकार की कक्षाएं उपयोगी हैं?

जैसा कि मैं इस ब्लॉग पोस्ट से समझता हूं "स्काला में टाइप क्लासेस" केवल लक्षणों और अंतर्निहित एडाप्टर के साथ लागू एक "पैटर्न" है

जैसा कि ब्लॉग कहता है कि मेरे पास गुण A और एडेप्टर B -> A तो मैं एक फ़ंक्शन का उपयोग कर सकता हूं, जिसके लिए टाइप A तर्क की आवश्यकता होती है, इस एडेप्टर को बिना किसी प्रकार के प्रकार के तर्क के साथ स्पष्ट रूप से

मुझे यह अच्छा लगा लेकिन विशेष रूप से उपयोगी नहीं मिला क्या आप उपयोग केस / उदाहरण दे सकते हैं, जो बताता है कि यह सुविधा किसके लिए उपयोगी है?

Solutions Collecting From Web of "स्काला में किस प्रकार की कक्षाएं उपयोगी हैं?"

एक उपयोग केस, जैसा कि अनुरोध किया गया है …

कल्पना कीजिए कि आपके पास चीजों की एक सूची है, पूर्णांक हो सकती है, फ्लोटिंग प्वाइंट नंबर, मैट्रिक्स, स्ट्रिंग्स, वेवफॉर्म्स आदि। इस सूची को देखते हुए, आप सामग्री जोड़ना चाहते हैं

ऐसा करने का एक तरीका कुछ Addable लक्षण है जिसे एक साथ जोड़ दिया जा सकता है, या जोड़कर एक अनन्य रूपान्तरण के लिए किसी भी तीसरे पक्ष की लाइब्रेरी से वस्तुओं से निपटने के लिए जो एक साथ जोड़ा जा सकता है, जिसे आप अंतरफलक के लिए Addable नहीं कर सकते ।

यह दृष्टिकोण तेजी से भारी हो जाता है जब आप ऐसे अन्य कार्यों को जोड़ना शुरू करना चाहते हैं जिन्हें ऑब्जेक्ट की सूची में किया जा सकता है। यदि आपको विकल्प की जरूरत है तो यह अच्छी तरह से काम नहीं करता है (उदाहरण के लिए, दो तरंगों को जोड़ना, उन्हें जोड़ना या उन्हें ओवरले करना है?) समाधान है तदर्थ पोलीमॉफिज़्म, जहां आप चुन सकते हैं और मौजूदा प्रकारों को पुन:

मूल समस्या के लिए, आप एक Addable type class को लागू कर सकते हैं:

 trait Addable[T] { def zero: T def append(a: T, b: T): T } //yup, it's our friend the monoid, with a different name! 

इसके बाद आप इसके अंतर्निहित सबवॉस्क्स्ड उदाहरण बना सकते हैं, प्रत्येक प्रकार के लिए जो आप जोड़ना चाहते हैं:

 implicit object IntIsAddable extends Addable[Int] { def zero = 0 def append(a: Int, b: Int) = a + b } implicit object StringIsAddable extends Addable[String] { def zero = "" def append(a: String, b: String) = a + b } //etc... 

एक सूची जमा करने की विधि लिखने के लिए तुच्छ बन जाता है …

 def sum[T](xs: List[T])(implicit addable: Addable[T]) = xs.FoldLeft(addable.zero)(addable.append) //or the same thing, using context bounds: def sum[T : Addable](xs: List[T]) = { val addable = implicitly[Addable[T]] xs.FoldLeft(addable.zero)(addable.append) } 

इस दृष्टिकोण की सुंदरता यह है कि आप कुछ प्रकार के वर्ग की एक वैकल्पिक परिभाषा की आपूर्ति कर सकते हैं, या तो आयात के माध्यम से आपके द्वारा आवेशित गुंजाइश को नियंत्रित कर सकते हैं या स्पष्ट रूप से अन्यथा अंतर्निहित तर्क प्रदान कर सकते हैं। इसलिए तरंगों को जोड़ने के विभिन्न तरीकों को प्रदान करना संभव है, या पूर्णांक जोड़ के लिए मॉड्यूलो अंकगणित निर्दिष्ट करना संभव है। यह भी एक प्रकार का कोई तृतीय-पक्षीय पुस्तकालय से अपने प्रकार वर्ग में जोड़ने के लिए काफी दर्द रहित है

संयोग से, यह वास्तव में 2.8 संग्रह एपीआई द्वारा लिया गया दृष्टिकोण है। यद्यपि sum विधि TraversableLike पर परिभाषित List , बजाय List पर, और प्रकार वर्ग Numeric (इसमें zero से अधिक कुछ परिचालन भी शामिल zero और append )

वहाँ पहली टिप्पणी फिर से पढ़ें:

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

मुझे लगता है कि यह प्रकार वर्गों का सबसे महत्वपूर्ण लाभ है।

साथ ही, वे ठीक से मामलों को संभालते हैं जहां ऑपरेशन के प्रकार का तर्क नहीं होता है, जिसे हम भेज रहे हैं, या एक से अधिक हैं। उदाहरण के लिए इस प्रकार के वर्ग पर विचार करें:

 case class Default[T](val default: T) object Default { implicit def IntDefault: Default[Int] = Default(0) implicit def OptionDefault[T]: Default[Option[T]] = Default(None) ... } 

मैं टाइप वर्गों को वर्ग में सुरक्षित मेटाडेटा जोड़ने की क्षमता के रूप में सोचता हूं।

तो आप सबसे पहले समस्या डोमेन को मॉडल के लिए एक क्लास को परिभाषित करते हैं और उसके बाद मेटाडाटा को जोड़ने के लिए सोचें। बराबर, हाशनीय, देखने योग्य, आदि जैसी चीजें यह समस्या डोमेन और मशीनीकरण को कक्षा का उपयोग करने के लिए अलग बनाता है और उप-क्लासेस को खोलता है क्योंकि क्लास लयनर है।

इसके अलावा, आप वर्ग में कहीं भी टाइप वर्ग जोड़ सकते हैं, न कि कक्षा को परिभाषित किया गया है और आप लागूकरण बदल सकते हैं। उदाहरण के लिए, यदि मैं प्वाइंट # हैशोडोड का उपयोग करके प्वाइंट क्लास के लिए एक हैश कोड की गणना करता हूं, तो मैं उस विशिष्ट क्रियान्वयन तक सीमित हूं जो कि मेरे पास विशिष्ट बिंदुओं के सेट के लिए मानों का अच्छा वितरण नहीं बना सकता है। लेकिन अगर मैं हाशनीय [बिंदु] का उपयोग करता हूं, तो मैं अपना स्वयं का कार्यान्वयन प्रदान कर सकता हूं।

[उदाहरण के साथ अपडेट किया गया] उदाहरण के तौर पर, यहां एक उपयोग का मामला है, जो पिछले सप्ताह था। हमारे उत्पाद में मूल्य के रूप में कंटेनरों वाले मानचित्र के कई मामले हैं उदाहरण के लिए, Map[Int, List[String]] या Map[String, Set[Int]] इन संग्रहों को जोड़ना शब्दशः हो सकता है:

 map += key -> (value :: map.getOrElse(key, List())) 

इसलिए मुझे ऐसा फ़ंक्शन मिलना है जो इसको छुपाता है इसलिए मैं लिख सकता हूं

 map +++= key -> value 

मुख्य मुद्दा यह है कि तत्वों को जोड़ने के लिए संग्रह में सभी एक ही तरीके नहीं होते हैं कुछ में '+' जबकि अन्य ':' मैं एक सूची में तत्वों को जोड़ने की क्षमता भी बरकरार रखना चाहता था, इसलिए मैं नया संग्रह बनाने वाले गुना / मैप का उपयोग नहीं करना चाहता था।

समाधान प्रकार वर्गों का उपयोग करना है:

  trait Addable[C, CC] { def add(c: C, cc: CC) : CC def empty: CC } object Addable { implicit def listAddable[A] = new Addable[A, List[A]] { def empty = Nil def add(c: A, cc: List[A]) = c :: cc } implicit def addableAddable[A, Add](implicit cbf: CanBuildFrom[Add, A, Add]) = new Addable[A, Add] { def empty = cbf().result def add(c: A, cc: Add) = (cbf(cc) += c).result } } 

यहां मैंने एक प्रकार का वर्ग Addable परिभाषित किया जो एक संग्रह सी को एक संग्रह सी में जोड़ सकते हैं। मेरे पास 2 डिफ़ॉल्ट कार्यान्वयन हैं: लिस्ट के लिए :: और अन्य संग्रह के लिए, बिल्डर फ्रेमवर्क का उपयोग कर।

फिर इस प्रकार वर्ग का उपयोग करना है:

 class RichCollectionMap[A, C, B[_], M[X, Y] <: collection.Map[X, Y]](map: M[A, B[C]])(implicit adder: Addable[C, B[C]]) { def updateSeq[That](a: A, c: C)(implicit cbf: CanBuildFrom[M[A, B[C]], (A, B[C]), That]): That = { val pair = (a -> adder.add(c, map.getOrElse(a, adder.empty) )) (map + pair).asInstanceOf[That] } def +++[That](t: (A, C))(implicit cbf: CanBuildFrom[M[A, B[C]], (A, B[C]), That]): That = updateSeq(t._1, t._2)(cbf) } implicit def toRichCollectionMap[A, C, B[_], M[X, Y] <: col 

विशेष बिट adder.add का उपयोग कर तत्वों और adder.empty जोड़ने के लिए नई कुंजी के लिए नए संग्रह बनाने के लिए उपयोग कर रहा है।

तुलना करने के लिए, टाइप वर्गों के बिना मुझे 3 विकल्प होंगे: 1. एक विधि प्रति संग्रह प्रकार लिखने के लिए। उदाहरण के लिए, addElementToSubList और addElementToSet इत्यादि। यह कार्यान्वयन में कई बॉयलरप्लेट बनाता है और नाम स्थान को प्रदूषित करता है। यह निर्धारित करने के लिए कि क्या उप संग्रह एक सूची / सेट है। यह मुश्किल है क्योंकि नक्शा खाली शुरू करने के लिए खाली है (बेशक स्कैला मेनिफेस्ट्स के साथ यहां भी मदद करता है) 3. उपयोगकर्ता को योजक की आपूर्ति करने के लिए गरीबों का प्रकार वर्ग होना चाहिए। तो addToMap(map, key, value, adder) तरह कुछ, जो सादे बदसूरत है

एक अन्य तरीके से मैं इस ब्लॉग पोस्ट को उपयोगी खोजता हूं जहां वह टाइप क्लासेस का वर्णन करता है: मोनाद्स नहीं हैं रूपकों

टाइप क्लास के लिए आलेख खोजें यह पहला मैच होना चाहिए। इस लेख में, लेखक मोनैड टाइपक्लास का एक उदाहरण प्रदान करता है।

प्रकार वर्गों को देखने का एक तरीका यह है कि वे पूर्वव्यापी विस्तार या पूर्वव्यापी बहुरूपता को सक्षम करते हैं । कैजुअल चमत्कार और डैनियल वेस्टहेइड के कुछ बड़े पद हैं जो इस प्रकार हासिल करने के लिए टाइप क्लासेस इन स्काला का इस्तेमाल करते हैं।

यहां मेरे ब्लॉग पर एक पोस्ट है जो रेट्रोएक्टिव सुपरटेपिंग के स्केल में विभिन्न तरीकों की खोज करता है, एक प्रकार का रेट्रोएक्टिव एक्सटेंशन, जिसमें एक टाइप-क्लास उदाहरण भी शामिल है

फोरम थ्रेड " किस प्रकार वर्गों को लक्षणों से बेहतर बना देता है ? " कुछ दिलचस्प बिंदु बनाता है:

  • टाइपक्लासेस बहुत आसानी से ऐसे विचारों का प्रतिनिधित्व कर सकते हैं जो उपप्रकार की उपस्थिति में प्रतिनिधित्व करने में काफी मुश्किल हैं, जैसे समानता और आदेश
    व्यायाम: एक छोटे वर्ग / विशेषता पदानुक्रम बनाएं और लागू करने की कोशिश करें। प्रत्येक वर्ग / विशेषता पर इस तरह से समानताएं हैं कि पदानुक्रम से मनमानी उदाहरणों पर कार्रवाई सही तरह से प्रतिक्रियात्मक, सममित और संक्रमणीय है।
  • टाइपक्लासेस आपको सबूत प्रदान करने की अनुमति देते हैं कि आपके "नियंत्रण" के बाहर एक प्रकार कुछ व्यवहार के अनुरूप है।
    किसी और का प्रकार आपके प्रकार वर्ग का सदस्य हो सकता है
  • आप अभिव्यक्त नहीं कर सकते "उप विधि के संदर्भ में यह विधि विधि प्राप्तकर्ता के रूप में एक ही प्रकार का मान देता है / देता है", लेकिन यह (बहुत उपयोगी) बाधा typeclasses का उपयोग करते हुए सरल है। यह एफ-बाउंड प्रकार की समस्या है (जहां एफ-बाउंड टाइप को अपने उपप्रकारों पर पैरामीटेट किया गया है)।
  • एक विशेषता पर परिभाषित सभी कार्यों को एक उदाहरण की आवश्यकता होती है ; वहाँ हमेशा एक तर्क है इसलिए आप उदाहरण से एक fromString(s:String): Foo को परिभाषित नहीं कर सकते हैं fromString(s:String): Foo पद्धति का तरीका इस तरह से है कि आप Foo एक उदाहरण के बिना इसे कॉल कर सकते हैं।
    Scala में यह प्रकट होता है क्योंकि लोग सशक्त रूप से साथी वस्तुओं पर सार करने की कोशिश कर रहे थे।
    लेकिन यह एक प्रकार वर्ग के साथ सीधा है, जैसा कि इस मोनोइड उदाहरण में शून्य तत्व से दिखाया गया है।
  • Typeclasses inductively परिभाषित किया जा सकता है ; उदाहरण के लिए, अगर आपके पास एक JsonCodec[Woozle] तो आप मुफ्त में JsonCodec[List[Woozle]] प्राप्त कर सकते हैं।
    उपर्युक्त उदाहरण "आप जो एक साथ जोड़ सकते हैं" के लिए यह दिखाता है

मुझे ऐड-हॉक पॉलिमोरिज़्म की तुलना में किसी भी अन्य उपयोग केस के बारे में पता नहीं है, जिसे यहां समझाया गया है कि संभवतः सबसे अच्छा तरीका है।

टाइप-कनवर्ज़न के लिए दोनों implicits और typeclasses का उपयोग किया जाता है उन दोनों के लिए प्रमुख उपयोग-मामले उन क्लासों पर तदर्थ बहुरूपता (यानी) प्रदान करना है जिन्हें आप संशोधित नहीं कर सकते हैं बल्कि विरासत प्रकार के बहुरूपता की अपेक्षा कर सकते हैं। अस्पष्टता के मामले में आप एक निहित डीईफ़ या एक निहित वर्ग दोनों का उपयोग कर सकते हैं (जो आपकी आवरण वर्ग है लेकिन ग्राहक से छिपी हुई है)। Typeclasses अधिक शक्तिशाली हैं क्योंकि वे पहले से ही मौजूदा वंशानुक्रम श्रृंखला में कार्यक्षमता जोड़ सकते हैं (उदाहरण के लिए: स्काला सॉर्ट फ़ंक्शन में [T] का आदेश देना) अधिक जानकारी के लिए आप https://lakshmirajagopalan.github.io/diving-into-scala-typeclasses/ देख सकते हैं

स्कला प्रकार वर्गों में

  • तदर्थ बहुरूपता को सक्षम करता है
  • स्टेटिक टाइप (यानी टाइप-सुरक्षित)
  • हास्केल से उधार लिया
  • अभिव्यक्ति समस्या हल करती है

मौजूदा कोड को बदलने / पुनः कंपाइलिंग के बिना व्यवहार को संकलित समय पर बढ़ाया जा सकता है

स्काला इम्प्लिकिट्स

किसी विधि की अंतिम पैरामीटर सूची को चिह्नित किया जा सकता है

  • अंतर्निहित पैरामीटर को संकलक द्वारा भर दिया जाता है

  • असल में, आपको संकलक के सबूत की आवश्यकता होती है

  • … जैसे दायरे में एक प्रकार वर्ग के अस्तित्व के रूप में

  • यदि आवश्यक हो, तो आप स्पष्ट रूप से पैरामीटर निर्दिष्ट कर सकते हैं

नीचे वर्ग श्रेणी के कार्यान्वयन के साथ स्ट्रिंग क्लास पर उदाहरण एक्सटेंशन के नीचे क्लास को नए तरीकों के साथ विस्तारित किया जाता है, हालांकि स्ट्रिंग अंतिम है 🙂

 /** * Created by nihat.hosgur on 2/19/17. */ case class PrintTwiceString(val original: String) { def printTwice = original + original } object TypeClassString extends App { implicit def stringToString(s: String) = PrintTwiceString(s) val name: String = "Nihat" name.printTwice } 

यह एक महत्वपूर्ण अंतर है (कार्यात्मक प्रोग्रामिंग के लिए आवश्यक है):

यहां छवि विवरण दर्ज करें

विचार करें inc:Num a=> a -> a :

प्राप्त हुआ a ही है जो लौट आया है, यह उप-प्रकार के साथ नहीं किया जा सकता है