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(IQC, IQD, IQE, IQF) :: {config,
        list(fun((config(IQC, IQD, IQE, IQF)) -> chomp:parser(IQC, IQD, IQE, IQF))),
        IQD,
        list(operator(IQC, IQD, IQE, IQF))}.

-opaque operator(IQG, IQH, IQI, IQJ) :: {operator,
        fun((config(IQG, IQH, IQI, IQJ)) -> {integer(),
            fun((IQG) -> chomp:parser(IQG, IQH, IQI, IQJ))})}.

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

-file("/home/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 68).
-spec operation(IRS, config(IRS, IRT, IRU, IRV), integer()) -> chomp:parser(IRS, IRT, IRU, IRV).
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/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 42).
-spec sub_expression(config(IRG, IRH, IRI, IRJ), integer()) -> chomp:parser(IRG, IRH, IRI, IRJ).
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/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 33).
-spec expression(
    list(fun((config(IQK, IQL, IQM, IQN)) -> chomp:parser(IQK, IQL, IQM, IQN))),
    IQL,
    list(operator(IQK, IQL, IQM, IQN))
) -> chomp:parser(IQK, IQL, IQM, IQN).
expression(First, Or_error, Then) ->
    Config = {config, First, Or_error, Then},
    sub_expression(Config, 0).

-file("/home/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 96).
-spec prefix_custom(
    integer(),
    fun((config(ISV, ISW, ISX, ISY)) -> chomp:parser(ITD, ISW, ISX, ISY)),
    fun((ISV, ITD) -> ISV)
) -> fun((config(ISV, ISW, ISX, ISY)) -> chomp:parser(ISV, ISW, ISX, ISY)).
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/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 88).
-spec prefix(integer(), chomp:parser(any(), ISF, ISG, ISH), fun((ISM) -> ISM)) -> fun((config(ISM, ISF, ISG, ISH)) -> chomp:parser(ISM, ISF, ISG, ISH)).
prefix(Precedence, Operator, Apply) ->
    prefix_custom(Precedence, fun(_) -> Operator end, fun(A, _) -> Apply(A) end).

-file("/home/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 117).
-spec infix_custom(
    precedence(),
    fun((config(IUD, IUE, IUF, IUG)) -> chomp:parser(IUL, IUE, IUF, IUG)),
    fun((IUD, IUD, IUL) -> IUD)
) -> operator(IUD, IUE, IUF, IUG).
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/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 109).
-spec infix(
    precedence(),
    chomp:parser(any(), ITR, ITS, ITT),
    fun((ITY, ITY) -> ITY)
) -> operator(ITY, ITR, ITS, ITT).
infix(Precedence, Operator, Apply) ->
    infix_custom(
        Precedence,
        fun(_) -> Operator end,
        fun(A, B, _) -> Apply(A, B) end
    ).

-file("/home/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 143).
-spec postfix_custom(
    integer(),
    fun((config(IVH, IVI, IVJ, IVK)) -> chomp:parser(IVP, IVI, IVJ, IVK)),
    fun((IVH, IVP) -> IVH)
) -> operator(IVH, IVI, IVJ, IVK).
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/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 135).
-spec postfix(integer(), chomp:parser(any(), IUV, IUW, IUX), fun((IVC) -> IVC)) -> operator(IVC, IUV, IUW, IUX).
postfix(Precedence, Operator, Apply) ->
    postfix_custom(
        Precedence,
        fun(_) -> Operator end,
        fun(A, _) -> Apply(A) end
    ).

-file("/home/mystic/projects/gleam/chomp/src/chomp/pratt.gleam", 155).
-spec operator_custom(
    fun((config(IVY, IVZ, IWA, IWB)) -> {integer(),
        fun((IVY) -> chomp:parser(IVY, IVZ, IWA, IWB))})
) -> operator(IVY, IVZ, IWA, IWB).
operator_custom(Build) ->
    {operator, Build}.