Cartas Blorkemon

Comparação

Igualdade

Os tipos de Elm podem ser verificados quanto a "serem iguais" com o operador de igualdade (==). O operador de diferença é (/=) (não != como em muitas linguagens). O operador de igualdade funciona com literais, tuplas, registros e tipos personalizados.

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

Repare que você nunca deve comparar funções, pois isso fará o programa quebrar em tempo de execução.

Comparações

Os operadores de comparação (<), (<=), (>), (>=) e as funções min, max, compare funcionam com tipos comparable. O tipo comparable é um tipo especial que agrupa todos os tipos embutidos que podem ser comparados: números, caracteres, strings, listas de coisas comparáveis e tuplas de coisas comparáveis.

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

Valores de outros tipos, como registros ou tipos personalizados, não podem ser comparados diretamente.

Alguns tipos embutidos exigem que seu conteúdo seja comparable, como as chaves de Set ou Dict, já que sua estrutura depende de uma ordenação interna.

Listas de valores comparable podem ser ordenadas com List.sort, e listas de valores que podem ser mapeados para valores comparáveis podem ser ordenadas com List.sortBy. Se você precisar de uma ordenação hierárquica (ordenar por uma propriedade e desempatar com outra), tuplas ou listas também podem ser usadas com List.sortBy, já que tuplas e listas são ordenadas em ordem lexicográfica.

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

A função compare recebe dois valores comparable e retorna um Order. Um Order é um tipo que verifica em uma única operação se um valor é maior (GT), igual (EQ) ou menor (LT) que outro.

compare 1 2
    --> LT

compare "" ""
    --> EQ

compare [12] []
    --> GT

Funções de comparação podem ser construídas para tipos arbitrários e usadas, por exemplo, para ordenar com 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]