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

-export([succeed/1, fail/0, fail_at/1, expected/2, item/0, cut/1, seq/2, either/2, with_start/1, eof/0, alt/2, chain/2, chain_first/2, 'of'/1, map/2, ap/2, ap_first/1, ap_second/1, flatten/1, zero/0, chain_rec/2, sat/1, cut_with/2, maybe/1, many/1, many1/1, sep_by/2, sep_by1/2, sep_by_cut/2, filter/1, between/2, surrounded_by/1, look_ahead/1, take_until/1, optional/1, many_till/2, many1_till/2, get_semigroup/1, get_monoid/1]).
-export_type([next/2]).

-type next(FGK, FGL) :: {next, FGL, parser_gleam@stream:stream(FGK)}.

-spec succeed(FGO) -> fun((parser_gleam@stream:stream(FGN)) -> {ok,
                                                                parser_gleam@parse_result:parse_success(FGN, FGO)} |
    {error, parser_gleam@parse_result:parse_error(FGN)}).
succeed(A) ->
    fun(I) -> parser_gleam@parse_result:success(A, I, I) end.

-spec fail() -> fun((parser_gleam@stream:stream(FGR)) -> {ok,
                                                          parser_gleam@parse_result:parse_success(FGR, any())} |
    {error, parser_gleam@parse_result:parse_error(FGR)}).
fail() ->
    fun(I) -> parser_gleam@parse_result:error(I, none, none) end.

-spec fail_at(parser_gleam@stream:stream(FGV)) -> fun((parser_gleam@stream:stream(FGV)) -> {ok,
                                                                                            parser_gleam@parse_result:parse_success(FGV, any())} |
    {error, parser_gleam@parse_result:parse_error(FGV)}).
fail_at(I) ->
    fun(_) -> parser_gleam@parse_result:error(I, none, none) end.

-spec expected(
    fun((parser_gleam@stream:stream(FHA)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FHA, FHB)} |
        {error, parser_gleam@parse_result:parse_error(FHA)}),
    binary()
) -> fun((parser_gleam@stream:stream(FHA)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FHA, FHB)} |
    {error, parser_gleam@parse_result:parse_error(FHA)}).
expected(P, Message) ->
    fun(I) ->
        _pipe = P(I),
        gleam@result:map_error(
            _pipe,
            fun(Err) ->
                parser_gleam@parse_result:with_expected(Err, [Message])
            end
        )
    end.

-spec item() -> fun((parser_gleam@stream:stream(FHG)) -> {ok,
                                                          parser_gleam@parse_result:parse_success(FHG, FHG)} |
    {error, parser_gleam@parse_result:parse_error(FHG)}).
item() ->
    fun(I) -> case parser_gleam@stream:get_and_next(I) of
            none ->
                parser_gleam@parse_result:error(I, none, none);

            {some, E} ->
                parser_gleam@parse_result:success(
                    erlang:element(2, E),
                    erlang:element(3, E),
                    I
                )
        end end.

-spec cut(
    fun((parser_gleam@stream:stream(FHJ)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FHJ, FHK)} |
        {error, parser_gleam@parse_result:parse_error(FHJ)})
) -> fun((parser_gleam@stream:stream(FHJ)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FHJ, FHK)} |
    {error, parser_gleam@parse_result:parse_error(FHJ)}).
cut(P) ->
    fun(I) ->
        _pipe = P(I),
        gleam@result:map_error(_pipe, fun parser_gleam@parse_result:escalate/1)
    end.

-spec seq(
    fun((parser_gleam@stream:stream(FHP)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FHP, FHQ)} |
        {error, parser_gleam@parse_result:parse_error(FHP)}),
    fun((FHQ) -> fun((parser_gleam@stream:stream(FHP)) -> {ok,
                                                           parser_gleam@parse_result:parse_success(FHP, FHT)} |
        {error, parser_gleam@parse_result:parse_error(FHP)}))
) -> fun((parser_gleam@stream:stream(FHP)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FHP, FHT)} |
    {error, parser_gleam@parse_result:parse_error(FHP)}).
seq(Fa, F) ->
    fun(I) ->
        _pipe = Fa(I),
        gleam@result:then(
            _pipe,
            fun(S) ->
                _pipe@1 = (F(erlang:element(2, S)))(erlang:element(3, S)),
                gleam@result:then(
                    _pipe@1,
                    fun(Next) ->
                        parser_gleam@parse_result:success(
                            erlang:element(2, Next),
                            erlang:element(3, Next),
                            I
                        )
                    end
                )
            end
        )
    end.

-spec either(
    fun((parser_gleam@stream:stream(FHX)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FHX, FHY)} |
        {error, parser_gleam@parse_result:parse_error(FHX)}),
    fun(() -> fun((parser_gleam@stream:stream(FHX)) -> {ok,
                                                        parser_gleam@parse_result:parse_success(FHX, FHY)} |
        {error, parser_gleam@parse_result:parse_error(FHX)}))
) -> fun((parser_gleam@stream:stream(FHX)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FHX, FHY)} |
    {error, parser_gleam@parse_result:parse_error(FHX)}).
either(P, F) ->
    fun(I) ->
        E = P(I),
        case E of
            {ok, E@1} ->
                {ok, E@1};

            {error, E@2} ->
                case erlang:element(4, E@2) of
                    true ->
                        {error, E@2};

                    false ->
                        _pipe = (F())(I),
                        gleam@result:map_error(
                            _pipe,
                            fun(Err) ->
                                parser_gleam@parse_result:extend(E@2, Err)
                            end
                        )
                end
        end
    end.

-spec with_start(
    fun((parser_gleam@stream:stream(FIF)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FIF, FIG)} |
        {error, parser_gleam@parse_result:parse_error(FIF)})
) -> fun((parser_gleam@stream:stream(FIF)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FIF, {FIG,
                                                                                             parser_gleam@stream:stream(FIF)})} |
    {error, parser_gleam@parse_result:parse_error(FIF)}).
with_start(P) ->
    fun(I) ->
        _pipe = P(I),
        gleam@result:map(
            _pipe,
            fun(P@1) ->
                {parse_success,
                 {erlang:element(2, P@1), I},
                 erlang:element(3, P@1),
                 erlang:element(4, P@1)}
            end
        )
    end.

-spec eof() -> fun((parser_gleam@stream:stream(FIM)) -> {ok,
                                                         parser_gleam@parse_result:parse_success(FIM, nil)} |
    {error, parser_gleam@parse_result:parse_error(FIM)}).
eof() ->
    expected(fun(I) -> case parser_gleam@stream:at_end(I) of
                true ->
                    parser_gleam@parse_result:success(nil, I, I);

                false ->
                    parser_gleam@parse_result:error(I, none, none)
            end end, <<"end of file"/utf8>>).

-spec alt(
    fun((parser_gleam@stream:stream(FIP)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FIP, FIQ)} |
        {error, parser_gleam@parse_result:parse_error(FIP)}),
    fun(() -> fun((parser_gleam@stream:stream(FIP)) -> {ok,
                                                        parser_gleam@parse_result:parse_success(FIP, FIQ)} |
        {error, parser_gleam@parse_result:parse_error(FIP)}))
) -> fun((parser_gleam@stream:stream(FIP)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FIP, FIQ)} |
    {error, parser_gleam@parse_result:parse_error(FIP)}).
alt(Fa, That) ->
    either(Fa, That).

-spec chain(
    fun((parser_gleam@stream:stream(FIX)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FIX, FIY)} |
        {error, parser_gleam@parse_result:parse_error(FIX)}),
    fun((FIY) -> fun((parser_gleam@stream:stream(FIX)) -> {ok,
                                                           parser_gleam@parse_result:parse_success(FIX, FJB)} |
        {error, parser_gleam@parse_result:parse_error(FIX)}))
) -> fun((parser_gleam@stream:stream(FIX)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FIX, FJB)} |
    {error, parser_gleam@parse_result:parse_error(FIX)}).
chain(Ma, F) ->
    seq(Ma, F).

-spec chain_first(
    fun((parser_gleam@stream:stream(FJF)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FJF, FJG)} |
        {error, parser_gleam@parse_result:parse_error(FJF)}),
    fun((FJG) -> fun((parser_gleam@stream:stream(FJF)) -> {ok,
                                                           parser_gleam@parse_result:parse_success(FJF, any())} |
        {error, parser_gleam@parse_result:parse_error(FJF)}))
) -> fun((parser_gleam@stream:stream(FJF)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FJF, FJG)} |
    {error, parser_gleam@parse_result:parse_error(FJF)}).
chain_first(Ma, F) ->
    chain(Ma, fun(A) -> map(F(A), fun(_) -> A end) end).

-spec 'of'(FJQ) -> fun((parser_gleam@stream:stream(FJP)) -> {ok,
                                                             parser_gleam@parse_result:parse_success(FJP, FJQ)} |
    {error, parser_gleam@parse_result:parse_error(FJP)}).
'of'(A) ->
    succeed(A).

-spec map(
    fun((parser_gleam@stream:stream(FJT)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FJT, FJU)} |
        {error, parser_gleam@parse_result:parse_error(FJT)}),
    fun((FJU) -> FJX)
) -> fun((parser_gleam@stream:stream(FJT)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FJT, FJX)} |
    {error, parser_gleam@parse_result:parse_error(FJT)}).
map(Ma, F) ->
    fun(I) ->
        _pipe = Ma(I),
        gleam@result:map(
            _pipe,
            fun(S) ->
                {parse_success,
                 F(erlang:element(2, S)),
                 erlang:element(3, S),
                 erlang:element(4, S)}
            end
        )
    end.

-spec ap(
    fun((parser_gleam@stream:stream(FKA)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FKA, fun((FKB) -> FKC))} |
        {error, parser_gleam@parse_result:parse_error(FKA)}),
    fun((parser_gleam@stream:stream(FKA)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FKA, FKB)} |
        {error, parser_gleam@parse_result:parse_error(FKA)})
) -> fun((parser_gleam@stream:stream(FKA)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FKA, FKC)} |
    {error, parser_gleam@parse_result:parse_error(FKA)}).
ap(Mab, Ma) ->
    chain(Mab, fun(F) -> map(Ma, F) end).

-spec ap_first(
    fun((parser_gleam@stream:stream(FKJ)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FKJ, any())} |
        {error, parser_gleam@parse_result:parse_error(FKJ)})
) -> fun((fun((parser_gleam@stream:stream(FKJ)) -> {ok,
                                                    parser_gleam@parse_result:parse_success(FKJ, FVR)} |
    {error, parser_gleam@parse_result:parse_error(FKJ)})) -> fun((parser_gleam@stream:stream(FKJ)) -> {ok,
                                                                                                       parser_gleam@parse_result:parse_success(FKJ, FVR)} |
    {error, parser_gleam@parse_result:parse_error(FKJ)})).
ap_first(Fb) ->
    fun(Fa) -> ap(map(Fa, fun(A) -> fun(_) -> A end end), Fb) end.

-spec ap_second(
    fun((parser_gleam@stream:stream(FKO)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FKO, FKP)} |
        {error, parser_gleam@parse_result:parse_error(FKO)})
) -> fun((fun((parser_gleam@stream:stream(FKO)) -> {ok,
                                                    parser_gleam@parse_result:parse_success(FKO, any())} |
    {error, parser_gleam@parse_result:parse_error(FKO)})) -> fun((parser_gleam@stream:stream(FKO)) -> {ok,
                                                                                                       parser_gleam@parse_result:parse_success(FKO, FKP)} |
    {error, parser_gleam@parse_result:parse_error(FKO)})).
ap_second(Fb) ->
    fun(Fa) -> ap(map(Fa, fun(_) -> fun(B) -> B end end), Fb) end.

-spec flatten(
    fun((parser_gleam@stream:stream(FKT)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FKT, fun((parser_gleam@stream:stream(FKT)) -> {ok,
                                                                                                                                     parser_gleam@parse_result:parse_success(FKT, FKU)} |
                                                  {error,
                                                   parser_gleam@parse_result:parse_error(FKT)}))} |
        {error, parser_gleam@parse_result:parse_error(FKT)})
) -> fun((parser_gleam@stream:stream(FKT)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FKT, FKU)} |
    {error, parser_gleam@parse_result:parse_error(FKT)}).
flatten(Mma) ->
    chain(Mma, fun fp_gl@function:identity/1).

-spec zero() -> fun((parser_gleam@stream:stream(FLB)) -> {ok,
                                                          parser_gleam@parse_result:parse_success(FLB, any())} |
    {error, parser_gleam@parse_result:parse_error(FLB)}).
zero() ->
    fail().

-spec chain_rec(
    FLH,
    fun((FLH) -> fun((parser_gleam@stream:stream(FLI)) -> {ok,
                                                           parser_gleam@parse_result:parse_success(FLI, {ok,
                                                                                                         FLJ} |
                                                               {error, FLH})} |
        {error, parser_gleam@parse_result:parse_error(FLI)}))
) -> fun((parser_gleam@stream:stream(FLI)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FLI, FLJ)} |
    {error, parser_gleam@parse_result:parse_error(FLI)}).
chain_rec(A, F) ->
    Split = fun(Start) -> fun(Result) -> case erlang:element(2, Result) of
                {error, E} ->
                    {error, {next, E, erlang:element(3, Result)}};

                {ok, R} ->
                    {ok,
                     parser_gleam@parse_result:success(
                         R,
                         erlang:element(3, Result),
                         Start
                     )}
            end end end,
    fun(Start@1) ->
        fp_gl@chain_rec:tail_rec(
            {next, A, Start@1},
            fun(State) ->
                Result@1 = (F(erlang:element(2, State)))(
                    erlang:element(3, State)
                ),
                case Result@1 of
                    {error, R@1} ->
                        {ok,
                         parser_gleam@parse_result:error(
                             erlang:element(3, State),
                             {some, erlang:element(3, R@1)},
                             {some, erlang:element(4, R@1)}
                         )};

                    {ok, R@2} ->
                        (Split(Start@1))(R@2)
                end
            end
        )
    end.

-spec sat(fun((FLQ) -> boolean())) -> fun((parser_gleam@stream:stream(FLQ)) -> {ok,
                                                                                parser_gleam@parse_result:parse_success(FLQ, FLQ)} |
    {error, parser_gleam@parse_result:parse_error(FLQ)}).
sat(Predicate) ->
    _pipe = with_start(item()),
    chain(
        _pipe,
        fun(T) ->
            {A, Start} = T,
            case Predicate(A) of
                true ->
                    'of'(A);

                false ->
                    fail_at(Start)
            end
        end
    ).

-spec cut_with(
    fun((parser_gleam@stream:stream(FLU)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FLU, any())} |
        {error, parser_gleam@parse_result:parse_error(FLU)}),
    fun((parser_gleam@stream:stream(FLU)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FLU, FLY)} |
        {error, parser_gleam@parse_result:parse_error(FLU)})
) -> fun((parser_gleam@stream:stream(FLU)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FLU, FLY)} |
    {error, parser_gleam@parse_result:parse_error(FLU)}).
cut_with(P1, P2) ->
    _pipe = P1,
    (ap_second(cut(P2)))(_pipe).

-spec maybe(fp_gl@models:monoid(FMD)) -> fun((fun((parser_gleam@stream:stream(FZR)) -> {ok,
                                                                                        parser_gleam@parse_result:parse_success(FZR, FMD)} |
    {error, parser_gleam@parse_result:parse_error(FZR)})) -> fun((parser_gleam@stream:stream(FZR)) -> {ok,
                                                                                                       parser_gleam@parse_result:parse_success(FZR, FMD)} |
    {error, parser_gleam@parse_result:parse_error(FZR)})).
maybe(M) ->
    fun(P) ->
        _pipe = P,
        alt(_pipe, fun() -> 'of'(erlang:element(3, M)) end)
    end.

-spec many(
    fun((parser_gleam@stream:stream(FMG)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FMG, FMH)} |
        {error, parser_gleam@parse_result:parse_error(FMG)})
) -> fun((parser_gleam@stream:stream(FMG)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FMG, list(FMH))} |
    {error, parser_gleam@parse_result:parse_error(FMG)}).
many(P) ->
    _pipe = many1(P),
    _pipe@1 = map(_pipe, fun fp_gl@non_empty_list:to_list/1),
    alt(_pipe@1, fun() -> 'of'([]) end).

-spec many1(
    fun((parser_gleam@stream:stream(FMN)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FMN, FMO)} |
        {error, parser_gleam@parse_result:parse_error(FMN)})
) -> fun((parser_gleam@stream:stream(FMN)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FMN, fp_gl@non_empty_list:non_empty_list(FMO))} |
    {error, parser_gleam@parse_result:parse_error(FMN)}).
many1(Parser) ->
    _pipe = Parser,
    chain(
        _pipe,
        fun(Head) ->
            chain_rec(
                fp_gl@non_empty_list:'of'(Head),
                fun(Acc) ->
                    _pipe@1 = Parser,
                    _pipe@2 = map(
                        _pipe@1,
                        fun(A) ->
                            {error, fp_gl@non_empty_list:append(Acc, A)}
                        end
                    ),
                    alt(_pipe@2, fun() -> 'of'({ok, Acc}) end)
                end
            )
        end
    ).

-spec sep_by(
    fun((parser_gleam@stream:stream(FMU)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FMU, any())} |
        {error, parser_gleam@parse_result:parse_error(FMU)}),
    fun((parser_gleam@stream:stream(FMU)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FMU, FMY)} |
        {error, parser_gleam@parse_result:parse_error(FMU)})
) -> fun((parser_gleam@stream:stream(FMU)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FMU, list(FMY))} |
    {error, parser_gleam@parse_result:parse_error(FMU)}).
sep_by(Sep, P) ->
    _pipe = sep_by1(Sep, P),
    _pipe@1 = map(_pipe, fun fp_gl@non_empty_list:to_list/1),
    alt(_pipe@1, fun() -> 'of'([]) end).

-spec sep_by1(
    fun((parser_gleam@stream:stream(FNE)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FNE, any())} |
        {error, parser_gleam@parse_result:parse_error(FNE)}),
    fun((parser_gleam@stream:stream(FNE)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FNE, FNI)} |
        {error, parser_gleam@parse_result:parse_error(FNE)})
) -> fun((parser_gleam@stream:stream(FNE)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FNE, fp_gl@non_empty_list:non_empty_list(FNI))} |
    {error, parser_gleam@parse_result:parse_error(FNE)}).
sep_by1(Sep, P) ->
    _pipe = P,
    chain(
        _pipe,
        fun(Head) ->
            _pipe@2 = many(
                begin
                    _pipe@1 = Sep,
                    (ap_second(P))(_pipe@1)
                end
            ),
            map(
                _pipe@2,
                fun(Tail) ->
                    _pipe@3 = Tail,
                    fp_gl@non_empty_list:prepend_list(_pipe@3, Head)
                end
            )
        end
    ).

-spec sep_by_cut(
    fun((parser_gleam@stream:stream(FNO)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FNO, any())} |
        {error, parser_gleam@parse_result:parse_error(FNO)}),
    fun((parser_gleam@stream:stream(FNO)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FNO, FNS)} |
        {error, parser_gleam@parse_result:parse_error(FNO)})
) -> fun((parser_gleam@stream:stream(FNO)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FNO, fp_gl@non_empty_list:non_empty_list(FNS))} |
    {error, parser_gleam@parse_result:parse_error(FNO)}).
sep_by_cut(Sep, P) ->
    _pipe = P,
    chain(
        _pipe,
        fun(Head) ->
            _pipe@1 = many(cut_with(Sep, P)),
            map(
                _pipe@1,
                fun(Tail) ->
                    _pipe@2 = Tail,
                    fp_gl@non_empty_list:prepend_list(_pipe@2, Head)
                end
            )
        end
    ).

-spec filter(fun((FNY) -> boolean())) -> fun((fun((parser_gleam@stream:stream(GCW)) -> {ok,
                                                                                        parser_gleam@parse_result:parse_success(GCW, FNY)} |
    {error, parser_gleam@parse_result:parse_error(GCW)})) -> fun((parser_gleam@stream:stream(GCW)) -> {ok,
                                                                                                       parser_gleam@parse_result:parse_success(GCW, FNY)} |
    {error, parser_gleam@parse_result:parse_error(GCW)})).
filter(Predicate) ->
    fun(P) ->
        fun(I) ->
            _pipe = P(I),
            gleam@result:then(
                _pipe,
                fun(Next) -> case Predicate(erlang:element(2, Next)) of
                        true ->
                            {ok, Next};

                        false ->
                            parser_gleam@parse_result:error(I, none, none)
                    end end
            )
        end
    end.

-spec between(
    fun((parser_gleam@stream:stream(FOB)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FOB, FOC)} |
        {error, parser_gleam@parse_result:parse_error(FOB)}),
    fun((parser_gleam@stream:stream(FOB)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FOB, FOC)} |
        {error, parser_gleam@parse_result:parse_error(FOB)})
) -> fun((fun((parser_gleam@stream:stream(FOB)) -> {ok,
                                                    parser_gleam@parse_result:parse_success(FOB, GDP)} |
    {error, parser_gleam@parse_result:parse_error(FOB)})) -> fun((parser_gleam@stream:stream(FOB)) -> {ok,
                                                                                                       parser_gleam@parse_result:parse_success(FOB, GDP)} |
    {error, parser_gleam@parse_result:parse_error(FOB)})).
between(Left, Right) ->
    fun(P) ->
        _pipe = Left,
        _pipe@1 = chain(_pipe, fun(_) -> P end),
        chain_first(_pipe@1, fun(_) -> Right end)
    end.

-spec surrounded_by(
    fun((parser_gleam@stream:stream(FOI)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FOI, any())} |
        {error, parser_gleam@parse_result:parse_error(FOI)})
) -> fun((fun((parser_gleam@stream:stream(FOI)) -> {ok,
                                                    parser_gleam@parse_result:parse_success(FOI, GEC)} |
    {error, parser_gleam@parse_result:parse_error(FOI)})) -> fun((parser_gleam@stream:stream(FOI)) -> {ok,
                                                                                                       parser_gleam@parse_result:parse_success(FOI, GEC)} |
    {error, parser_gleam@parse_result:parse_error(FOI)})).
surrounded_by(Bound) ->
    fun(P) -> (between(Bound, Bound))(P) end.

-spec look_ahead(
    fun((parser_gleam@stream:stream(FON)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FON, FOO)} |
        {error, parser_gleam@parse_result:parse_error(FON)})
) -> fun((parser_gleam@stream:stream(FON)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FON, FOO)} |
    {error, parser_gleam@parse_result:parse_error(FON)}).
look_ahead(P) ->
    fun(I) ->
        _pipe = P(I),
        gleam@result:then(
            _pipe,
            fun(Next) ->
                parser_gleam@parse_result:success(erlang:element(2, Next), I, I)
            end
        )
    end.

-spec take_until(fun((FOT) -> boolean())) -> fun((parser_gleam@stream:stream(FOT)) -> {ok,
                                                                                       parser_gleam@parse_result:parse_success(FOT, list(FOT))} |
    {error, parser_gleam@parse_result:parse_error(FOT)}).
take_until(Predicate) ->
    _pipe = Predicate,
    _pipe@1 = fp_gl@predicate:'not'(_pipe),
    _pipe@2 = sat(_pipe@1),
    many(_pipe@2).

-spec optional(
    fun((parser_gleam@stream:stream(FOY)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FOY, FOZ)} |
        {error, parser_gleam@parse_result:parse_error(FOY)})
) -> fun((parser_gleam@stream:stream(FOY)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FOY, gleam@option:option(FOZ))} |
    {error, parser_gleam@parse_result:parse_error(FOY)}).
optional(Parser) ->
    _pipe = Parser,
    _pipe@1 = map(_pipe, fun(A) -> {some, A} end),
    alt(_pipe@1, fun() -> succeed(none) end).

-spec many_till(
    fun((parser_gleam@stream:stream(FPF)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FPF, FPG)} |
        {error, parser_gleam@parse_result:parse_error(FPF)}),
    fun((parser_gleam@stream:stream(FPF)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FPF, any())} |
        {error, parser_gleam@parse_result:parse_error(FPF)})
) -> fun((parser_gleam@stream:stream(FPF)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FPF, list(FPG))} |
    {error, parser_gleam@parse_result:parse_error(FPF)}).
many_till(Parser, Terminator) ->
    _pipe = Terminator,
    _pipe@1 = map(_pipe, fun(_) -> [] end),
    alt(
        _pipe@1,
        fun() ->
            _pipe@2 = many1_till(Parser, Terminator),
            map(_pipe@2, fun fp_gl@non_empty_list:to_list/1)
        end
    ).

-spec many1_till(
    fun((parser_gleam@stream:stream(FPP)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FPP, FPQ)} |
        {error, parser_gleam@parse_result:parse_error(FPP)}),
    fun((parser_gleam@stream:stream(FPP)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FPP, any())} |
        {error, parser_gleam@parse_result:parse_error(FPP)})
) -> fun((parser_gleam@stream:stream(FPP)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FPP, fp_gl@non_empty_list:non_empty_list(FPQ))} |
    {error, parser_gleam@parse_result:parse_error(FPP)}).
many1_till(Parser, Terminator) ->
    _pipe = Parser,
    chain(
        _pipe,
        fun(X) ->
            chain_rec(
                fp_gl@non_empty_list:'of'(X),
                fun(Acc) ->
                    _pipe@1 = Terminator,
                    _pipe@2 = map(_pipe@1, fun(_) -> {ok, Acc} end),
                    alt(
                        _pipe@2,
                        fun() ->
                            _pipe@3 = Parser,
                            map(
                                _pipe@3,
                                fun(A) ->
                                    {error, fp_gl@non_empty_list:append(Acc, A)}
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec get_semigroup(fp_gl@models:semigroup(FPZ)) -> fp_gl@models:semigroup(fun((parser_gleam@stream:stream(FQB)) -> {ok,
                                                                                                                     parser_gleam@parse_result:parse_success(FQB, FPZ)} |
    {error, parser_gleam@parse_result:parse_error(FQB)})).
get_semigroup(S) ->
    {semigroup,
     fun(X, Y) ->
         ap(
             map(
                 X,
                 fun(X@1) ->
                     fun(Y@1) -> (erlang:element(2, S))(X@1, Y@1) end
                 end
             ),
             Y
         )
     end}.

-spec monoid_to_semigroup(fp_gl@models:monoid(FQF)) -> fp_gl@models:semigroup(FQF).
monoid_to_semigroup(M) ->
    {semigroup, erlang:element(2, M)}.

-spec get_monoid(fp_gl@models:monoid(FQI)) -> fp_gl@models:monoid(fun((parser_gleam@stream:stream(FQK)) -> {ok,
                                                                                                            parser_gleam@parse_result:parse_success(FQK, FQI)} |
    {error, parser_gleam@parse_result:parse_error(FQK)})).
get_monoid(M) ->
    {semigroup, Concat} = begin
        _pipe = M,
        _pipe@1 = monoid_to_semigroup(_pipe),
        get_semigroup(_pipe@1)
    end,
    {monoid, Concat, succeed(erlang:element(3, M))}.