anchor.diff:  
   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,
  +    [{_Key, #dv{waiting_threads=Threads,
  +                binding_list=BindingList,
  +                lazy=Lazy}}] = ets:lookup(Variables, Key),
       Functions = lists:usort(Functions0),
       V1 = #dv{type=Type, value=Value, functions=Functions, next=Next,
                lazy=Lazy, bound=true},
  
positive.code:                   lazy=Lazy,
                    type=Type,
                    next=NextKey,
                    functions=Functions0}}] = ets:lookup(Variables, X),
      case Bound of
          true ->
              lager:info("Read received: ~p, bound: ~p", [X, V]),
              case is_lattice(Type) of
                  true ->
                      case Function of
  
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}) ->
  