anchor.diff:                    lazy=Lazy,
                     type=Type,
                     next=NextKey,
  -                  functions=Functions0}}] = ets:lookup(Variables, X),
  +                  functions=Functions0}}] = ets:lookup(Variables, Id),
       case Bound of
           true ->
  -            lager:info("Read received: ~p, bound: ~p", [X, V]),
  +            lager:info("Read received: ~p, bound: ~p", [Id, V]),
               case is_lattice(Type) of
                   true ->
                       case Function of
  
positive.code: 
  write(Type, Value, Next, Functions0, Key, Variables) ->
      lager:info("Writing key: ~p next: ~p", [Key, Next]),
      [{_Key, V}] = ets:lookup(Variables, Key),
      Threads = V#dv.waiting_threads,
      BindingList = V#dv.binding_list,
      Lazy = V#dv.lazy,
      Functions = lists:usort(Functions0),
      V1 = #dv{type=Type, value=Value, functions=Functions, next=Next,
               lazy=Lazy, bound=true},
  
negative.code:     notify_all(BindingList, Value),
      reply_to_all(Threads, {ok, Value, Next}).
  
  reply_to_all([H|T], Result) ->
      {server, undefined, {Address, Ref}} = H,
      gen_server:reply({Address, Ref}, Result),
      reply_to_all(T, Result);
  reply_to_all([], _Result) ->
      ok.
  
  next_key(undefined, Type, State) ->
      {ok, NextKey} = declare_next(Type, State),
      NextKey;
  next_key(NextKey0, _, _) ->
      NextKey0.
  
  notify_all([H|T], Value) ->
      notify_value(H, Value),
      notify_all(T, Value);
  notify_all([], _) ->
      ok.
  
  %% @doc Declare the next object for streams.
  declare_next(Type, State=#state{partition=Partition, node=Node}) ->
  