chomp

-module(chomp@pratt).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([sub_expression/2, expression/3, prefix_custom/3, prefix/3, infix_custom/3, infix/3, postfix_custom/3, postfix/3, operator_custom/1]).
-export_type([config/4, operator/4, precedence/0]).

-opaque config(HYP, HYQ, HYR, HYS) :: {config,
        list(fun((config(HYP, HYQ, HYR, HYS)) -> chomp:parser(HYP, HYQ, HYR, HYS))),
        HYQ,
        list(operator(HYP, HYQ, HYR, HYS))}.

-opaque operator(HYT, HYU, HYV, HYW) :: {operator,
        fun((config(HYT, HYU, HYV, HYW)) -> {integer(),
            fun((HYT) -> chomp:parser(HYT, HYU, HYV, HYW))})}.

-type precedence() :: {left, integer()} | {right, integer()}.

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 68).
-spec operation(IAF, config(IAF, IAG, IAH, IAI), integer()) -> chomp:parser(IAF, IAG, IAH, IAI).
operation(Expr, Config, Current_precedence) ->
    _pipe = erlang:element(4, Config),
    _pipe@1 = gleam@list:filter_map(
        _pipe,
        fun(Operator) ->
            {operator, Op} = Operator,
            case Op(Config) of
                {Precedence, Parser} when Precedence > Current_precedence ->
                    {ok, Parser(Expr)};

                _ ->
                    {error, nil}
            end
        end
    ),
    chomp:one_of(_pipe@1).

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 42).
-spec sub_expression(config(HZT, HZU, HZV, HZW), integer()) -> chomp:parser(HZT, HZU, HZV, HZW).
sub_expression(Config, Precedence) ->
    Expr = (chomp:lazy(fun() -> _pipe = erlang:element(2, Config),
            _pipe@1 = gleam@list:map(_pipe, fun(P) -> P(Config) end),
            _pipe@2 = chomp:one_of(_pipe@1),
            chomp:or_error(_pipe@2, erlang:element(3, Config)) end)),
    Go = fun(Expr@1) ->
        chomp:one_of(
            [begin
                    _pipe@3 = operation(Expr@1, Config, Precedence),
                    chomp:map(_pipe@3, fun(Field@0) -> {continue, Field@0} end)
                end,
                begin
                    _pipe@4 = chomp:return(Expr@1),
                    chomp:map(_pipe@4, fun(Field@0) -> {break, Field@0} end)
                end]
        )
    end,
    chomp:do(Expr, fun(E) -> chomp:loop(E, Go) end).

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 33).
-spec expression(
    list(fun((config(HYX, HYY, HYZ, HZA)) -> chomp:parser(HYX, HYY, HYZ, HZA))),
    HYY,
    list(operator(HYX, HYY, HYZ, HZA))
) -> chomp:parser(HYX, HYY, HYZ, HZA).
expression(First, Or_error, Then) ->
    Config = {config, First, Or_error, Then},
    sub_expression(Config, 0).

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 96).
-spec prefix_custom(
    integer(),
    fun((config(IBI, IBJ, IBK, IBL)) -> chomp:parser(IBQ, IBJ, IBK, IBL)),
    fun((IBI, IBQ) -> IBI)
) -> fun((config(IBI, IBJ, IBK, IBL)) -> chomp:parser(IBI, IBJ, IBK, IBL)).
prefix_custom(Precedence, Operator, Apply) ->
    fun(Config) ->
        chomp:do(
            Operator(Config),
            fun(Op) ->
                chomp:do(
                    sub_expression(Config, Precedence),
                    fun(Subexpr) -> chomp:return(Apply(Subexpr, Op)) end
                )
            end
        )
    end.

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 88).
-spec prefix(integer(), chomp:parser(any(), IAS, IAT, IAU), fun((IAZ) -> IAZ)) -> fun((config(IAZ, IAS, IAT, IAU)) -> chomp:parser(IAZ, IAS, IAT, IAU)).
prefix(Precedence, Operator, Apply) ->
    prefix_custom(Precedence, fun(_) -> Operator end, fun(A, _) -> Apply(A) end).

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 117).
-spec infix_custom(
    precedence(),
    fun((config(ICQ, ICR, ICS, ICT)) -> chomp:parser(ICY, ICR, ICS, ICT)),
    fun((ICQ, ICQ, ICY) -> ICQ)
) -> operator(ICQ, ICR, ICS, ICT).
infix_custom(Precedence, Operator, Apply) ->
    {Left_precedence, Right_precedence} = case Precedence of
        {left, P} ->
            {P, P};

        {right, P@1} ->
            {P@1, P@1 - 1}
    end,
    {operator,
        fun(Config) ->
            {Left_precedence,
                fun(Lhs) ->
                    chomp:do(
                        Operator(Config),
                        fun(Op) ->
                            chomp:do(
                                sub_expression(Config, Right_precedence),
                                fun(Subexpr) ->
                                    chomp:return(Apply(Lhs, Subexpr, Op))
                                end
                            )
                        end
                    )
                end}
        end}.

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 109).
-spec infix(
    precedence(),
    chomp:parser(any(), ICE, ICF, ICG),
    fun((ICL, ICL) -> ICL)
) -> operator(ICL, ICE, ICF, ICG).
infix(Precedence, Operator, Apply) ->
    infix_custom(
        Precedence,
        fun(_) -> Operator end,
        fun(A, B, _) -> Apply(A, B) end
    ).

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 143).
-spec postfix_custom(
    integer(),
    fun((config(IDU, IDV, IDW, IDX)) -> chomp:parser(IEC, IDV, IDW, IDX)),
    fun((IDU, IEC) -> IDU)
) -> operator(IDU, IDV, IDW, IDX).
postfix_custom(Precedence, Operator, Apply) ->
    {operator,
        fun(Config) ->
            {Precedence,
                fun(Lhs) ->
                    chomp:do(
                        Operator(Config),
                        fun(Op) -> chomp:return(Apply(Lhs, Op)) end
                    )
                end}
        end}.

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 135).
-spec postfix(integer(), chomp:parser(any(), IDI, IDJ, IDK), fun((IDP) -> IDP)) -> operator(IDP, IDI, IDJ, IDK).
postfix(Precedence, Operator, Apply) ->
    postfix_custom(
        Precedence,
        fun(_) -> Operator end,
        fun(A, _) -> Apply(A) end
    ).

-file("/home/noah/Projects/gleam/chomp/src/chomp/pratt.gleam", 155).
-spec operator_custom(
    fun((config(IEL, IEM, IEN, IEO)) -> {integer(),
        fun((IEL) -> chomp:parser(IEL, IEM, IEN, IEO))})
) -> operator(IEL, IEM, IEN, IEO).
operator_custom(Build) ->
    {operator, Build}.