तुलना
समानता
Elm के टाइप में समानता ऑपरेटर (==) से जाँच की जा सकती है कि वे "एक जैसे" हैं।
असमानता ऑपरेटर (/=) है (नहीं कि कई भाषाओं की तरह !=)।
समानता ऑपरेटर लिटरल, टपल, रिकॉर्ड और कस्टम टाइप पर काम करता है।
1 == 2
--> False
1 /= 2
--> True
(1, 2) == (2, 1)
--> False
type alias MyRecord = { myInt : Int, myStrings : List String }
a : MyRecord
a = MyRecord (1 + 1) ["hello world"]
type alias MyOtherRecord = { myInt : Int, myStrings : List String }
myStrings = (String.join " " ["hello", "world"]) :: []
b : MyOtherRecord
b = { myInt = 2, myStrings = myStrings}
a == b
--> True
ध्यान दें कि आपको फंक्शन की तुलना कभी नहीं करनी चाहिए, क्योंकि इससे प्रोग्राम रनटाइम पर क्रैश हो जाएगा।
तुलनाएँ
तुलना ऑपरेटर (<), (<=), (>), (>=) और फंक्शन min, max, compare comparable टाइप पर काम करते हैं।
comparable टाइप एक विशेष टाइप है जो उन सभी बिल्ट-इन टाइप को एक साथ रखता है जिनकी तुलना की जा सकती है: संख्याएँ, अक्षर, स्ट्रिंग, comparable चीज़ों के ऐरे, और comparable चीज़ों के टपल।
1 < 1 + 1
--> True
'x' < 'X'
--> False
"abc" < "abz"
--> True
"abc" < "abcd"
--> True
"abc" < "b"
--> True
min [1 , 2, 9000] [10]
--> [1 , 2, 9000]
min (1, "hello") (3, "bye")
--> (1, "hello")
रिकॉर्ड या कस्टम टाइप जैसे अन्य टाइप की वैल्यू की सीधे तुलना नहीं की जा सकती।
कुछ बिल्ट-इन टाइप के लिए ज़रूरी है कि उनका कंटेंट comparable हो, जैसे Set या Dict की कीज़, क्योंकि उनकी संरचना एक आंतरिक क्रम पर निर्भर करती है।
comparable वैल्यू वाले ऐरे को List.sort से क्रमबद्ध किया जा सकता है, और ऐसी वैल्यू वाले ऐरे जिन्हें comparable वैल्यू में मैप किया जा सकता है, उन्हें List.sortBy से क्रमबद्ध किया जा सकता है।
अगर आपको एक के बाद एक कई आधारों पर क्रम लगाना है (पहले एक प्रॉपर्टी से, और बराबरी होने पर दूसरी से), तो टपल या ऐरे का इस्तेमाल List.sortBy के साथ भी किया जा सकता है, क्योंकि टपल और ऐरे लेक्सिकोग्राफिक क्रम में क्रमबद्ध होते हैं।
List.sort ["hi", "hello", "bye", "goodbye"]
--> ["bye", "goodbye", "hello", "hi"]
List.sortBy String.length ["hi", "hello", "bye", "goodbye"]
--> ["hi", "bye", "hello", "goodbye"]
-- sort by length, then alphabetically
List.sortBy (\str -> (String.length str, str)) ["hi", "mum", "hello", "sis", "bye", "dad"]
--> ["hi", "bye", "dad", "mum", "sis", "hello"]
फंक्शन compare दो comparable वैल्यू लेता है और एक Order लौटाता है।
एक Order एक ऐसा टाइप है जो एक ही ऑपरेशन में जाँचता है कि कोई वैल्यू दूसरी से बड़ी (GT), बराबर (EQ) या छोटी (LT) है या नहीं।
compare 1 2
--> LT
compare "" ""
--> EQ
compare [12] []
--> GT
तुलना फंक्शन किसी भी टाइप के लिए बनाए जा सकते हैं और उनका उपयोग, उदाहरण के लिए, List.sortWith से क्रमबद्ध करने के लिए किया जा सकता है:
type Color = Red | Green | Blue
compareColors : Color -> Color -> Order
compareColors a b =
case (a, b) of
(Red, Red) -> EQ
(Red, _) -> LT
(_, Red) -> GT
(Green, Green) -> EQ
(Green, _) -> LT
(_, Green) -> GT
(Blue, Blue) -> EQ
List.sortWith compareColors [Blue, Red, Green, Green, Blue]
--> [Red, Green, Green, Blue, Blue]
सीखने का अभ्यास
