anchor.diff:          die -> 
               % Nothing to do here. guardian_process will detect that
               % we've died and update the pool.
  -            ok;
  +            ?PRINT({accumulator_loop, dieing}),
  +            erlang:exit({accumulator_loop, exiting_lease_expired});
   
           Other ->
  -            ?PRINT({accumulator_loop, unhandled_event, Other})
  +            ?PRINT({accumulator_loop, unhandled_event, Other}),
  +            accumulator_loop(Guardians, Actions, Waiting, TimerRef)
       end.
   
   % The guardian process monitors the running AsyncFunction and
  
positive.code:     erlang:monitor(process, PoolPid),	
      receive
          {'DOWN', _, process, FunctionPid, _} ->
              % The AsyncFunction process has died. 
              % Communicate dying_message to the pool and exit.
              case DyingMessage of
                  undefined -> ignore;
                  _ -> PoolPid!DyingMessage
              end;
  
          {'DOWN', _, process, AccumulatorPid, _} -> 
              % The accumulator process has died. 
              % Communicate dying_message to the pool, 
              % kill the AsyncFunction process, and exit.
  
negative.code:                 undefined -> ignore;
                  _ -> PoolPid!DyingMessage
              end,
              erlang:exit(FunctionPid, async_die),
              erlang:exit({guardian_process, exiting_accumulator_died});
  
          {'DOWN', _, process, PoolPid, _} ->
              ?PRINT({down, process, PoolPid}),
              % The pool should never die on us.
              ?PRINT(unexpected_pool_death),
              erlang:exit({guardian_process, exiting_pool_died});
  
          Other ->
              ?PRINT({FunctionPid, AccumulatorPid, PoolPid}),
              ?PRINT({guardian_process, unhandled_event, Other}),
              guardian_process(FunctionPid, AccumulatorPid, PoolPid, DyingMessage)
      end.
  
  
  