anchor.diff:  %% specialized for the uses in this module
   %%--------------------------------------------------------------------
   
  --type map() :: dict().
  -
  --spec map__new() -> map().
  +-type map_dict() :: dict().
  +
  +-spec map__new() -> map_dict().
   map__new() ->
     dict:new().
   
  --spec map__insert({term(), term()}, map()) -> map().
  +-spec map__insert({term(), term()}, map_dict()) -> map_dict().
   map__insert(Object, Map) ->
     {Key, Value} = Object,
     dict:store(Key, Value, Map).
   
  --spec map__lookup(term(), map()) -> term().
  +-spec map__lookup(term(), map_dict()) -> term().
   map__lookup(Key, Map) ->
     try dict:fetch(Key, Map) catch error:_ -> none end.
   
  --spec map__from_list([{fa(), term()}]) -> map().
  +-spec map__from_list([{fa(), term()}]) -> map_dict().
   map__from_list(List) ->
     dict:from_list(List).
   
  --spec map__remove(term(), map()) -> map().
  +-spec map__remove(term(), map_dict()) -> map_dict().
   map__remove(Key, Dict) ->
     dict:erase(Key, Dict).
   
  --spec map__fold(fun((term(), term(), term()) -> map()), map(), map()) -> map().
  +-spec map__fold(fun((term(), term(), term()) -> map_dict()), map_dict(), map_dict()) -> map_dict().
   map__fold(Fun, Acc0, Dict) -> 
     dict:fold(Fun, Acc0, Dict).
  
positive.code: -type fa()        :: {atom(), arity()}.
  -type func_info() :: {line(), atom(), arity()}.
  
  -record(info, {records = map__new() :: map(),
  	       functions = []       :: [func_info()],
  	       types = map__new()   :: map(),
  	       edoc = false	    :: boolean()}).
  -record(inc, {map = map__new() :: map(), filter = [] :: files()}).
  -type inc() :: #inc{}.
  
  -spec show_or_annotate(analysis()) -> 'ok'.
  
negative.code: 	 %% Files in 'fms' are compilable with option 'to_pp'; we keep them
  	 %% as {FileName, ModuleName} in case the ModuleName is different
  	 fms        = []		 :: [{file:filename(), module()}],
  	 ex_func    = map__new()	 :: map_dict(),
  	 record     = map__new()	 :: map_dict(),
  	 func       = map__new()	 :: map_dict(),
  	 inc_func   = map__new()	 :: map_dict(),
  	 trust_plt  = dialyzer_plt:new() :: plt()}).
  -type analysis() :: #analysis{}.
  
  