anchor.diff:                      FolderFun = fun(X, Value, Acc) ->
                               case Function(X) of
                                   true ->
  -                                    New = gb_trees:enter(X, Value, gb_trees:empty()),
  +                                    New = gb_trees:enter(X,
  +                                                         Value,
  +                                                         gb_trees:empty()),
                                       lasp_orset_gbtree:merge(New, Acc);
                                   _ ->
                                       Acc
                               end
                       end,
                       gb_trees_ext:foldl(FolderFun, T:new(), V);
  -                _ ->
  -                    FolderFun = fun(Element, Acc) ->
  -                            Z = case Element of
  -                                {X, _} ->
  -                                    %% lasp_orset
  -                                    X
  -                            end,
  -
  -                            case Function(Z) of
  +                lasp_orset ->
  +                    FolderFun = fun({X, _} = Element, Acc) ->
  +                            case Function(X) of
                                   true ->
                                       Acc ++ [Element];
                                   _ ->
                                       Acc
                               end
                       end,
  -
  -                    %% Apply change.
                       lists:foldl(FolderFun, T:new(), V)
               end,
  -
  -            %% Bind new value back.
               {ok, _} = BindFun(AccId, AccValue, Store)
       end,
       gen_flow:start_link(lasp_process, [[{Id, ReadFun}], Fun]).
  
positive.code:             AccValue = case T of
                  lasp_orset_gbtree ->
                      FolderFun = fun(X, Value, Acc) ->
                              New = gb_trees:enter(Function(X), Value, gb_trees:empty()),
                              lasp_orset_gbtree:merge(New, Acc)
                      end,
                      gb_trees_ext:foldl(FolderFun, T:new(), V);
                  _ ->
                      FolderFun = fun(Element, Acc) ->
                              Z = case Element of
                                  {X, Causality} ->
                                      %% lasp_orset
                                      {Function(X), Causality}
                              end,
  
                              Acc ++ [Z]
                      end,
                      lists:foldl(FolderFun, T:new(), V)
              end,
  
              %% Bind new value back.
              {ok, _} = BindFun(AccId, AccValue, Store)
      end,
      gen_flow:start_link(lasp_process, [[{Id, ReadFun}], Fun]).
  
negative.code:                                     gb_trees_ext:foldl(InnerFoldFun, XAcc, RValue)
                              end,
                              gb_trees_ext:foldl(FolderFun, T:new(), LValue);
                          lasp_orset ->
                              FolderFun = fun({X, XCausality}, Acc) ->
                                      Acc ++ [{{X, Y}, lasp_lattice:causal_product(T, XCausality, YCausality)} || {Y, YCausality} <- RValue]
                              end,
                              lists:foldl(FolderFun, T:new(), LValue)
                      end,
                      {ok, _} = BindFun(AccId, AccValue, Store)
              end
      end,
  