anchor.diff:  
       ok.
   
  -intersection_test(Config) ->
  -    [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  -
  +%% @doc Intersection test.
  +intersection_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,3]}, a])),
  +    ?assertMatch({ok, _}, lasp:update(S1, {add_all, [1,2,3]}, a)),
  +    ?assertMatch({ok, _}, lasp:update(S2, {add_all, [a,b,3]}, a)),
   
       %% Apply intersection.
  -    ?assertMatch(ok, rpc:call(Node1, lasp, intersection, [S1, S2, S3])),
  +    ?assertMatch(ok, lasp:intersection(S1, S2, S3)),
   
       %% Sleep.
       timer:sleep(400),
   
       %% Read intersection.
  -    {ok, {_, _, _, Intersection0}} = rpc:call(Node1, lasp, read, [S3, undefined]),
  +    {ok, {_, _, _, Intersection0}} = lasp:read(S3, undefined),
   
       %% Read intersection value.
       Intersection = ?SET:value(Intersection0),
  
positive.code: %                         fun sum_pairs/2, 
  %                         GlobalAverage)
  
  orset_test(Config) ->
      [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  
      {ok, {L1, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
      {ok, {L2, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
      {ok, {L3, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Attempt pre, and post- dataflow variable bind operations.
      ?assertMatch(ok, rpc:call(Node1, lasp, bind_to, [L2, L1])),
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [L1, {add, 1}, a])),
      ?assertMatch(ok, rpc:call(Node1, lasp, bind_to, [L3, L1])),
  
      timer:sleep(4000),
  
      %% Verify the same value is contained by all.
      {ok, {_, _, _, S1}} = rpc:call(Node1, lasp, read, [L3, {strict, undefined}]),
      {ok, {_, _, _, S1}} = rpc:call(Node1, lasp, read, [L2, {strict, undefined}]),
      {ok, {_, _, _, S1}} = rpc:call(Node1, lasp, read, [L1, {strict, undefined}]),
  
      %% Test inflations.
      {ok, S2} = ?SET:update({add, 2}, a, S1),
  
      Self = self(),
  
      spawn_link(Node1, fun() ->
                    {ok, _} = lasp:wait_needed(L1, {strict, S1}),
                    Self ! threshold_met
                 end),
  
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, bind, [L1, S2])),
  
      timer:sleep(4000),
  
      %% Verify the same value is contained by all.
      ?assertMatch({ok, {_, _, _, S2}}, rpc:call(Node1, lasp, read, [L3, {strict, undefined}])),
      ?assertMatch({ok, {_, _, _, S2}}, rpc:call(Node1, lasp, read, [L2, {strict, undefined}])),
      ?assertMatch({ok, {_, _, _, S2}}, rpc:call(Node1, lasp, read, [L1, {strict, undefined}])),
  
      %% Read at the S2 threshold level.
      {ok, {_, _, _, S2}} = rpc:call(Node1, lasp, read, [L1, S2]),
  
      %% Wait for wait_needed to unblock.
      receive
  
negative.code:     end,
  
      %% Perform more inflations.
      {ok, {_, _, _, V1}} = lasp:update(SetId, {add_all, [4]}, actor),
  
      ?assertMatch({ok, _}, lasp:update(SetId, {add_all, [5]}, actor)),
  
      %% Spawn fun which should block until lattice is a strict inflation
      %% of V1.
      I2 = second_read,
      spawn(fun() -> Me ! {I2, lasp:read(SetId, {strict, V1})} end),
  
      %% Ensure we receive [1, 2, 3, 4].
      Set2 = receive
  