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

assert order.break_tie(in: int.compare(1, 1), with: Lt) == Lt

import gleam/int

assert order.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.

assert 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

assert order.lazy_break_tie(in: int.compare(1, 1), with: fn() { Lt }) == Lt

import gleam/int

assert order.lazy_break_tie(in: int.compare(1, 0), with: fn() { Eq }) == Gt

</>

pub fn negate(order: Order) -> Order

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

assert order.negate(Lt) == Gt

assert order.negate(Eq) == Eq

assert order.negate(Gt) == Lt

</>

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

assert list.sort([1, 5, 4], by: order.reverse(int.compare)) == [5, 4, 1]

</>

pub fn to_int(order: Order) -> Int

Produces a numeric representation of the order.

assert order.to_int(Lt) == -1

assert order.to_int(Eq) == 0

assert order.to_int(Gt) == 1