Elm Language
डेटा एकत्रित करना: ट्यूपल्स, रिकॉर्ड्स और शब्दकोश

tuples

ट्यूपल्स को किसी भी प्रकार के मूल्यों की सूची का आदेश दिया जाता है।

(True, "Hello!", 42)

टपल की संरचना को बदलना या मूल्य को अद्यतन करना असंभव है।

एल्म में ट्यूपल्स को एक आदिम डेटा प्रकार माना जाता है, जिसका अर्थ है कि आपको ट्यूपल्स का उपयोग करने के लिए किसी भी मॉड्यूल को आयात करने की आवश्यकता नहीं है।

पहुंच मूल्यों

बेसिक्स मॉड्यूल में दो पैटर्न के उपयोग के बिना टुपल के मान को दो ( a, b ) तक पहुंचाने के लिए दो सहायक कार्य हैं:

fst (True, "Hello!") -- True
snd (True, "Hello!") -- "Hello!"

एक बड़ी लंबाई के साथ ट्यूपल्स का एक्सेस मान पैटर्न मिलान के माध्यम से किया जाता है।

पैटर्न मिलान

पैटर्न मिलान के साथ संयोजन में ट्यूपल बेहद उपयोगी हैं:

toggleFlag: (Sting, Bool) -> (Sting, Bool)
toggleFlag (name, flag) =
    (name, not flag)

टुपल्स पर टिप्पणी

Tuples में comparable डेटा प्रकार के 7 से कम मूल्य हैं

शब्दकोश

डिक्शन कोर लाइब्रेरी में डिक्शनरी लागू की जाती है।

मूल्यों के लिए एक अद्वितीय मानचित्रण शब्दकोश। कुंजियाँ किसी भी तुलनीय प्रकार की हो सकती हैं। इसमें Int, Float, Time, Char, String, और tuples या तुलनीय प्रकार की सूचियाँ शामिल हैं।

सभी ओ (लॉग एन) समय डालें, निकालें, और क्वेरी ऑपरेशन डालें।

ट्यूपल्स और रिकॉर्ड्स के विपरीत, शब्दकोश अपनी संरचना को बदल सकते हैं, दूसरे शब्दों में यह कुंजी जोड़ना और निकालना संभव है।

एक कुंजी द्वारा एक मूल्य को अद्यतन करना संभव है।

डायनेमिक कुंजियों का उपयोग करके किसी मान को एक्सेस या अपडेट करना भी संभव है।

पहुंच मूल्यों

आप Dict.get फ़ंक्शन का उपयोग करके किसी शब्दकोश से एक मान प्राप्त कर सकते हैं।

Dict.get परिभाषा:

get : comparable -> Dict comparable v -> Maybe v

यह हमेशा Maybe v वापस आएगा, क्योंकि गैर-मौजूद कुंजी द्वारा मूल्य प्राप्त करने की कोशिश करना संभव है।

import Dict

initialUsers =
      Dict.fromList [ (1, "John"), (2, "Brad") ]

getUserName id =
  initialUsers
  |> Dict.get id
  |> Maybe.withDefault "Anonymous"
  
getUserName 2 -- "Brad"
getUserName 0 -- "Anonymous"

मूल्यों को अद्यतन करना

डिक्शनरी में अपडेट ऑपरेशन, Maybe.map का उपयोग करके किया जाता है, क्योंकि अनुरोधित कुंजी अनुपस्थित हो सकती है।

import Dict

initialUsers =
  Dict.fromList [ (1, "John"), (2, "Brad") ]

updatedUsers =
  Dict.update 1 (Maybe.map (\name -> name ++ " Johnson")) initialUsers

Maybe.withDefault "No user" (Dict.get 1 updatedUsers) -- "John Johnson"

अभिलेख

रिकॉर्ड कुंजी-मूल्य जोड़े का एक सेट है।

greeter =
    { isMorning: True
    , greeting: "Good morning!"
    }

एक गैर-मौजूद कुंजी द्वारा एक मूल्य तक पहुंचना असंभव है।

रिकॉर्ड की संरचना को गतिशील रूप से संशोधित करना असंभव है।

रिकॉर्ड केवल आपको निरंतर कुंजियों द्वारा मूल्यों को अपडेट करने की अनुमति देते हैं।

पहुंच मूल्यों

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

isMorningKeyName =
    "isMorning "


greeter[isMorningKeyName] -- Compiler error
greeter.isMorning -- True

मूल्य तक पहुँचने के लिए वैकल्पिक वाक्यविन्यास आपको रिकॉर्ड के माध्यम से पाइपिंग करते समय, मूल्य निकालने की अनुमति देता है:

greeter
    |> .greeting
    |> (++) " Have a nice day!" -- "Good morning! Have a nice day!"

विस्तार प्रकार

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

type alias Person =
    { name : String
    }


type alias Animal =
    { name : String
    }


peter : Person
peter =
    { name = "Peter" }


dog : Animal
dog =
    { name = "Dog" }


getName : { a | name : String } -> String
getName livingThing =
    livingThing.name


bothNames : String
bothNames =
    getName peter ++ " " ++ getName dog

हम भी एक कदम आगे रिकॉर्ड बढ़ा सकते हैं और कुछ ऐसा कर सकते हैं:

type alias Named a = { a | name : String }
type alias Totalled a = { a | total : Int }


totallyNamed : Named ( Totalled { age : Int })
totallyNamed =
  { name = "Peter Pan"
  , total = 1337
  , age = 14
  }

अब हमारे पास इन आंशिक प्रकारों को फ़ंक्शन में पास करने के तरीके हैं:

changeName : Named a -> String -> Named a
changeName a newName =
  { a | name = newName }
  
cptHook = changeName totallyNamed "Cpt. Hook" |> Debug.log "who?"

मूल्यों को अद्यतन करना

एल्म के पास रिकॉर्ड अपडेट के लिए एक विशेष वाक्यविन्यास है:

model =
    { id: 1
    , score: 0
    , name: "John Doe"
    }


update model =
    { model
       | score = model.score + 100
       | name = "John Johnson"
    }