🛣️ 🍻 🤙🏿 स्काला। हर किसी के लिए शाम से बाहर निकलना! 👄 🤽🏿 🤞🏻

और अब आपको उड़ाने की ज़रूरत है, क्योंकि यदि आप नहीं उड़ाते हैं, तो कुछ भी काम नहीं करेगा।
- महान के उद्धरण

और नमस्ते!

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

1. लागू रूपांतरण

और हम निहित परिवर्तनों के अपेक्षाकृत सरल खंड के साथ शुरू करेंगे। और एक जीवन उदाहरण है।
वसीली निर्माता रेनॉल्ट की एक कार चाहते हैं। पूरा परिवार लंबे समय से पैसे बचा रहा था, लेकिन वे पूरी राशि जमा नहीं कर सकते थे। एक नए WHA के लिए केवल पर्याप्त धन। और फिर अचानक ताली! रेनॉल्ट ने AvtoVAZ खरीदता है। ऐसा लगता है कि निर्माता को अब जरूरत है, और पर्याप्त पैसा है। और इसलिए, स्पष्ट रूप से, वासिया अब एक विदेशी कार के खुश मालिक हैं।
अब हम इसे कोड के रूप में औपचारिक रूप देने की कोशिश करते हैं:

जीवन उदाहरण

case class Vasiliy(auto: Renault) { println("Vasiliy owns "+auto) } case class Renault(isRussian: Boolean = false) case class VAZ(isRussian: Boolean = true) object VAZ { implicit def vaz2renault(vaz: VAZ): Renault = Renault(vaz.isRussian) //   } object Family { def present = { Vasiliy(VAZ()) //  .   ! } }

Family.present के निष्पादन के Family.present हम देखेंगे कि Vasiliy owns Renault(true) । यह कैसे स्काला इस कठिन जीवन में आम लोगों की मदद करता है!
यदि आप अधिक प्रोग्रामेटिक उदाहरण देते हैं (मैं अपनी परियोजना में कुछ इसी तरह का उपयोग करता हूं):

बेजान उदाहरण

 case class PermissionsList(permissions: Set[String] = Set("UL")); object PermissionsList { implicit def str2permissions(str: String) = PermissionsList(str.split(";").toSet) implicit def permissions2str(p: PermissionsList) = p.permissions.mkString(";") } // case class User(login: String, permissions: PermissionsList) /* somewhere in a galaxy far far away */ User(login = "Vasiliy", permissions = "UL;AL") //

उपरोक्त कोड आपको एक एक्सेस ऑब्जेक्ट को स्पष्ट रूप से तार डालने की अनुमति देता है और इसके विपरीत। यह उसी वेब पर काम करते समय सुविधाजनक हो सकता है, जब हमें क्लाइंट को फॉर्म "UL;AL" की वांछित लाइन को गोंद करना होगा और इसे सर्वर पर भेजना होगा, जहां यह पहले से ही सही समय पर हमारी वस्तु में परिवर्तित हो जाएगा।
और इसलिए हम एक महत्वपूर्ण बिंदु पर आए । कब और किन परिस्थितियों में हमारे वीएजेड ~~कद्दू~~ रेनॉल्ट में बदल जाएंगे और स्ट्रिंग को एक Permissionsलिस्ट में बदल दिया जाएगा?

अधिकांश मामलों में, सभी स्काला जादू संकलन-समय (भाषा दृढ़ता से टाइप किया जाता है) में होता है। स्थानीय कंपाइलर एक बेहद स्मार्ट और संसाधन वाला प्राणी है। जैसे ही हम VAZ वर्ग के एक उदाहरण पर एक्सट () विधि को कॉल करने का प्रयास करते हैं, जो कभी भी वहां मौजूद नहीं होता है, हमारा कंपाइलर अपनी पूरी गंभीरता से शुरू होता है और मेटा को VAZ के निहित रूपांतरण की तलाश में कुछ पकता है जो एक्सैट () कर सकता है। दूसरे शब्दों में, implicit def a2b(a: A): B
वह निहित रूपांतरणों की तलाश कर रहा है:

वर्तमान दायरे में (उदाहरण के लिए, वर्तमान वस्तु के अंदर)
स्पष्ट रूप से ( import app.VAZ.vaz2renault )
या समूह आयात ( import app.VAZ._ )
एक साथी वस्तु में परिवर्तनीय

वैसे, केवल एक गैर-प्रासंगिक विधि को कॉल करने के अलावा, कंपाइलर ऑब्जेक्ट को परिवर्तित करने का प्रयास करेगा यदि हम इसे एक विधि / फ़ंक्शन को पास करने का प्रयास करते हैं जिसके लिए एक अलग डेटा प्रकार के साथ एक पैरामीटर की आवश्यकता होती है। यह सिर्फ वसीली और उनके परिवार के उदाहरण से है।

१.१ निहित वर्ग

संस्करण 2.10 के साथ शुरू, इंप्लाट क्लासेस स्काला में दिखाई दिए हैं जो किसी भी मौजूदा कक्षाओं के लिए सुविधाजनक तरीके से ग्रुपिंग एक्सटेंशन (तरीकों को जोड़ने) की अनुमति देते हैं। यहाँ एक सरल उदाहरण है:

 object MySimpleHelper { implicit class StringExtended(str: String) { def sayIt = println(str) def sayItLouderBitch = println(str.toUpperCase +"!!!") } }

जैसा कि आप उद्धृत कच्चे से देख सकते हैं, हमारे पास ऑब्जेक्ट के अंदर घोषित एक वर्ग है जो एक तर्क लेता है - एक स्ट्रिंग। यह रेखा हमें क्लास के तरीकों में टुकड़ों में फाड़ने के लिए दी गई है। और यह बात बस तड़पी है:

 import MySimpleHelper._ "oh gosh" sayIt > oh gosh "oh gosh" sayItLouderBitch > OH GOSH!!!

लेकिन यहाँ कई सीमाएँ हैं जिन्हें ध्यान में रखा जाना चाहिए:

निहित वर्गों के लिए, आप केवल एक स्पष्ट निर्माता तर्क का उपयोग कर सकते हैं, जो वास्तव में, "फैलता है" (हम थोड़े समय बाद निहित मापदंडों के बारे में बात करेंगे)
ऐसी कक्षाएं केवल वस्तुओं, लक्षणों, अन्य कक्षाओं के अंदर ही घोषित की जा सकती हैं।
एक वर्ग की घोषणा के दायरे में, एक ही नाम के तरीके, गुण, या ऑब्जेक्ट मौजूद नहीं हो सकते हैं। यदि आपके पास एक VAZ संपत्ति है, उदाहरण के लिए, एक ऑब्जेक्ट, तो implicit class VAZ पास में सह-अस्तित्व नहीं कर सकता है

ठीक है, वास्तव में, हमारे StringExtended को कंपाइलर द्वारा परिवर्तित किया जाएगा:

 class StringExtended(str: String) { def sayIt = println(str) def sayItLouderBitch = println(str.toUpperCase +"!!!") } implicit def String2StringExtended(str: String): StringExtended = new StringExtended(str)

परिचित, है ना?

2. लागू मापदंडों

किसी तरह सब कुछ बहुत आसान है और आप पहले से ही ऊब गए हैं? यह थोड़ा कट्टर के लिए समय है! आइए हमारे दिमाग को हिलाएं और चट्टान के स्रोत में चढ़ें:

सूरी कोड

 /** * TraversableOnce.scala: minBy * ,  ,      ,      ,    ,    B    A . ,   B    ,    A,  B  . - . */ def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A = { //   -   ? if (isEmpty) throw new UnsupportedOperationException("empty.minBy") //     var minF: B = null.asInstanceOf[B] var minElem: A = null.asInstanceOf[A] var first = true //    //   for (elem <- self) { //    A,   B val fx = f(elem) if (first || cmp.lt(fx, minF)) { //     -     . //  cmp.lt  true   ,  f: B <   minF: B minElem = elem minF = fx first = false } } minElem }

धक्का दिया, ऐसा लगता है कि सब कुछ स्पष्ट है।
बंद करो, दूसरा। लेकिन हम इस तरह से कुछ का उपयोग करते हैं:

 val cities = Seq(new City(population = 100000), new City(500000)) val smallCity = cities.minBy( city => city.population )

और हम किसी भी cmp: Ordering[B] ( B == Int) पास नहीं करते हैं cmp: Ordering[B] ( B == Int) । हालांकि ऐसा लगता है कि कोड काम करता है ... आराम करो, यार। यह जादू है।
आयातित दायरे में, विशेष रूप से scala.math.Ordering मौजूद है

इस तरह के एक कोड

 object Ordering extends LowPriorityOrderingImplicits { ... trait IntOrdering extends Ordering[Int] { def compare(x: Int, y: Int) = if (x < y) -1 else if (x == y) 0 else 1 } implicit object Int extends IntOrdering ... }

आइए अंतिम पंक्ति पर ध्यान दें - एक अंतर्निहित इंट ऑब्जेक्ट है जो कि अपने शस्त्रागार में है जब इंट्रोडरिंग IntOrdering Ordering[Int] इनहेरिट करते समय लागू की गई compare विधि। वास्तव में, इस वस्तु का उपयोग तुलनात्मक रूप से अशुभ minBy से पास होने के लिए किया minBy ।
एक बहुत ही सरल उदाहरण कुछ इस तरह दिखता है:

दोस्ताना कोड

 implicit val myValue: Int = 5 object Jules { def doesHeLookLikeABitch(answer: String)(implicit times: Int) = { for(x <- 1 to times) println(answer ) } } Jules.doesHeLookLikeABitch("WHAT?") >WHAT? >WHAT? >WHAT? >WHAT? >WHAT?

बेशक, कोई भी हमें हैंडल द्वारा निहित मापदंडों को स्थानांतरित करने के लिए मना नहीं करता है। नहीं, ठीक है, अचानक इसकी जरूरत होगी।
और फिर से, फिर से, सीमाओं, जहां उनके बिना।

निहितार्थ के रूप में चिह्नित एक वस्तु / मूल्य विधि कॉल के दायरे में मौजूद होना चाहिए, और एक डेटा प्रकार के लिए केवल एक पैरामीटर हो सकता है। अन्यथा, संकलक समझ नहीं पाएंगे कि विधि को पारित करने की आवश्यकता क्या है।
वैकल्पिक रूप से, कंपाइलर हमारे implicit T के साथी ऑब्जेक्ट में चारों ओर घूमता रहेगा, यदि कोई मौजूद है, और implicit val x: T खींचता है। लेकिन ये मेरे लिए पहले से ही बहुत कठिन दवाएं हैं।

3. देखें / प्रसंग सीमा

यदि आपका मस्तिष्क पहले से ही पिघला हुआ है, तो ब्रेक लें और कॉफी पीएं, या शायद कुछ मजबूत। मैं आज के लिए नवीनतम गैर-स्पष्टता के बारे में बात करने जा रहा हूं।
मान लीजिए कि हमारी वासिली, जो एक नई कार (एक exat() ) exat() , एक सफल व्यक्ति बन गई है, संक्षेप में एक प्रोग्रामर। और अब वैसिली स्काला पर लिखता है, और वह एक और अधिक अरहर चाहता था। मार्टिन ने सोचा और कहा - ठीक है। और उन पर प्रकार और प्रतिबंध लगा दिए। वही डी def f[T](a: T)

३.१ देखें सीमा

एक प्रकार की घोषणा करते समय यह प्रतिबंध संकलक को बताता है कि ~~सही~~ अंतर्निहित रूपांतरण कहीं आस-पास है।

 def f[A <% B](a: A) = a.bMethod

यानी सुलभ दायरे में A से B तक A अंतर्निहित रूपांतरण है। सिद्धांत रूप में, आप निम्न रूप में प्रविष्टि की कल्पना कर सकते हैं:

 def f[A](a: A) (implicit a2b: A => B) = a.bMethod:

एक रूसी व्यक्ति का एक करीबी उदाहरण कुछ इस तरह दिखता है:

 class Car { def exat() = println("POEXALI") } class VAZ object VAZ { implicit def vaz2car(v: VAZ): Car = new Car() } def go[A <% Car](a: A) = a.exat() go(new VAZ()) > POEXALI

अद्भुत! जीवन सुंदर हो गया है, बाल वापस हो गए हैं, मेरी पत्नी वापस आ गई है, तो सूची में आगे क्या है।
लेकिन वसीली ने इसके लिए कहा, और मार्टिन को अब नहीं रोका जा सकता ... इसलिए यह दिखाई दिया

3.2 प्रसंग सीमा

यह प्रतिबंध स्केल 2.8 में पेश किया गया था, और व्यू बाउंड्स के विपरीत, यह निहितार्थ रूपांतरणों के लिए जिम्मेदार नहीं है, लेकिन निहित मापदंडों के लिए , अर्थात्।

 def f[A : B](a: A) = g(a) //  g    B[A]

इस तरह की जोड़ी सबसे सरल उदाहरण होगी:

 def f[A : Ordering](a: A, b: A) = if (implicitly[Ordering[A]].lt(a, b)) a else b vs def f[A](a: A, b: A)(implicit ord: Ordering[A]) = { import ord._ if (a < b) a else b }

वास्तव में, यह हास्केल और उनके टाइपेकेल पैटर्न के लिए एक दूर का नमस्ते है।

एक आफ्टरवर्ड के बजाय

सड़क खत्म नहीं होती है, आप लंबे समय तक स्काला के बारे में बात कर सकते हैं। लेकिन सभी एक बार में नहीं, क्योंकि मुख्य बात समझ और समझने की इच्छा है। इच्छा से जागरूकता आती है कि क्या हो रहा है।
ठीक है, अगर इस लेख को पढ़ने के बाद, आप कुछ प्रोजेक्ट के कोड को नहीं समझते हैं जो अंतर्निहित रूपांतरण का उपयोग करता है, तो मैं आपको नोटबुक को बंद करने और सामान्य आईडीई को खोलने की सलाह देता हूं, वहां सब कुछ खूबसूरती से हाइलाइट किया गया है। और मेरा सिर नहीं फोड़ा, मैं जाऊंगा ध्यान देने के लिए आप सभी का धन्यवाद।

स्काला। हर किसी के लिए शाम से बाहर निकलना!