Current section
Files
Jump to
Current section
Files
src/ramble_old.erl
-module(ramble_old).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([get_config/0, go_on_tokens/3, position/0, any_token/0, either/2, choice/1, many/1, many1/1, get_errors/1, seq/2, do_and_recover/2, map/2, 'try'/2, optional/1, 'not'/1, lazy/1, extract_and_recover/3, extract/2, all/1, return/1, sep1/2, sep/2, until/2, recover/0, satisfy/1, 'end'/0, fail/0, peek/1, label/2, token/1, string/1, go/3, lowercase_letter/0, uppercase_letter/0, letter/0, digit/0, alphanum/0, many_as_string/1, many1_as_string/1, digits/0, desperate_custom_parser/1, main/0, whitespace/0, whitespace1/0]).
-export_type([position/0, token/1, parse_error/1, parse_result/2, final_parse_result/2, parser_config/1, parser/2]).
-type position() :: {position, integer(), integer()}.
-type token(GLK) :: {token, GLK} | {labeled_token, binary()}.
-type parse_error(GLL) :: {unexpected, position(), token(GLL), list(token(GLL))}.
-type parse_result(GLM, GLN) :: {parse_result,
{ok, GLN} | {error, parse_error(GLM)},
list(GLM),
position(),
list(parse_error(GLM))}.
-type final_parse_result(GLO, GLP) :: {final_parse_result,
{ok, GLP} | {error, parse_error(GLO)},
list(parse_error(GLO))}.
-type parser_config(GLQ) :: {parser_config,
GLQ,
GLQ,
binary(),
fun((GLQ) -> binary())}.
-type parser(GLR, GLS) :: {parser,
fun((list(GLR), position(), parser_config(GLR), gleam@option:option(parser(GLR, GLR))) -> parse_result(GLR, GLS))}.
-spec get_config() -> parser(GLT, parser_config(GLT)).
get_config() ->
{parser,
fun(Source, Pos, Config, _) ->
{parse_result, {ok, Config}, Source, Pos, []}
end}.
-spec run_on_tokens(
parser(GLX, GLY),
list(GLX),
position(),
parser_config(GLX),
gleam@option:option(parser(GLX, GLX))
) -> parse_result(GLX, GLY).
run_on_tokens(P, Src, Pos, Config, Recovery) ->
(erlang:element(2, P))(Src, Pos, Config, Recovery).
-spec go_on_tokens(parser(GMI, GMJ), list(GMI), parser_config(GMI)) -> final_parse_result(GMI, GMJ).
go_on_tokens(P, Src, Config) ->
Res = run_on_tokens(P, Src, {position, 1, 1}, Config, none),
{final_parse_result, erlang:element(2, Res), erlang:element(5, Res)}.
-spec position() -> parser(any(), position()).
position() ->
{parser, fun(Source, P, _, _) -> {parse_result, {ok, P}, Source, P, []} end}.
-spec any_token() -> parser(GNF, GNF).
any_token() ->
{parser,
fun(Source, Pos, Config, _) ->
{position, Row, Col} = case Pos of
{position, _, _} -> Pos;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Assertion pattern match failed"/utf8>>,
value => _assert_fail,
module => <<"ramble_old"/utf8>>,
function => <<"any_token"/utf8>>,
line => 151})
end,
case Source of
[H | T] ->
New_pos = case H =:= erlang:element(2, Config) of
true ->
{position, Row + 1, 0};
false ->
{position, Row, Col + 1}
end,
{parse_result, {ok, H}, T, New_pos, []};
[] ->
Err = {unexpected,
Pos,
{token, erlang:element(3, Config)},
[]},
{parse_result, {error, Err}, Source, Pos, []}
end
end}.
-spec either(parser(GNV, GNW), parser(GNV, GNW)) -> parser(GNV, GNW).
either(P, Q) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, _} ->
Res;
{error, E1} ->
Res2 = run_on_tokens(Q, Source, Pos, Config, Recovery),
case erlang:element(2, Res2) of
{ok, _} ->
Res2;
{error, E2} ->
Err = {unexpected,
Pos,
erlang:element(3, E2),
gleam@list:append(
erlang:element(4, E1),
erlang:element(4, E2)
)},
{parse_result, {error, Err}, Source, Pos, []}
end
end
end}.
-spec choice_helper(list(parser(GOK, GOL)), list(token(GOK))) -> parser(GOK, GOL).
choice_helper(Ps, Expected) ->
{parser, fun(Source, Pos, Config, Recovery) -> case Ps of
[] ->
erlang:error(#{gleam_error => panic,
message => <<"`ramble.choice()` doesn't accept an empty list of parsers"/utf8>>,
module => <<"ramble_old"/utf8>>,
function => <<"choice_helper"/utf8>>,
line => 248});
[P] ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, _} ->
Res;
{error, E} ->
Err = {unexpected,
erlang:element(2, E),
erlang:element(3, E),
gleam@list:reverse(
gleam@list:append(
erlang:element(4, E),
Expected
)
)},
{parse_result, {error, Err}, Source, Pos, []}
end;
[P@1 | T] ->
Res@1 = run_on_tokens(P@1, Source, Pos, Config, Recovery),
case erlang:element(2, Res@1) of
{ok, V} ->
{parse_result, {ok, V}, Source, Pos, []};
{error, E@1} ->
run_on_tokens(
choice_helper(
T,
gleam@list:append(
erlang:element(4, E@1),
Expected
)
),
Source,
Pos,
Config,
Recovery
)
end
end end}.
-spec choice(list(parser(GOD, GOE))) -> parser(GOD, GOE).
choice(Ps) ->
choice_helper(Ps, []).
-spec many(parser(GOZ, GPA)) -> parser(GOZ, list(GPA)).
many(P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{error, _} ->
{parse_result, {ok, []}, Source, Pos, []};
{ok, V} ->
Res2 = run_on_tokens(
many(P),
erlang:element(3, Res),
erlang:element(4, Res),
Config,
Recovery
),
case erlang:element(2, Res2) of
{error, _} ->
{parse_result, {ok, []}, Source, Pos, []};
{ok, Vs} ->
{parse_result,
{ok, [V | Vs]},
erlang:element(3, Res2),
erlang:element(4, Res2),
gleam@list:append(
erlang:element(5, Res),
erlang:element(5, Res2)
)}
end
end
end}.
-spec many1(parser(GPL, GPM)) -> parser(GPL, list(GPM)).
many1(P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{error, E} ->
{parse_result,
{error, E},
Source,
Pos,
erlang:element(5, Res)};
{ok, V} ->
Res2 = run_on_tokens(
many(P),
erlang:element(3, Res),
erlang:element(4, Res),
Config,
Recovery
),
case erlang:element(2, Res2) of
{error, _} ->
{parse_result,
{ok, [V]},
erlang:element(3, Res),
erlang:element(4, Res),
erlang:element(5, Res)};
{ok, Vs} ->
{parse_result,
{ok, [V | Vs]},
erlang:element(3, Res2),
erlang:element(4, Res2),
gleam@list:append(
erlang:element(5, Res),
erlang:element(5, Res2)
)}
end
end
end}.
-spec get_errors(parse_result(GQG, any())) -> list(parse_error(GQG)).
get_errors(Res) ->
case erlang:element(2, Res) of
{ok, _} ->
erlang:element(5, Res);
{error, E} ->
[E | erlang:element(5, Res)]
end.
-spec seq(parser(GPX, any()), parser(GPX, GQB)) -> parser(GPX, GQB).
seq(P, Q) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res1 = run_on_tokens(P, Source, Pos, Config, Recovery),
Res1_errors = get_errors(Res1),
Res2 = run_on_tokens(
Q,
erlang:element(3, Res1),
erlang:element(4, Res1),
Config,
Recovery
),
{parse_result,
erlang:element(2, Res2),
erlang:element(3, Res2),
erlang:element(4, Res2),
gleam@list:append(Res1_errors, erlang:element(5, Res2))}
end}.
-spec do_and_recover(parser(GQM, GQN), parser(GQM, GQM)) -> parser(GQM, GQN).
do_and_recover(P, R) ->
{parser,
fun(Source, Pos, Config, _) ->
run_on_tokens(P, Source, Pos, Config, {some, R})
end}.
-spec map(parser(GRO, GRP), fun((GRP) -> GRS)) -> parser(GRO, GRS).
map(P, F) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, V} ->
{parse_result,
{ok, F(V)},
erlang:element(3, Res),
erlang:element(4, Res),
erlang:element(5, Res)};
{error, E} ->
{parse_result,
{error, E},
Source,
Pos,
erlang:element(5, Res)}
end
end}.
-spec 'try'(
parser(GRV, GRW),
fun((GRW) -> {ok, GRW} | {error, parse_error(GRV)})
) -> parser(GRV, GRW).
'try'(P, F) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, V} ->
case F(V) of
{ok, A} ->
{parse_result,
{ok, A},
erlang:element(3, Res),
erlang:element(4, Res),
erlang:element(5, Res)};
{error, E} ->
{parse_result, {error, E}, Source, Pos, []}
end;
{error, E@1} ->
{parse_result,
{error, E@1},
Source,
Pos,
erlang:element(5, Res)}
end
end}.
-spec optional(parser(GSE, GSF)) -> parser(GSE, {ok, GSF} | {error, nil}).
optional(P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, V} ->
{parse_result,
{ok, {ok, V}},
erlang:element(3, Res),
erlang:element(4, Res),
[]};
{error, _} ->
{parse_result, {ok, {error, nil}}, Source, Pos, []}
end
end}.
-spec 'not'(parser(GSV, any())) -> parser(GSV, nil).
'not'(P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, _} ->
case Source of
[H | _] ->
Err = {unexpected, Pos, {token, H}, []},
{parse_result, {error, Err}, Source, Pos, []};
_ ->
Err@1 = {unexpected,
Pos,
{token, erlang:element(3, Config)},
[]},
{parse_result, {error, Err@1}, Source, Pos, []}
end;
{error, _} ->
{parse_result, {ok, nil}, Source, Pos, []}
end
end}.
-spec lazy(fun(() -> parser(GTE, GTF))) -> parser(GTE, GTF).
lazy(P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
run_on_tokens(P(), Source, Pos, Config, Recovery)
end}.
-spec extract_and_recover(
parser(GTT, GTU),
parser(GTT, GTT),
fun((GTU) -> parser(GTT, GTZ))
) -> parser(GTT, GTZ).
extract_and_recover(P, R, F) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, {some, R}),
case erlang:element(2, Res) of
{ok, V} ->
run_on_tokens(
F(V),
erlang:element(3, Res),
erlang:element(4, Res),
Config,
Recovery
);
{error, E} ->
{parse_result,
{error, E},
Source,
Pos,
erlang:element(5, Res)}
end
end}.
-spec extract(parser(GTK, GTL), fun((GTL) -> parser(GTK, GTO))) -> parser(GTK, GTO).
extract(P, F) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Recovery_parser = case Recovery of
{some, R} ->
R;
none ->
any_token()
end,
run_on_tokens(
extract_and_recover(P, Recovery_parser, F),
Source,
Pos,
Config,
Recovery
)
end}.
-spec all(list(parser(GSM, GSN))) -> parser(GSM, GSN).
all(Ps) ->
case Ps of
[P] ->
P;
[H | T] ->
extract(H, fun(_) -> all(T) end);
_ ->
erlang:error(#{gleam_error => panic,
message => <<"`ramble.all()` doesn't accept an empty list of parsers"/utf8>>,
module => <<"ramble_old"/utf8>>,
function => <<"all"/utf8>>,
line => 526})
end.
-spec return(GUE) -> parser(any(), GUE).
return(X) ->
{parser,
fun(Source, Pos, _, _) -> {parse_result, {ok, X}, Source, Pos, []} end}.
-spec sep1(parser(GRE, GRF), parser(GRE, any())) -> parser(GRE, list(GRF)).
sep1(Parser, S) ->
extract(
Parser,
fun(First) ->
extract(
many(seq(S, Parser)),
fun(Rest) -> return([First | Rest]) end
)
end
).
-spec sep(parser(GQU, GQV), parser(GQU, any())) -> parser(GQU, list(GQV)).
sep(Parser, S) ->
extract(optional(sep1(Parser, S)), fun(Res) -> case Res of
{ok, Sequence} ->
return(Sequence);
{error, nil} ->
return([])
end end).
-spec until(parser(GUM, GUN), parser(GUM, GUM)) -> parser(GUM, list(GUN)).
until(P, Terminator) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(Terminator, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, _} ->
{parse_result, {ok, []}, Source, Pos, []};
{error, _} ->
Parser = (extract(
position(),
fun(Pos1) ->
extract_and_recover(
P,
Terminator,
fun(First) ->
extract(
position(),
fun(Pos2) ->
gleam@io:debug({1, Pos1, Pos2}),
extract(
until(P, Terminator),
fun(Rest) ->
return([First | Rest])
end
)
end
)
end
)
end
)),
run_on_tokens(Parser, Source, Pos, Config, Recovery)
end
end}.
-spec recover() -> parser(any(), nil).
recover() ->
{parser,
fun(Source, Pos, Config, Recovery) ->
P = case Recovery of
{some, R} ->
_pipe = until(any_token(), R),
map(_pipe, fun(_) -> nil end);
none ->
_pipe@1 = any_token(),
map(_pipe@1, fun(_) -> nil end)
end,
Res = run_on_tokens(P, Source, Pos, Config, none),
{parse_result,
{ok, nil},
erlang:element(3, Res),
erlang:element(4, Res),
[]}
end}.
-spec satisfy(fun((GNC) -> boolean())) -> parser(GNC, GNC).
satisfy(Pred) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
{position, Row, Col} = case Pos of
{position, _, _} -> Pos;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Assertion pattern match failed"/utf8>>,
value => _assert_fail,
module => <<"ramble_old"/utf8>>,
function => <<"satisfy"/utf8>>,
line => 118})
end,
case Source of
[H | T] ->
case Pred(H) of
true ->
New_pos = case H =:= erlang:element(2, Config) of
true ->
{position, Row + 1, 0};
false ->
{position, Row, Col + 1}
end,
{parse_result, {ok, H}, T, New_pos, []};
false ->
Err = {unexpected, Pos, {token, H}, []},
Res = run_on_tokens(
recover(),
Source,
Pos,
Config,
Recovery
),
gleam@io:debug(
{Pos, erlang:element(4, Res), Recovery}
),
{parse_result,
{error, Err},
erlang:element(3, Res),
erlang:element(4, Res),
[]}
end;
[] ->
Err@1 = {unexpected,
Pos,
{token, erlang:element(3, Config)},
[]},
{parse_result, {error, Err@1}, Source, Pos, []}
end
end}.
-spec 'end'() -> parser(any(), nil).
'end'() ->
{parser, fun(Source, Pos, Config, Recovery) -> case Source of
[] ->
{parse_result, {ok, nil}, [], Pos, []};
[H | _] ->
Err = {unexpected,
Pos,
{token, H},
[{token, erlang:element(3, Config)}]},
Res = run_on_tokens(
recover(),
Source,
Pos,
Config,
Recovery
),
{parse_result,
{error, Err},
erlang:element(3, Res),
erlang:element(4, Res),
[Err]}
end end}.
-spec fail() -> parser(any(), any()).
fail() ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Unexpected_token = case Source of
[] ->
erlang:element(3, Config);
[H | _] ->
H
end,
Err = {unexpected, Pos, {token, Unexpected_token}, []},
Res = run_on_tokens(recover(), Source, Pos, Config, Recovery),
{parse_result,
{error, Err},
erlang:element(3, Res),
erlang:element(4, Res),
[Err]}
end}.
-spec peek(parser(GUV, any())) -> parser(GUV, boolean()).
peek(P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P, Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, _} ->
{parse_result, {ok, true}, Source, Pos, []};
{error, _} ->
{parse_result, {ok, false}, Source, Pos, []}
end
end}.
-spec label(binary(), fun(() -> parser(GVB, GVC))) -> parser(GVB, GVC).
label(Label, P) ->
{parser,
fun(Source, Pos, Config, Recovery) ->
Res = run_on_tokens(P(), Source, Pos, Config, Recovery),
case erlang:element(2, Res) of
{ok, _} ->
Res;
{error, E} ->
E@1 = case E of
{unexpected, Pos@1, T, _} ->
{unexpected, Pos@1, T, [{labeled_token, Label}]}
end,
{parse_result,
{error, E@1},
Source,
Pos,
erlang:element(5, Res)}
end
end}.
-spec token(GNO) -> parser(GNO, GNO).
token(C) ->
extract(
get_config(),
fun(Config) ->
label(
<<<<"a '"/utf8, ((erlang:element(5, Config))(C))/binary>>/binary,
"'"/utf8>>,
fun() -> satisfy(fun(C2) -> C =:= C2 end) end
)
end
).
-spec string(binary()) -> parser(binary(), binary()).
string(S) ->
case gleam@string:pop_grapheme(S) of
{ok, {H, T}} ->
extract(
token(H),
fun(C) ->
extract(
string(T),
fun(Rest) -> return(<<C/binary, Rest/binary>>) end
)
end
);
{error, _} ->
return(<<""/utf8>>)
end.
-spec go(parser(binary(), GMQ), binary(), parser_config(binary())) -> final_parse_result(binary(), GMQ).
go(P, Src, Config) ->
go_on_tokens(P, gleam@string:to_graphemes(Src), Config).
-spec lowercase_letter() -> parser(binary(), binary()).
lowercase_letter() ->
label(
<<"a lowercase letter"/utf8>>,
fun() ->
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(
<<"abcdefghijklmnopqrstuvwxyz"/utf8>>,
_capture
)
end
)
end
).
-spec uppercase_letter() -> parser(binary(), binary()).
uppercase_letter() ->
label(
<<"an uppercase letter"/utf8>>,
fun() ->
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(
<<"ABCDEFGHIJKLMNOPQRSTUVWXYZ"/utf8>>,
_capture
)
end
)
end
).
-spec letter() -> parser(binary(), binary()).
letter() ->
label(
<<"a letter"/utf8>>,
fun() ->
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(
<<"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"/utf8>>,
_capture
)
end
)
end
).
-spec digit() -> parser(binary(), binary()).
digit() ->
label(
<<"a digit"/utf8>>,
fun() ->
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(
<<"0123456789"/utf8>>,
_capture
)
end
)
end
).
-spec alphanum() -> parser(binary(), binary()).
alphanum() ->
label(
<<"an alphanumeric character"/utf8>>,
fun() ->
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(
<<"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"/utf8>>,
_capture
)
end
)
end
).
-spec many_as_string(parser(GPG, binary())) -> parser(GPG, binary()).
many_as_string(P) ->
_pipe = many(P),
map(_pipe, fun gleam@string:concat/1).
-spec many1_as_string(parser(GPS, binary())) -> parser(GPS, binary()).
many1_as_string(P) ->
_pipe = many1(P),
map(_pipe, fun gleam@string:concat/1).
-spec digits() -> parser(binary(), binary()).
digits() ->
many1_as_string(digit()).
-spec desperate_custom_parser(
fun((list(GVH), position(), parser_config(GVH), gleam@option:option(parser(GVH, GVH))) -> parse_result(GVH, GVN))
) -> parser(GVH, GVN).
desperate_custom_parser(Parse) ->
{parser, Parse}.
-spec pretty_expectations(binary(), list(binary())) -> binary().
pretty_expectations(Head, Tail) ->
case Tail of
[] ->
Head;
[X] ->
<<<<Head/binary, " or "/utf8>>/binary, X/binary>>;
[X@1, Y] ->
<<<<<<<<Head/binary, ", "/utf8>>/binary, X@1/binary>>/binary,
", or "/utf8>>/binary,
Y/binary>>;
[X@2 | Rest] ->
<<<<Head/binary, ", "/utf8>>/binary,
(pretty_expectations(X@2, Rest))/binary>>
end.
-spec pretty_err(parse_error(GVT), fun((GVT) -> binary()), binary()) -> binary().
pretty_err(Err, Show_token, Source_name) ->
Show = fun(Token) -> case Token of
{token, T} ->
Show_token(T);
{labeled_token, S} ->
S
end end,
case gleam@list:map(erlang:element(4, Err), Show) of
[] ->
<<<<<<<<<<<<<<<<"I didn't expect the `"/utf8,
(Show(erlang:element(3, Err)))/binary>>/binary,
"` at position "/utf8>>/binary,
(gleam@int:to_string(
erlang:element(
2,
erlang:element(2, Err)
)
))/binary>>/binary,
":"/utf8>>/binary,
(gleam@int:to_string(
erlang:element(3, erlang:element(2, Err))
))/binary>>/binary,
" in "/utf8>>/binary,
Source_name/binary>>/binary,
"."/utf8>>;
[Hd | Tl] ->
<<<<<<<<<<<<<<<<<<<<"I didn't expect the `"/utf8,
(Show(
erlang:element(3, Err)
))/binary>>/binary,
"` at position "/utf8>>/binary,
(gleam@int:to_string(
erlang:element(
2,
erlang:element(2, Err)
)
))/binary>>/binary,
":"/utf8>>/binary,
(gleam@int:to_string(
erlang:element(
3,
erlang:element(2, Err)
)
))/binary>>/binary,
" in "/utf8>>/binary,
Source_name/binary>>/binary,
". I expected "/utf8>>/binary,
(pretty_expectations(Hd, Tl))/binary>>/binary,
"."/utf8>>
end.
-spec main() -> nil.
main() ->
Config = {parser_config,
<<"\n"/utf8>>,
<<"EOF"/utf8>>,
<<"DEBUG"/utf8>>,
fun(S) -> S end},
{final_parse_result, V, Errs} = go(
seq(
do_and_recover(token(<<"c"/utf8>>), token(<<";"/utf8>>)),
token(<<"a"/utf8>>)
),
<<"ab;c"/utf8>>,
Config
),
gleam@io:debug({V, Errs}),
Errs@1 = case V of
{error, E} ->
[E | Errs];
_ ->
Errs
end,
gleam@list:each(
Errs@1,
fun(It) ->
gleam@io:println(
pretty_err(
It,
erlang:element(5, Config),
erlang:element(4, Config)
)
)
end
).
-spec whitespace() -> parser(binary(), binary()).
whitespace() ->
label(
<<"whitespace"/utf8>>,
fun() ->
many_as_string(
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(<<" \t\n"/utf8>>, _capture)
end
)
)
end
).
-spec whitespace1() -> parser(binary(), binary()).
whitespace1() ->
label(
<<"whitespace"/utf8>>,
fun() ->
many1_as_string(
satisfy(
fun(_capture) ->
gleam_stdlib:contains_string(<<" \t\n"/utf8>>, _capture)
end
)
)
end
).