-module(cel@interpreter@evaluate).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([evaluate_expr/2]).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 320).
-spec find_in_list(list(GQW), integer(), integer()) -> {ok, GQW} |
    {error, cel@interpreter@error:execution_error()}.
find_in_list(Container, Target, Index) ->
    case Container of
        [] ->
            {error, {index_out_of_bounds, Index, Target}};

        [Item | _] when Target =:= Index ->
            {ok, Item};

        [_ | Rest] ->
            find_in_list(Rest, Target, Index + 1)
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 94).
-spec evaluate_arithmetic(
    cel@parser:expression(),
    cel@parser:arithmetic(),
    cel@parser:expression(),
    cel@interpreter@context:context()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_arithmetic(Lhs, Op, Rhs, Ctx) ->
    gleam@result:'try'(
        evaluate_expr(Lhs, Ctx),
        fun(Lhs_value) ->
            gleam@result:'try'(
                evaluate_expr(Rhs, Ctx),
                fun(Rhs_value) -> case {Lhs_value, Op, Rhs_value} of
                        {{int, L}, add, {int, R}} ->
                            _pipe = {int, L + R},
                            {ok, _pipe};

                        {{int, L@1}, 'div', {int, R@1}} ->
                            _pipe@1 = {int, case R@1 of
                                    0 -> 0;
                                    Gleam@denominator -> L@1 div Gleam@denominator
                                end},
                            {ok, _pipe@1};

                        {{int, L@2}, mod, {int, R@2}} ->
                            _pipe@2 = {int, case R@2 of
                                    0 -> 0;
                                    Gleam@denominator@1 -> L@2 rem Gleam@denominator@1
                                end},
                            {ok, _pipe@2};

                        {{int, L@3}, mul, {int, R@3}} ->
                            _pipe@3 = {int, L@3 * R@3},
                            {ok, _pipe@3};

                        {{int, L@4}, sub, {int, R@4}} ->
                            _pipe@4 = {int, L@4 - R@4},
                            {ok, _pipe@4};

                        {{u_int, L@5}, add, {u_int, R@5}} ->
                            _pipe@5 = {u_int, L@5 + R@5},
                            {ok, _pipe@5};

                        {{u_int, L@6}, 'div', {u_int, R@6}} ->
                            _pipe@6 = {u_int, case R@6 of
                                    0 -> 0;
                                    Gleam@denominator@2 -> L@6 div Gleam@denominator@2
                                end},
                            {ok, _pipe@6};

                        {{u_int, L@7}, mod, {u_int, R@7}} ->
                            _pipe@7 = {u_int, case R@7 of
                                    0 -> 0;
                                    Gleam@denominator@3 -> L@7 rem Gleam@denominator@3
                                end},
                            {ok, _pipe@7};

                        {{u_int, L@8}, mul, {u_int, R@8}} ->
                            _pipe@8 = {u_int, L@8 * R@8},
                            {ok, _pipe@8};

                        {{u_int, L@9}, sub, {u_int, R@9}} ->
                            _pipe@9 = {u_int, L@9 - R@9},
                            {ok, _pipe@9};

                        {{float, L@10}, add, {float, R@10}} ->
                            _pipe@10 = {float, L@10 + R@10},
                            {ok, _pipe@10};

                        {{float, L@11}, 'div', {float, R@11}} ->
                            _pipe@11 = {float, case R@11 of
                                    +0.0 -> +0.0;
                                    -0.0 -> -0.0;
                                    Gleam@denominator@4 -> L@11 / Gleam@denominator@4
                                end},
                            {ok, _pipe@11};

                        {{float, L@12}, mod, {float, R@12}} ->
                            _pipe@12 = gleam@float:modulo(L@12, R@12),
                            _pipe@13 = gleam@result:map(
                                _pipe@12,
                                fun(Field@0) -> {float, Field@0} end
                            ),
                            gleam@result:map_error(
                                _pipe@13,
                                fun(_) -> arithmetic_error end
                            );

                        {{float, L@13}, mul, {float, R@13}} ->
                            _pipe@14 = {float, L@13 * R@13},
                            {ok, _pipe@14};

                        {{float, L@14}, sub, {float, R@14}} ->
                            _pipe@15 = {float, L@14 - R@14},
                            {ok, _pipe@15};

                        {{int, L@15}, add, {float, R@15}} ->
                            _pipe@16 = {float, erlang:float(L@15) + R@15},
                            {ok, _pipe@16};

                        {{u_int, L@15}, add, {float, R@15}} ->
                            _pipe@16 = {float, erlang:float(L@15) + R@15},
                            {ok, _pipe@16};

                        {{float, L@16}, add, {int, R@16}} ->
                            _pipe@17 = {float, L@16 + erlang:float(R@16)},
                            {ok, _pipe@17};

                        {{float, L@16}, add, {u_int, R@16}} ->
                            _pipe@17 = {float, L@16 + erlang:float(R@16)},
                            {ok, _pipe@17};

                        {{int, L@17}, sub, {float, R@17}} ->
                            _pipe@18 = {float, erlang:float(L@17) - R@17},
                            {ok, _pipe@18};

                        {{u_int, L@17}, sub, {float, R@17}} ->
                            _pipe@18 = {float, erlang:float(L@17) - R@17},
                            {ok, _pipe@18};

                        {{float, L@18}, sub, {int, R@18}} ->
                            _pipe@19 = {float, L@18 - erlang:float(R@18)},
                            {ok, _pipe@19};

                        {{float, L@18}, sub, {u_int, R@18}} ->
                            _pipe@19 = {float, L@18 - erlang:float(R@18)},
                            {ok, _pipe@19};

                        {{int, L@19}, mul, {float, R@19}} ->
                            _pipe@20 = {float, erlang:float(L@19) * R@19},
                            {ok, _pipe@20};

                        {{u_int, L@19}, mul, {float, R@19}} ->
                            _pipe@20 = {float, erlang:float(L@19) * R@19},
                            {ok, _pipe@20};

                        {{float, L@20}, mul, {int, R@20}} ->
                            _pipe@21 = {float, L@20 * erlang:float(R@20)},
                            {ok, _pipe@21};

                        {{float, L@20}, mul, {u_int, R@20}} ->
                            _pipe@21 = {float, L@20 * erlang:float(R@20)},
                            {ok, _pipe@21};

                        {{int, L@21}, 'div', {float, R@21}} ->
                            _pipe@22 = {float, case R@21 of
                                    +0.0 -> +0.0;
                                    -0.0 -> -0.0;
                                    Gleam@denominator@5 -> erlang:float(L@21) / Gleam@denominator@5
                                end},
                            {ok, _pipe@22};

                        {{u_int, L@21}, 'div', {float, R@21}} ->
                            _pipe@22 = {float, case R@21 of
                                    +0.0 -> +0.0;
                                    -0.0 -> -0.0;
                                    Gleam@denominator@5 -> erlang:float(L@21) / Gleam@denominator@5
                                end},
                            {ok, _pipe@22};

                        {{float, L@22}, 'div', {int, R@22}} ->
                            _pipe@23 = {float, case erlang:float(R@22) of
                                    +0.0 -> +0.0;
                                    -0.0 -> -0.0;
                                    Gleam@denominator@6 -> L@22 / Gleam@denominator@6
                                end},
                            {ok, _pipe@23};

                        {{float, L@22}, 'div', {u_int, R@22}} ->
                            _pipe@23 = {float, case erlang:float(R@22) of
                                    +0.0 -> +0.0;
                                    -0.0 -> -0.0;
                                    Gleam@denominator@6 -> L@22 / Gleam@denominator@6
                                end},
                            {ok, _pipe@23};

                        {{int, L@23}, mod, {float, R@23}} ->
                            _pipe@24 = gleam@float:modulo(
                                erlang:float(L@23),
                                R@23
                            ),
                            _pipe@25 = gleam@result:map(
                                _pipe@24,
                                fun(Field@0) -> {float, Field@0} end
                            ),
                            gleam@result:map_error(
                                _pipe@25,
                                fun(_) -> arithmetic_error end
                            );

                        {{u_int, L@23}, mod, {float, R@23}} ->
                            _pipe@24 = gleam@float:modulo(
                                erlang:float(L@23),
                                R@23
                            ),
                            _pipe@25 = gleam@result:map(
                                _pipe@24,
                                fun(Field@0) -> {float, Field@0} end
                            ),
                            gleam@result:map_error(
                                _pipe@25,
                                fun(_) -> arithmetic_error end
                            );

                        {{float, L@24}, mod, {int, R@24}} ->
                            _pipe@26 = gleam@float:modulo(
                                L@24,
                                erlang:float(R@24)
                            ),
                            _pipe@27 = gleam@result:map(
                                _pipe@26,
                                fun(Field@0) -> {float, Field@0} end
                            ),
                            gleam@result:map_error(
                                _pipe@27,
                                fun(_) -> arithmetic_error end
                            );

                        {{float, L@24}, mod, {u_int, R@24}} ->
                            _pipe@26 = gleam@float:modulo(
                                L@24,
                                erlang:float(R@24)
                            ),
                            _pipe@27 = gleam@result:map(
                                _pipe@26,
                                fun(Field@0) -> {float, Field@0} end
                            ),
                            gleam@result:map_error(
                                _pipe@27,
                                fun(_) -> arithmetic_error end
                            );

                        {{string, L@25}, add, {string, R@25}} ->
                            _pipe@28 = {string, <<L@25/binary, R@25/binary>>},
                            {ok, _pipe@28};

                        {{list, L@26}, add, {list, R@26}} ->
                            _pipe@29 = {list, gleam@list:flatten([L@26, R@26])},
                            {ok, _pipe@29};

                        {L@27, add, R@27} ->
                            _pipe@30 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@27),
                                <<"+"/utf8>>,
                                cel@interpreter@value:to_type(R@27)},
                            {error, _pipe@30};

                        {L@28, 'div', R@28} ->
                            _pipe@31 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@28),
                                <<"/"/utf8>>,
                                cel@interpreter@value:to_type(R@28)},
                            {error, _pipe@31};

                        {L@29, mod, R@29} ->
                            _pipe@32 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@29),
                                <<"%"/utf8>>,
                                cel@interpreter@value:to_type(R@29)},
                            {error, _pipe@32};

                        {L@30, mul, R@30} ->
                            _pipe@33 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@30),
                                <<"*"/utf8>>,
                                cel@interpreter@value:to_type(R@30)},
                            {error, _pipe@33};

                        {L@31, sub, R@31} ->
                            _pipe@34 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@31),
                                <<"-"/utf8>>,
                                cel@interpreter@value:to_type(R@31)},
                            {error, _pipe@34}
                    end end
            )
        end
    ).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 15).
-spec evaluate_expr(cel@parser:expression(), cel@interpreter@context:context()) -> {ok,
        cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_expr(Expr, Ctx) ->
    case Expr of
        {binary_operation, Lhs, Op, Rhs} ->
            evaluate_binop(Lhs, Op, Rhs, Ctx);

        {ident, Ident} ->
            _pipe = cel@interpreter@context:resolve_variable(Ctx, Ident),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {context_error, Field@0} end
            );

        {ternary, Cond, Then, Otherwise} ->
            evaluate_ternary(Cond, Then, Otherwise, Ctx);

        {unary, Op@1, Unary_expr} ->
            evaluate_unary(Op@1, Unary_expr, Ctx);

        {member, Ident@1, Member} ->
            gleam@result:'try'(
                evaluate_expr(Ident@1, Ctx),
                fun(Parent) -> resolve_member(Ctx, Parent, Member) end
            );

        {list, Exprs} ->
            _pipe@1 = gleam@list:try_map(
                Exprs,
                fun(L) -> evaluate_expr(L, Ctx) end
            ),
            gleam@result:map(_pipe@1, fun(Field@0) -> {list, Field@0} end);

        {map, Fields} ->
            _pipe@3 = gleam@list:try_map(
                Fields,
                fun(Field) ->
                    {Field_key, Field_value} = Field,
                    gleam@result:'try'(
                        evaluate_expr(Field_key, Ctx),
                        fun(Field_key@1) ->
                            gleam@result:'try'(
                                begin
                                    _pipe@2 = cel@interpreter@value:key_from_value(
                                        Field_key@1
                                    ),
                                    gleam@result:map_error(
                                        _pipe@2,
                                        fun(_) ->
                                            {invalid_value_as_key, Field_key@1}
                                        end
                                    )
                                end,
                                fun(Key) ->
                                    gleam@result:'try'(
                                        evaluate_expr(Field_value, Ctx),
                                        fun(Val) -> {ok, {Key, Val}} end
                                    )
                                end
                            )
                        end
                    )
                end
            ),
            _pipe@4 = gleam@result:map(_pipe@3, fun maps:from_list/1),
            gleam@result:map(_pipe@4, fun(Field@0) -> {map, Field@0} end);

        {function_call, Ident@2, This, Args} ->
            gleam@result:'try'(case This of
                    {some, Expr@1} ->
                        _pipe@5 = evaluate_expr(Expr@1, Ctx),
                        gleam@result:map(
                            _pipe@5,
                            fun(Field@0) -> {some, Field@0} end
                        );

                    none ->
                        {ok, none}
                end, fun(Target) ->
                    Ftx = {function_context, Ident@2, Target, Ctx, Args},
                    gleam@result:'try'(
                        begin
                            _pipe@6 = cel@interpreter@context:resolve_function(
                                Ctx,
                                Ident@2
                            ),
                            gleam@result:map_error(
                                _pipe@6,
                                fun(Field@0) -> {context_error, Field@0} end
                            )
                        end,
                        fun(Function) -> (erlang:element(2, Function))(Ftx) end
                    )
                end);

        {atom, {int, N}} ->
            _pipe@7 = {int, N},
            {ok, _pipe@7};

        {atom, {u_int, N@1}} ->
            _pipe@8 = {u_int, N@1},
            {ok, _pipe@8};

        {atom, {bool, B}} ->
            _pipe@9 = {bool, B},
            {ok, _pipe@9};

        {atom, {float, F}} ->
            _pipe@10 = {float, F},
            {ok, _pipe@10};

        {atom, null} ->
            _pipe@11 = null,
            {ok, _pipe@11};

        {atom, {string, S}} ->
            _pipe@12 = {string, S},
            {ok, _pipe@12};

        {atom, {bytes, S@1}} ->
            _pipe@13 = {bytes, S@1},
            {ok, _pipe@13}
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 81).
-spec evaluate_binop(
    cel@parser:expression(),
    cel@parser:binary_op(),
    cel@parser:expression(),
    cel@interpreter@context:context()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_binop(Lhs, Op, Rhs, Ctx) ->
    case Op of
        {arithmetic, Op@1} ->
            evaluate_arithmetic(Lhs, Op@1, Rhs, Ctx);

        {relation, Op@2} ->
            evaluate_relation(Lhs, Op@2, Rhs, Ctx);

        {logical, Op@3} ->
            evaluate_logical(Lhs, Op@3, Rhs, Ctx)
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 170).
-spec evaluate_logical(
    cel@parser:expression(),
    cel@parser:logical(),
    cel@parser:expression(),
    cel@interpreter@context:context()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_logical(Lhs, Op, Rhs, Ctx) ->
    gleam@result:'try'(
        evaluate_expr(Lhs, Ctx),
        fun(Lhs_value) ->
            gleam@result:'try'(
                evaluate_expr(Rhs, Ctx),
                fun(Rhs_value) -> case {Lhs_value, Op, Rhs_value} of
                        {{bool, L}, 'and', {bool, R}} ->
                            _pipe = {bool, L andalso R},
                            {ok, _pipe};

                        {{bool, L@1}, 'or', {bool, R@1}} ->
                            _pipe@1 = {bool, L@1 orelse R@1},
                            {ok, _pipe@1};

                        {L@2, 'and', R@2} ->
                            _pipe@2 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@2),
                                <<"&&"/utf8>>,
                                cel@interpreter@value:to_type(R@2)},
                            {error, _pipe@2};

                        {L@3, 'or', R@3} ->
                            _pipe@3 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@3),
                                <<"||"/utf8>>,
                                cel@interpreter@value:to_type(R@3)},
                            {error, _pipe@3}
                    end end
            )
        end
    ).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 190).
-spec evaluate_relation(
    cel@parser:expression(),
    cel@parser:relation(),
    cel@parser:expression(),
    cel@interpreter@context:context()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_relation(Lhs, Op, Rhs, Ctx) ->
    gleam@result:'try'(
        evaluate_expr(Lhs, Ctx),
        fun(Lhs_value) ->
            gleam@result:'try'(
                evaluate_expr(Rhs, Ctx),
                fun(Rhs_value) -> case {Lhs_value, Op, Rhs_value} of
                        {{int, L}, equals, {float, R}} ->
                            _pipe = {bool, erlang:float(L) =:= R},
                            {ok, _pipe};

                        {{u_int, L@1}, equals, {float, R@1}} ->
                            _pipe@1 = {bool, erlang:float(L@1) =:= R@1},
                            {ok, _pipe@1};

                        {{float, L@2}, equals, {int, R@2}} ->
                            _pipe@2 = {bool, L@2 =:= erlang:float(R@2)},
                            {ok, _pipe@2};

                        {{float, L@3}, equals, {u_int, R@3}} ->
                            _pipe@3 = {bool, L@3 =:= erlang:float(R@3)},
                            {ok, _pipe@3};

                        {{u_int, L@4}, equals, {int, R@4}} ->
                            _pipe@4 = {bool, L@4 =:= R@4},
                            {ok, _pipe@4};

                        {{int, L@5}, equals, {u_int, R@5}} ->
                            _pipe@5 = {bool, L@5 =:= R@5},
                            {ok, _pipe@5};

                        {L@6, equals, R@6} ->
                            _pipe@6 = {bool, L@6 =:= R@6},
                            {ok, _pipe@6};

                        {L@7, not_equals, R@7} ->
                            _pipe@7 = {bool, L@7 /= R@7},
                            {ok, _pipe@7};

                        {{int, L@8}, less_than_eq, {int, R@8}} ->
                            _pipe@8 = {bool, L@8 =< R@8},
                            {ok, _pipe@8};

                        {{int, L@9}, less_than, {int, R@9}} ->
                            _pipe@9 = {bool, L@9 < R@9},
                            {ok, _pipe@9};

                        {{int, L@10}, greater_than_eq, {int, R@10}} ->
                            _pipe@10 = {bool, L@10 >= R@10},
                            {ok, _pipe@10};

                        {{int, L@11}, greater_than, {int, R@11}} ->
                            _pipe@11 = {bool, L@11 > R@11},
                            {ok, _pipe@11};

                        {{u_int, L@12}, less_than_eq, {u_int, R@12}} ->
                            _pipe@12 = {bool, L@12 =< R@12},
                            {ok, _pipe@12};

                        {{u_int, L@13}, less_than, {u_int, R@13}} ->
                            _pipe@13 = {bool, L@13 < R@13},
                            {ok, _pipe@13};

                        {{u_int, L@14}, greater_than_eq, {u_int, R@14}} ->
                            _pipe@14 = {bool, L@14 >= R@14},
                            {ok, _pipe@14};

                        {{u_int, L@15}, greater_than, {u_int, R@15}} ->
                            _pipe@15 = {bool, L@15 > R@15},
                            {ok, _pipe@15};

                        {{int, L@16}, less_than_eq, {u_int, R@16}} ->
                            _pipe@16 = {bool, L@16 =< R@16},
                            {ok, _pipe@16};

                        {{int, L@17}, less_than, {u_int, R@17}} ->
                            _pipe@17 = {bool, L@17 < R@17},
                            {ok, _pipe@17};

                        {{int, L@18}, greater_than_eq, {u_int, R@18}} ->
                            _pipe@18 = {bool, L@18 >= R@18},
                            {ok, _pipe@18};

                        {{int, L@19}, greater_than, {u_int, R@19}} ->
                            _pipe@19 = {bool, L@19 > R@19},
                            {ok, _pipe@19};

                        {{u_int, L@20}, less_than_eq, {int, R@20}} ->
                            _pipe@20 = {bool, L@20 =< R@20},
                            {ok, _pipe@20};

                        {{u_int, L@21}, less_than, {int, R@21}} ->
                            _pipe@21 = {bool, L@21 < R@21},
                            {ok, _pipe@21};

                        {{u_int, L@22}, greater_than_eq, {int, R@22}} ->
                            _pipe@22 = {bool, L@22 >= R@22},
                            {ok, _pipe@22};

                        {{u_int, L@23}, greater_than, {int, R@23}} ->
                            _pipe@23 = {bool, L@23 > R@23},
                            {ok, _pipe@23};

                        {{int, L@24}, less_than_eq, {float, R@24}} ->
                            _pipe@24 = {bool, erlang:float(L@24) =< R@24},
                            {ok, _pipe@24};

                        {{int, L@25}, less_than, {float, R@25}} ->
                            _pipe@25 = {bool, erlang:float(L@25) < R@25},
                            {ok, _pipe@25};

                        {{int, L@26}, greater_than_eq, {float, R@26}} ->
                            _pipe@26 = {bool, erlang:float(L@26) >= R@26},
                            {ok, _pipe@26};

                        {{int, L@27}, greater_than, {float, R@27}} ->
                            _pipe@27 = {bool, erlang:float(L@27) > R@27},
                            {ok, _pipe@27};

                        {{u_int, L@28}, less_than_eq, {float, R@28}} ->
                            _pipe@28 = {bool, erlang:float(L@28) =< R@28},
                            {ok, _pipe@28};

                        {{u_int, L@29}, less_than, {float, R@29}} ->
                            _pipe@29 = {bool, erlang:float(L@29) < R@29},
                            {ok, _pipe@29};

                        {{u_int, L@30}, greater_than_eq, {float, R@30}} ->
                            _pipe@30 = {bool, erlang:float(L@30) >= R@30},
                            {ok, _pipe@30};

                        {{u_int, L@31}, greater_than, {float, R@31}} ->
                            _pipe@31 = {bool, erlang:float(L@31) > R@31},
                            {ok, _pipe@31};

                        {{float, L@32}, less_than_eq, {int, R@32}} ->
                            _pipe@32 = {bool, L@32 =< erlang:float(R@32)},
                            {ok, _pipe@32};

                        {{float, L@33}, less_than, {int, R@33}} ->
                            _pipe@33 = {bool, L@33 < erlang:float(R@33)},
                            {ok, _pipe@33};

                        {{float, L@34}, greater_than_eq, {int, R@34}} ->
                            _pipe@34 = {bool, L@34 >= erlang:float(R@34)},
                            {ok, _pipe@34};

                        {{float, L@35}, greater_than, {int, R@35}} ->
                            _pipe@35 = {bool, L@35 > erlang:float(R@35)},
                            {ok, _pipe@35};

                        {{float, L@36}, less_than_eq, {u_int, R@36}} ->
                            _pipe@36 = {bool, L@36 =< erlang:float(R@36)},
                            {ok, _pipe@36};

                        {{float, L@37}, less_than, {u_int, R@37}} ->
                            _pipe@37 = {bool, L@37 < erlang:float(R@37)},
                            {ok, _pipe@37};

                        {{float, L@38}, greater_than_eq, {u_int, R@38}} ->
                            _pipe@38 = {bool, L@38 >= erlang:float(R@38)},
                            {ok, _pipe@38};

                        {{float, L@39}, greater_than, {u_int, R@39}} ->
                            _pipe@39 = {bool, L@39 > erlang:float(R@39)},
                            {ok, _pipe@39};

                        {{string, L@40}, in, {string, R@40}} ->
                            _pipe@40 = {bool,
                                gleam_stdlib:contains_string(R@40, L@40)},
                            {ok, _pipe@40};

                        {Item, in, {list, Container}} ->
                            _pipe@44 = {bool,
                                begin
                                    _pipe@41 = Container,
                                    _pipe@42 = gleam@list:find(
                                        _pipe@41,
                                        fun(X) -> X =:= Item end
                                    ),
                                    _pipe@43 = gleam@result:map(
                                        _pipe@42,
                                        fun(_) -> true end
                                    ),
                                    gleam@result:unwrap(_pipe@43, false)
                                end},
                            {ok, _pipe@44};

                        {Item@1, in, {map, Container@1}} ->
                            Item_as_key = begin
                                _pipe@45 = cel@interpreter@value:key_from_value(
                                    Item@1
                                ),
                                gleam@result:map_error(
                                    _pipe@45,
                                    fun(_) -> {invalid_value_as_key, Item@1} end
                                )
                            end,
                            gleam@result:map(
                                Item_as_key,
                                fun(Item_key) ->
                                    {bool,
                                        gleam@dict:has_key(
                                            Container@1,
                                            Item_key
                                        )}
                                end
                            );

                        {L@41, less_than_eq, R@41} ->
                            _pipe@46 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@41),
                                <<"<="/utf8>>,
                                cel@interpreter@value:to_type(R@41)},
                            {error, _pipe@46};

                        {L@42, less_than, R@42} ->
                            _pipe@47 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@42),
                                <<"<"/utf8>>,
                                cel@interpreter@value:to_type(R@42)},
                            {error, _pipe@47};

                        {L@43, greater_than_eq, R@43} ->
                            _pipe@48 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@43),
                                <<">="/utf8>>,
                                cel@interpreter@value:to_type(R@43)},
                            {error, _pipe@48};

                        {L@44, greater_than, R@44} ->
                            _pipe@49 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@44),
                                <<">"/utf8>>,
                                cel@interpreter@value:to_type(R@44)},
                            {error, _pipe@49};

                        {L@45, in, R@45} ->
                            _pipe@50 = {unsupported_binop,
                                cel@interpreter@value:to_type(L@45),
                                <<"in"/utf8>>,
                                cel@interpreter@value:to_type(R@45)},
                            {error, _pipe@50}
                    end end
            )
        end
    ).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 286).
-spec evaluate_ternary(
    cel@parser:expression(),
    cel@parser:expression(),
    cel@parser:expression(),
    cel@interpreter@context:context()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_ternary(Cond, Then, Otherwise, Ctx) ->
    gleam@result:'try'(
        evaluate_expr(Cond, Ctx),
        fun(Cond_val) -> case Cond_val of
                {bool, true} ->
                    evaluate_expr(Then, Ctx);

                {bool, false} ->
                    evaluate_expr(Otherwise, Ctx);

                _ ->
                    {error,
                        {unsupported_ternary_condition,
                            cel@interpreter@value:to_type(Cond_val)}}
            end end
    ).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 301).
-spec evaluate_unary(
    cel@parser:unary_op(),
    cel@parser:expression(),
    cel@interpreter@context:context()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
evaluate_unary(Op, Expr, Ctx) ->
    gleam@result:'try'(evaluate_expr(Expr, Ctx), fun(Val) -> case {Op, Val} of
                {'not', {bool, B}} ->
                    _pipe = {bool, not B},
                    {ok, _pipe};

                {unary_sub, {int, N}} ->
                    _pipe@1 = {int, - N},
                    {ok, _pipe@1};

                {unary_sub, {u_int, N@1}} ->
                    _pipe@2 = {u_int, - N@1},
                    {ok, _pipe@2};

                {unary_sub, {float, N@2}} ->
                    _pipe@3 = {float, +0.0 - N@2},
                    {ok, _pipe@3};

                {unary_sub, _} ->
                    _pipe@4 = {unsupported_unary,
                        <<"-"/utf8>>,
                        cel@interpreter@value:to_type(Val)},
                    {error, _pipe@4};

                {'not', _} ->
                    _pipe@5 = {unsupported_unary,
                        <<"!"/utf8>>,
                        cel@interpreter@value:to_type(Val)},
                    {error, _pipe@5}
            end end).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/evaluate.gleam", 332).
-spec resolve_member(
    cel@interpreter@context:context(),
    cel@interpreter@value:value(),
    cel@parser:member()
) -> {ok, cel@interpreter@value:value()} |
    {error, cel@interpreter@error:execution_error()}.
resolve_member(Ctx, Parent, Member) ->
    case Member of
        {attribute, Attr} ->
            _pipe@1 = case Parent of
                {map, M} ->
                    _pipe = gleam_stdlib:map_get(M, {key_string, Attr}),
                    gleam@result:replace_error(_pipe, {no_such_key, Member});

                Other ->
                    {error,
                        {invalid_member_parent,
                            cel@interpreter@value:to_type(Other),
                            Member}}
            end,
            gleam@result:map_error(
                _pipe@1,
                fun(Field@0) -> {context_error, Field@0} end
            );

        {index, I} ->
            gleam@result:'try'(
                evaluate_expr(I, Ctx),
                fun(Index) -> case {Parent, Index} of
                        {{list, Container}, {int, Idx}} ->
                            find_in_list(Container, Idx, 0);

                        {{list, Container}, {u_int, Idx}} ->
                            find_in_list(Container, Idx, 0);

                        {{map, M@1}, {string, Attr@1}} ->
                            _pipe@2 = gleam_stdlib:map_get(
                                M@1,
                                {key_string, Attr@1}
                            ),
                            _pipe@3 = gleam@result:replace_error(
                                _pipe@2,
                                {unknown_identifier, Attr@1}
                            ),
                            gleam@result:map_error(
                                _pipe@3,
                                fun(Field@0) -> {context_error, Field@0} end
                            );

                        {{map, M@2}, {int, Attr@2}} ->
                            _pipe@4 = gleam_stdlib:map_get(
                                M@2,
                                {key_int, Attr@2}
                            ),
                            _pipe@5 = gleam@result:replace_error(
                                _pipe@4,
                                {no_such_key, Member}
                            ),
                            gleam@result:map_error(
                                _pipe@5,
                                fun(Field@0) -> {context_error, Field@0} end
                            );

                        {{map, M@3}, {u_int, Attr@3}} ->
                            _pipe@7 = begin
                                _pipe@6 = gleam_stdlib:map_get(
                                    M@3,
                                    {key_u_int, Attr@3}
                                ),
                                gleam@result:replace_error(
                                    _pipe@6,
                                    {no_such_key, Member}
                                )
                            end,
                            gleam@result:map_error(
                                _pipe@7,
                                fun(Field@0) -> {context_error, Field@0} end
                            );

                        {Other@1, _} ->
                            _pipe@8 = {error,
                                {invalid_member_parent,
                                    cel@interpreter@value:to_type(Other@1),
                                    Member}},
                            gleam@result:map_error(
                                _pipe@8,
                                fun(Field@0) -> {context_error, Field@0} end
                            )
                    end end
            )
    end.