anchor.diff:  %% broadcast the result.
   handle_call({bind, Id, Value}, _From,
               #state{store=Store, actor=Actor, counter=Counter}=State) ->
  -    {_Time, Result} = timer:tc(?CORE,
  -                               bind,
  -                               [Id, Value, ?CLOCK_INCR, Store]),
  -    Result1 = case Result of
  -                  {error, not_found} ->
  -                      case Id of
  -                          {StorageId, TypeId} ->
  -                              {ok, {Id, _, _, _}} = ?CORE:declare(StorageId,
  -                                                                  TypeId,
  -                                                                  ?CLOCK_INIT,
  -                                                                  Store),
  -                              {_Time0, Result0} = timer:tc(?CORE,
  -                                                           bind,
  -                                                           [Id, Value,
  -                                                            ?CLOCK_INCR, Store]),
  -                              Result0;
  -                          _ ->
  -                              {error, not_found}
  -                      end;
  -                  X ->
  -                      X
  -              end,
  -    {reply, Result1, State#state{counter=increment_counter(Counter)}};
  +    {_Time, Result0} = timer:tc(?CORE,
  +                                bind,
  +                                [Id, Value, ?CLOCK_INCR, Store]),
  +    Result1 = not_found_handling(Result0, Id, State, timer, tc,
  +                                 [?CORE, bind, [Id, Value, ?CLOCK_INCR, Store]]),
  +    Result = case Result1 of
  +                 {error, not_found} ->
  +                     {error, not_found};
  +                 {found, Result2} ->
  +                     Result2;
  +                 {_NewTime, Result2} ->
  +                     Result2
  +             end,
  +    {reply, Result, State#state{counter=increment_counter(Counter)}};
   
   %% Incoming bind operation; merge incoming clock with the remote clock.
   %%
  
positive.code:                           end, lasp_type:new(Type), SmallDeltaMap),
      {delta, Deltas}.
  
  -ifdef(TEST).
  
  do(Function, Args) ->
  
negative.code: %% perform the update.
  handle_call({update, Id, Operation, Actor}, _From,
              #state{store=Store, counter=Counter}=State) ->
      Result0 = ?CORE:update(Id, Operation, Actor, ?CLOCK_INCR, Store),
      Result1 = not_found_handling(Result0, Id, State, ?CORE, update,
                                   [Id, Operation, Actor, ?CLOCK_INCR, Store]),
      {ok, Result} = case Result1 of
                         {found, Result2} ->
                             Result2;
                         _ ->
                             Result1
                     end,
      {reply, {ok, Result}, State#state{counter=increment_counter(Counter)}};
  
  