anchor.diff:      {noreply, State}.
   
   handle_handoff_command(?FOLD_REQ{foldfun=FoldFun, acc0=Acc0}, _Sender,
  -                       #state{table=Table}=State) ->
  +                       #state{variables=Variable}=State) ->
       F = fun({Key, Operation}, Acc) -> FoldFun(Key, Operation, Acc) end,
  -    Acc = ets:foldl(F, Acc0, Table),
  +    Acc = ets:foldl(F, Acc0, Variable),
       {reply, Acc, State}.
   
   handoff_starting(_TargetNode, State) ->
  
positive.code:     riak_core_vnode_master:get_vnode_pid(I, ?MODULE).
  
  init([Partition]) ->
      Table = string:concat(integer_to_list(Partition), "dvstore"),
      TableAtom = list_to_atom(Table),
      TableAtom = ets:new(TableAtom, [set, named_table, public,
                                      {write_concurrency, true}]),
      {ok, #state {partition=Partition, table=TableAtom}}.
  
  handle_command({declare, Id, Type}, _From, State=#state{table=Table}) ->
      Record = case Type of
          undefined ->
              #dv{value=undefined, type=undefined, bounded=false};
          Type ->
              #dv{value=Type:new(), type=Type, bounded=true}
      end,
      true = ets:insert(Table, {Id, Record}),
      {reply, {ok, Id}, State};
  
  handle_command({bind, Id, Value}, From,
                 State=#state{table=Table}) ->
      case Value of
          {id, DVId} ->
              true = ets:insert(Table, {Id, #dv{value={id, DVId}}}),
              fetch(DVId, Id, From),
              {noreply, State};
          _ ->
              [{_Key, V}] = ets:lookup(Table, Id),
              NextKey = next_key(V#dv.next, V#dv.type),
              case V#dv.bounded of
                  true ->
  
negative.code:                 [_H|_T] ->
                      {reply, ok, State};
                  _ ->
                      true = ets:insert(Variables, {Id, V#dv{lazy=true, creator=From}}),
                      {noreply, State}
                  end
      end;
  
  handle_command({read, X}, From,
                 State=#state{variables=Variables}) ->
      [{_Key, V}] = ets:lookup(Variables, X),
      Value = V#dv.value,
      Bounded = V#dv.bounded,
      Creator = V#dv.creator,
  