स्काला में टाइप निर्माण

मल्टी-लेयर ("एंटरप्राइज़") सिस्टम का निर्माण करते समय, यह अक्सर पता चलता है कि ValueObject



(या केस क्लासेस) को बनाया जाता है जो सिस्टम द्वारा संसाधित किसी भी इकाई उदाहरण के बारे में जानकारी संग्रहीत करता है। उदाहरण के लिए, वर्ग

 case class Person(name: String, address: Address)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सिस्टम में डेटा प्रस्तुत करने के इस तरीके में दोनों सकारात्मक गुण हैं:

• ज़ोर से टाइप किया गया डेटा एक्सेस
• एनोटेशन का उपयोग कर गुणों के लिए मेटा-जानकारी को बाँधने की क्षमता,

साथ ही कुछ नुकसान:

• यदि बहुत सारी संस्थाएँ हैं, तो इस तरह की बहुत सारी कक्षाएं हैं, और उनके प्रसंस्करण के लिए एक ही प्रकार के कोड (कॉपी-पेस्ट) की बहुत आवश्यकता होती है;
• मेटा-जानकारी के लिए सिस्टम की अलग-अलग परतों की जरूरतों को इस वस्तु के गुणों के लिए एनोटेशन द्वारा दर्शाया जा सकता है, लेकिन एनोटेशन की संभावनाएं सीमित हैं और प्रतिबिंब के उपयोग की आवश्यकता होती है;
• यदि किसी वस्तु के सभी गुणों पर एक बार में डेटा प्रस्तुत करना आवश्यक है, तो बनाई गई कक्षाओं का उपयोग करना मुश्किल है;
• संपत्ति मूल्य (डेल्टा) में बदलाव की कल्पना करना भी मुश्किल है।

हम एक ऐसी रूपरेखा को लागू करना चाहते हैं जो हमें नई "कक्षाएं" (प्रकार, इन प्रकारों के निर्माणकर्ता, नए प्रकार की वस्तुएं) बनाने के लिए, अपनी स्वयं की "ईंटों" का उपयोग करके वृद्धिशील रूप से बनाने की अनुमति देती है। इस तरह से, इस तथ्य का लाभ उठाते हुए कि हम खुद "ईंट" बनाते हैं, हम इस तरह के उपयोगी गुणों को प्राप्त कर सकते हैं:

• संस्थाओं के व्यक्तिगत गुणों का वर्णन करने की क्षमता (इस संपत्ति में डेटा प्रकार के संकेत के साथ और आवेदन के लिए आवश्यक किसी भी मेटा-जानकारी विशेष रूप से इस आवेदन के लिए उपयुक्त है);
• जोरदार तरीके से उदाहरणों के गुणों पर काम करने की क्षमता (संकलन चरण में प्रकार की जांच के साथ);
• घोषित गुणों का उपयोग करके इकाई उदाहरण के गुणों के बारे में आंशिक / अधूरी जानकारी प्रदान करना;
• एक इकाई प्रकार के गुणों के बारे में आंशिक जानकारी युक्त एक ऑब्जेक्ट प्रकार बनाएं। और अन्य प्रकार (वर्ग, आदिम प्रकार, आदि) के साथ एक सममूल्य पर इस प्रकार का उपयोग करें।

एक नए मिश्रित प्रकार के निर्माण के लिए, आपको यह पता लगाने की आवश्यकता है कि एक नियमित वर्ग कैसे काम करता है। आप Person



वर्ग की घोषणा में घटकों को उजागर कर सकते हैं

• संपत्तियों / स्लॉट्स (स्लॉट अनुक्रम) की आदेशित सूची,
• संपत्ति / स्लॉट नाम (स्लॉट आईडी),
• संपत्ति / स्लॉट प्रकार।

Person



वर्ग और उसके गुणों का उपयोग करते समय, संचालन को प्रतिष्ठित किया जा सकता है -

• एक इंस्टेंस प्रॉपर्टी का मूल्य प्राप्त करें (example.name)
• एक परिवर्तित संपत्ति के साथ एक नया उदाहरण प्राप्त करना (चूंकि Person
  
  
  
  वर्ग अपरिवर्तनीय है, उत्परिवर्तनीय वर्गों के लिए, सादृश्य एक वस्तु संपत्ति का मूल्य बदल रहा है)

इसके अलावा, "प्रथम श्रेणी" का सार Person



वर्ग Person



, और इसके गुण "द्वितीय श्रेणी" का सार हैं। वे वस्तु नहीं हैं और हमारे पास उनके साथ काम करने की क्षमता नहीं है।



हम "प्रथम श्रेणी" के गुणों को स्वतंत्र बनाना चाहते हैं, जिससे एक नए "वर्ग" का निर्माण किया जाएगा।



इसलिए, name



संपत्ति घोषित करें:

 trait SlotId[T] case class SlotIdImpl[T](slotId:String, ...) extends SlotId[T] def slot[T](slotId:String, ...) = SlotIdImpl[T](slotId, ...) val name = slot[String]("name", ...)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस तरह की घोषणा संपत्ति की परवाह किए बिना खुद को उजागर करती है, जिसमें उस संपत्ति का उपयोग किया जाएगा। मेटा की जानकारी स्पष्ट रूप से संपत्ति पहचानकर्ता (बाहरी मानचित्रण का उपयोग करके) से जुड़ी हो सकती है, या इसे सीधे संपत्ति का प्रतिनिधित्व करने वाली वस्तु में निर्दिष्ट किया जा सकता है। बाद के मामले में, डेटा हैंडलिंग कुछ सरलीकृत है, हालांकि नए प्रकार के मेटा-जानकारी के साथ विस्तार मुश्किल है।

स्लॉट क्रम

एक नया प्रकार प्राप्त करने के लिए, आपको एक ऑर्डर की गई सूची में कई गुण एकत्र करने की आवश्यकता होती है। दूसरों से बना एक प्रकार का निर्माण करने के लिए, हम उसी दृष्टिकोण का उपयोग करेंगे जैसे कि HList प्रकार (अद्भुत आकारहीन पुस्तकालय से, उदाहरण के लिए)।

 sealed trait SlotSeq { type ValueType <: HList } case object SNil extends SlotSeq { type ValueType = HNil } case class ::[H<:SlotId, T<:SlotSeq](head:H, tail : T) extends SlotSeq { type ValueType = H :: T#ValueType }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि आप देख सकते हैं, गुणों की सूची के निर्माण की प्रक्रिया में, हम गुणों की सूची के साथ संगत एक प्रकार का मान ( ValueType



) भी ValueType



हैं।

संपत्ति समूहन

गुणों का उपयोग किया जा सकता है, बस सभी संभावित गुणों का एक पूरा संग्रह बनाकर। हालांकि, "समूहों" में गुणों को व्यवस्थित करना बेहतर है - एक ही वर्ग / प्रकार की वस्तुओं से संबंधित गुणों के सेट।

 object PersonType { val name = slot[String]("name", ...) val address ... ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह समूहीकरण लक्षणों का उपयोग करके भी किया जा सकता है, जो आपको अलग-अलग "क्लस्टर्स" में समान गुणों की घोषणा करने की अनुमति देता है।

 trait Identifiable { val id = slot[Long]("id") } object Employee extends Identifiable
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

उदाहरणों की प्रस्तुति

दरअसल, एक इकाई से संबंधित डेटा को दो मुख्य रूपों में दर्शाया जा सकता है: Map



या RecordSet



। Map



- में संपत्ति-मूल्य जोड़े शामिल हैं, जबकि RecordSet



में गुणों की एक क्रमबद्ध सूची और समान क्रम में व्यवस्थित मूल्यों की एक सरणी है। RecordSet



आपको आर्थिक रूप से बड़ी संख्या में इंस्टेंस पर डेटा प्रस्तुत करने की अनुमति देता है, और Map



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



RecordSet



के तार के टाइप किए गए प्रतिनिधित्व के लिए, एक अद्भुत HList



संरचना का उपयोग किया जा सकता है (आकारहीन पुस्तकालय से, उदाहरण के लिए)। हमें केवल एक सुसंगत HList



प्रकार बनाने के लिए एक ऑर्डर किए गए स्लॉट अनुक्रम को HList



।

 type ValueType = head.Type :: tail.ValueType
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक दृढ़ता से टाइप किया गया Map



बनाने के लिए Map



हमें सामान्य Entry



क्लास के बजाय हमारे SlotValue



क्लास का उपयोग करना होगा,

 case class SlotValue[T](slot:SlotId[T], value:T)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जिसमें संपत्ति के नाम और संपत्ति के मूल्य के अलावा एक सामान्य मूल्य प्रकार भी शामिल है। यह हमें संकलन चरण में यह गारंटी देता है कि संपत्ति को एक संगत प्रकार का मूल्य प्राप्त होगा। Map



स्वयं एक अलग कार्यान्वयन की आवश्यकता होगी। सरलतम स्थिति में, आप SlotValue



सूची का उपयोग कर सकते हैं, जो स्वचालित रूप से आवश्यकतानुसार नियमित मानचित्र में बदल जाती है।

निष्कर्ष

ऊपर वर्णित बुनियादी डेटा संरचना और प्रकार की संरचना के अलावा, बुनियादी उपकरणों के आधार पर सहायक कार्य उपयोगी होते हैं।

• Map
  
  
  
  उदाहरण का क्रमिक निर्माण (दृढ़ता से टाइप किया गया MapBuilder
  
  
  
  );
• संलग्न गुणों की पहुंच और संशोधन के लिए लेंस;
• Map
  
  
  
  रूपांतरण - RecordSet
  
  
  
  और इसके विपरीत

ऐसे ढांचे का उपयोग किया जा सकता है, यदि गुणों के बारे में मेटा-जानकारी के आधार पर विषम डेटा को संसाधित करना आवश्यक है, उदाहरण के लिए:

• डेटाबेस के साथ काम करें:
• विभिन्न संस्थाओं के गुणों से संबंधित घटनाओं के समान प्रसंस्करण, उदाहरण के लिए, वस्तुओं के गुणों को बदलना।

मेटा-जानकारी प्रस्तुत करने की सुविधा के कारण, एनोटेशन का सहारा लिए बिना डेटा प्रोसेसिंग के सभी पहलुओं का विस्तार से वर्णन करना संभव है।



वर्णित डिजाइनों के लिए कोड ।

UPD: विषय की निरंतरता: अधूरे डेटा के कड़ाई से लिखे गए प्रतिनिधित्व