anchor.diff:  	{lc, _, _, _} -> list_comp;
   	{bc, _, _, _} -> binary_comp;		
   	{match, _, _, _} -> match_expr;
  +        {map, _, _, _} -> map_expr;
  +        {map, _, _} -> map_expr;
  +        {map_field_assoc, _, _, _} -> map_field_assoc;
  +        {map_field_exact, _, _, _} -> map_field_exact;
   	{op, _, _, _, _} -> infix_expr;
   	{op, _, _, _} -> prefix_expr;
  -	{map,_,_} -> map;
  -	{map_field_assoc,_,_,_} -> map_field_assoc;
  -	{map_field_exact,_,_,_} -> map_field_exact;
   	{record, _, _, _, _} -> record_expr;
   	{record, _, _, _} -> record_expr;
   	{record_field, _, _, _, _} -> record_access;
  
positive.code: make_tree(list_comp, [[T], B]) -> list_comp(T, B);
  make_tree(macro, [[N]]) -> macro(N);
  make_tree(macro, [[N], A]) -> macro(N, A);
  make_tree(match_expr, [[P], [E]]) -> match_expr(P, E);
  make_tree(named_fun_expr, [[N], C]) -> named_fun_expr(N, C);
  make_tree(module_qualifier, [[M], [N]]) -> module_qualifier(M, N);
  
negative.code: 
  
  %% =====================================================================
  %% @equiv map_expr(none, Fields)
  
  -spec map_expr([syntaxTree()]) -> syntaxTree().
  
  map_expr(Fields) ->
      map_expr(none, Fields).
  
  
  %% =====================================================================
  %% @doc Creates an abstract map expression. If `Fields' is
  %% `[F1, ..., Fn]', then if `Argument' is `none', the result represents
  %% "<code>#{<em>F1</em>, ..., <em>Fn</em>}</code>",
  %% otherwise it represents
  %% "<code><em>Argument</em>#{<em>F1</em>, ..., <em>Fn</em>}</code>".
  %%
  %% @see map_expr/1
  %% @see map_expr_argument/1
  %% @see map_expr_fields/1
  %% @see map_field_assoc/2
  %% @see map_field_exact/2
  
  -record(map_expr, {argument :: 'none' | syntaxTree(),
                     fields   :: [syntaxTree()]}).
  
  %% `erl_parse' representation:
  %%
  %% {map, Pos, Fields}
  %% {map, Pos, Argument, Fields}
  
  -spec map_expr('none' | syntaxTree(), [syntaxTree()]) -> syntaxTree().
  
  map_expr(Argument, Fields) ->
      tree(map_expr, #map_expr{argument = Argument, fields = Fields}).
  
  revert_map_expr(Node) ->
      Pos = get_pos(Node),
      Argument = map_expr_argument(Node),
      Fields = map_expr_fields(Node),
      case Argument of
          none ->
              {map, Pos, Fields};
          _ ->
              {map, Pos, Argument, Fields}
      end.
  
  
  %% =====================================================================
  %% @doc Returns the argument subtree of a `map_expr' node, if any. If `Node'
  %% represents "<code>#{...}</code>", `none' is returned.
  %% Otherwise, if `Node' represents "<code><em>Argument</em>#{...}</code>",
  %% `Argument' is returned.
  %%
  %% @see map_expr/3
  
  -spec map_expr_argument(syntaxTree()) -> 'none' | syntaxTree().
  
  map_expr_argument(Node) ->
      case unwrap(Node) of
          {map, _, _} ->
              none;
          {map, _, Argument, _} ->
              Argument;
          Node1 ->
              (data(Node1))#map_expr.argument
      end.
  
  
  %% =====================================================================
  %% @doc Returns the list of field subtrees of a `map_expr' node.
  %%
  %% @see map_expr/3
  
  -spec map_expr_fields(syntaxTree()) -> [syntaxTree()].
  
  map_expr_fields(Node) ->
      case unwrap(Node) of
          {map, _, Fields} ->
              Fields;
          {map, _, _, Fields} ->
              Fields;
          Node1 ->
              (data(Node1))#map_expr.fields
      end.
  
  
  %% =====================================================================
  %% @doc Creates an abstract map assoc field. The result represents
  %% "<code><em>Name</em> => <em>Value</em></code>".
  %%
  %% @see map_field_assoc_name/1
  %% @see map_field_assoc_value/1
  %% @see map_expr/3
  
  -record(map_field_assoc, {name :: syntaxTree(), value :: syntaxTree()}).
  
  %% `erl_parse' representation:
  %%
  %% {map_field_assoc, Pos, Name, Value}
  
  -spec map_field_assoc(syntaxTree(), syntaxTree()) -> syntaxTree().
  
  map_field_assoc(Name, Value) ->
      tree(map_field_assoc, #map_field_assoc{name = Name, value = Value}).
  
  revert_map_field_assoc(Node) ->
      Pos = get_pos(Node),
      Name = map_field_assoc_name(Node),
      Value = map_field_assoc_value(Node),
      {map_field_assoc, Pos, Name, Value}.
  
  
  %% =====================================================================
  %% @doc Returns the name subtree of a `map_field_assoc' node.
  %%
  %% @see map_field_assoc/2
  
  -spec map_field_assoc_name(syntaxTree()) -> syntaxTree().
  
  map_field_assoc_name(Node) ->
      case Node of
          {map_field_assoc, _, Name, _} ->
              Name;
          _ ->
              (data(Node))#map_field_assoc.name
      end.
  
  
  %% =====================================================================
  %% @doc Returns the value subtree of a `map_field_assoc' node.
  %%
  %% @see map_field_assoc/2
  
  -spec map_field_assoc_value(syntaxTree()) -> syntaxTree().
  
  map_field_assoc_value(Node) ->
      case Node of
          {map_field_assoc, _, _, Value} ->
              Value;
          _ ->
              (data(Node))#map_field_assoc.name
      end.
  
  
  %% =====================================================================
  %% @doc Creates an abstract map exact field. The result represents
  %% "<code><em>Name</em> := <em>Value</em></code>".
  %%
  %% @see map_field_exact_name/1
  %% @see map_field_exact_value/1
  %% @see map_expr/3
  
  -record(map_field_exact, {name :: syntaxTree(), value :: syntaxTree()}).
  
  %% `erl_parse' representation:
  %%
  %% {map_field_exact, Pos, Name, Value}
  
  -spec map_field_exact(syntaxTree(), syntaxTree()) -> syntaxTree().
  
  map_field_exact(Name, Value) ->
      tree(map_field_exact, #map_field_exact{name = Name, value = Value}).
  
  revert_map_field_exact(Node) ->
      Pos = get_pos(Node),
      Name = map_field_exact_name(Node),
      Value = map_field_exact_value(Node),
      {map_field_exact, Pos, Name, Value}.
  
  
  %% =====================================================================
  %% @doc Returns the name subtree of a `map_field_exact' node.
  %%
  %% @see map_field_exact/2
  
  -spec map_field_exact_name(syntaxTree()) -> syntaxTree().
  
  map_field_exact_name(Node) ->
      case Node of
          {map_field_exact, _, Name, _} ->
              Name;
          _ ->
              (data(Node))#map_field_exact.name
      end.
  
  
  %% =====================================================================
  %% @doc Returns the value subtree of a `map_field_exact' node.
  %%
  %% @see map_field_exact/2
  
  -spec map_field_exact_value(syntaxTree()) -> syntaxTree().
  
  map_field_exact_value(Node) ->
      case Node of
          {map_field_exact, _, _, Value} ->
              Value;
          _ ->
              (data(Node))#map_field_exact.name
      end.
  
  
  %% =====================================================================
  %% @doc Creates an abstract tuple. If `Elements' is
  