anchor.diff:  
   -export([try_eval/2]).
   
  -%% -define(DEBUG, true).
  +-compile(export_all).
  +
  +%%-define(DEBUG, true).
   
   -ifdef(DEBUG).
   -define(debug(__String, __Args), ?wrangler_io(__String, __Args)).
  
positive.code: 	    case get_type_info({M, F, A}) of 
  		none -> Args;
  		{ParTypes, _RtnTypes} ->
  		    ?debug("ParTypes:\n~p\n", [ParTypes]),
  		    do_type_ann_args_1(ParTypes, MappedArgs, Args)
  	    end;
  	{ParTypes, _RtnType} ->
  
negative.code:     end.
  
  do_type_ann_args_1(ParTypes, MappedArgs, Args) ->
      ZippedParTypeArgs = lists:zip(ParTypes, Args),
      lists:map(fun ({ParType, Arg}) ->
  		      ?debug("AT:\n~p\n", [{Arg, ParType}]),
  		      case ParType of
  			any ->
  			    Arg;
  			_ when is_function(ParType) ->
  			    ?debug("MappedArgS:\n~p\n", [MappedArgs]),
  			    ?debug("TMappedArgs:\n~p\n", [ParType(MappedArgs)]),
  			    add_type_info({type, ParType(MappedArgs)}, Arg);
  			{f_atom, [M, F, Arity]} ->
  			    ?debug("T:\n~p\n", [ParType]),
  			    M1 = case is_function(M) of
  				   true -> M(MappedArgs);
  				   _ -> M
  				 end,
  			    F1 = case is_function(F) of
  				   true ->
  				       F(MappedArgs);
  				   _ -> M
  				 end,
  			    Arity1 = case is_function(Arity) of
  				       true ->
  					   Arity(MappedArgs);
  				       _ -> Arity
  				     end,
  			    ?debug("M1:\n~p\n", [M1]),
  			    ?debug("F1:\n~p\n", [F1]),
  			    ?debug("Arity1:\n~p\n", [Arity1]),
  			    add_type_info({type, {f_atom, [M1, F1, Arity1]}}, Arg);
  			_ ->
  			    ?debug("T:\n~p\n", [ParType]),
  			    ?debug("A:\n~p\n", [Arg]),
  			    add_type_info({type, ParType}, Arg)
  		      end
  	      end, ZippedParTypeArgs).
  
  
  add_type_info({type, Type}, Node) ->
      As =refac_syntax:get_ann(Node),
      Ps = [{Pos, {type, Type}}|| {value, {_,  Pos}} <- As],
      Ps1 =lists:append([[{Pos, {type, Type}}|| Pos<-Poss] ||{def, Poss} <-As]),
      add_to_type_env(Ps++Ps1),
      refac_syntax:add_ann({type, Type}, Node).
     
  
  map_args(Pats, ActualArgs) ->
      Fun = fun (ActualArg) ->
  		  case refac_syntax:type(ActualArg) of
  		      literal ->
  			  ActualArg;
  		      variable ->
  			  As = refac_syntax:get_ann(ActualArg),
  			  case lists:keysearch(def, 1, As) of
  			      {value, {def, DefinePos}} ->
  				  {Ps1, _Ps2} = lists:splitwith(
  					      fun (P) -> case refac_syntax:type(P) of
  							     variable ->
  								 As1 = refac_syntax:get_ann(P),
  								 case lists:keysearch(def, 1, As1) of
  								     {value, {def, DefinePos}} ->
  									 false;
  								     _ -> true
  								 end;
  							     _ -> true
  							 end
  					      end, Pats),
  				  case length(Ps1) == length(Pats) of
  				      true ->
  					  ActualArg;
  				      _ ->
  					  ?debug("nth:\n~p\n", [length(Ps1) + 1]),
  					  fun (P) -> lists:nth(length(Ps1) + 1, P) end
  				  end;
  			      _ ->
  				  ActualArg
  			  end;
  		      _ -> ActualArg
  		  end
  	  end,
      Res = lists:map(Fun, ActualArgs),
      ?debug("Res:\n~p\n", [Res]),
      Res.
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%	
  
  get_pat_type(P, TypeInfo) ->
      case refac_syntax:type(P) of
  	variable ->
  	    As = refac_syntax:get_ann(P),
  	    case lists:keysearch(def, 1, As) of
  		{value, {def, [DefinePos]}} ->
  		    case lists:keysearch(DefinePos, 1, TypeInfo) of
  			{value, {DefinePos, {type, T}}} ->
  			    T;
  			_ -> any
  		    end;
  		_ -> any
  	    end;
  	_ -> any
      end.
  
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %%                                                                       %%
  %%                 Propagate Type Information to Atoms                   %%
  %%                                                                       %%
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  prop_type_info(AnnAST, TypeEnv) ->  
      refac_util:stop_tdTP(fun do_prop_type_info/2, AnnAST, TypeEnv).
    
  do_prop_type_info(Node, TypeEnv) ->
      case refac_syntax:type(Node) of 
  	atom ->
  	    Pos = refac_syntax:get_pos(Node),
  	    Ts =lists:usort([Type||{P, Type} <-TypeEnv, P==Pos]),
  	    case Ts of
  		[] ->
  		    {Node, true};
  		_ ->
  		    Type = element(2, lists:unzip(Ts)),
  		    Node1 = refac_syntax:add_ann({type, Type}, Node),
  		    refac_io:format("AtomNodeWithTypeInfo:\n~p\n", [Node1]),
  		    {Node1, true}
  	    end;	    
  	_ -> {Node, false}
      end.
    
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %%                                                                       %%
  %%                 Type Info Server                                      %%
  %%                                                                       %%
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  start_type_env_process() ->
      Pid = spawn_link(fun() -> type_env_loop([]) end), 
  