Cartas Blorkemon

Comparação

Igualdade

Os tipos de Elm podem ser verificados quanto a "serem iguais" com o operador de igualdade (==). O operador de desigualdade é (/=) (não !=, como em muitas linguagens). O operador de igualdade funciona com literais, tuplos, registos 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

Repara que nunca deves comparar funções, pois isso faz com que o programa rebente em tempo de execução.

Comparações

Os operadores de comparação (<), (<=), (>), (>=) e as funções min, max e compare funcionam com tipos comparable. O tipo comparable é um tipo especial que agrupa todos os tipos incorporados que podem ser comparados: números, carateres, strings, listas de elementos comparáveis e tuplos de elementos 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")

Os valores de outros tipos, como registos ou tipos personalizados, não podem ser comparados diretamente.

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

As listas de valores comparable podem ser ordenadas com List.sort e as listas de valores que podem ser mapeados para valores comparáveis podem ser ordenadas com List.sortBy. Se precisares de uma ordenação hierárquica (ordenar por uma propriedade e desempatar com outra), também podes usar tuplos ou listas com List.sortBy, uma vez que os tuplos e as listas são ordenados por 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 devolve um Order. Um Order é um tipo que verifica, numa única operação, se um valor é maior (GT), igual (EQ) ou menor (LT) do que outro.

compare 1 2
    --> LT

compare "" ""
    --> EQ

compare [12] []
    --> GT

É possível construir funções de comparação para tipos arbitrários e usá-las, 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]