anchor.diff:                              gb_trees_ext:foldl(FolderFun,
                                                  T:new(),
                                                  LValue);
  -                        _ ->
  -                            FolderFun = fun(Element, Acc) ->
  -                                    Values = case Element of
  -                                        {X, XCausality} ->
  -                                            %% lasp_orset
  -                                            case lists:keyfind(X, 1, RValue) of
  -                                                {_Y, YCausality} ->
  -                                                    [{X, lasp_lattice:causal_union(T, XCausality, YCausality)}];
  -                                                false ->
  -                                                    []
  -                                            end
  +                        lasp_orset ->
  +                            FolderFun = fun({X, XCausality}, Acc) ->
  +                                    Values = case lists:keyfind(X, 1, RValue) of
  +                                        {_Y, YCausality} ->
  +                                            [{X, lasp_lattice:causal_union(T, XCausality, YCausality)}];
  +                                        false ->
  +                                            []
                                       end,
  -
                                       Acc ++ Values
                               end,
                               lists:foldl(FolderFun, T:new(), LValue)
                       end,
  -
  -                    %% Bind new value back.
                       {ok, _} = BindFun(AccId, AccValue, Store)
               end
       end,
  
positive.code:                     FolderFun = fun(X, Value, Acc) ->
                              case Function(X) of
                                  true ->
                                      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
                                  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]).
  
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,
  