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