Le carte Blorkemon

Confronto

Uguaglianza

I tipi di Elm possono essere controllati per «essere uguali» con l'operatore di uguaglianza (==). L'operatore di disuguaglianza è (/=) (non != come in molti linguaggi). L'operatore di uguaglianza funziona su letterali, tuple, record e tipi personalizzati.

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

Tieni presente che non dovresti mai confrontare le funzioni, perché così il programma andrà in crash a runtime.

Confronti

Gli operatori di confronto (<), (<=), (>), (>=) e le funzioni min, max, compare funzionano con i tipi comparable. Il tipo comparable è un tipo speciale che raggruppa tutti i tipi predefiniti che si possono confrontare: numeri, caratteri, stringhe, liste di elementi comparabili e tuple di elementi comparabili.

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

I valori di altri tipi, come i record o i tipi personalizzati, non possono essere confrontati direttamente.

Alcuni tipi predefiniti richiedono che il loro contenuto sia comparable, come le chiavi di Set o Dict, poiché la loro struttura si basa su un ordinamento interno.

Le liste di valori comparable possono essere ordinate con List.sort e le liste di valori che possono essere mappati a valori comparabili possono essere ordinate con List.sortBy. Se hai bisogno di un ordinamento gerarchico (ordina per una proprietà e risolvi i pareggi con un'altra), anche tuple o liste possono essere usate con List.sortBy, poiché tuple e liste vengono ordinate in ordine lessicografico.

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 funzione compare prende due valori comparable e restituisce un Order. Un Order è un tipo che permette di verificare in una sola operazione se un valore è maggiore (GT), uguale (EQ) o minore (LT) di un altro.

compare 1 2
    --> LT

compare "" ""
    --> EQ

compare [12] []
    --> GT

Le funzioni di confronto possono essere costruite per tipi arbitrari e usate, per esempio, per ordinare con 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]