anchor.diff:      {ok, Result} = gen_server:call(?MODULE, info),
       Result.
   
  -info(Mod) when is_atom(Mod) -> 
  +info(Mod) when is_atom(Mod) ->
       {ok, Result} = gen_server:call(?MODULE, {info, Mod}),
       Result.
   
  
positive.code: 
  hotload_app(App, State) when is_atom(App) ->
      case application:get_key(App, modules) of
  	    {ok, Mods} ->
  	        NewState = lists:foldl(fun(M, S) -> reload_mod(M, S) end, State, Mods),
  	        ok = ?info("Reloaded Application ~s", [App]),
  	        NewState
      end.
  
  hotload_mod(Mod, State) when is_atom(Mod) ->
      case code:which(Mod) of
      	Path when is_list(Path) -> reload_mod(Mod, State);
      	non_existing -> 
      	    ok = ?warn("attempted to reload non-existent module ~p", [Mod]),
      	    State
      end.
  
  reload_mod(Mod, #hotbeam_state{beams = Beams} = State) when is_atom(Mod) -> 
      HF = fun(M, B) -> case lists:keyfind(M, #hotbeam.mod, B) of false -> undefined; #hotbeam{} = HB -> HB end end,
      case {loaded, HF(Mod, Beams)} of
          {loaded, undefined} ->
              S0 = #hotbeam_state{beams = NewBeams} = p_rescan_fun(Mod, State),
              case {new, HF(Mod, NewBeams)} of
                  {new, undefined} -> 
                      ?info("unable to add ~p", [Mod]),
                      State;
                  {new, #hotbeam{} = HB} -> 
                      reload_mod(HB, S0)
              end;
          {loaded, #hotbeam{} = HB} -> 
              reload_mod(HB, State)
      end;
  reload_mod(#hotbeam{mod = Mod} = HB, #hotbeam_state{hotload_count = HC, beams = Beams} = State) when is_atom(Mod)->
  
negative.code:     {noreply, hotload_mod(Module, State)};
  handle_cast(reload_all, State) ->
      {noreply, hotload(State#hotbeam_state.apps, State)};
  handle_cast({lazyload, Mod}, State) ->
      ?info("manually recompiling ~p", [Mod]),
      {noreply, case lists:keysearch(Mod, #hotbeam.mod, State#hotbeam_state.beams) of
                    {value, #hotbeam{} = HB} ->
                        p_lazy_load(HB, State);
                    false ->
                        reload_mod(Mod, State)
                end};
  handle_cast(rehash, State) ->
      {noreply, p_rehash(State)};
  handle_cast(_, State) -> {noreply, State}.
  