anchor.diff:  %%     {{ann_type, [Left, Right]}, ParseState};
   parse_type(TypeSpec, Module, ParseState) ->
       ct:pal("unknown type ~p in module ~p~n", [TypeSpec, Module]),
  +    throw(unkown_type),
       {unkown, ParseState}.
   
   -spec parse_type_list/3 :: (list(type_spec()), module(), tester_parse_state:state()) ->
  
positive.code:                   _ ->
                        TheFunSpec
                end || TheFunSpec <- AFunSpec],
      {CleanFunSpec, NewParseState} = parse_type({union_fun, FunSpec}, Module, ParseState),
      tester_parse_state:add_type_spec({'fun', Module, FunName, FunArity},
                                       CleanFunSpec, [], NewParseState);
  parse_chunk({attribute, _Line, record, {TypeName, TypeList}}, Module, ParseState) ->
      {TheTypeSpec, NewParseState} = parse_type(TypeList, Module, ParseState),
      tester_parse_state:add_type_spec({record, Module, TypeName}, TheTypeSpec, [],
                                       NewParseState);
  parse_chunk({attribute, _Line, _AttributeName, _AttributeValue}, _Module,
  
negative.code:     tester_value_collector:parse_expression(FunCode, ParseState);
  parse_chunk({eof, _Line}, _Module, ParseState) ->
      ParseState.
  
  -spec parse_type_log/4 :: (any(), module(), tester_parse_state:state(), tuple()) ->
                                    {type_spec() , tester_parse_state:state()}.
  parse_type_log(Type, Module, ParseState, Info) ->
      try
          parse_type(Type, Module, ParseState)
      catch
          unkown_type ->
              ct:pal("~p:~p: failed to parse  ~p", [Module, Info, Type]),
              exit(foobar)
      end.
  
  -spec parse_type/3 :: (any(), module(), tester_parse_state:state()) ->
      {type_spec() , tester_parse_state:state()}.
  