स्काला 2.11.0 में मैक्रोज़ और क्वासी-उद्धरण

ऐसा नहीं है, बहुत पहले, Scala 2.11.0 जारी किया गया था । इस संस्करण के उल्लेखनीय नवाचारों में से एक अर्ध-उद्धरण है - संकलन के दौरान पारस लाइनों का उपयोग करके स्काला सिंटैक्स पेड़ों का वर्णन करने के लिए एक सुविधाजनक तंत्र; जाहिर है, यह तंत्र मुख्य रूप से मैक्रोज़ के साथ उपयोग करने के लिए है।



हैरानी की बात है, जबकि स्काला में मैक्रों का विषय अभी भी बहुत सक्रिय रूप से नहीं माना जा रहा है; अंतिम पोस्ट

मैक्रोज़ के गंभीर विचार के साथ एक पूरे साल पहले ही था।



इस पोस्ट में, हम JSON डिसेरलाइज़ेशन कोड को एक वर्ग पदानुक्रम में उत्पन्न करने के लिए डिज़ाइन किए गए एक साधारण मैक्रो को लिखने पर एक करीब से देखेंगे।

समस्या का बयान

Scala - spray.json के लिए JSON के साथ काम करने के लिए एक महान पुस्तकालय है।



आमतौर पर, इस लाइब्रेरी का उपयोग करके किसी JSON ऑब्जेक्ट को डिसेर्बलाइज करने के लिए, आयात के एक जोड़े पर्याप्त हैं:

//  ,   : case class MyClass(field: String) //   spray.json: import spray.json._ import DefaultJsonProtocol._ implicit val myClassFormat = jsonFormat1(MyClass) val json = """{ "field\": "value" }""" val obj = json.parseJson.convertTo[MyClass] // ok
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

काफी आसान है, है ना? और अगर हम पूरी कक्षा के पदानुक्रम को हटाना चाहते हैं? मैं एक पदानुक्रम का उदाहरण दूंगा, जिस पर हम भविष्य में विचार करेंगे:

 abstract sealed class Message() case class SimpleMessage() extends Message case class FieldMessage(field: String) extends Message case class NestedMessage(nested: Message) extends Message case class MultiMessage(field: Int, nested: Message) extends Message
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि आप देख सकते हैं, कई अलग-अलग प्रकार के तर्कों के साथ कई अलग-अलग वर्ग अमूर्त जनक से विरासत में मिले हैं। इस तरह की संस्थाओं को डिसेररलाइज़ करते समय, JSON ऑब्जेक्ट में एक type



फ़ील्ड को जोड़ना काफी स्वाभाविक है, और डीसर्लाइज़ करते समय इस फ़ील्ड पर डिस्पैच करना। निम्नलिखित छद्म कोड में एक विचार व्यक्त किया जा सकता है:

 json.type match { case "SimpleMessage" => SimpleMessage() case "FieldMessage" => FieldMessage(json.field) // ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Spray.json लाइब्रेरी RootJsonFormat



फॉर्मेट का विस्तार करके उपयोगकर्ता-परिभाषित नियमों के अनुसार किसी भी प्रकार से JSON के रूपांतरण को निर्धारित करने की क्षमता प्रदान करता है। यह वैसा ही लगता है जैसा हमें चाहिए। हमारे फॉर्मेटर का मूल इस तरह दिखना चाहिए:

 val typeName = ... typeName match { case "FieldMessage" => map.getFields("field") match { case Seq(field) => new FieldMessage(field.convertTo[String]) } case "NestedMessage" => map.getFields("nested") match { case Seq(nested) => new NestedMessage(nested.convertTo[Message]) } case "MultiMessage" => map.getFields("field", "nested") match { case Seq(field, nested) => new MultiMessage(field.convertTo[Int], nested.convertTo[Message]) } case "SimpleMessage" => map.getFields() match { case Seq() => new SimpleMessage() } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह कोड थोड़ा दिखता है ... बॉयलरप्लेट। यह एक महान स्थूल कार्य है! लेख का बाकी हिस्सा एक मैक्रो के विकास के लिए समर्पित है जो शुरुआती बिंदु के रूप में केवल Message



प्रकार के साथ इस तरह के कोड को उत्पन्न कर सकता है।

परियोजना संगठन

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



मैक्रो कोड और मुख्य एप्लिकेशन कोड को दो प्रोजेक्ट में अलग करना आवश्यक है, जिसे मुख्य project/Build.sbt



. project/Build.sbt



में संदर्भित किया जाना चाहिए। ये तैयारी पहले से ही लेख के साथ कोड में की गई है, यहां परिणामी फाइलों के लिंक दिए गए हैं:

• मुख्य असेंबली फ़ाइल project/Build.sbt
  
  
  
  ;
• मैक्रो प्रोजेक्ट: macro/build.sbt
  
  
  
  . macro/build.sbt
  
  
  
  ;
• मुख्य परियोजना: main/build.sbt
  
  
  
  

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



मैक्रोज़ को डीबग करते समय, -Ymacro-debug-lite



संकलक विकल्प -Ymacro-debug-lite



मदद करता है, जो आपको प्रोजेक्ट में सभी मैक्रोज़ की तैनाती के परिणामों को कंसोल पर प्रदर्शित करने की अनुमति देता है (ये परिणाम स्केल कोड के समान हैं, और अक्सर संकलक में परिवर्तन किए बिना मैन्युअल रूप से संकलित किया जा सकता है, जो मदद कर सकता है। गैर-तुच्छ मामलों में डिबगिंग)।

मैक्रो

स्काला में मैक्रोज़ प्रतिबिंब की तरह बहुत काम करते हैं। कृपया ध्यान दें कि स्केल प्रतिबिंब एपीआई जावा प्रतिबिंब से काफी अलग है, क्योंकि जावा मानक पुस्तकालय में सभी स्काला अवधारणाओं को नहीं जाना जाता है।



स्काला का मैक्रो इंजन संकलन समय पर कोड के अनुभाग बनाने की क्षमता प्रदान करता है। यह एक दृढ़ता से टाइप किए गए एपीआई का उपयोग करके किया जाता है जो आपके द्वारा बनाई गई कोड के अनुरूप सिंटैक्स पेड़ों को उत्पन्न करता है। स्काला मैक्रोज़ सभी सामान्य सी भाषा मैक्रोज़ से काफी अलग हैं, इसलिए उन्हें भ्रमित न करें।



स्काला मैक्रों Context



क्लास पर आधारित हैं। इस वर्ग का एक उदाहरण हमेशा विस्तार पर मैक्रो को दिया जाता है। फिर आप इसमें से Universe



ऑब्जेक्ट के अंदरूनी हिस्से को आयात कर सकते हैं और उन्हें उसी तरह से उपयोग कर सकते हैं जैसे रनटाइम रिफ्लेक्शन में - वहाँ के प्रकार, विधियों, गुणों आदि के विवरणों से अनुरोध करते हैं। एक ही संदर्भ आपको Literal



, Constant



, List



, आदि जैसे वर्गों का उपयोग करके वाक्यविन्यास के पेड़ बनाने की अनुमति देता है



संक्षेप में, एक मैक्रो एक फ़ंक्शन है जो सिंटैक्स पेड़ों को प्राप्त करता है और वापस करता है। चलो हमारे मैक्रो टेम्पलेट लिखें:

 import scala.language.experimental.macros import scala.reflect.macros.blackbox.Context import spray.json._ object Parsers { def impl[T: c.WeakTypeTag](c: Context)(typeName: c.Expr[String], map: c.Expr[JsObject]): c.Expr[T] = { import c.universe._ val cls = weakTypeOf[T].typeSymbol.asClass val tree = ??? //       c.Expr[T](tree) } def parseMessage[T](typeName: String, map: JsObject): T = macro Parsers.impl[T] }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

parseMessage[T]



मैक्रो एक प्रकार T



स्वीकार करता है, जो कि parseMessage[T]



के पदानुक्रम के लिए आधार है, और डीज़ेरिसेबल map



ऑब्जेक्ट का प्रकार प्राप्त करने के लिए एक सिंटैक्स ट्री है, और डीज़ेरिलेस ट्री को बेस टाइप T



पर लाने के लिए एक सिंटैक्स ट्री देता है T







टाइप T



एक तर्क को एक विशेष तरीके T



वर्णित किया गया है: यह इंगित किया गया है कि संकलक को एक c.WeakTypeTag



रूप से उत्पन्न हुई वस्तु को संलग्न करना होगा c.WeakTypeTag



। सामान्यतया, अंतर्निहित TypeTag



तर्क TypeTag



उपयोग स्काला द्वारा जेनेरिक तर्क प्रकारों के साथ काम करने के लिए किया जाता है जो आमतौर पर टाइप एरासुरेज के कारण रनटाइम पर उपलब्ध नहीं होते हैं। मैक्रो तर्कों के लिए, कंपाइलर को केवल TypeTag



का उपयोग करने की आवश्यकता नहीं है, लेकिन WeakTypeTag



, जिसे मैं समझता हूं कि यह कंपाइलर के प्रदर्शन से संबंधित है (इसमें टाइप के लिए "पूर्ण" TypeTag



नहीं है जो मैक्रो विस्तार के दौरान पूरी तरह से उत्पन्न नहीं हो सकता है)। TypeTag



के साथ जुड़े प्रकार को Universe



ऑब्जेक्ट के typeOf[T]



विधि का उपयोग करके प्राप्त किया जा सकता है; तदनुसार, WeakTypeTag



लिए एक weakTypeOf[T]



विधि।



मैक्रोज़ की कमियों में से एक सिंटैक्स पेड़ों के विवरण की स्पष्टता नहीं है। उदाहरण के लिए, पीढ़ी के दौरान कोड का टुकड़ा 2 + 2



Apply(Select(Literal(Constant(2)), TermName("$plus")), List(Literal(Constant(2))))



होना चाहिए Apply(Select(Literal(Constant(2)), TermName("$plus")), List(Literal(Constant(2))))



; और भी गंभीर मामले शुरू होते हैं जब हमें पैटर्न प्रतिस्थापन के साथ कोड के बड़े टुकड़ों को पेश करने की आवश्यकता होती है। स्वाभाविक रूप से, हम इस कठिनाई को पसंद नहीं करते हैं और हम इसे दूर करेंगे।

Kvazitsitaty

स्कैला 2.11.0 के बाद से मैक्रोज़ की उपरोक्त कमी को क्वैसी-कोट्स के साथ आसानी से हल किया जा सकता है। उदाहरण के लिए, अर्ध-उद्धरण के रूप में अभिव्यक्ति 2 + 2



का वर्णन करने वाला उपर्युक्त निर्माण बिल्कुल q"2 + 2"



तरह दिखेगा, जो बहुत सुविधाजनक है। सामान्य तौर पर, स्काला में क्यूसिकोट्स स्ट्रिंग इंटरपोलर का एक सेट है जो Universe



ऑब्जेक्ट में स्थित हैं। इन प्रक्षेपकों को वर्तमान दायरे में आयात करने के बाद, स्ट्रिंग स्थिरांक से पहले पात्रों की एक श्रृंखला का उपयोग करना संभव हो जाता है, जो संकलक द्वारा इसकी प्रसंस्करण निर्धारित करते हैं। विशेष रूप से, विचाराधीन समस्या के कार्यान्वयन में, cq



पैटर्न के लिए pq



, match



अभिव्यक्ति शाखाओं के लिए cq



, और संपूर्ण भाषा अभिव्यक्तियों के लिए q



हमारे लिए उपयोगी हैं।



अन्य स्लाला स्ट्रिंग स्ट्रिंग इंटरपोलर के रूप में, अर्ध-उद्धरण उनके आसपास के दायरे के चर को संदर्भित कर सकते हैं। उदाहरण के लिए, एक अभिव्यक्ति 2 + 2



उत्पन्न करने के लिए 2 + 2



आप निम्नलिखित कोड का उपयोग कर सकते हैं:

 val a = 2 q"$a + $a"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



ऑब्जेक्ट बनाने की आवश्यकता है।



जैसा कि आप लेख की शुरुआत में उत्पन्न कोड के उदाहरण से देख सकते हैं, हमें निम्नलिखित तत्वों को उत्पन्न करने में सक्षम होने की आवश्यकता है:

• प्रत्येक प्रकार के पदानुक्रम के अनुरूप case
  
  
  
  शाखाओं के साथ typeName
  
  
  
  वैरिएबल द्वारा match
  
  
  
  ;
• प्रत्येक शाखा में - इसी श्रेणी के कंस्ट्रक्टर के तर्क नामों की सूची को map.getFields
  
  
  
  विधि में पास करना;
• एक ही स्थान पर - परिणामी अनुक्रम (एक ही match
  
  
  
  अभिव्यक्ति का उपयोग करके) को चर में विभाजित करना और इन चरों को टाइप कंस्ट्रक्टर के पास भेजना।

सबसे पहले, पूरे match



अभिव्यक्ति के एक आम पेड़ की पीढ़ी पर विचार करें। ऐसा करने के लिए, आपको अर्ध-उद्धरण के संदर्भ में चर के प्रक्षेप का उपयोग करना होगा:

 val clauses: Set[Tree] = ??? // .  val tree = q"$typeName match { case ..$clauses }"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कोड का यह खंड एक विशेष प्रकार के प्रक्षेप का उपयोग करता है। अभिव्यक्ति का case ..$clauses



match



ब्लॉक के अंदर case ..$clauses



को case



शाखाओं की सूची के रूप में विस्तारित किया जाएगा। जैसा कि हमें याद है, प्रत्येक शाखा को इस तरह दिखना चाहिए:

 case "FieldMessage" => map.getFields("field") match { case Seq(field) => new FieldMessage(field.convertTo[String]) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Quasicitals के रूप में, इस तरह की एक शाखा इस प्रकार लिखी जा सकती है:

 val tpe: Type //   val constructorParameters: List[Symbol] //    val parameterNames = constructorParameters.map(_.name) val parameterNameStrings = parameterNames.map(_.toString) //         pq: val parameterBindings = parameterNames.map(name => pq"$name") //   ,     : val args = constructorParameters.map { param => val parameterName = TermName(param.name.toString) val parameterType = param.typeSignature q"$parameterName.convertTo[$parameterType]" } //     case: val typeName = tpe.typeSymbol val typeNameString = typeName.name.toString cq"""$typeNameString => $map.getFields(..$parameterNameStrings) match { case Seq(..$parameterBindings) => new $typeName(..$args) }"""
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कोड के टुकड़े में, कई अर्ध-उद्धरणों का उपयोग किया जाता है: अभिव्यक्ति pq"$name"



पैटर्न का एक सेट बनाता है जिसे बाद में अभिव्यक्ति Seq(...)



में प्रतिस्थापित किया जाता है। इन अभिव्यक्तियों में से प्रत्येक में एक JsValue



प्रकार है, जिसे JsValue



को पास करने से पहले संबंधित प्रकार में परिवर्तित किया जाना चाहिए; इसके लिए, एक quasi- convertTo



उपयोग किया जाता है जो convertTo



विधि में कॉल उत्पन्न करता है। कृपया ध्यान दें कि यदि आवश्यक हो तो यह विधि हमारे फॉर्मेटर को पुन: कॉल कर सकती है (अर्थात, आप एक दूसरे में टाइप Message



की वस्तुओं को घोंसला कर सकते हैं।



अंत में, परिणामी वाक्यविन्यास पेड़ जिसमें हम उत्पन्न case



शाखाओं के साथ match



अभिव्यक्ति है, का उपयोग इंटरपोलेशन द्वारा भी किया जा सकता है:

 val tree = q"$typeName match { case ..$clauses }"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह पेड़ मैक्रो के आवेदन के स्थान पर कंपाइलर द्वारा बनाया जाएगा।

निष्कर्ष

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



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

सामग्री का इस्तेमाल किया

1. स्काला प्रलेखन से मैक्रो अवलोकन ।
2. स्काला डॉक्यूमेंटेशन से क्वैश्चन का अवलोकन ।
3. स्काला प्रलेखन से स्ट्रिंग प्रक्षेप का अवलोकन ।
4. एसबीटी के लिए मैक्रो प्रोजेक्ट गाइड ।
5. स्रोत कोड और लेख के लिए परीक्षण ।