Initial commit

build/dev/javascript/gleam_stdlib/gleam/order.mjs

@@ -0,0 +1,178 @@
+import { CustomType as $CustomType, isEqual } from "../gleam.mjs";
+
+export class Lt extends $CustomType {}
+export const Order$Lt = () => new Lt();
+export const Order$isLt = (value) => value instanceof Lt;
+
+export class Eq extends $CustomType {}
+export const Order$Eq = () => new Eq();
+export const Order$isEq = (value) => value instanceof Eq;
+
+export class Gt extends $CustomType {}
+export const Order$Gt = () => new Gt();
+export const Order$isGt = (value) => value instanceof Gt;
+
+/**
+ * Inverts an order, so less-than becomes greater-than and greater-than
+ * becomes less-than.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * negate(Lt)
+ * // -> Gt
+ * ```
+ *
+ * ```gleam
+ * negate(Eq)
+ * // -> Eq
+ * ```
+ *
+ * ```gleam
+ * negate(Gt)
+ * // -> Lt
+ * ```
+ */
+export function negate(order) {
+  if (order instanceof Lt) {
+    return new Gt();
+  } else if (order instanceof Eq) {
+    return order;
+  } else {
+    return new Lt();
+  }
+}
+
+/**
+ * Produces a numeric representation of the order.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * to_int(Lt)
+ * // -> -1
+ * ```
+ *
+ * ```gleam
+ * to_int(Eq)
+ * // -> 0
+ * ```
+ *
+ * ```gleam
+ * to_int(Gt)
+ * // -> 1
+ * ```
+ */
+export function to_int(order) {
+  if (order instanceof Lt) {
+    return -1;
+  } else if (order instanceof Eq) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+/**
+ * Compares two `Order` values to one another, producing a new `Order`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * compare(Eq, with: Lt)
+ * // -> Gt
+ * ```
+ */
+export function compare(a, b) {
+  let x = a;
+  let y = b;
+  if (isEqual(x, y)) {
+    return new Eq();
+  } else if (a instanceof Lt) {
+    return new Lt();
+  } else if (a instanceof Eq && b instanceof Gt) {
+    return new Lt();
+  } else {
+    return new Gt();
+  }
+}
+
+/**
+ * Inverts an ordering function, so less-than becomes greater-than and greater-than
+ * becomes less-than.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * import gleam/int
+ * import gleam/list
+ *
+ * list.sort([1, 5, 4], by: reverse(int.compare))
+ * // -> [5, 4, 1]
+ * ```
+ */
+export function reverse(orderer) {
+  return (a, b) => { return orderer(b, a); };
+}
+
+/**
+ * Return a fallback `Order` in case the first argument is `Eq`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * break_tie(in: int.compare(1, 1), with: Lt)
+ * // -> Lt
+ * ```
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * break_tie(in: int.compare(1, 0), with: Eq)
+ * // -> Gt
+ * ```
+ */
+export function break_tie(order, other) {
+  if (order instanceof Lt) {
+    return order;
+  } else if (order instanceof Eq) {
+    return other;
+  } else {
+    return 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.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * lazy_break_tie(in: int.compare(1, 1), with: fn() { Lt })
+ * // -> Lt
+ * ```
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * lazy_break_tie(in: int.compare(1, 0), with: fn() { Eq })
+ * // -> Gt
+ * ```
+ */
+export function lazy_break_tie(order, comparison) {
+  if (order instanceof Lt) {
+    return order;
+  } else if (order instanceof Eq) {
+    return comparison();
+  } else {
+    return order;
+  }
+}