anchor.diff:              collect_timeout(Replies, Parent);
           false ->
               collect_replies(Collect)
  +    end.
  +
  +-spec try_collect_all(#collect{}) -> _.
  +try_collect_all(Collect=#collect{reqid=ReqId}) ->
  +    %% FIXME make this timeout configurable:
  +    erlang:send_after(1000, self(), {try_collect_all_timeout, ReqId}),
  +    try_collect_all_impl(Collect).
  +
  +try_collect_all_impl(Collect=#collect{id=Id,
  +                                      replies=Replies0,
  +                                      parent={From, Ref},
  +                                      reqid=ReqId,
  +                                      views=Views}) ->
  +    receive
  +        {'$gen_all_state_event', Event} ->
  +            {reply, ReqId, Peer, Reply} = Event,
  +            Replies = [{Peer, Reply}|Replies0],
  +            case quorum_met(Replies, Id, Views, all) of
  +                true ->
  +                    %% At this point we should be guaranteed to have already
  +                    %% gotten a parent that we can reply to:
  +                    ?OUT("Met quorum with Event ~p Replies ~p", [Event, Replies, Views]),
  +                    From ! {Ref, ok, Replies};
  +                false ->
  +                    ?OUT("Got additional message ~p but quorum still not met", [Event]),
  +                    try_collect_all(Collect#collect{replies=Replies});
  +                nack ->
  +                    %% Since we're waiting for all, we may see a nack from even
  +                    %% just a single negative response. But, we already know we
  +                    %% have a quorum of positive replies, so we can still send
  +                    %% back an 'ok' response with the replies we've gotten.
  +                    ?OUT("Got a nack! Returning replies so far: ~p", [Replies]),
  +                    From ! {Ref, ok, Replies}
  +            end;
  +        {try_collect_all_timeout, ReqId} ->
  +            ?OUT("Timed out waiting for try_collect_all", []),
  +            From ! {Ref, ok, Replies0}
       end.
   
   -spec wait_for_quorum(future()) -> {quorum_met, [peer_reply()]} |
  
positive.code:                               required=Required,
                                extra=Extra}) ->
      case quorum_met(Replies, Id, Views, Required, Extra) of
          true ->
              From ! {Ref, ok, Replies},
              ok;
  
negative.code: 
  %%%===================================================================
  
  -type required()   :: quorum | other | all | all_or_quorum.
  
  -record(msgstate, {awaiting = undefined :: 'undefined' | reqid(),
                     timer    = undefined :: 'undefined' | reference(),
  