cel

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

-export([key_from_value/1, from_atom/1, decode/1]).
-export_type([key/0, value/0]).

-type key() :: {key_int, integer()} |
    {key_u_int, integer()} |
    {key_bool, boolean()} |
    {key_string, binary()}.

-type value() :: {list, list(value())} |
    {map, gleam@dict:dict(key(), value())} |
    {function, binary(), list(value())} |
    {int, integer()} |
    {u_int, integer()} |
    {float, float()} |
    {string, binary()} |
    {bytes, bitstring()} |
    {bool, boolean()} |
    null.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/value.gleam", 16).
-spec key_from_value(value()) -> {ok, key()} | {error, nil}.
key_from_value(Value) ->
    case Value of
        {bool, K} ->
            {ok, {key_bool, K}};

        {int, K@1} ->
            {ok, {key_int, K@1}};

        {u_int, K@2} ->
            {ok, {key_u_int, K@2}};

        {string, K@3} ->
            {ok, {key_string, K@3}};

        _ ->
            {error, nil}
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/value.gleam", 26).
-spec from_atom(cel@parser:atom_()) -> value().
from_atom(Atom) ->
    case Atom of
        {int, V} ->
            {int, V};

        {u_int, V@1} ->
            {u_int, V@1};

        {float, V@2} ->
            {float, V@2};

        {bool, V@3} ->
            {bool, V@3};

        null ->
            null;

        {string, V@4} ->
            {string, V@4};

        {bytes, V@5} ->
            {bytes, V@5}
    end.

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/value.gleam", 58).
-spec value_decoder() -> decode@zero:decoder(value()).
value_decoder() ->
    decode@zero:recursive(
        fun() ->
            decode@zero:one_of(
                begin
                    _pipe = {decoder, fun decode@zero:decode_int/1},
                    decode@zero:map(_pipe, fun(Field@0) -> {int, Field@0} end)
                end,
                [begin
                        _pipe@1 = {decoder, fun decode@zero:decode_float/1},
                        decode@zero:map(
                            _pipe@1,
                            fun(Field@0) -> {float, Field@0} end
                        )
                    end,
                    begin
                        _pipe@2 = {decoder, fun decode@zero:decode_bool/1},
                        decode@zero:map(
                            _pipe@2,
                            fun(Field@0) -> {bool, Field@0} end
                        )
                    end,
                    begin
                        _pipe@3 = {decoder, fun decode@zero:decode_string/1},
                        decode@zero:map(
                            _pipe@3,
                            fun(Field@0) -> {string, Field@0} end
                        )
                    end,
                    begin
                        _pipe@4 = {decoder, fun decode@zero:decode_bit_array/1},
                        decode@zero:map(
                            _pipe@4,
                            fun(Field@0) -> {bytes, Field@0} end
                        )
                    end,
                    begin
                        _pipe@5 = decode@zero:list(value_decoder()),
                        decode@zero:map(
                            _pipe@5,
                            fun(Field@0) -> {list, Field@0} end
                        )
                    end,
                    begin
                        _pipe@6 = decode@zero:dict(
                            key_decoder(),
                            value_decoder()
                        ),
                        decode@zero:map(
                            _pipe@6,
                            fun(Field@0) -> {map, Field@0} end
                        )
                    end,
                    begin
                        _pipe@7 = decode@zero:optional(value_decoder()),
                        decode@zero:map(
                            _pipe@7,
                            fun(Opt) -> gleam@option:unwrap(Opt, null) end
                        )
                    end]
            )
        end
    ).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/value.gleam", 73).
-spec decode(gleam@dynamic:dynamic_()) -> {ok, value()} |
    {error, list(gleam@dynamic:decode_error())}.
decode(Input) ->
    decode@zero:run(Input, value_decoder()).

-file("/Users/jonas/src/personal/cel-gleam/src/cel/interpreter/value.gleam", 51).
-spec key_decoder() -> decode@zero:decoder(key()).
key_decoder() ->
    decode@zero:one_of(
        begin
            _pipe = {decoder, fun decode@zero:decode_int/1},
            decode@zero:map(_pipe, fun(Field@0) -> {key_int, Field@0} end)
        end,
        [begin
                _pipe@1 = {decoder, fun decode@zero:decode_string/1},
                decode@zero:map(
                    _pipe@1,
                    fun(Field@0) -> {key_string, Field@0} end
                )
            end,
            begin
                _pipe@2 = {decoder, fun decode@zero:decode_bool/1},
                decode@zero:map(
                    _pipe@2,
                    fun(Field@0) -> {key_bool, Field@0} end
                )
            end]
    ).