init

2026-06-29 15:56:30 +02:00
commit 6fe57399c4
152 changed files with 32122 additions and 0 deletions
@@ -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([]));
+}