Current section
Files
Jump to
Current section
Files
src/eyg@ir@tree.erl
-module(eyg@ir@tree).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/eyg/ir/tree.gleam").
-export([variable/1, lambda/2, apply/2, let_/3, binary/1, integer/1, string/1, tail/0, cons/0, vacant/0, empty/0, extend/1, select/1, overwrite/1, tag/1, case_/1, nocases/0, perform/1, handle/1, builtin/1, reference/1, release/3, do_list/2, list/1, func/2, call/2, block/2, do_record/2, record/1, unit/0, get/2, tagged/2, true/0, false/0, match/2, add/2, subtract/2, multiply/2, get_annotation/1, map_annotation/2, clear_annotation/1, list_builtins/1, list_references/1, list_named_references/1, map_release/2, free_variables/1, from_block/2, do_gather_snippets/4, gather_snippets/1]).
-export_type([expression/1]).
-type expression(EDO) :: {variable, binary()} |
{lambda, binary(), {expression(EDO), EDO}} |
{apply, {expression(EDO), EDO}, {expression(EDO), EDO}} |
{'let', binary(), {expression(EDO), EDO}, {expression(EDO), EDO}} |
{binary, bitstring()} |
{integer, integer()} |
{string, binary()} |
tail |
cons |
vacant |
empty |
{extend, binary()} |
{select, binary()} |
{overwrite, binary()} |
{tag, binary()} |
{'case', binary()} |
no_cases |
{perform, binary()} |
{handle, binary()} |
{builtin, binary()} |
{content_reference, multiformats@cid@v1:cid()} |
{release_reference, binary(), integer(), multiformats@cid@v1:cid()} |
{relative_reference, binary()}.
-file("src/eyg/ir/tree.gleam", 41).
-spec variable(binary()) -> {expression(any()), nil}.
variable(Label) ->
{{variable, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 45).
-spec lambda(binary(), {expression(EIY), EIY}) -> {expression(EIY), nil}.
lambda(Label, Body) ->
{{lambda, Label, Body}, nil}.
-file("src/eyg/ir/tree.gleam", 49).
-spec apply({expression(EIZ), EIZ}, {expression(EIZ), EIZ}) -> {expression(EIZ),
nil}.
apply(Func, Argument) ->
{{apply, Func, Argument}, nil}.
-file("src/eyg/ir/tree.gleam", 53).
-spec let_(binary(), {expression(EJA), EJA}, {expression(EJA), EJA}) -> {expression(EJA),
nil}.
let_(Label, Value, Then) ->
{{'let', Label, Value, Then}, nil}.
-file("src/eyg/ir/tree.gleam", 57).
-spec binary(bitstring()) -> {expression(any()), nil}.
binary(Value) ->
{{binary, Value}, nil}.
-file("src/eyg/ir/tree.gleam", 61).
-spec integer(integer()) -> {expression(any()), nil}.
integer(Value) ->
{{integer, Value}, nil}.
-file("src/eyg/ir/tree.gleam", 65).
-spec string(binary()) -> {expression(any()), nil}.
string(Value) ->
{{string, Value}, nil}.
-file("src/eyg/ir/tree.gleam", 69).
-spec tail() -> {expression(any()), nil}.
tail() ->
{tail, nil}.
-file("src/eyg/ir/tree.gleam", 73).
-spec cons() -> {expression(any()), nil}.
cons() ->
{cons, nil}.
-file("src/eyg/ir/tree.gleam", 77).
-spec vacant() -> {expression(any()), nil}.
vacant() ->
{vacant, nil}.
-file("src/eyg/ir/tree.gleam", 81).
-spec empty() -> {expression(any()), nil}.
empty() ->
{empty, nil}.
-file("src/eyg/ir/tree.gleam", 85).
-spec extend(binary()) -> {expression(any()), nil}.
extend(Label) ->
{{extend, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 89).
-spec select(binary()) -> {expression(any()), nil}.
select(Label) ->
{{select, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 93).
-spec overwrite(binary()) -> {expression(any()), nil}.
overwrite(Label) ->
{{overwrite, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 97).
-spec tag(binary()) -> {expression(any()), nil}.
tag(Label) ->
{{tag, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 101).
-spec case_(binary()) -> {expression(any()), nil}.
case_(Label) ->
{{'case', Label}, nil}.
-file("src/eyg/ir/tree.gleam", 105).
-spec nocases() -> {expression(any()), nil}.
nocases() ->
{no_cases, nil}.
-file("src/eyg/ir/tree.gleam", 109).
-spec perform(binary()) -> {expression(any()), nil}.
perform(Label) ->
{{perform, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 113).
-spec handle(binary()) -> {expression(any()), nil}.
handle(Label) ->
{{handle, Label}, nil}.
-file("src/eyg/ir/tree.gleam", 117).
-spec builtin(binary()) -> {expression(any()), nil}.
builtin(Identifier) ->
{{builtin, Identifier}, nil}.
-file("src/eyg/ir/tree.gleam", 121).
-spec reference(multiformats@cid@v1:cid()) -> {expression(any()), nil}.
reference(Identifier) ->
{{content_reference, Identifier}, nil}.
-file("src/eyg/ir/tree.gleam", 125).
-spec release(binary(), integer(), multiformats@cid@v1:cid()) -> {expression(any()),
nil}.
release(Package, Release, Identifier) ->
{{release_reference, Package, Release, Identifier}, nil}.
-file("src/eyg/ir/tree.gleam", 148).
-spec do_list(list({expression(nil), nil}), {expression(nil), nil}) -> {expression(nil),
nil}.
do_list(Reversed, Acc) ->
case Reversed of
[Item | Rest] ->
do_list(Rest, apply(apply(cons(), Item), Acc));
[] ->
Acc
end.
-file("src/eyg/ir/tree.gleam", 144).
-spec list(list({expression(nil), nil})) -> {expression(nil), nil}.
list(Items) ->
do_list(lists:reverse(Items), tail()).
-file("src/eyg/ir/tree.gleam", 129).
-spec func(list(binary()), {expression(nil), nil}) -> {expression(nil), nil}.
func(Params, Body) ->
gleam@list:fold_right(
Params,
Body,
fun(Acc, Param) -> lambda(Param, Acc) end
).
-file("src/eyg/ir/tree.gleam", 133).
-spec call({expression(nil), nil}, list({expression(nil), nil})) -> {expression(nil),
nil}.
call(F, Args) ->
gleam@list:fold(Args, F, fun(Acc, Arg) -> apply(Acc, Arg) end).
-file("src/eyg/ir/tree.gleam", 137).
-spec block(list({binary(), {expression(nil), nil}}), {expression(nil), nil}) -> {expression(nil),
nil}.
block(Assignments, Then) ->
gleam@list:fold_right(
Assignments,
Then,
fun(Acc, Assignment) ->
{Label, Value} = Assignment,
let_(Label, Value, Acc)
end
).
-file("src/eyg/ir/tree.gleam", 159).
-spec do_record(
list({binary(), {expression(nil), nil}}),
{expression(nil), nil}
) -> {expression(nil), nil}.
do_record(Reversed, Acc) ->
case Reversed of
[{Key, Value} | Rest] ->
do_record(Rest, apply(apply(extend(Key), Value), Acc));
[] ->
Acc
end.
-file("src/eyg/ir/tree.gleam", 155).
-spec record(list({binary(), {expression(nil), nil}})) -> {expression(nil), nil}.
record(Fields) ->
do_record(lists:reverse(Fields), empty()).
-file("src/eyg/ir/tree.gleam", 167).
-spec unit() -> {expression(any()), nil}.
unit() ->
empty().
-file("src/eyg/ir/tree.gleam", 171).
-spec get({expression(nil), nil}, binary()) -> {expression(nil), nil}.
get(Value, Label) ->
apply(select(Label), Value).
-file("src/eyg/ir/tree.gleam", 175).
-spec tagged(binary(), {expression(nil), nil}) -> {expression(nil), nil}.
tagged(Label, Inner) ->
apply(tag(Label), Inner).
-file("src/eyg/ir/tree.gleam", 179).
-spec true() -> {expression(nil), nil}.
true() ->
tagged(<<"True"/utf8>>, unit()).
-file("src/eyg/ir/tree.gleam", 183).
-spec false() -> {expression(nil), nil}.
false() ->
tagged(<<"False"/utf8>>, unit()).
-file("src/eyg/ir/tree.gleam", 187).
-spec match({expression(nil), nil}, list({binary(), {expression(nil), nil}})) -> {expression(nil),
nil}.
match(Value, Matches) ->
M = gleam@list:fold_right(
Matches,
nocases(),
fun(Acc, Match) ->
{Label, Branch} = Match,
call(case_(Label), [Branch, Acc])
end
),
apply(M, Value).
-file("src/eyg/ir/tree.gleam", 196).
-spec add({expression(nil), nil}, {expression(nil), nil}) -> {expression(nil),
nil}.
add(A, B) ->
apply(apply(builtin(<<"int_add"/utf8>>), A), B).
-file("src/eyg/ir/tree.gleam", 200).
-spec subtract({expression(nil), nil}, {expression(nil), nil}) -> {expression(nil),
nil}.
subtract(A, B) ->
apply(apply(builtin(<<"int_subtract"/utf8>>), A), B).
-file("src/eyg/ir/tree.gleam", 204).
-spec multiply({expression(nil), nil}, {expression(nil), nil}) -> {expression(nil),
nil}.
multiply(A, B) ->
apply(apply(builtin(<<"int_multiply"/utf8>>), A), B).
-file("src/eyg/ir/tree.gleam", 213).
-spec do_get_annotation({expression(ENA), ENA}, list(ENA)) -> list(ENA).
do_get_annotation(In, Acc) ->
{Exp, Meta} = In,
Acc@1 = [Meta | Acc],
case Exp of
{variable, _} ->
Acc@1;
{lambda, _, Body} ->
do_get_annotation(Body, Acc@1);
{apply, Func, Arg} ->
Acc@2 = do_get_annotation(Func, Acc@1),
Acc@3 = do_get_annotation(Arg, Acc@2),
Acc@3;
{'let', _, Value, Then} ->
Acc@4 = do_get_annotation(Value, Acc@1),
Acc@5 = do_get_annotation(Then, Acc@4),
Acc@5;
{binary, _} ->
Acc@1;
{integer, _} ->
Acc@1;
{string, _} ->
Acc@1;
tail ->
Acc@1;
cons ->
Acc@1;
vacant ->
Acc@1;
empty ->
Acc@1;
{extend, _} ->
Acc@1;
{select, _} ->
Acc@1;
{overwrite, _} ->
Acc@1;
{tag, _} ->
Acc@1;
{'case', _} ->
Acc@1;
no_cases ->
Acc@1;
{perform, _} ->
Acc@1;
{handle, _} ->
Acc@1;
{builtin, _} ->
Acc@1;
{content_reference, _} ->
Acc@1;
{release_reference, _, _, _} ->
Acc@1;
{relative_reference, _} ->
Acc@1
end.
-file("src/eyg/ir/tree.gleam", 208).
-spec get_annotation({expression(ENC), ENC}) -> list(ENC).
get_annotation(In) ->
Acc = do_get_annotation(In, []),
lists:reverse(Acc).
-file("src/eyg/ir/tree.gleam", 256).
-spec map_annotation({expression(EHE), EHE}, fun((EHE) -> EHG)) -> {expression(EHG),
EHG}.
map_annotation(In, F) ->
{Exp, Meta} = In,
case Exp of
{variable, Label} ->
{{variable, Label}, F(Meta)};
{lambda, Label@1, Body} ->
Body@1 = map_annotation(Body, F),
{{lambda, Label@1, Body@1}, F(Meta)};
{apply, Func, Arg} ->
Func@1 = map_annotation(Func, F),
Arg@1 = map_annotation(Arg, F),
{{apply, Func@1, Arg@1}, F(Meta)};
{'let', Label@2, Value, Then} ->
Value@1 = map_annotation(Value, F),
Then@1 = map_annotation(Then, F),
{{'let', Label@2, Value@1, Then@1}, F(Meta)};
{binary, Value@2} ->
{{binary, Value@2}, F(Meta)};
{integer, Value@3} ->
{{integer, Value@3}, F(Meta)};
{string, Value@4} ->
{{string, Value@4}, F(Meta)};
tail ->
{tail, F(Meta)};
cons ->
{cons, F(Meta)};
vacant ->
{vacant, F(Meta)};
empty ->
{empty, F(Meta)};
{extend, Label@3} ->
{{extend, Label@3}, F(Meta)};
{select, Label@4} ->
{{select, Label@4}, F(Meta)};
{overwrite, Label@5} ->
{{overwrite, Label@5}, F(Meta)};
{tag, Label@6} ->
{{tag, Label@6}, F(Meta)};
{'case', Label@7} ->
{{'case', Label@7}, F(Meta)};
no_cases ->
{no_cases, F(Meta)};
{perform, Label@8} ->
{{perform, Label@8}, F(Meta)};
{handle, Label@9} ->
{{handle, Label@9}, F(Meta)};
{builtin, Identifier} ->
{{builtin, Identifier}, F(Meta)};
{content_reference, Identifier@1} ->
{{content_reference, Identifier@1}, F(Meta)};
{release_reference, Package, Release, Identifier@2} ->
{{release_reference, Package, Release, Identifier@2}, F(Meta)};
{relative_reference, Location} ->
{{relative_reference, Location}, F(Meta)}
end.
-file("src/eyg/ir/tree.gleam", 307).
-spec clear_annotation({expression(EPB), EPB}) -> {expression(nil), nil}.
clear_annotation(Source) ->
map_annotation(Source, fun(_) -> nil end).
-file("src/eyg/ir/tree.gleam", 316).
-spec do_list_builtins({expression(EPL), EPL}, list(binary())) -> list(binary()).
do_list_builtins(Exp, Found) ->
{Exp@1, _} = Exp,
case Exp@1 of
{builtin, Identifier} ->
case gleam@list:contains(Found, Identifier) of
true ->
Found;
false ->
[Identifier | Found]
end;
{'let', _, Value, Then} ->
Found@1 = do_list_builtins(Then, Found),
do_list_builtins(Value, Found@1);
{lambda, _, Body} ->
do_list_builtins(Body, Found);
{apply, Func, Arg} ->
Found@2 = do_list_builtins(Arg, Found),
do_list_builtins(Func, Found@2);
_ ->
Found
end.
-file("src/eyg/ir/tree.gleam", 311).
-spec list_builtins({expression(EPM), EPM}) -> list(binary()).
list_builtins(Exp) ->
do_list_builtins(Exp, []).
-file("src/eyg/ir/tree.gleam", 342).
-spec do_list_references(
{expression(EQB), EQB},
list(multiformats@cid@v1:cid())
) -> list(multiformats@cid@v1:cid()).
do_list_references(Exp, Found) ->
{Exp@1, _} = Exp,
case Exp@1 of
{release_reference, _, _, Identifier} ->
case gleam@list:contains(Found, Identifier) of
true ->
Found;
false ->
[Identifier | Found]
end;
{content_reference, Identifier@1} ->
case gleam@list:contains(Found, Identifier@1) of
true ->
Found;
false ->
[Identifier@1 | Found]
end;
{'let', _, Value, Then} ->
Found@1 = do_list_references(Then, Found),
do_list_references(Value, Found@1);
{lambda, _, Body} ->
do_list_references(Body, Found);
{apply, Func, Arg} ->
Found@2 = do_list_references(Arg, Found),
do_list_references(Func, Found@2);
_ ->
Found
end.
-file("src/eyg/ir/tree.gleam", 337).
-spec list_references({expression(EQC), EQC}) -> list(multiformats@cid@v1:cid()).
list_references(Exp) ->
do_list_references(Exp, []).
-file("src/eyg/ir/tree.gleam", 373).
-spec do_list_named_references(
{expression(EQN), EQN},
list({binary(), integer(), multiformats@cid@v1:cid()})
) -> list({binary(), integer(), multiformats@cid@v1:cid()}).
do_list_named_references(Exp, Found) ->
{Exp@1, _} = Exp,
case Exp@1 of
{release_reference, Package, Release, Identifier} ->
case gleam@list:contains(Found, {Package, Release, Identifier}) of
true ->
Found;
false ->
[{Package, Release, Identifier} | Found]
end;
{'let', _, Value, Then} ->
Found@1 = do_list_named_references(Then, Found),
do_list_named_references(Value, Found@1);
{lambda, _, Body} ->
do_list_named_references(Body, Found);
{apply, Func, Arg} ->
Found@2 = do_list_named_references(Arg, Found),
do_list_named_references(Func, Found@2);
_ ->
Found
end.
-file("src/eyg/ir/tree.gleam", 368).
-spec list_named_references({expression(EQO), EQO}) -> list({binary(),
integer(),
multiformats@cid@v1:cid()}).
list_named_references(Exp) ->
do_list_named_references(Exp, []).
-file("src/eyg/ir/tree.gleam", 394).
-spec map_release(
{expression(ERG), ERG},
fun((binary(), integer(), multiformats@cid@v1:cid()) -> {binary(),
integer(),
multiformats@cid@v1:cid()})
) -> {expression(ERG), ERG}.
map_release(Exp, Mapper) ->
{Exp@1, Meta} = Exp,
case Exp@1 of
{release_reference, Package, Release, Identifier} ->
{Package@1, Release@1, Identifier@1} = Mapper(
Package,
Release,
Identifier
),
{{release_reference, Package@1, Release@1, Identifier@1}, Meta};
{'let', Label, Value, Then} ->
Value@1 = map_release(Value, Mapper),
Then@1 = map_release(Then, Mapper),
{{'let', Label, Value@1, Then@1}, Meta};
{lambda, Label@1, Body} ->
Body@1 = map_release(Body, Mapper),
{{lambda, Label@1, Body@1}, Meta};
{apply, Func, Arg} ->
Func@1 = map_release(Func, Mapper),
Arg@1 = map_release(Arg, Mapper),
{{apply, Func@1, Arg@1}, Meta};
_ ->
{Exp@1, Meta}
end.
-file("src/eyg/ir/tree.gleam", 423).
-spec do_free_variables({expression(ERY), ERY}, list(binary()), list(binary())) -> list(binary()).
do_free_variables(Exp, Found, Ignore) ->
{Exp@1, _} = Exp,
case Exp@1 of
{variable, Var} ->
case gleam@list:contains(Found, Var) orelse gleam@list:contains(
Ignore,
Var
) of
true ->
Found;
false ->
[Var | Found]
end;
{'let', Var@1, Value, Then} ->
Found@1 = do_free_variables(Then, Found, Ignore),
Ignore@1 = case gleam@list:contains(Ignore, Var@1) of
true ->
Ignore;
false ->
[Var@1 | Ignore]
end,
do_free_variables(Value, Found@1, Ignore@1);
{lambda, Var@2, Body} ->
Ignore@2 = case gleam@list:contains(Ignore, Var@2) of
true ->
Ignore;
false ->
[Var@2 | Ignore]
end,
do_free_variables(Body, Found, Ignore@2);
{apply, Func, Arg} ->
Found@2 = do_free_variables(Arg, Found, Ignore),
do_free_variables(Func, Found@2, Ignore);
_ ->
Found
end.
-file("src/eyg/ir/tree.gleam", 419).
-spec free_variables({expression(ERZ), ERZ}) -> list(binary()).
free_variables(Exp) ->
do_free_variables(Exp, [], []).
-file("src/eyg/ir/tree.gleam", 483).
-spec from_block(
list({binary(), {expression(ESI), ESI}, ESI}),
{expression(ESI), ESI}
) -> {expression(ESI), ESI}.
from_block(Assigns, Tail) ->
gleam@list:fold(
Assigns,
Tail,
fun(Acc, Assign) ->
{Label, Value, Meta} = Assign,
{{'let', Label, Value, Acc}, Meta}
end
).
-file("src/eyg/ir/tree.gleam", 490).
-spec do_gather_snippets(
{expression(ESY), ESY},
list(binary()),
list({binary(), {expression(ESY), ESY}, ESY}),
list({list(binary()), list({binary(), {expression(ESY), ESY}, ESY})})
) -> list({list(binary()), list({binary(), {expression(ESY), ESY}, ESY})}).
do_gather_snippets(Node, Comments, Assigns, Acc) ->
{Exp, Meta} = Node,
case {Exp, Assigns} of
{{'let', <<"_"/utf8>>, {{string, Comment}, _}, Then}, []} ->
do_gather_snippets(Then, [Comment | Comments], Assigns, Acc);
{{'let', <<"_"/utf8>>, {{string, New}, _}, Then@1}, _} ->
Comments@1 = lists:reverse(Comments),
Assigns@1 = lists:reverse(Assigns),
Acc@1 = [{Comments@1, Assigns@1} | Acc],
do_gather_snippets(Then@1, [New], [], Acc@1);
{{'let', Label, Value, Then@2}, _} ->
Assigns@2 = [{Label, Value, Meta} | Assigns],
do_gather_snippets(Then@2, Comments, Assigns@2, Acc);
{Tail, _} ->
gleam_stdlib:println(gleam@string:inspect(Tail)),
[{Comments, Assigns} | Acc]
end.
-file("src/eyg/ir/tree.gleam", 516).
-spec gather_snippets({expression(ETD), ETD}) -> list({list(binary()),
list({binary(), {expression(ETD), ETD}, ETD})}).
gather_snippets(Source) ->
do_gather_snippets(Source, [], [], []).