anchor.diff:      {reply, {ok, Result}, State#state{counter=increment_counter(Counter)}};
   
   %% Spawn a function.
  -handle_call({thread, Module, Function, Args}, _From, #state{store=Store}=State) ->
  +handle_call({thread, Module, Function, Args},
  +            _From,
  +            #state{store=Store}=State) ->
       ok = ?CORE:thread(Module, Function, Args, Store),
       {reply, ok, State};
   
  
positive.code:     {reply, ok, State};
  
  %% Spawn a process to compute a product.
  handle_call({product, Left, Right, Product}, _From, #state{store=Store}=State) ->
      {ok, _Pid} = ?CORE:product(Left, Right, Product, Store, ?BIND, ?READ, ?READ),
      {reply, ok, State};
  
  %% Spawn a process to compute the intersection.
  handle_call({intersection, Left, Right, Intersection}, _From, #state{store=Store}=State) ->
      {ok, _Pid} = ?CORE:intersection(Left, Right, Intersection, Store, ?BIND, ?READ, ?READ),
      {reply, ok, State};
  
  %% Spawn a process to compute the union.
  handle_call({union, Left, Right, Union}, _From, #state{store=Store}=State) ->
      {ok, _Pid} = ?CORE:union(Left, Right, Union, Store, ?BIND, ?READ, ?READ),
      {reply, ok, State};
  
  %% Spawn a process to perform a map.
  
negative.code: %% @private
  broadcast({Id, Type, Metadata, Value}) ->
      Clock = orddict:fetch(clock, Metadata),
      Broadcast = #broadcast{id=Id, clock=Clock, type=Type,
                             metadata=Metadata, value=Value},
      plumtree_broadcast:broadcast(Broadcast, ?MODULE).
  
  %% @private
  local_bind(Id, Type, Metadata, Value) ->
      case gen_server:call(?MODULE, {bind, Id, Metadata, Value}, infinity) of
          {error, not_found} ->
              {ok, _} = gen_server:call(?MODULE,
                                        {declare, Id, Metadata, Type},
                                        infinity),
              local_bind(Id, Type, Metadata, Value);
          {ok, X} ->
             {ok, X}
  