add an order function to help chain comparisons about stdlib HOT 6 CLOSED

pub fn break_tie(in order: Order, with comparison: Order) -> Order {
  case order {
    Lt | Gt -> order
    Eq -> comparison
  }
}

pub fn lazy_break_tie(in order: Order, with comparison: fn() -> Order) -> Order {
  case order {
   Lt | Gt -> order
   Eq -> comparison()
  }
}

// Lazy version that plays nicely with `use`
use <- order.lazy_break_tie(in: string.compare(a.name, b.name))
use <- order.lazy_break_tie(in: int.compare(a.age, b.age))
int.compare(a.cuteness, b.cuteness)

// Non lazy version
string.compare(a.name, b.name)
|> order.break_tie(with: int.compare(a.age, b.age))
|> order.break_tie(with: int.compare(a.cuteness, b.cuteness))

fn compare_cat2(a: Cat, b: Cat) -> Order {
  let name_order = string.compare(a.name, b.name)
  use <- bool.guard(when: name_order != Eq, return: name_order)
  // ^ if the name comparison is not `Eq`, we return it immediately
  //   otherwise we go on and compare the rest.
  let age_order = int.compare(a.age, b.age)
  use <- bool.guard(when: age_order != Eq, return: age_order)
  // ^ if the age comparison is not `Eq`, we return it immediately
  //   otherwise we go on and compare the rest
  int.compare(a.cuteness, b.cuteness)
  // ^ if everything else is equal, the comparison on `cuteness`
  //   will decide the outcome of the comparison
}

pub fn then(order: Order, compare: fn(a, a) -> Order, a1: a, to a2: a) -> Order {
  case order {
    Eq -> compare(a1, a2)
    _ -> order
  }
}

pub fn then(order: Order, compare: fn(a, a) -> Order, a1: a, to a2: a) -> Order {
  use <- bool.guard(when: order != Eq, return: order)
  compare(a1, a2)
}

pub fn compare_cat(a: Cat, b: Cat) -> Order {
  string.compare(a.name, b.name)
  |> order.then(int.compare, a.age, to: b.age)
  |> order.then(int.compare, a.cuteness, to: b.cuteness)
}