parser_gleam

-module(parser_gleam@parse_result).
-compile(no_auto_import).

-export([success/3, error/3, with_expected/2, escalate/1, extend/2]).
-export_type([parse_success/2, parse_error/1]).

-type parse_success(EPN, EPO) :: {parse_success,
                                  EPO,
                                  parser_gleam@stream:stream(EPN),
                                  parser_gleam@stream:stream(EPN)}.

-type parse_error(EPP) :: {parse_error,
                           parser_gleam@stream:stream(EPP),
                           list(binary()),
                           boolean()}.

-spec success(
    EQF,
    parser_gleam@stream:stream(EQG),
    parser_gleam@stream:stream(EQG)
) -> {ok, parse_success(EQG, EQF)} | {error, parse_error(EQG)}.
success(Value, Next, Start) ->
    {ok, {parse_success, Value, Next, Start}}.

-spec error(
    parser_gleam@stream:stream(EQL),
    gleam@option:option(list(binary())),
    gleam@option:option(boolean())
) -> {ok, parse_success(EQL, any())} | {error, parse_error(EQL)}.
error(Input, Expected, Fatal) ->
    {error,
     {parse_error,
      Input,
      begin
          _pipe = Expected,
          gleam@option:unwrap(_pipe, [])
      end,
      begin
          _pipe@1 = Fatal,
          gleam@option:unwrap(_pipe@1, false)
      end}}.

-spec with_expected(parse_error(EQT), list(binary())) -> parse_error(EQT).
with_expected(Err, Expected) ->
    {parse_error, erlang:element(2, Err), Expected, erlang:element(4, Err)}.

-spec escalate(parse_error(EQX)) -> parse_error(EQX).
escalate(Err) ->
    {parse_error, erlang:element(2, Err), erlang:element(3, Err), true}.

-spec extend(parse_error(ERA), parse_error(ERA)) -> parse_error(ERA).
extend(Err1, Err2) ->
    (erlang:element(2, get_semigroup()))(Err1, Err2).

-spec get_semigroup() -> fp2@semigroup:semigroup(parse_error(any())).
get_semigroup() ->
    {semigroup,
     fun(X, Y) ->
         case erlang:element(3, erlang:element(2, X))
         < erlang:element(3, erlang:element(2, Y)) of
             true ->
                 Y;

             false ->
                 case erlang:element(3, erlang:element(2, X))
                 > erlang:element(3, erlang:element(2, Y)) of
                     true ->
                         X;

                     false ->
                         {parse_error,
                          erlang:element(2, X),
                          gleam@list:append(
                              erlang:element(3, X),
                              erlang:element(3, Y)
                          ),
                          erlang:element(4, X)}
                 end
         end
     end}.