anchor.diff:  %%      computation.
   %%
   -spec wait_needed(id(), threshold()) -> ok | error().
  -wait_needed(_Id, _Threshold) ->
  -    {error, not_implemented}.
  +wait_needed(Id, Threshold) ->
  +    gen_server:call(?MODULE, {wait_needed, Id, Threshold}, infinity).
   
   %%%===================================================================
   %%% gen_server callbacks
   %%%===================================================================
   
   %% @private
  --spec init([]) -> {ok, #state{}} |
  -                  {ok, #state{}, non_neg_integer() | infinity} |
  -                  ignore |
  -                  {stop, term()}.
  +-spec init([]) -> {ok, #state{}}.
   init([]) ->
  -    {ok, #state{}}.
  -
  -%% @private
  --spec handle_call(term(), {pid(), term()}, #state{}) ->
  -                         {reply, term(), #state{}} |
  -                         {reply, term(), #state{}, non_neg_integer()} |
  -                         {noreply, #state{}} |
  -                         {noreply, #state{}, non_neg_integer()} |
  -                         {stop, term(), term(), #state{}} |
  -                         {stop, term(), #state{}}.
  +    {ok, Store} = ?CORE:start(node()),
  +    {ok, #state{store=Store}}.
  +
  +%% @private
  +-spec handle_call(term(), {pid(), term()}, #state{}) -> {reply, term(), #state{}}.
  +handle_call({declare, Id, Type}, _From, #state{store=Store}=State) ->
  +    {ok, Id} = ?CORE:declare(Id, Type, Store),
  +    {reply, {ok, Id}, State};
  +handle_call({bind, Id, Value}, _From, #state{store=Store}=State) ->
  +    {ok, Result} = ?CORE:bind(Id, Value, Store),
  +    {reply, {ok, Result}, State};
  +handle_call({bind_to, Id, DVId}, _From, #state{store=Store}=State) ->
  +    {ok, _Pid} = ?CORE:bind_to(Id, DVId, Store, ?BIND, ?READ),
  +    {reply, ok, State};
  +handle_call({update, Id, Operation, Actor}, _From, #state{store=Store}=State) ->
  +    {ok, Result} = ?CORE:update(Id, Operation, Actor, Store),
  +    {reply, {ok, Result}, State};
  +handle_call({thread, Module, Function, Args}, _From, #state{store=Store}=State) ->
  +    ok = ?CORE:thread(Module, Function, Args, Store),
  +    {reply, ok, State};
  +handle_call({wait_needed, Id, Threshold}, From, #state{store=Store}=State) ->
  +    ReplyFun = fun(ReadThreshold) ->
  +                        {reply, {ok, ReadThreshold}, State}
  +               end,
  +    ?CORE:wait_needed(Id, Threshold, Store, From, ReplyFun, ?BLOCKING);
  +handle_call({read, Id, Threshold}, From, #state{store=Store}=State) ->
  +    %% @todo Normalize this ReplyFun in the future.
  +    ReplyFun = fun(_Id, Type, Value) ->
  +                    {reply, {ok, {_Id, Type, Value}}, State}
  +               end,
  +    ?CORE:read(Id, Threshold, Store, From, ReplyFun, ?BLOCKING);
  +handle_call({filter, Id, Function, AccId}, _From, #state{store=Store}=State) ->
  +    {ok, _Pid} = ?CORE:filter(Id, Function, AccId, Store, ?BIND, ?READ),
  +    {reply, ok, State};
  +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};
  +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};
  +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};
  +handle_call({map, Id, Function, AccId}, _From, #state{store=Store}=State) ->
  +    {ok, _Pid} = ?CORE:map(Id, Function, AccId, Store, ?BIND, ?READ),
  +    {reply, ok, State};
  +handle_call({fold, Id, Function, AccId}, _From, #state{store=Store}=State) ->
  +    {ok, _Pid} = ?CORE:fold(Id, Function, AccId, Store, ?BIND, ?READ),
  +    {reply, ok, State};
   handle_call(Msg, _From, State) ->
       lager:warning("Unhandled messages: ~p", [Msg]),
       {reply, ok, State}.
   
   %% @private
  --spec handle_cast(term(), #state{}) -> {noreply, #state{}} |
  -                                       {noreply, #state{}, non_neg_integer()} |
  -                                       {stop, term(), #state{}}.
  +-spec handle_cast(term(), #state{}) -> {noreply, #state{}}.
   handle_cast(Msg, State) ->
       lager:warning("Unhandled messages: ~p", [Msg]),
       {noreply, State}.
   
   %% @private
  --spec handle_info(term(), #state{}) -> {noreply, #state{}} |
  -                                       {noreply, #state{}, non_neg_integer()} |
  -                                       {stop, term(), #state{}}.
  +-spec handle_info(term(), #state{}) -> {noreply, #state{}}.
   handle_info(Msg, State) ->
       lager:warning("Unhandled messages: ~p", [Msg]),
       {noreply, State}.
  
positive.code: %%      variables.
  %%
  -spec filter(id(), function(), id()) -> ok | error().
  filter(_Id, _Function, _AccId) ->
      {error, not_implemented}.
  
  %% @doc Spawn a function.
  %%
  %%      Spawn a process executing `Module:Function(Args)'.
  %%
  -spec thread(module(), func(), args()) -> ok | error().
  thread(_Module, _Function, _Args) ->
      {error, not_implemented}.
  
  %% @doc Pause execution until value requested with given threshold.
  %%
  
negative.code: %%      variables.
  %%
  -spec fold(id(), function(), id()) -> ok | error().
  fold(Id, Function, AccId) ->
      gen_server:call(?MODULE, {fold, Id, Function, AccId}, infinity).
  
  %% @doc Filter values from one lattice into another.
  %%
  