शीर्ष स्कोरर

Dict

Elm में Dict शून्य या अधिक की-वैल्यू जोड़ों वाली एक अपरिवर्तनीय डिक्शनरी होती है।

डिक्शनरी पर काम Dict मॉड्यूल में परिभाषित फंक्शन और ऑपरेटर करते हैं।

डिक्शनरी के टाइप एनोटेशन इस तरह लिखे जाते हैं:

Dict String (List Int) --> a dict with String keys and List Int values
Dict Int String --> a dict with Int keys and String values

डिक्शनरी इस तरह बनाई जा सकती है:

empty : Dict Int String
empty = Dict.empty

singleValue = Dict.singleton 5 "Value for key 5" --> Dict Int String

twoValues = Dict.fromList [ ( "Alice", 0 ), ( "Bob", 1 ) ] --> Dict String Int

एलिमेंट get की मदद से निकाले जा सकते हैं। चूँकि कोई की डिक्शनरी में हो भी सकती है और नहीं भी, इसलिए परिणाम Maybe में लपेटकर दिया जाता है।

alice = Dict.fromList [ ( 0, "Alice" ) ]
keyExists = Dict.get 0 alice --> Just "Alice"
keyNotPresent = Dict.get 1 alice --> Nothing

एलिमेंट insert की मदद से जोड़े जा सकते हैं। जो की पहले से डिक्शनरी में मौजूद हैं, उनके एलिमेंट बदल दिए जाते हैं।

alice = Dict.fromList [ ( "Alice", 0 ) ]
aliceAndBob = Dict.insert "Bob" 1 alice  --> Dict.fromList [ ( "Alice", 0 ), ( "Bob", 1 ) ]
aliceAndAlice = Dict.insert "Alice" 1 alice  --> Dict.fromList [ ( "Alice", 1 ) ]

एलिमेंट update की मदद से अपडेट किए जा सकते हैं। अगर की मौजूद न हो, तो अपडेट फंक्शन को Nothing के साथ कॉल किया जाता है।

alice = Dict.fromList [ ( 0, "Alice" ) ]
aliceUpperCase = Dict.update 0 (Maybe.map String.toUpper) alice --> Dict.fromList [ ( 0, "ALICE" ) ]
aliceNoCase = Dict.update 0 (\_ -> Nothing) alice --> Dict.empty
bobUpperCase = Dict.update 1 (\_ -> Just "BOB") alice --> Dict.fromList [ ( 0, "Alice" ), ( 1, "BOB" ) ]
bobNoCase = Dict.update 1 (\_ -> Nothing) alice --> Dict.fromList [ ( 0, "Alice" ) ]

एलिमेंट remove की मदद से हटाए जा सकते हैं। अगर की मौजूद न हो, तो कोई बदलाव नहीं होता।

alice = Dict.fromList [ ( 0, "Alice" ) ]
stillAlice = Dict.remove 1 --> ( 0, "Alice" )
empty = Dict.remove 0 alice --> Dict.empty

की-वैल्यू जोड़ों के ऐरे को fromList की मदद से डिक्शनरी में बदला जा सकता है।

alice = Dict.fromList [ ( 0, "Bob" ), ( 0, "Alice" ) ]
--> True Dict.fromList [ ( 0, "Alice" ) ]

एलिमेंट को toList की मदद से ऐरे में बदला जा सकता है। ऐरे को की के हिसाब से क्रम में रखा जाता है।

aliceAndBob = Dict.fromList [ ( 1, "Alice" ), ( 0, "Bob" ) ]
bobAndAlice = Dict.toList aliceAndBob
--> [ ( 0, "Bob" ), ( 1, "Alice" ) ]

कई एलिमेंट filter की मदद से हटाए जा सकते हैं।

aliceAndBob = Dict.fromList [ ( "Alice", 1 ), ( "Bob", 0 ) ]
bob = Dict.filter (\name count -> name == "Bob") aliceAndBob --> Dict.fromList [ ( "Bob", 0 ) ]

एलिमेंट को map की मदद से बदला जा सकता है।

alice = Dict.fromList [ ( "Alice", 0 ) ]
empty = Dict.map (\player count -> count + 1) alice --> Dict.fromList [ ( "Alice", 1 ) ]

डिक्शनरी को merge की मदद से जोड़ा या बदला जा सकता है।

aliceAndBob = Dict.fromList [ ( "Alice", 1 ), ( "Bob", 1 ) ]
bobAndCedd = Dict.fromList [ ( "Bob", 1 ), ( "Cedd", 1 ) ]
firstDictCountsDouble = Dict.merge
        -- when only in aliceAndBob
        (\name count mergedCounts -> Dict.insert name (2 * count) mergedCounts)
        -- when in aliceAndBob and bobAndCedd
        (\name aliceAndBobCount bobAndCeddCount mergedCounts -> Dict.insert name (2 * aliceAndBobCount + bobAndCeddCount) mergedCounts)
        -- when only in bobAndCedd
        (\name count mergedCounts -> Dict.insert name count mergedCounts)
        -- the two dicts to merge
        aliceAndBob
        bobAndCedd
        -- the initial state of the merge
        Dict.empty
--> Dict.fromList [ ( "Alice", 2 ), ( "Bob", 3 ), ( "Cedd", 1 ) ]

जो भी फंक्शन या ऑपरेटर डिक्शनरी में बदलाव करता दिखता है (जैसे कोई एलिमेंट जोड़ना), वह वास्तव में एक नई डिक्शनरी लौटाता है। आम तौर पर परफॉर्मेंस की कोई समस्या नहीं होती, क्योंकि इस इम्प्लीमेंटेशन में गैर-ज़रूरी एलोकेशन और कॉपी रोकी जाती है।

Elm में आम तौर पर बेहतर यही होता है कि Dict.get और Dict.remove जैसे निचले स्तर के अब्सट्रैक्शन के बजाय Dict.map, Dict.filter और Dict.merge जैसे ऊँचे स्तर के अब्सट्रैक्शन इस्तेमाल किए जाएँ, हालाँकि यह संदर्भ पर भी निर्भर करता है।