Les cartes Blorkemon

Comparaison

Égalité

On peut vérifier si deux types Elm sont « identiques » avec l'opérateur d'égalité (==). L'opérateur de non-égalité est (/=) (et non != comme dans beaucoup de langages). L'opérateur d'égalité fonctionne sur les littéraux, les tuples, les enregistrements et les types personnalisés.

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

Note que tu ne dois jamais comparer de fonctions, sous peine de faire planter le programme à l'exécution.

Comparaisons

Les opérateurs de comparaison (<), (<=), (>), (>=) et les fonctions min, max, compare fonctionnent sur les types comparable. Le type comparable est un type spécial qui regroupe tous les types natifs que l'on peut comparer : les nombres, les caractères, les strings, les listes d'éléments comparables et les tuples d'éléments comparables.

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")

Les valeurs d'autres types, comme les enregistrements ou les types personnalisés, ne peuvent pas être comparées directement.

Certains types natifs exigent que leur contenu soit comparable, comme les clés de Set ou de Dict, car leur structure repose sur un ordre interne.

Les listes de valeurs comparable peuvent être triées avec List.sort, et les listes de valeurs que l'on peut transformer en valeurs comparables peuvent être triées avec List.sortBy. Si tu as besoin d'un tri hiérarchique (trier selon une propriété, puis départager les égalités avec une autre), tu peux aussi utiliser des tuples ou des listes avec List.sortBy, car les tuples et les listes sont triés dans l'ordre lexicographique.

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"]

La fonction compare prend deux valeurs comparable et renvoie un Order. Un Order est un type qui permet de vérifier en une seule opération si une valeur est supérieure (GT), égale (EQ) ou inférieure (LT) à une autre.

compare 1 2
    --> LT

compare "" ""
    --> EQ

compare [12] []
    --> GT

On peut construire des fonctions de comparaison pour des types arbitraires et les utiliser, par exemple, pour trier avec 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]