anchor.diff:                end,
   
       %% Apply fold.
  -    ?assertMatch(ok, rpc:call(Node1, lasp, fold, [S1, FoldFun, S2])),
  +    ?assertMatch(ok, lasp:fold(S1, FoldFun, S2)),
   
       %% Wait.
       timer:sleep(4000),
   
       %% Read resulting value.
  -    {ok, {_, _, _, S1V4}} = rpc:call(Node1, lasp, read, [S1, {strict, undefined}]),
  +    {ok, {_, _, _, S1V4}} = lasp:read(S1, {strict, undefined}),
   
       %% Read resulting value.
  -    {ok, {_, _, _, S2V1}} = rpc:call(Node1, lasp, read, [S2, {strict, undefined}]),
  +    {ok, {_, _, _, S2V1}} = lasp:read(S2, {strict, undefined}),
   
       ?assertEqual({ok, [1,2], 1},
                    {ok, ?SET:value(S1V4), ?COUNTER:value(S2V1)}),
   
       ok.
   
  -union_test(Config) ->
  -    [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  -
  +%% @doc Union operation test.
  +union_test(_Config) ->
       %% Create initial sets.
  -    {ok, {S1, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  -    {ok, {S2, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  +    {ok, {S1, _, _, _}} = lasp:declare(?SET),
  +    {ok, {S2, _, _, _}} = lasp:declare(?SET),
   
       %% Create output set.
  -    {ok, {S3, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  +    {ok, {S3, _, _, _}} = lasp:declare(?SET),
   
       %% Populate initial sets.
  -    ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S1, {add_all, [1,2,3]}, a])),
  -    ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S2, {add_all, [a,b,c]}, a])),
  +    ?assertMatch({ok, _}, lasp:update(S1, {add_all, [1,2,3]}, a)),
  +    ?assertMatch({ok, _}, lasp:update(S2, {add_all, [a,b,c]}, a)),
   
       %% Apply union.
  -    ?assertMatch(ok, rpc:call(Node1, lasp, union, [S1, S2, S3])),
  +    ?assertMatch(ok, lasp:union(S1, S2, S3)),
   
       %% Sleep.
       timer:sleep(400),
   
       %% Read union.
  -    {ok, {_, _, _, Union0}} = rpc:call(Node1, lasp, read, [S3, undefined]),
  +    {ok, {_, _, _, Union0}} = lasp:read(S3, undefined),
   
       %% Read union value.
       Union = ?SET:value(Union0),
  
positive.code: 
      ok.
  
  intersection_test(Config) ->
      [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  
      %% Create initial sets.
      {ok, {S1, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
      {ok, {S2, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Create output set.
      {ok, {S3, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Populate initial sets.
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S1, {add_all, [1,2,3]}, a])),
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S2, {add_all, [a,b,3]}, a])),
  
      %% Apply intersection.
      ?assertMatch(ok, rpc:call(Node1, lasp, intersection, [S1, S2, S3])),
  
      %% Sleep.
      timer:sleep(400),
  
      %% Read intersection.
      {ok, {_, _, _, Intersection0}} = rpc:call(Node1, lasp, read, [S3, undefined]),
  
      %% Read intersection value.
      Intersection = ?SET:value(Intersection0),
  
negative.code:             ok
      end,
  
      {ok, {L5, _, _, _}} = lasp:declare(?SET),
      {ok, {L6, _, _, _}} = lasp:declare(?SET),
  
      spawn_link(fun() ->
                  {ok, _} = lasp:read_any([{L5, {strict, undefined}}, {L6, {strict, undefined}}]),
                  Self ! read_any
          end),
  
      {ok, _} = lasp:update(L5, {add, 1}, a),
  
      receive
          read_any ->
  