Cartas de Blorkemon

Comparación

Igualdad

Puedes comprobar si dos valores de Elm «son lo mismo» con el operador de igualdad (==). El operador de desigualdad es (/=) (no != como en muchos lenguajes). El operador de igualdad funciona con literales, tuplas, records y 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

Ten en cuenta que nunca debes comparar funciones, ya que esto hará que el programa falle en tiempo de ejecución.

Comparaciones

Los operadores de comparación (<), (<=), (>), (>=) y las funciones min, max, compare funcionan con tipos comparable. El tipo comparable es un tipo especial que agrupa todos los tipos integrados que se pueden comparar: números, caracteres, strings, listas de cosas comparables y tuplas de cosas 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")

Los valores de otros tipos, como los records o los tipos personalizados, no se pueden comparar directamente.

Algunos tipos integrados requieren que su contenido sea comparable, como las claves de Set o Dict, ya que su estructura depende de un orden interno.

Las listas de valores comparable se pueden ordenar con List.sort, y las listas de valores que se pueden transformar en valores comparables se pueden ordenar con List.sortBy. Si necesitas una ordenación jerárquica (ordenar por una propiedad y desempatar con otra), también puedes usar tuplas o listas con List.sortBy, ya que las tuplas y las listas se ordenan en orden lexicográfico.

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 función compare toma dos valores comparable y devuelve un Order. Un Order es un tipo que comprueba en una sola operación si un valor es mayor (GT), igual (EQ) o menor (LT) que otro.

compare 1 2
    --> LT

compare "" ""
    --> EQ

compare [12] []
    --> GT

Se pueden construir funciones de comparación para tipos arbitrarios y usarlas, por ejemplo, para ordenar 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]