anchor.diff:      {ok, #state{}}.
   
   handle_call({get, Pid}, _From, State) when is_pid(Pid) ->
  -    case fetch_object(Pid) of
  -        Object = #object{} ->
  -            Object;
  -        _ ->
  -            undefined
  -    end.
  +    Reply =
  +       case fetch_object(Pid) of
  +           Object = #object{} ->
  +               Object;
  +           _ ->
  +               undefined
  +       end,
  +    {reply, Reply, State};
   handle_call({get, Id}, _From, State) ->
       Fun =
           fun() ->
  
positive.code:     gen_server:call(?MODULE, {get, IdOrPid}).
  
  subscribe_dead(Subscriber, DeadPid) ->
      gen_server:cast(?MODULE, {subscribe_dead, Subscriber, Pid}).
  
  unsubscribe_dead(Subscriber, DeadPid) ->
      gen_server:cast(?MODULE, {unsubscribe_dead, Subscriber, Pid}).
  
  replace_dead(OldPid, NewPid) ->
      gen_server:cast(?MODULE, {replace_pid, OldPid, NewPid}).
  
negative.code:         fun() ->
              MatchHead = #object{pid=Pid, _='_'},
              Result = '$_',
              mnesia:select(object, [{MatchHead, [], [Result]}])
          end,
      case mnesia:transaction(Fun) of
          {atomic, []} ->
              undefined;
          {atomic, [Object = #object{properties = Props} | _]} ->
              Object#object{properties = ids2pids(Props)}
      end.
  
  subscribe_dead_(Subscriber, Pid) ->
      Fun =
         fun() ->
             case mnesia:read(replacement_pid, Pid) of
                 [#replacement_pid{new_pid = NewPid} | _] ->
                     Subscriber ! {replace_pid, Pid, NewPid};
                 [] ->
                     mnesia:write(#dead_pid_subscription{subscriber = self(),
                                                         dead_pid = Pid}),
                     OneMinute = 60 * 1000,
                     Message = {delete, #dead_pid_subscription{subscriber = self(),
                                                               dead_pid = Pid}},
                     erlang:send_after(OneMinute, self(), Message)
             end
         end,
      mnesia:transaction(Fun).
  
  unsubscribe_dead_(Subscriber, OldPid) ->
      OldRecord = #dead_pid_subscription{subscriber = Subscriber,
                                         dead_pid = OldPid},
      Fun =
          fun() ->
              mnesia:delete(OldRecord)
          end,
      {atomic, ok} = mnesia:transaction(Fun).
  
  replace_dead_(OldPid, NewPid) ->
      Fun =
          fun() ->
              Object = #dead_pid_subscription{dead_pid = OldPid, _ = '_'},
              Subs = mnesia:match_object(Object),
              [Sub ! {replace_pid, OldPid, NewPid}
               || #dead_pid_subscription{subscriber = Sub} <- Subs],
  
              mnesia:write(#replacement_pid{old_pid = OldPid,
                                            new_pid = NewPid})
  