anchor.diff:  -record(replicator, {
             id,
             request,
  -          monitors,
  +          monitors = [],
             notify_pid,
             notify_data,
             replica_addrs,
  
positive.code: 
  handle_info({'DOWN', Monitor, _, _, _} = Msg,
              #rmgr{curr = Replicators} = RMgr) ->
      % Invoked when a monitored downstream is signaling that it died.
      Replicators2 =
          dict:filter(fun (_Id, #replicator{notify_pid = NotifyPid,
                                            notify_data = NotifyData,
  
negative.code: 
  notify(P, D, V) when is_pid(P) -> P ! {D, V};
  notify(_, _, _)                -> ok.
  
  create_replicator(Request, NotifyPid, NotifyData, Addrs) ->
      Id = make_ref(),
      #replicator{id = Id,
                  request = Request,
                  notify_pid = NotifyPid,
                  notify_data = NotifyData,
                  replica_addrs = Addrs,
                  replica_min = 1}.
  
  send_cycle(#replicator{id = Id,
                         request = Request,
                         monitors = Monitors} = Replicator) ->
      {replicate, Addrs, Out, Cmd, CmdArgs,
       ResponseFilter, ResponseModule, _Policy} = Request,
      Monitors2 =
          lists:flatmap(
            fun (Addr) ->
                {ok, AddrMonitors} =
                    mc_downstream:send(Addr, Out, Cmd, CmdArgs,
                                       ResponseFilter, ResponseModule,
                                       self(), Id),
                AddrMonitors
            end,
            Addrs),
      Replicator#replicator{monitors = Monitors2 ++ Monitors}.
  
  