skill-universe 1.1.0

package/build/dev/javascript/gleam_stdlib/gleam/bytes_tree.mjs

@@ -0,0 +1,225 @@
+import {
+  toList,
+  Empty as $Empty,
+  prepend as listPrepend,
+  CustomType as $CustomType,
+} from "../gleam.mjs";
+import * as $bit_array from "../gleam/bit_array.mjs";
+import * as $list from "../gleam/list.mjs";
+import * as $string_tree from "../gleam/string_tree.mjs";
+
+class Bytes extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Text extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Many extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+/**
+ * Appends a bytes tree onto the end of another.
+ *
+ * Runs in constant time.
+ */
+export function append_tree(first, second) {
+  if (second instanceof Bytes) {
+    return new Many(toList([first, second]));
+  } else if (second instanceof Text) {
+    return new Many(toList([first, second]));
+  } else {
+    let trees = second[0];
+    return new Many(listPrepend(first, trees));
+  }
+}
+
+/**
+ * Prepends a bytes tree onto the start of another.
+ *
+ * Runs in constant time.
+ */
+export function prepend_tree(second, first) {
+  return append_tree(first, second);
+}
+
+/**
+ * Joins a list of bytes trees into a single one.
+ *
+ * Runs in constant time.
+ */
+export function concat(trees) {
+  return new Many(trees);
+}
+
+/**
+ * Create an empty `BytesTree`. Useful as the start of a pipe chaining many
+ * trees together.
+ */
+export function new$() {
+  return concat(toList([]));
+}
+
+/**
+ * Creates a new bytes tree from a string.
+ *
+ * Runs in constant time when running on Erlang.
+ * Runs in linear time otherwise.
+ */
+export function from_string(string) {
+  return new Text($string_tree.from_string(string));
+}
+
+/**
+ * Prepends a string onto the start of a bytes tree.
+ *
+ * Runs in constant time when running on Erlang.
+ * Runs in linear time with the length of the string otherwise.
+ */
+export function prepend_string(second, first) {
+  return append_tree(from_string(first), second);
+}
+
+/**
+ * Appends a string onto the end of a bytes tree.
+ *
+ * Runs in constant time when running on Erlang.
+ * Runs in linear time with the length of the string otherwise.
+ */
+export function append_string(first, second) {
+  return append_tree(first, from_string(second));
+}
+
+/**
+ * Creates a new bytes tree from a string tree.
+ *
+ * Runs in constant time when running on Erlang.
+ * Runs in linear time otherwise.
+ */
+export function from_string_tree(tree) {
+  return new Text(tree);
+}
+
+function wrap_list(bits) {
+  return new Bytes(bits);
+}
+
+/**
+ * Creates a new bytes tree from a bit array.
+ *
+ * Runs in constant time.
+ */
+export function from_bit_array(bits) {
+  let _pipe = bits;
+  let _pipe$1 = $bit_array.pad_to_bytes(_pipe);
+  return wrap_list(_pipe$1);
+}
+
+/**
+ * Prepends a bit array to the start of a bytes tree.
+ *
+ * Runs in constant time.
+ */
+export function prepend(second, first) {
+  return append_tree(from_bit_array(first), second);
+}
+
+/**
+ * Appends a bit array to the end of a bytes tree.
+ *
+ * Runs in constant time.
+ */
+export function append(first, second) {
+  return append_tree(first, from_bit_array(second));
+}
+
+/**
+ * Joins a list of bit arrays into a single bytes tree.
+ *
+ * Runs in constant time.
+ */
+export function concat_bit_arrays(bits) {
+  let _pipe = bits;
+  let _pipe$1 = $list.map(_pipe, from_bit_array);
+  return concat(_pipe$1);
+}
+
+function to_list(loop$stack, loop$acc) {
+  while (true) {
+    let stack = loop$stack;
+    let acc = loop$acc;
+    if (stack instanceof $Empty) {
+      return acc;
+    } else {
+      let $ = stack.head;
+      if ($ instanceof $Empty) {
+        let remaining_stack = stack.tail;
+        loop$stack = remaining_stack;
+        loop$acc = acc;
+      } else {
+        let $1 = $.head;
+        if ($1 instanceof Bytes) {
+          let remaining_stack = stack.tail;
+          let rest = $.tail;
+          let bits = $1[0];
+          loop$stack = listPrepend(rest, remaining_stack);
+          loop$acc = listPrepend(bits, acc);
+        } else if ($1 instanceof Text) {
+          let remaining_stack = stack.tail;
+          let rest = $.tail;
+          let tree = $1[0];
+          let bits = $bit_array.from_string($string_tree.to_string(tree));
+          loop$stack = listPrepend(rest, remaining_stack);
+          loop$acc = listPrepend(bits, acc);
+        } else {
+          let remaining_stack = stack.tail;
+          let rest = $.tail;
+          let trees = $1[0];
+          loop$stack = listPrepend(trees, listPrepend(rest, remaining_stack));
+          loop$acc = acc;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Turns a bytes tree into a bit array.
+ *
+ * Runs in linear time.
+ *
+ * When running on Erlang this function is implemented natively by the
+ * virtual machine and is highly optimised.
+ */
+export function to_bit_array(tree) {
+  let _pipe = toList([toList([tree])]);
+  let _pipe$1 = to_list(_pipe, toList([]));
+  let _pipe$2 = $list.reverse(_pipe$1);
+  return $bit_array.concat(_pipe$2);
+}
+
+/**
+ * Returns the size of the bytes tree's content in bytes.
+ *
+ * Runs in linear time.
+ */
+export function byte_size(tree) {
+  let _pipe = toList([toList([tree])]);
+  let _pipe$1 = to_list(_pipe, toList([]));
+  return $list.fold(
+    _pipe$1,
+    0,
+    (acc, bits) => { return $bit_array.byte_size(bits) + acc; },
+  );
+}

package/build/dev/javascript/gleam_stdlib/gleam/dict.mjs

@@ -0,0 +1,456 @@
+import {
+  toTransient as to_transient,
+  fromTransient as from_transient,
+  size,
+  has as has_key,
+  make as new$,
+  get,
+  insert,
+  destructiveTransientInsert as transient_insert,
+  map as map_values,
+  destructiveTransientDelete as transient_delete,
+  fold,
+  destructiveTransientUpdateWith as transient_update_with,
+} from "../dict.mjs";
+import { Ok, toList, Empty as $Empty, prepend as listPrepend } from "../gleam.mjs";
+import * as $option from "../gleam/option.mjs";
+
+export { fold, get, has_key, insert, map_values, new$, size };
+
+/**
+ * Determines whether or not the dict is empty.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * new() |> is_empty
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * new() |> insert("b", 1) |> is_empty
+ * // -> False
+ * ```
+ */
+export function is_empty(dict) {
+  return size(dict) === 0;
+}
+
+function from_list_loop(loop$transient, loop$list) {
+  while (true) {
+    let transient = loop$transient;
+    let list = loop$list;
+    if (list instanceof $Empty) {
+      return from_transient(transient);
+    } else {
+      let rest = list.tail;
+      let key = list.head[0];
+      let value = list.head[1];
+      loop$transient = transient_insert(key, value, transient);
+      loop$list = rest;
+    }
+  }
+}
+
+/**
+ * Converts a list of 2-element tuples `#(key, value)` to a dict.
+ *
+ * If two tuples have the same key the last one in the list will be the one
+ * that is present in the dict.
+ */
+export function from_list(list) {
+  return from_list_loop(to_transient(new$()), list);
+}
+
+function do_take_loop(loop$dict, loop$desired_keys, loop$acc) {
+  while (true) {
+    let dict = loop$dict;
+    let desired_keys = loop$desired_keys;
+    let acc = loop$acc;
+    if (desired_keys instanceof $Empty) {
+      return from_transient(acc);
+    } else {
+      let key = desired_keys.head;
+      let rest = desired_keys.tail;
+      let $ = get(dict, key);
+      if ($ instanceof Ok) {
+        let value = $[0];
+        loop$dict = dict;
+        loop$desired_keys = rest;
+        loop$acc = transient_insert(key, value, acc);
+      } else {
+        loop$dict = dict;
+        loop$desired_keys = rest;
+        loop$acc = acc;
+      }
+    }
+  }
+}
+
+function do_take(desired_keys, dict) {
+  return do_take_loop(dict, desired_keys, to_transient(new$()));
+}
+
+/**
+ * Creates a new dict from a given dict, only including any entries for which the
+ * keys are in a given list.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)])
+ * |> take(["b"])
+ * // -> from_list([#("b", 1)])
+ * ```
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)])
+ * |> take(["a", "b", "c"])
+ * // -> from_list([#("a", 0), #("b", 1)])
+ * ```
+ */
+export function take(dict, desired_keys) {
+  return do_take(desired_keys, dict);
+}
+
+/**
+ * Creates a new dict from a given dict with all the same entries except for the
+ * one with a given key, if it exists.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> delete("a")
+ * // -> from_list([#("b", 1)])
+ * ```
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> delete("c")
+ * // -> from_list([#("a", 0), #("b", 1)])
+ * ```
+ */
+export function delete$(dict, key) {
+  let _pipe = to_transient(dict);
+  let _pipe$1 = ((_capture) => { return transient_delete(key, _capture); })(
+    _pipe,
+  );
+  return from_transient(_pipe$1);
+}
+
+function drop_loop(loop$transient, loop$disallowed_keys) {
+  while (true) {
+    let transient = loop$transient;
+    let disallowed_keys = loop$disallowed_keys;
+    if (disallowed_keys instanceof $Empty) {
+      return from_transient(transient);
+    } else {
+      let key = disallowed_keys.head;
+      let rest = disallowed_keys.tail;
+      loop$transient = transient_delete(key, transient);
+      loop$disallowed_keys = rest;
+    }
+  }
+}
+
+function do_drop(disallowed_keys, dict) {
+  return drop_loop(to_transient(dict), disallowed_keys);
+}
+
+/**
+ * Creates a new dict from a given dict with all the same entries except any with
+ * keys found in a given list.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> drop(["a"])
+ * // -> from_list([#("b", 1)])
+ * ```
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> drop(["c"])
+ * // -> from_list([#("a", 0), #("b", 1)])
+ * ```
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> drop(["a", "b", "c"])
+ * // -> from_list([])
+ * ```
+ */
+export function drop(dict, disallowed_keys) {
+  return do_drop(disallowed_keys, dict);
+}
+
+/**
+ * Creates a new dict with one entry inserted or updated using a given function.
+ *
+ * If there was not an entry in the dict for the given key then the function
+ * gets `None` as its argument, otherwise it gets `Some(value)`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let dict = from_list([#("a", 0)])
+ * let increment = fn(x) {
+ *   case x {
+ *     Some(i) -> i + 1
+ *     None -> 0
+ *   }
+ * }
+ *
+ * upsert(dict, "a", increment)
+ * // -> from_list([#("a", 1)])
+ *
+ * upsert(dict, "b", increment)
+ * // -> from_list([#("a", 0), #("b", 0)])
+ * ```
+ */
+export function upsert(dict, key, fun) {
+  let $ = get(dict, key);
+  if ($ instanceof Ok) {
+    let value = $[0];
+    return insert(dict, key, fun(new $option.Some(value)));
+  } else {
+    return insert(dict, key, fun(new $option.None()));
+  }
+}
+
+/**
+ * Converts the dict to a list of 2-element tuples `#(key, value)`, one for
+ * each key-value pair in the dict.
+ *
+ * The tuples in the list have no specific order.
+ *
+ * ## Examples
+ *
+ * Calling `to_list` on an empty `dict` returns an empty list.
+ *
+ * ```gleam
+ * new() |> to_list
+ * // -> []
+ * ```
+ *
+ * The ordering of elements in the resulting list is an implementation detail
+ * that should not be relied upon.
+ *
+ * ```gleam
+ * new() |> insert("b", 1) |> insert("a", 0) |> insert("c", 2) |> to_list
+ * // -> [#("a", 0), #("b", 1), #("c", 2)]
+ * ```
+ */
+export function to_list(dict) {
+  return fold(
+    dict,
+    toList([]),
+    (acc, key, value) => { return listPrepend([key, value], acc); },
+  );
+}
+
+/**
+ * Gets a list of all keys in a given dict.
+ *
+ * Dicts are not ordered so the keys are not returned in any specific order. Do
+ * not write code that relies on the order keys are returned by this function
+ * as it may change in later versions of Gleam or Erlang.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> keys
+ * // -> ["a", "b"]
+ * ```
+ */
+export function keys(dict) {
+  return fold(
+    dict,
+    toList([]),
+    (acc, key, _) => { return listPrepend(key, acc); },
+  );
+}
+
+/**
+ * Gets a list of all values in a given dict.
+ *
+ * Dicts are not ordered so the values are not returned in any specific order. Do
+ * not write code that relies on the order values are returned by this function
+ * as it may change in later versions of Gleam or Erlang.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)]) |> values
+ * // -> [0, 1]
+ * ```
+ */
+export function values(dict) {
+  return fold(
+    dict,
+    toList([]),
+    (acc, _, value) => { return listPrepend(value, acc); },
+  );
+}
+
+function do_filter(f, dict) {
+  let _pipe = to_transient(new$());
+  let _pipe$1 = fold(
+    dict,
+    _pipe,
+    (transient, key, value) => {
+      let $ = f(key, value);
+      if ($) {
+        return transient_insert(key, value, transient);
+      } else {
+        return transient;
+      }
+    },
+  );
+  return from_transient(_pipe$1);
+}
+
+/**
+ * Creates a new dict from a given dict, minus any entries that a given function
+ * returns `False` for.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)])
+ * |> filter(fn(key, value) { value != 0 })
+ * // -> from_list([#("b", 1)])
+ * ```
+ *
+ * ```gleam
+ * from_list([#("a", 0), #("b", 1)])
+ * |> filter(fn(key, value) { True })
+ * // -> from_list([#("a", 0), #("b", 1)])
+ * ```
+ */
+export function filter(dict, predicate) {
+  return do_filter(predicate, dict);
+}
+
+/**
+ * Calls a function for each key and value in a dict, discarding the return
+ * value.
+ *
+ * Useful for producing a side effect for every item of a dict.
+ *
+ * ```gleam
+ * import gleam/io
+ *
+ * let dict = from_list([#("a", "apple"), #("b", "banana"), #("c", "cherry")])
+ *
+ * each(dict, fn(k, v) {
+ *   io.println(key <> " => " <> value)
+ * })
+ * // -> Nil
+ * // a => apple
+ * // b => banana
+ * // c => cherry
+ * ```
+ *
+ * The order of elements in the iteration is an implementation detail that
+ * should not be relied upon.
+ */
+export function each(dict, fun) {
+  return fold(
+    dict,
+    undefined,
+    (nil, k, v) => {
+      fun(k, v);
+      return nil;
+    },
+  );
+}
+
+function do_combine(combine, left, right) {
+  let _block;
+  let $1 = size(left) >= size(right);
+  if ($1) {
+    _block = [left, right, combine];
+  } else {
+    _block = [right, left, (k, l, r) => { return combine(k, r, l); }];
+  }
+  let $ = _block;
+  let big;
+  let small;
+  let combine$1;
+  big = $[0];
+  small = $[1];
+  combine$1 = $[2];
+  let _pipe = to_transient(big);
+  let _pipe$1 = fold(
+    small,
+    _pipe,
+    (transient, key, value) => {
+      let update = (existing) => { return combine$1(key, existing, value); };
+      return transient_update_with(key, update, value, transient);
+    },
+  );
+  return from_transient(_pipe$1);
+}
+
+/**
+ * Creates a new dict from a pair of given dicts by combining their entries.
+ *
+ * If there are entries with the same keys in both dicts the given function is
+ * used to determine the new value to use in the resulting dict.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let a = from_list([#("a", 0), #("b", 1)])
+ * let b = from_list([#("a", 2), #("c", 3)])
+ * combine(a, b, fn(one, other) { one + other })
+ * // -> from_list([#("a", 2), #("b", 1), #("c", 3)])
+ * ```
+ */
+export function combine(dict, other, fun) {
+  return do_combine((_, l, r) => { return fun(l, r); }, dict, other);
+}
+
+/**
+ * Creates a new dict from a pair of given dicts by combining their entries.
+ *
+ * If there are entries with the same keys in both dicts the entry from the
+ * second dict takes precedence.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let a = from_list([#("a", 0), #("b", 1)])
+ * let b = from_list([#("b", 2), #("c", 3)])
+ * merge(a, b)
+ * // -> from_list([#("a", 0), #("b", 2), #("c", 3)])
+ * ```
+ */
+export function merge(dict, new_entries) {
+  return combine(dict, new_entries, (_, new_entry) => { return new_entry; });
+}
+
+function group_loop(loop$transient, loop$to_key, loop$list) {
+  while (true) {
+    let transient = loop$transient;
+    let to_key = loop$to_key;
+    let list = loop$list;
+    if (list instanceof $Empty) {
+      return from_transient(transient);
+    } else {
+      let value = list.head;
+      let rest = list.tail;
+      let key = to_key(value);
+      let update = (existing) => { return listPrepend(value, existing); };
+      let _pipe = transient;
+      let _pipe$1 = ((_capture) => {
+        return transient_update_with(key, update, toList([value]), _capture);
+      })(_pipe);
+      loop$transient = _pipe$1;
+      loop$to_key = to_key;
+      loop$list = rest;
+    }
+  }
+}
+
+export function group(key, list) {
+  return group_loop(to_transient(new$()), key, list);
+}