anchor.diff:  
   %% Internal functions.
   
  +-record(read, {id :: id(),
  +               value :: value(),
  +               read_fun :: function()}).
  +
   -spec internal_fold(store(), id(), function(), id(), fun(), function()) -> ok.
  -internal_fold(Variables, Id, Function, AccId, BindFun, ReadFun) ->
  +internal_fold(Variables, Id, Function, AccId, BindFun, _ReadFun) ->
  +    ReadDict = dict:store(Id,
  +                          #read{id=Id},
  +                          dict:new()),
       spawn_link(?MODULE, internal_fold_harness, [Variables,
  -                                                Id,
  +                                                ReadDict,
                                                   Function,
                                                   AccId,
  -                                                BindFun,
  -                                                ReadFun,
  -                                                undefined]),
  +                                                BindFun]),
       ok.
   
  --spec internal_fold_harness(store(), id(), function(), id(), function(),
  -                            function(), value()) -> function().
  -internal_fold_harness(Variables, Id, Function, AccId, BindFun, ReadFun,
  -                      PreviousValue) ->
  -    %% Blocking threshold read on source value.
  -    {ok, {Id, Type, Value, _}} = ReadFun(Id,
  -                                         {strict, PreviousValue},
  -                                         Variables),
  +-spec internal_fold_harness(store(), dict(), function(), id(),
  +                            function()) -> function().
  +internal_fold_harness(Variables, ReadDict0, Function, AccId, BindFun) ->
  +
  +    %% Perform a read against all variables in the dict.
  +    Reads = [{Id, {strict, Value}} ||
  +             {Id, #read{value=Value}} <- dict:to_list(ReadDict0)],
  +
  +    lager:info("About to issue read for: ~p", [Reads]),
  +
  +    %% Wait for one of the variables to be modified.
  +    %% @TODO: Assume objects all have the same type.
  +    {ok, {Id, Type, Value, _}} = lasp:read_any(Reads),
  +
  +    lager:info("Read succeeded for: ~p with value ~p", [Id, Value]),
  +
  +    %% Store updated value in the dict.
  +    ReadDict = dict:store(Id, #read{id=Id, value=Value}, ReadDict0),
   
       %% @TODO: Generate a delta-CRDT; for now, we will use the entire
       %% object as the delta for simplicity.  Eventually, replace this
  
positive.code:     %% Update with result.
      {ok, _} = BindFun(AccId, AccValue, Variables),
  
      internal_fold_harness(Variables, Id, Function, AccId, BindFun,
                            ReadFun, Value).
  
  %% @doc Send responses to waiting threads, via messages.
  %%
  
negative.code:         true ->
              case From of
                  {server, undefined, {Address, Ref}} ->
                      gen_server:reply({Address, Ref},
                                       {ok, {Id, Type, Value, Next}});
                  {fsm, undefined, Address} ->
                      gen_fsm:send_event(Address,
                                         {ok, undefined,
                                          {Id, Type, Value, Next}});
                  _ ->
                      From ! Result
              end,
  