skill-universe 1.1.0

package/build/dev/javascript/gleam_stdlib/gleam@option.erl

@@ -0,0 +1,413 @@
+-module(gleam@option).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/option.gleam").
+-export([all/1, is_some/1, is_none/1, to_result/2, from_result/1, unwrap/2, lazy_unwrap/2, map/2, flatten/1, then/2, 'or'/2, lazy_or/2, values/1]).
+-export_type([option/1]).
+
+-if(?OTP_RELEASE >= 27).
+-define(MODULEDOC(Str), -moduledoc(Str)).
+-define(DOC(Str), -doc(Str)).
+-else.
+-define(MODULEDOC(Str), -compile([])).
+-define(DOC(Str), -compile([])).
+-endif.
+
+-type option(EL) :: {some, EL} | none.
+
+-file("src/gleam/option.gleam", 59).
+-spec reverse_and_prepend(list(FA), list(FA)) -> list(FA).
+reverse_and_prepend(Prefix, Suffix) ->
+    case Prefix of
+        [] ->
+            Suffix;
+
+        [First | Rest] ->
+            reverse_and_prepend(Rest, [First | Suffix])
+    end.
+
+-file("src/gleam/option.gleam", 44).
+-spec all_loop(list(option(ER)), list(ER)) -> option(list(ER)).
+all_loop(List, Acc) ->
+    case List of
+        [] ->
+            {some, lists:reverse(Acc)};
+
+        [none | _] ->
+            none;
+
+        [{some, First} | Rest] ->
+            all_loop(Rest, [First | Acc])
+    end.
+
+-file("src/gleam/option.gleam", 40).
+?DOC(
+    " Combines a list of `Option`s into a single `Option`.\n"
+    " If all elements in the list are `Some` then returns a `Some` holding the list of values.\n"
+    " If any element is `None` then returns `None`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " all([Some(1), Some(2)])\n"
+    " // -> Some([1, 2])\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " all([Some(1), None])\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec all(list(option(EM))) -> option(list(EM)).
+all(List) ->
+    all_loop(List, []).
+
+-file("src/gleam/option.gleam", 80).
+?DOC(
+    " Checks whether the `Option` is a `Some` value.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " is_some(Some(1))\n"
+    " // -> True\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " is_some(None)\n"
+    " // -> False\n"
+    " ```\n"
+).
+-spec is_some(option(any())) -> boolean().
+is_some(Option) ->
+    Option /= none.
+
+-file("src/gleam/option.gleam", 98).
+?DOC(
+    " Checks whether the `Option` is a `None` value.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " is_none(Some(1))\n"
+    " // -> False\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " is_none(None)\n"
+    " // -> True\n"
+    " ```\n"
+).
+-spec is_none(option(any())) -> boolean().
+is_none(Option) ->
+    Option =:= none.
+
+-file("src/gleam/option.gleam", 116).
+?DOC(
+    " Converts an `Option` type to a `Result` type.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " to_result(Some(1), \"some_error\")\n"
+    " // -> Ok(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " to_result(None, \"some_error\")\n"
+    " // -> Error(\"some_error\")\n"
+    " ```\n"
+).
+-spec to_result(option(FI), FL) -> {ok, FI} | {error, FL}.
+to_result(Option, E) ->
+    case Option of
+        {some, A} ->
+            {ok, A};
+
+        none ->
+            {error, E}
+    end.
+
+-file("src/gleam/option.gleam", 137).
+?DOC(
+    " Converts a `Result` type to an `Option` type.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " from_result(Ok(1))\n"
+    " // -> Some(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " from_result(Error(\"some_error\"))\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec from_result({ok, FO} | {error, any()}) -> option(FO).
+from_result(Result) ->
+    case Result of
+        {ok, A} ->
+            {some, A};
+
+        {error, _} ->
+            none
+    end.
+
+-file("src/gleam/option.gleam", 158).
+?DOC(
+    " Extracts the value from an `Option`, returning a default value if there is none.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " unwrap(Some(1), 0)\n"
+    " // -> 1\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " unwrap(None, 0)\n"
+    " // -> 0\n"
+    " ```\n"
+).
+-spec unwrap(option(FT), FT) -> FT.
+unwrap(Option, Default) ->
+    case Option of
+        {some, X} ->
+            X;
+
+        none ->
+            Default
+    end.
+
+-file("src/gleam/option.gleam", 179).
+?DOC(
+    " Extracts the value from an `Option`, evaluating the default function if the option is `None`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " lazy_unwrap(Some(1), fn() { 0 })\n"
+    " // -> 1\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " lazy_unwrap(None, fn() { 0 })\n"
+    " // -> 0\n"
+    " ```\n"
+).
+-spec lazy_unwrap(option(FV), fun(() -> FV)) -> FV.
+lazy_unwrap(Option, Default) ->
+    case Option of
+        {some, X} ->
+            X;
+
+        none ->
+            Default()
+    end.
+
+-file("src/gleam/option.gleam", 204).
+?DOC(
+    " Updates a value held within the `Some` of an `Option` by calling a given function\n"
+    " on it.\n"
+    "\n"
+    " If the `Option` is a `None` rather than `Some`, the function is not called and the\n"
+    " `Option` stays the same.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " map(over: Some(1), with: fn(x) { x + 1 })\n"
+    " // -> Some(2)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " map(over: None, with: fn(x) { x + 1 })\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec map(option(FX), fun((FX) -> FZ)) -> option(FZ).
+map(Option, Fun) ->
+    case Option of
+        {some, X} ->
+            {some, Fun(X)};
+
+        none ->
+            none
+    end.
+
+-file("src/gleam/option.gleam", 230).
+?DOC(
+    " Merges a nested `Option` into a single layer.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " flatten(Some(Some(1)))\n"
+    " // -> Some(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " flatten(Some(None))\n"
+    " // -> None\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " flatten(None)\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec flatten(option(option(GB))) -> option(GB).
+flatten(Option) ->
+    case Option of
+        {some, X} ->
+            X;
+
+        none ->
+            none
+    end.
+
+-file("src/gleam/option.gleam", 269).
+?DOC(
+    " Updates a value held within the `Some` of an `Option` by calling a given function\n"
+    " on it, where the given function also returns an `Option`. The two options are\n"
+    " then merged together into one `Option`.\n"
+    "\n"
+    " If the `Option` is a `None` rather than `Some` the function is not called and the\n"
+    " option stays the same.\n"
+    "\n"
+    " This function is the equivalent of calling `map` followed by `flatten`, and\n"
+    " it is useful for chaining together multiple functions that return `Option`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " then(Some(1), fn(x) { Some(x + 1) })\n"
+    " // -> Some(2)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " then(Some(1), fn(x) { Some(#(\"a\", x)) })\n"
+    " // -> Some(#(\"a\", 1))\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " then(Some(1), fn(_) { None })\n"
+    " // -> None\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " then(None, fn(x) { Some(x + 1) })\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec then(option(GF), fun((GF) -> option(GH))) -> option(GH).
+then(Option, Fun) ->
+    case Option of
+        {some, X} ->
+            Fun(X);
+
+        none ->
+            none
+    end.
+
+-file("src/gleam/option.gleam", 300).
+?DOC(
+    " Returns the first value if it is `Some`, otherwise returns the second value.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " or(Some(1), Some(2))\n"
+    " // -> Some(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " or(Some(1), None)\n"
+    " // -> Some(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " or(None, Some(2))\n"
+    " // -> Some(2)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " or(None, None)\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec 'or'(option(GK), option(GK)) -> option(GK).
+'or'(First, Second) ->
+    case First of
+        {some, _} ->
+            First;
+
+        none ->
+            Second
+    end.
+
+-file("src/gleam/option.gleam", 331).
+?DOC(
+    " Returns the first value if it is `Some`, otherwise evaluates the given function for a fallback value.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " lazy_or(Some(1), fn() { Some(2) })\n"
+    " // -> Some(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " lazy_or(Some(1), fn() { None })\n"
+    " // -> Some(1)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " lazy_or(None, fn() { Some(2) })\n"
+    " // -> Some(2)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " lazy_or(None, fn() { None })\n"
+    " // -> None\n"
+    " ```\n"
+).
+-spec lazy_or(option(GO), fun(() -> option(GO))) -> option(GO).
+lazy_or(First, Second) ->
+    case First of
+        {some, _} ->
+            First;
+
+        none ->
+            Second()
+    end.
+
+-file("src/gleam/option.gleam", 352).
+-spec values_loop(list(option(GW)), list(GW)) -> list(GW).
+values_loop(List, Acc) ->
+    case List of
+        [] ->
+            lists:reverse(Acc);
+
+        [none | Rest] ->
+            values_loop(Rest, Acc);
+
+        [{some, First} | Rest@1] ->
+            values_loop(Rest@1, [First | Acc])
+    end.
+
+-file("src/gleam/option.gleam", 348).
+?DOC(
+    " Given a list of `Option`s,\n"
+    " returns only the values inside `Some`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " values([Some(1), None, Some(3)])\n"
+    " // -> [1, 3]\n"
+    " ```\n"
+).
+-spec values(list(option(GS))) -> list(GS).
+values(Options) ->
+    values_loop(Options, []).

package/build/dev/javascript/gleam_stdlib/gleam@order.erl

@@ -0,0 +1,200 @@
+-module(gleam@order).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/order.gleam").
+-export([negate/1, to_int/1, compare/2, reverse/1, break_tie/2, lazy_break_tie/2]).
+-export_type([order/0]).
+
+-if(?OTP_RELEASE >= 27).
+-define(MODULEDOC(Str), -moduledoc(Str)).
+-define(DOC(Str), -doc(Str)).
+-else.
+-define(MODULEDOC(Str), -compile([])).
+-define(DOC(Str), -compile([])).
+-endif.
+
+-type order() :: lt | eq | gt.
+
+-file("src/gleam/order.gleam", 35).
+?DOC(
+    " Inverts an order, so less-than becomes greater-than and greater-than\n"
+    " becomes less-than.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " negate(Lt)\n"
+    " // -> Gt\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " negate(Eq)\n"
+    " // -> Eq\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " negate(Gt)\n"
+    " // -> Lt\n"
+    " ```\n"
+).
+-spec negate(order()) -> order().
+negate(Order) ->
+    case Order of
+        lt ->
+            gt;
+
+        eq ->
+            eq;
+
+        gt ->
+            lt
+    end.
+
+-file("src/gleam/order.gleam", 62).
+?DOC(
+    " Produces a numeric representation of the order.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " to_int(Lt)\n"
+    " // -> -1\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " to_int(Eq)\n"
+    " // -> 0\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " to_int(Gt)\n"
+    " // -> 1\n"
+    " ```\n"
+).
+-spec to_int(order()) -> integer().
+to_int(Order) ->
+    case Order of
+        lt ->
+            -1;
+
+        eq ->
+            0;
+
+        gt ->
+            1
+    end.
+
+-file("src/gleam/order.gleam", 79).
+?DOC(
+    " Compares two `Order` values to one another, producing a new `Order`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " compare(Eq, with: Lt)\n"
+    " // -> Gt\n"
+    " ```\n"
+).
+-spec compare(order(), order()) -> order().
+compare(A, B) ->
+    case {A, B} of
+        {X, Y} when X =:= Y ->
+            eq;
+
+        {lt, _} ->
+            lt;
+
+        {eq, gt} ->
+            lt;
+
+        {_, _} ->
+            gt
+    end.
+
+-file("src/gleam/order.gleam", 100).
+?DOC(
+    " Inverts an ordering function, so less-than becomes greater-than and greater-than\n"
+    " becomes less-than.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " import gleam/int\n"
+    " import gleam/list\n"
+    "\n"
+    " list.sort([1, 5, 4], by: reverse(int.compare))\n"
+    " // -> [5, 4, 1]\n"
+    " ```\n"
+).
+-spec reverse(fun((I, I) -> order())) -> fun((I, I) -> order()).
+reverse(Orderer) ->
+    fun(A, B) -> Orderer(B, A) end.
+
+-file("src/gleam/order.gleam", 122).
+?DOC(
+    " Return a fallback `Order` in case the first argument is `Eq`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " import gleam/int\n"
+    "\n"
+    " break_tie(in: int.compare(1, 1), with: Lt)\n"
+    " // -> Lt\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " import gleam/int\n"
+    "\n"
+    " break_tie(in: int.compare(1, 0), with: Eq)\n"
+    " // -> Gt\n"
+    " ```\n"
+).
+-spec break_tie(order(), order()) -> order().
+break_tie(Order, Other) ->
+    case Order of
+        lt ->
+            Order;
+
+        gt ->
+            Order;
+
+        eq ->
+            Other
+    end.
+
+-file("src/gleam/order.gleam", 151).
+?DOC(
+    " Invokes a fallback function returning an `Order` in case the first argument\n"
+    " is `Eq`.\n"
+    "\n"
+    " This can be useful when the fallback comparison might be expensive and it\n"
+    " needs to be delayed until strictly necessary.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " import gleam/int\n"
+    "\n"
+    " lazy_break_tie(in: int.compare(1, 1), with: fn() { Lt })\n"
+    " // -> Lt\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " import gleam/int\n"
+    "\n"
+    " lazy_break_tie(in: int.compare(1, 0), with: fn() { Eq })\n"
+    " // -> Gt\n"
+    " ```\n"
+).
+-spec lazy_break_tie(order(), fun(() -> order())) -> order().
+lazy_break_tie(Order, Comparison) ->
+    case Order of
+        lt ->
+            Order;
+
+        gt ->
+            Order;
+
+        eq ->
+            Comparison()
+    end.

package/build/dev/javascript/gleam_stdlib/gleam@pair.erl

@@ -0,0 +1,110 @@
+-module(gleam@pair).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleam/pair.gleam").
+-export([first/1, second/1, swap/1, map_first/2, map_second/2, new/2]).
+
+-if(?OTP_RELEASE >= 27).
+-define(MODULEDOC(Str), -moduledoc(Str)).
+-define(DOC(Str), -doc(Str)).
+-else.
+-define(MODULEDOC(Str), -compile([])).
+-define(DOC(Str), -compile([])).
+-endif.
+
+-file("src/gleam/pair.gleam", 10).
+?DOC(
+    " Returns the first element in a pair.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " first(#(1, 2))\n"
+    " // -> 1\n"
+    " ```\n"
+).
+-spec first({CMC, any()}) -> CMC.
+first(Pair) ->
+    {A, _} = Pair,
+    A.
+
+-file("src/gleam/pair.gleam", 24).
+?DOC(
+    " Returns the second element in a pair.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " second(#(1, 2))\n"
+    " // -> 2\n"
+    " ```\n"
+).
+-spec second({any(), CMF}) -> CMF.
+second(Pair) ->
+    {_, A} = Pair,
+    A.
+
+-file("src/gleam/pair.gleam", 38).
+?DOC(
+    " Returns a new pair with the elements swapped.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " swap(#(1, 2))\n"
+    " // -> #(2, 1)\n"
+    " ```\n"
+).
+-spec swap({CMG, CMH}) -> {CMH, CMG}.
+swap(Pair) ->
+    {A, B} = Pair,
+    {B, A}.
+
+-file("src/gleam/pair.gleam", 53).
+?DOC(
+    " Returns a new pair with the first element having had `with` applied to\n"
+    " it.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " #(1, 2) |> map_first(fn(n) { n * 2 })\n"
+    " // -> #(2, 2)\n"
+    " ```\n"
+).
+-spec map_first({CMI, CMJ}, fun((CMI) -> CMK)) -> {CMK, CMJ}.
+map_first(Pair, Fun) ->
+    {A, B} = Pair,
+    {Fun(A), B}.
+
+-file("src/gleam/pair.gleam", 68).
+?DOC(
+    " Returns a new pair with the second element having had `with` applied to\n"
+    " it.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " #(1, 2) |> map_second(fn(n) { n * 2 })\n"
+    " // -> #(1, 4)\n"
+    " ```\n"
+).
+-spec map_second({CML, CMM}, fun((CMM) -> CMN)) -> {CML, CMN}.
+map_second(Pair, Fun) ->
+    {A, B} = Pair,
+    {A, Fun(B)}.
+
+-file("src/gleam/pair.gleam", 83).
+?DOC(
+    " Returns a new pair with the given elements. This can also be done using the dedicated\n"
+    " syntax instead: `new(1, 2) == #(1, 2)`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " new(1, 2)\n"
+    " // -> #(1, 2)\n"
+    " ```\n"
+).
+-spec new(CMO, CMP) -> {CMO, CMP}.
+new(First, Second) ->
+    {First, Second}.