neoaggelos
commented
2 years ago Erlang maps AST
This comment intends to serve as a reference of how map expressions and patterns match to c_map and c_map_pair nodes in the AST tree.
Expressions (for eval_expr)
% erlang map expression
- spec myfunc(float()) -> map().
myfunc(A) ->
#{A => value}.The #{A => value} expression matches the following AST:
{c_map,
[_Annotations], % annotations
{c_literal, [_As], #{}}, % operator that introduces the map, always `#{}`
[{c_map_pair, % list of key-value pairs
[_Annotations],
{c_literal, [], assoc}, % '=>' maps to 'assoc'
{c_var, ....}, % key expression
{c_literal, [], value}}], % value expression
false, % whether this map is a pattern (false for expressions)
}Suggested implementation for eval_expr
- For map pairs (
c_map_pair), evaluate symbolic and concrete values for the key and the value of the map pair separately (by recursively callingeval_expron each, then returnmk_result({symbolic.key, symbolic.value}, {concrete.key, concrete.value}) - For maps (
c_map), iterate over all map pairs, then returnmk_result(maps:from_list(symbolic_keyvalue_pairs), maps:from_list(concrete_keyvalue_pairs) - Raise exception when any of the preconditions in the notes above do not hold (e.g. operator is not
#{}, the map pair operator is notassocetc), mainly to protect our future selves.
Pattern Matching (for pattern_match)
-spec myfunc(map()) -> float().
myfunc(A) ->
case A of
#{ mkey := X } = A -> X;
_ -> 0
end.The #{ mkey := X } = A pattern matches the following AST (when A is bound):
{c_clause,
[Annotations],
[{c_map,
[Annotations],
{c_literal, [Annotations], #{}}, % the operator that introduces the map, always `#{}`
[{c_map_pair, % list of key-value pairs
[Annotations],
{c_literal, [], exact}, % ':=' maps to 'exact'
{c_literal, [Annotations], mkey}, % key; must be literal or a bound variable
{c_var, ...}}], % value; can be literal or variable
true} % this map is a pattern
],
....
}Notes:
#{key1 := Y, key2 => value}syntax is not allowed by Erlang,#{key1 := Y, key2 := value}should be used instead -> this can be a rule to disallowassocin map pairs when map is a pattern (and vice versa).#{Z := value} = #{key => value}cannot be used to bind Z.
Suggested implementation for pattern_match:
(Rough idea) The map keys in the pattern are always bound, so call match_pattern for each map_pair_value with the value in maps:get(Map, map_pair_key)
Summary
Add support for Erlang maps in cuter. Cuter already contains some of the required machinery needed for supporting maps, but it currently crashes when parsing code that uses maps.
TODO
This is a rough TODO of things that are required for maps support:
map()type in specs (in progress)c_mapandc_map_pairAST nodes in concolic execution, as well as pattern matching (ref https://github.com/erlang/otp/blob/master/lib/compiler/src/core_parse.hrl#L75-L84). This mainly revolves around extendingeval_expr/andpattern_match/. (in progress)maps:get,maps:put, ...).Notes
WIP
Some early work is in https://github.com/neoaggelos/cuter/tree/maps-support