gleam/order

Types

Represents the result of a single comparison to determine the precise ordering of two values.

pub type Order {
  Lt
  Eq
  Gt
}

</>

pub fn break_tie(in order: Order, with other: Order) -> Order

Return a fallback Order in case the first argument is Eq.

import gleam/int

break_tie(in: int.compare(1, 1), with: Lt)
// -> Lt

import gleam/int

break_tie(in: int.compare(1, 0), with: Eq)
// -> Gt

</>

pub fn compare(a: Order, with b: Order) -> Order

Compares two Order values to one another, producing a new Order.

compare(Eq, with: Lt)
// -> Gt

</>

pub fn lazy_break_tie(
  in order: Order,
  with comparison: fn() -> Order,
) -> Order

Invokes a fallback function returning an Order in case the first argument is Eq.

This can be useful when the fallback comparison might be expensive and it needs to be delayed until strictly necessary.

import gleam/int

lazy_break_tie(in: int.compare(1, 1), with: fn() { Lt })
// -> Lt

import gleam/int

lazy_break_tie(in: int.compare(1, 0), with: fn() { Eq })
// -> Gt

</>

pub fn max(a: Order, b: Order) -> Order

Returns the largest of two orders given that Gt > Eq > Lt.

max(Eq, Lt)
// -> Eq

</>

pub fn min(a: Order, b: Order) -> Order

Returns the smallest of two orders given that Gt > Eq > Lt.

min(Eq, Lt)
// -> Lt

</>

pub fn negate(order: Order) -> Order

Inverts an order, so less-than becomes greater-than and greater-than becomes less-than.

negate(Lt)
// -> Gt

negate(Eq)
// -> Eq

negate(Lt)
// -> Gt

</>

pub fn reverse(orderer: fn(a, a) -> Order) -> fn(a, a) -> Order

Inverts an ordering function, so less-than becomes greater-than and greater-than becomes less-than.

import gleam/int
import gleam/list

list.sort([1, 5, 4], by: reverse(int.compare))
// -> [5, 4, 1]

</>

pub fn to_int(order: Order) -> Int

Produces a numeric representation of the order.

to_int(Lt)
// -> -1

to_int(Eq)
// -> 0

to_int(Gt)
// -> 1