200 lines
4 KiB
Erlang
200 lines
4 KiB
Erlang
-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.
|