anchor.diff:  from_type_defs(Ts) ->
       lists:map(fun from_type_def/1, Ts).
   
  +from_map_pairs(Pairs) ->
  +    %% Lose distinction between assoc and exact pairs.
  +    Fun = fun ({type,_L,_P,Types}) -> from_type_defs(Types) end,
  +    lists:map(Fun, Pairs).
  +
   from_lambda_args({type,_L,any}) -> any;         %Any arity
   from_lambda_args(Args) -> from_func_prod(Args).
   
   
   %% to_type_def(Def, Line) -> AST.
   
  -to_type_def(?Q(Val), Line) ->                   %Quoted atom literal
  -    to_lit(Val, Line);
  +to_type_def(['UNION'|Types], Line) ->                   %Union
  +    {type,Line,union,to_type_defs(Types, Line)};
   to_type_def([tuple], Line) ->                   %Undefined tuple
       {type,Line,tuple,any};
   to_type_def([tuple|Args], Line) ->
       {type,Line,tuple,to_type_defs(Args, Line)};
  -to_type_def(['UNION'|Types], Line) ->			%Union
  -    {type,Line,union,to_type_defs(Types, Line)};
  +to_type_def([map|Pairs], Line) ->
  +    {type,Line,map,to_map_pairs(Pairs, Line)};
   to_type_def([record,Name,Fields], Line) ->
       {type,Line,record,[to_lit(Name, Line)|to_type_rec_fields(Fields, Line)]};
   to_type_def([lambda,Args,Ret], Line) ->
       {type,Line,'fun',[to_lambda_args(Args, Line),to_type_def(Ret, Line)]};
  +to_type_def(?Q(Val), Line) ->                   %Quoted atom literal
  +    to_lit(Val, Line);
   to_type_def([Type|Args], Line) ->
       Dargs = to_type_defs(Args, Line),
       case string:tokens(atom_to_list(Type), ":") of
  
positive.code: %%  nothing.  We don't differentiate here between pre-defined or user
  %%  defined types.
  
  from_type_def({type,_L,tuple,any}) -> [tuple];
  from_type_def({type,_L,union,Types}) ->		%Special case union
      ['UNION'|from_type_defs(Types)];
  from_type_def({type,_L,record,[{atom,_L,Name}|Fields]}) ->
      [record,Name,from_type_defs(Fields)];
  from_type_def({type,_L,field_type,[{atom,_,Name},Type]}) ->
  
negative.code: 
  %% Handling types in LFE including functions for converting between
  %% Erlang and LFE type formats.
  %% We can correctly do most types except for maps where we lose the
  %% distinction between assoc and exact pairs.
  
  -module(lfe_types).
  
  