create-mendix-widget-gleam 2.0.14 → 2.0.15

package/tui/build/dev/javascript/gleam_stdlib/gleam/option.mjs

@@ -0,0 +1,386 @@
+import {
+  Ok,
+  Error,
+  toList,
+  Empty as $Empty,
+  prepend as listPrepend,
+  CustomType as $CustomType,
+} from "../gleam.mjs";
+
+export class Some extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Option$Some = ($0) => new Some($0);
+export const Option$isSome = (value) => value instanceof Some;
+export const Option$Some$0 = (value) => value[0];
+
+export class None extends $CustomType {}
+export const Option$None = () => new None();
+export const Option$isNone = (value) => value instanceof None;
+
+function reverse_and_prepend(loop$prefix, loop$suffix) {
+  while (true) {
+    let prefix = loop$prefix;
+    let suffix = loop$suffix;
+    if (prefix instanceof $Empty) {
+      return suffix;
+    } else {
+      let first = prefix.head;
+      let rest = prefix.tail;
+      loop$prefix = rest;
+      loop$suffix = listPrepend(first, suffix);
+    }
+  }
+}
+
+function reverse(list) {
+  return reverse_and_prepend(list, toList([]));
+}
+
+function all_loop(loop$list, loop$acc) {
+  while (true) {
+    let list = loop$list;
+    let acc = loop$acc;
+    if (list instanceof $Empty) {
+      return new Some(reverse(acc));
+    } else {
+      let $ = list.head;
+      if ($ instanceof Some) {
+        let rest = list.tail;
+        let first = $[0];
+        loop$list = rest;
+        loop$acc = listPrepend(first, acc);
+      } else {
+        return new None();
+      }
+    }
+  }
+}
+
+/**
+ * Combines a list of `Option`s into a single `Option`.
+ * If all elements in the list are `Some` then returns a `Some` holding the list of values.
+ * If any element is `None` then returns `None`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert all([Some(1), Some(2)]) == Some([1, 2])
+ * ```
+ *
+ * ```gleam
+ * assert all([Some(1), None]) == None
+ * ```
+ */
+export function all(list) {
+  return all_loop(list, toList([]));
+}
+
+/**
+ * Checks whether the `Option` is a `Some` value.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert is_some(Some(1))
+ * ```
+ *
+ * ```gleam
+ * assert !is_some(None)
+ * ```
+ */
+export function is_some(option) {
+  return !(option instanceof None);
+}
+
+/**
+ * Checks whether the `Option` is a `None` value.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert !is_none(Some(1))
+ * ```
+ *
+ * ```gleam
+ * assert is_none(None)
+ * ```
+ */
+export function is_none(option) {
+  return option instanceof None;
+}
+
+/**
+ * Converts an `Option` type to a `Result` type.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert to_result(Some(1), "some_error") == Ok(1)
+ * ```
+ *
+ * ```gleam
+ * assert to_result(None, "some_error") == Error("some_error")
+ * ```
+ */
+export function to_result(option, e) {
+  if (option instanceof Some) {
+    let a = option[0];
+    return new Ok(a);
+  } else {
+    return new Error(e);
+  }
+}
+
+/**
+ * Converts a `Result` type to an `Option` type.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert from_result(Ok(1)) == Some(1)
+ * ```
+ *
+ * ```gleam
+ * assert from_result(Error("some_error")) == None
+ * ```
+ */
+export function from_result(result) {
+  if (result instanceof Ok) {
+    let a = result[0];
+    return new Some(a);
+  } else {
+    return new None();
+  }
+}
+
+/**
+ * Extracts the value from an `Option`, returning a default value if there is none.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert unwrap(Some(1), 0) == 1
+ * ```
+ *
+ * ```gleam
+ * assert unwrap(None, 0) == 0
+ * ```
+ */
+export function unwrap(option, default$) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return x;
+  } else {
+    return default$;
+  }
+}
+
+/**
+ * Extracts the value from an `Option`, evaluating the default function if the option is `None`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert lazy_unwrap(Some(1), fn() { 0 }) == 1
+ * ```
+ *
+ * ```gleam
+ * assert lazy_unwrap(None, fn() { 0 }) == 0
+ * ```
+ */
+export function lazy_unwrap(option, default$) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return x;
+  } else {
+    return default$();
+  }
+}
+
+/**
+ * Updates a value held within the `Some` of an `Option` by calling a given function
+ * on it.
+ *
+ * If the `Option` is a `None` rather than `Some`, the function is not called and the
+ * `Option` stays the same.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert map(over: Some(1), with: fn(x) { x + 1 }) == Some(2)
+ * ```
+ *
+ * ```gleam
+ * assert map(over: None, with: fn(x) { x + 1 }) == None
+ * ```
+ */
+export function map(option, fun) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return new Some(fun(x));
+  } else {
+    return option;
+  }
+}
+
+/**
+ * Merges a nested `Option` into a single layer.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert flatten(Some(Some(1))) == Some(1)
+ * ```
+ *
+ * ```gleam
+ * assert flatten(Some(None)) == None
+ * ```
+ *
+ * ```gleam
+ * assert flatten(None) == None
+ * ```
+ */
+export function flatten(option) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return x;
+  } else {
+    return option;
+  }
+}
+
+/**
+ * Updates a value held within the `Some` of an `Option` by calling a given function
+ * on it, where the given function also returns an `Option`. The two options are
+ * then merged together into one `Option`.
+ *
+ * If the `Option` is a `None` rather than `Some` the function is not called and the
+ * option stays the same.
+ *
+ * This function is the equivalent of calling `map` followed by `flatten`, and
+ * it is useful for chaining together multiple functions that return `Option`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert then(Some(1), fn(x) { Some(x + 1) }) == Some(2)
+ * ```
+ *
+ * ```gleam
+ * assert then(Some(1), fn(x) { Some(#("a", x)) }) == Some(#("a", 1))
+ * ```
+ *
+ * ```gleam
+ * assert then(Some(1), fn(_) { None }) == None
+ * ```
+ *
+ * ```gleam
+ * assert then(None, fn(x) { Some(x + 1) }) == None
+ * ```
+ */
+export function then$(option, fun) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return fun(x);
+  } else {
+    return option;
+  }
+}
+
+/**
+ * Returns the first value if it is `Some`, otherwise returns the second value.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert or(Some(1), Some(2)) == Some(1)
+ * ```
+ *
+ * ```gleam
+ * assert or(Some(1), None) == Some(1)
+ * ```
+ *
+ * ```gleam
+ * assert or(None, Some(2)) == Some(2)
+ * ```
+ *
+ * ```gleam
+ * assert or(None, None) == None
+ * ```
+ */
+export function or(first, second) {
+  if (first instanceof Some) {
+    return first;
+  } else {
+    return second;
+  }
+}
+
+/**
+ * Returns the first value if it is `Some`, otherwise evaluates the given function for a fallback value.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert lazy_or(Some(1), fn() { Some(2) }) == Some(1)
+ * ```
+ *
+ * ```gleam
+ * assert lazy_or(Some(1), fn() { None }) == Some(1)
+ * ```
+ *
+ * ```gleam
+ * assert lazy_or(None, fn() { Some(2) }) == Some(2)
+ * ```
+ *
+ * ```gleam
+ * assert lazy_or(None, fn() { None }) == None
+ * ```
+ */
+export function lazy_or(first, second) {
+  if (first instanceof Some) {
+    return first;
+  } else {
+    return second();
+  }
+}
+
+function values_loop(loop$list, loop$acc) {
+  while (true) {
+    let list = loop$list;
+    let acc = loop$acc;
+    if (list instanceof $Empty) {
+      return reverse(acc);
+    } else {
+      let $ = list.head;
+      if ($ instanceof Some) {
+        let rest = list.tail;
+        let first = $[0];
+        loop$list = rest;
+        loop$acc = listPrepend(first, acc);
+      } else {
+        let rest = list.tail;
+        loop$list = rest;
+        loop$acc = acc;
+      }
+    }
+  }
+}
+
+/**
+ * Given a list of `Option`s,
+ * returns only the values inside `Some`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert values([Some(1), None, Some(3)]) == [1, 3]
+ * ```
+ */
+export function values(options) {
+  return values_loop(options, toList([]));
+}

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

@@ -0,0 +1,166 @@
+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
+ * assert negate(Lt) == Gt
+ * ```
+ *
+ * ```gleam
+ * assert negate(Eq) == Eq
+ * ```
+ *
+ * ```gleam
+ * assert 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
+ * assert to_int(Lt) == -1
+ * ```
+ *
+ * ```gleam
+ * assert to_int(Eq) == 0
+ * ```
+ *
+ * ```gleam
+ * assert 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
+ * assert 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
+ *
+ * assert 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
+ *
+ * assert break_tie(in: int.compare(1, 1), with: Lt) == Lt
+ * ```
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * assert 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
+ *
+ * assert lazy_break_tie(in: int.compare(1, 1), with: fn() { Lt }) == Lt
+ * ```
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * assert 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;
+  }
+}

package/tui/build/dev/javascript/gleam_stdlib/gleam/pair.mjs

@@ -0,0 +1,96 @@
+/**
+ * Returns the first element in a pair.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert first(#(1, 2)) == 1
+ * ```
+ */
+export function first(pair) {
+  let a;
+  a = pair[0];
+  return a;
+}
+
+/**
+ * Returns the second element in a pair.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert second(#(1, 2)) == 2
+ * ```
+ */
+export function second(pair) {
+  let a;
+  a = pair[1];
+  return a;
+}
+
+/**
+ * Returns a new pair with the elements swapped.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert swap(#(1, 2)) == #(2, 1)
+ * ```
+ */
+export function swap(pair) {
+  let a;
+  let b;
+  a = pair[0];
+  b = pair[1];
+  return [b, a];
+}
+
+/**
+ * Returns a new pair with the first element having had `with` applied to
+ * it.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert #(1, 2) |> map_first(fn(n) { n * 2 }) == #(2, 2)
+ * ```
+ */
+export function map_first(pair, fun) {
+  let a;
+  let b;
+  a = pair[0];
+  b = pair[1];
+  return [fun(a), b];
+}
+
+/**
+ * Returns a new pair with the second element having had `with` applied to
+ * it.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert #(1, 2) |> map_second(fn(n) { n * 2 }) == #(1, 4)
+ * ```
+ */
+export function map_second(pair, fun) {
+  let a;
+  let b;
+  a = pair[0];
+  b = pair[1];
+  return [a, fun(b)];
+}
+
+/**
+ * Returns a new pair with the given elements. This can also be done using the dedicated
+ * syntax instead: `new(1, 2) == #(1, 2)`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * assert new(1, 2) == #(1, 2)
+ * ```
+ */
+export function new$(first, second) {
+  return [first, second];
+}