touch_grass

-module(touch_grass@eyg_parse).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/touch_grass/eyg_parse.gleam").
-export([lift/0, lower/0, decode/1, encode/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Parse EYG source text into its Abstract Syntax Tree.\n"
    "\n"
    " The AST is the canonical flat representation\n"
).

-file("src/touch_grass/eyg_parse.gleam", 14).
-spec lift() -> eyg@analysis@type_@isomorphic:type(any()).
lift() ->
    string.

-file("src/touch_grass/eyg_parse.gleam", 18).
-spec lower() -> eyg@analysis@type_@isomorphic:type(any()).
lower() ->
    eyg@analysis@type_@isomorphic:result(
        eyg@analysis@type_@isomorphic:ast(),
        string
    ).

-file("src/touch_grass/eyg_parse.gleam", 22).
-spec decode(eyg@interpreter@value:value(QIE, QIF)) -> {ok, binary()} |
    {error, eyg@interpreter@break:reason(QIE, QIF)}.
decode(Lift) ->
    eyg@interpreter@cast:as_string(Lift).

-file("src/touch_grass/eyg_parse.gleam", 33).
-spec tagged(binary(), eyg@interpreter@value:value(QIG, QIH)) -> eyg@interpreter@value:value(QIG, QIH).
tagged(Tag, Attribute) ->
    {tagged, Tag, Attribute}.

-file("src/touch_grass/eyg_parse.gleam", 39).
?DOC(
    " Pre-order flatten a node onto `rest`. Children are appended after the node\n"
    " in left-to-right order.\n"
).
-spec flatten(
    {eyg@ir@tree:expression(QHQ), QHQ},
    list(eyg@interpreter@value:value(QHS, QHT))
) -> list(eyg@interpreter@value:value(QHS, QHT)).
flatten(Node, Rest) ->
    {Expression, _} = Node,
    case Expression of
        {variable, Label} ->
            [tagged(<<"Variable"/utf8>>, {string, Label}) | Rest];

        {lambda, Label@1, Body} ->
            [tagged(<<"Lambda"/utf8>>, {string, Label@1}) | flatten(Body, Rest)];

        {apply, Function, Argument} ->
            [tagged(<<"Apply"/utf8>>, eyg@interpreter@value:unit()) |
                flatten(Function, flatten(Argument, Rest))];

        {'let', Label@2, Value, Then} ->
            [tagged(<<"Let"/utf8>>, {string, Label@2}) |
                flatten(Value, flatten(Then, Rest))];

        {binary, Value@1} ->
            [tagged(<<"Binary"/utf8>>, {binary, Value@1}) | Rest];

        {integer, Value@2} ->
            [tagged(<<"Integer"/utf8>>, {integer, Value@2}) | Rest];

        {string, Value@3} ->
            [tagged(<<"String"/utf8>>, {string, Value@3}) | Rest];

        tail ->
            [tagged(<<"Tail"/utf8>>, eyg@interpreter@value:unit()) | Rest];

        cons ->
            [tagged(<<"Cons"/utf8>>, eyg@interpreter@value:unit()) | Rest];

        vacant ->
            [tagged(<<"Vacant"/utf8>>, eyg@interpreter@value:unit()) | Rest];

        empty ->
            [tagged(<<"Empty"/utf8>>, eyg@interpreter@value:unit()) | Rest];

        {extend, Label@3} ->
            [tagged(<<"Extend"/utf8>>, {string, Label@3}) | Rest];

        {select, Label@4} ->
            [tagged(<<"Select"/utf8>>, {string, Label@4}) | Rest];

        {overwrite, Label@5} ->
            [tagged(<<"Overwrite"/utf8>>, {string, Label@5}) | Rest];

        {tag, Label@6} ->
            [tagged(<<"Tag"/utf8>>, {string, Label@6}) | Rest];

        {'case', Label@7} ->
            [tagged(<<"Case"/utf8>>, {string, Label@7}) | Rest];

        no_cases ->
            [tagged(<<"NoCases"/utf8>>, eyg@interpreter@value:unit()) | Rest];

        {perform, Label@8} ->
            [tagged(<<"Perform"/utf8>>, {string, Label@8}) | Rest];

        {handle, Label@9} ->
            [tagged(<<"Handle"/utf8>>, {string, Label@9}) | Rest];

        {builtin, Identifier} ->
            [tagged(<<"Builtin"/utf8>>, {string, Identifier}) | Rest];

        {content_reference, Identifier@1} ->
            [tagged(
                    <<"ContentReference"/utf8>>,
                    {string, multiformats@cid@v1:to_string(Identifier@1)}
                ) |
                Rest];

        {release_reference, Package, Version, Identifier@2} ->
            [tagged(
                    <<"ReleaseReference"/utf8>>,
                    {record,
                        maps:from_list(
                            [{<<"package"/utf8>>, {string, Package}},
                                {<<"version"/utf8>>, {integer, Version}},
                                {<<"cid"/utf8>>,
                                    {string,
                                        multiformats@cid@v1:to_string(
                                            Identifier@2
                                        )}}]
                        )}
                ) |
                Rest];

        {relative_reference, Location} ->
            [tagged(<<"RelativeReference"/utf8>>, {string, Location}) | Rest]
    end.

-file("src/touch_grass/eyg_parse.gleam", 26).
-spec encode({ok, {eyg@ir@tree:expression(QHF), QHF}} | {error, binary()}) -> eyg@interpreter@value:value(any(), any()).
encode(Result) ->
    case Result of
        {ok, Node} ->
            eyg@interpreter@value:ok({linked_list, flatten(Node, [])});

        {error, Message} ->
            eyg@interpreter@value:error({string, Message})
    end.