anchor.diff:      {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),
  +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),
  +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),
  +    {ok, _Pid} = ?CORE:union(Left, Right, Union, Store, ?BIND, ?READ,
  +                             ?READ),
       {reply, ok, State};
   
   %% Spawn a process to perform a map.
  
positive.code: %% @doc Returns from the broadcast message the identifier and the payload.
  -spec broadcast_data(broadcast_message()) ->
      {{broadcast_id(), broadcast_clock()}, broadcast_payload()}.
  broadcast_data(#broadcast{id=Id, type=Type, clock=Clock, metadata=Metadata, value=Value}) ->
      {{Id, Clock}, {Id, Type, Metadata, Value}}.
  
  %% @doc Perform a merge of an incoming object with an object in the
  %%      local datastore, as long as we haven't seen a more recent clock
  %%      for the same object.
  -spec merge({broadcast_id(), broadcast_clock()}, broadcast_payload()) -> boolean().
  merge({Id, Clock}, {Id, Type, Metadata, Value}) ->
      case is_stale({Id, Clock}) of
          true ->
  
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}
  