Current section
Files
Jump to
Current section
Files
src/gleyre.erl
-module(gleyre).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([to_string/1, error/1, okay/1, from/1, into/1, annotate/2, map/2, wrap/2, 'try'/2, try_or_wrap/3, yield_errors/1, yield_indexed/1, all/1, replace/2, unwrap/2, is_err/1, is_okay/1]).
-export_type([report/0, outcome/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.
-opaque report() :: {report, list(binary())}.
-type outcome(EWH) :: {okay, EWH} | {err, report()}.
-file("src/gleyre.gleam", 16).
?DOC(
" Turn a `Report` into a formatted message displaying the layers of\n"
" error messaging.\n"
).
-spec to_string(report()) -> binary().
to_string(Report) ->
_pipe@3 = gleam@list:index_fold(
erlang:element(2, Report),
gleam@string_tree:new(),
fun(Acc, Next, Idx) ->
_pipe@1 = [begin
_pipe = erlang:integer_to_binary(Idx),
gleam@string:pad_start(_pipe, 4, <<" "/utf8>>)
end,
<<": "/utf8>>,
Next,
<<"\n"/utf8>>],
_pipe@2 = gleam_stdlib:identity(_pipe@1),
gleam_stdlib:iodata_append(_pipe@2, Acc)
end
),
unicode:characters_to_binary(_pipe@3).
-file("src/gleyre.gleam", 32).
?DOC(" Create a new error variant.\n").
-spec error(binary()) -> outcome(any()).
error(Message) ->
{err, {report, [Message]}}.
-file("src/gleyre.gleam", 37).
?DOC(" Create a new okay variant.\n").
-spec okay(EWK) -> outcome(EWK).
okay(Ok) ->
{okay, Ok}.
-file("src/gleyre.gleam", 43).
?DOC(
" Convert from a regular `Result` by using `string.inspect()` if the\n"
" `Result` is an error.\n"
).
-spec from({ok, EWM} | {error, any()}) -> outcome(EWM).
from(Std_result) ->
case Std_result of
{ok, X} ->
{okay, X};
{error, E} ->
{err, {report, [gleam@string:inspect(E)]}}
end.
-file("src/gleyre.gleam", 51).
?DOC(" Turn you `Outcome` back into a regular Gleam `Error`.\n").
-spec into(outcome(EWR)) -> {ok, EWR} | {error, binary()}.
into(Outcome) ->
case Outcome of
{okay, X} ->
{ok, X};
{err, Err} ->
_pipe = to_string(Err),
{error, _pipe}
end.
-file("src/gleyre.gleam", 59).
?DOC(" Add a layer of messaging to an error variant.\n").
-spec annotate(report(), binary()) -> report().
annotate(Report, Message) ->
{report, [Message | erlang:element(2, Report)]}.
-file("src/gleyre.gleam", 65).
?DOC(
" Like `result.map()` -- applies the given function if the outcome is\n"
" `Okay`.\n"
).
-spec map(outcome(EWV), fun((EWV) -> EWX)) -> outcome(EWX).
map(Outcome, F) ->
case Outcome of
{okay, X} ->
{okay, F(X)};
{err, E} ->
{err, E}
end.
-file("src/gleyre.gleam", 73).
?DOC(" If the `Outcome` is an error, this adds another layer of message to it.\n").
-spec wrap(outcome(EWZ), binary()) -> outcome(EWZ).
wrap(Outcome, Message) ->
case Outcome of
{okay, X} ->
{okay, X};
{err, E} ->
{err, annotate(E, Message)}
end.
-file("src/gleyre.gleam", 90).
?DOC(
" Like `result.try`; for exploiting `use` sugar.\n"
"\n"
" ```gleam\n"
" fn fallible_function(data: Kind) -> Outcome(OtherKind) {\n"
" use step_one <- gleyre.try(other_fallible_function(data))\n"
" use step_two <- gleyre.try(yet_another(step_one))\n"
"\n"
" Okay(step_two)\n"
" }\n"
" ```\n"
).
-spec 'try'(outcome(EXC), fun((EXC) -> outcome(EXE))) -> outcome(EXE).
'try'(Outcome, Next) ->
case Outcome of
{okay, X} ->
Next(X);
{err, Y} ->
{err, Y}
end.
-file("src/gleyre.gleam", 98).
?DOC(" For the `use`-case, but also adds an extra level of messaging to the error.\n").
-spec try_or_wrap(outcome(EXH), binary(), fun((EXH) -> outcome(EXJ))) -> outcome(EXJ).
try_or_wrap(Outcome, Message, Next) ->
case Outcome of
{okay, X} ->
Next(X);
{err, Y} ->
{err, annotate(Y, Message)}
end.
-file("src/gleyre.gleam", 110).
?DOC(" Iterate down through the layers of error messages.\n").
-spec yield_errors(report()) -> gleam@yielder:yielder(binary()).
yield_errors(Report) ->
gleam@yielder:from_list(erlang:element(2, Report)).
-file("src/gleyre.gleam", 115).
?DOC(" Iterate down through the _indexed_ layers of error messages.\n").
-spec yield_indexed(report()) -> gleam@yielder:yielder({binary(), integer()}).
yield_indexed(Report) ->
_pipe = yield_errors(Report),
gleam@yielder:index(_pipe).
-file("src/gleyre.gleam", 119).
-spec all_aux(list(EXO), list(outcome(EXO))) -> outcome(list(EXO)).
all_aux(Acc, Dsp) ->
case Dsp of
[] ->
_pipe = lists:reverse(Acc),
{okay, _pipe};
[{okay, X} | Rest] ->
all_aux([X | Acc], Rest);
[{err, E} | _] ->
{err, E}
end.
-file("src/gleyre.gleam", 129).
?DOC(
" Like `result.all()`, either returns the first `Err()` value in the\n"
" list, or the whole list of positive outcomes.\n"
).
-spec all(list(outcome(EXU))) -> outcome(list(EXU)).
all(Outcomes) ->
all_aux([], Outcomes).
-file("src/gleyre.gleam", 134).
?DOC(" Like `result.replace()`, replaces the `Outcome`'s value if it's `Okay`.\n").
-spec replace(outcome(any()), EYB) -> outcome(EYB).
replace(Outcome, Replacement) ->
case Outcome of
{okay, _} ->
{okay, Replacement};
{err, E} ->
{err, E}
end.
-file("src/gleyre.gleam", 142).
?DOC(" Like `result.unwrap()`, returns the `Okay` variant or the provided default.\n").
-spec unwrap(outcome(EYD), EYD) -> EYD.
unwrap(Outcome, Default) ->
case Outcome of
{okay, X} ->
X;
{err, _} ->
Default
end.
-file("src/gleyre.gleam", 150).
?DOC(" Like `result.is_error()`, returns `True` if it's an `Err` variant.\n").
-spec is_err(outcome(any())) -> boolean().
is_err(Outcome) ->
case Outcome of
{okay, _} ->
false;
{err, _} ->
true
end.
-file("src/gleyre.gleam", 158).
?DOC(" Like `result.is_ok()`, returns `True` if it's an `Okay` variant.\n").
-spec is_okay(outcome(any())) -> boolean().
is_okay(Outcome) ->
case Outcome of
{okay, _} ->
true;
{err, _} ->
false
end.