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(IPR, IPS, IPT, IPU) :: {config,
        list(fun((config(IPR, IPS, IPT, IPU)) -> chomp:parser(IPR, IPS, IPT, IPU))),
        IPS,
        list(operator(IPR, IPS, IPT, IPU))}.

-opaque operator(IPV, IPW, IPX, IPY) :: {operator,
        fun((config(IPV, IPW, IPX, IPY)) -> {integer(),
            fun((IPV) -> chomp:parser(IPV, IPW, IPX, IPY))})}.

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

-spec operation(IRH, config(IRH, IRI, IRJ, IRK), integer()) -> chomp:parser(IRH, IRI, IRJ, IRK).
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).

-spec sub_expression(config(IQV, IQW, IQX, IQY), integer()) -> chomp:parser(IQV, IQW, IQX, IQY).
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).

-spec expression(
    list(fun((config(IPZ, IQA, IQB, IQC)) -> chomp:parser(IPZ, IQA, IQB, IQC))),
    IQA,
    list(operator(IPZ, IQA, IQB, IQC))
) -> chomp:parser(IPZ, IQA, IQB, IQC).
expression(First, Or_error, Then) ->
    Config = {config, First, Or_error, Then},
    sub_expression(Config, 0).

-spec prefix_custom(
    integer(),
    chomp:parser(ISK, ISL, ISM, ISN),
    fun((ISS, ISK) -> ISS)
) -> fun((config(ISS, ISL, ISM, ISN)) -> chomp:parser(ISS, ISL, ISM, ISN)).
prefix_custom(Precedence, Operator, Apply) ->
    fun(Config) ->
        chomp:do(
            Operator,
            fun(Op) ->
                chomp:do(
                    sub_expression(Config, Precedence),
                    fun(Subexpr) -> chomp:return(Apply(Subexpr, Op)) end
                )
            end
        )
    end.

-spec prefix(integer(), chomp:parser(any(), IRU, IRV, IRW), fun((ISB) -> ISB)) -> fun((config(ISB, IRU, IRV, IRW)) -> chomp:parser(ISB, IRU, IRV, IRW)).
prefix(Precedence, Operator, Apply) ->
    prefix_custom(Precedence, Operator, fun(A, _) -> Apply(A) end).

-spec infix_custom(
    precedence(),
    chomp:parser(ITO, ITP, ITQ, ITR),
    fun((ITW, ITW, ITO) -> ITW)
) -> operator(ITW, ITP, ITQ, ITR).
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,
                        fun(Op) ->
                            chomp:do(
                                sub_expression(Config, Right_precedence),
                                fun(Subexpr) ->
                                    chomp:return(Apply(Lhs, Subexpr, Op))
                                end
                            )
                        end
                    )
                end}
        end}.

-spec infix(
    precedence(),
    chomp:parser(any(), ITC, ITD, ITE),
    fun((ITJ, ITJ) -> ITJ)
) -> operator(ITJ, ITC, ITD, ITE).
infix(Precedence, Operator, Apply) ->
    infix_custom(Precedence, Operator, fun(A, B, _) -> Apply(A, B) end).

-spec postfix_custom(
    integer(),
    chomp:parser(IUO, IUP, IUQ, IUR),
    fun((IUW, IUO) -> IUW)
) -> operator(IUW, IUP, IUQ, IUR).
postfix_custom(Precedence, Operator, Apply) ->
    {operator,
        fun(_) ->
            {Precedence,
                fun(Lhs) ->
                    chomp:do(
                        Operator,
                        fun(Op) -> chomp:return(Apply(Lhs, Op)) end
                    )
                end}
        end}.

-spec postfix(integer(), chomp:parser(any(), IUC, IUD, IUE), fun((IUJ) -> IUJ)) -> operator(IUJ, IUC, IUD, IUE).
postfix(Precedence, Operator, Apply) ->
    postfix_custom(Precedence, Operator, fun(A, _) -> Apply(A) end).

-spec operator_custom(
    fun((config(IVB, IVC, IVD, IVE)) -> {integer(),
        fun((IVB) -> chomp:parser(IVB, IVC, IVD, IVE))})
) -> operator(IVB, IVC, IVD, IVE).
operator_custom(Build) ->
    {operator, Build}.