Vergleich
Gleichheit
Mit dem Gleichheitsoperator (==) kannst du bei Elm-Typen prüfen, ob sie „gleich" sind.
Der Ungleichheitsoperator ist (/=) (nicht != wie in vielen Sprachen).
Der Gleichheitsoperator funktioniert mit Literalen, Tupeln, Records und eigenen Typen.
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
Beachte, dass du niemals Funktionen vergleichen solltest, da das Programm sonst zur Laufzeit abstürzt.
Vergleiche
Die Vergleichsoperatoren (<), (<=), (>), (>=) und die Funktionen min, max, compare arbeiten mit comparable-Typen.
Der Typ comparable ist ein spezieller Typ, der alle eingebauten Typen zusammenfasst, die sich vergleichen lassen: Zahlen, Zeichen, Strings, Listen vergleichbarer Dinge und Tupel vergleichbarer Dinge.
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")
Werte anderer Typen wie Records oder eigene Typen lassen sich nicht direkt vergleichen.
Bei manchen eingebauten Typen müssen die Inhalte comparable sein, etwa die Schlüssel von Set oder Dict, da ihre Struktur auf einer internen Ordnung beruht.
Listen mit comparable-Werten lassen sich mit List.sort sortieren, und Listen von Werten, die sich auf vergleichbare Werte abbilden lassen, mit List.sortBy.
Wenn du eine hierarchische Sortierung brauchst (nach einer Eigenschaft sortieren und bei Gleichstand eine andere entscheiden lassen), kannst du ebenfalls Tupel oder Listen mit List.sortBy verwenden, da Tupel und Listen in lexikografischer Reihenfolge sortiert werden.
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"]
Die Funktion compare nimmt zwei comparable-Werte und gibt eine Order zurück.
Eine Order ist ein Typ, der in einem einzigen Schritt prüft, ob ein Wert größer (GT), gleich (EQ) oder kleiner (LT) als ein anderer ist.
compare 1 2
--> LT
compare "" ""
--> EQ
compare [12] []
--> GT
Vergleichsfunktionen lassen sich für beliebige Typen erstellen und zum Beispiel mit List.sortWith zum Sortieren verwenden:
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]
Lernübung
