anchor.diff:      end;
   %% parse_type({ann_type,_Line,[Left,Right]}, _Module, ParseState) ->
   %%     {{ann_type, [Left, Right]}, ParseState};
  +parse_type({union, L}, Module, ParseState) ->
  +    Foldl = fun (NextType, {TypeList, AParseState}) ->
  +                    {TheTypeSpec, NewParseState} = parse_type(NextType, Module, AParseState),
  +                    {[TheTypeSpec | TypeList], NewParseState}
  +            end,
  +    {Types, NextParseState} = lists:foldl(Foldl, {[], ParseState}, L),
  +    {{union, Types}, NextParseState};
   parse_type(TypeSpec, Module, ParseState) ->
       ct:pal("unknown type ~p in module ~p~n", [TypeSpec, Module]),
       throw(unkown_type),
  
positive.code:     {ListType, ParseState2} = parse_type(Type, Module, ParseState),
      {{nonempty_list, ListType}, ParseState2};
  parse_type({type, _Line, list, []}, _Module, ParseState) ->
      {{list, {typedef, tester, test_any, []}}, ParseState};
  parse_type({type, _Line, range, [Begin, End]}, Module, ParseState) ->
      {BeginType, ParseState2} = parse_type(Begin, Module, ParseState),
  
negative.code:     end;
  parse_type({var, _Line, Atom}, _Module, ParseState) when is_atom(Atom) ->
      {{var, Atom}, ParseState};
  parse_type({var, Atom}, _Module, ParseState) when is_atom(Atom) ->
      {{var, Atom}, ParseState};
  parse_type({type, _Line, constraint, _Constraint}, _Module, ParseState) ->
      {{constraint, nyi}, ParseState};
  parse_type({type, _, bounded_fun, [FunType, ConstraintList]}, Module, ParseState) ->
  