anchor.diff:        List :: [Element],
         Set :: set(Element).
   from_list(Ls, [{version, 2}]) ->
  -    maps:from_list([{K,?VALUE}||K<-Ls]);
  +    maps:from_keys(Ls, ?VALUE);
   from_list(Ls, Opts) ->
       case proplists:get_value(version, Opts, 1) of
           1 -> from_list(Ls);
  
positive.code:         {K, _, NextIter} ->
              case Fun(K) of
                  true ->
                      [{K,?VALUE} | filter_1(Fun, NextIter)];
                  false ->
                      filter_1(Fun, NextIter)
              end;
  
negative.code:         false ->
  	    filter(fun (E) -> is_element(E, S1) end, S2)
      end.
  
  %% If we are keeping more than 75% of the keys, then it is
  %% cheaper to delete them. Stop accumulating and start deleting.
  intersection_heuristic(Next, _Keep, Delete, 0, Acc, Reference) ->
    intersection_decided(Next, remove_keys(Delete, Acc), Reference);
  intersection_heuristic({Key, _Value, Iterator}, Keep, Delete, KeepCount, Acc, Reference) ->
      Next = maps:next(Iterator),
      case Reference of
          #{Key := _} ->
              intersection_heuristic(Next, [Key | Keep], Delete, KeepCount - 1, Acc, Reference);
          _ ->
              intersection_heuristic(Next, Keep, [Key | Delete], KeepCount, Acc, Reference)
      end;
  intersection_heuristic(none, Keep, _Delete, _Count, _Acc, _Reference) ->
      maps:from_keys(Keep, ?VALUE).
  
  intersection_decided({Key, _Value, Iterator}, Acc0, Reference) ->
      Acc1 = case Reference of
          #{Key := _} -> Acc0;
          #{} -> maps:remove(Key, Acc0)
      end,
      intersection_decided(maps:next(Iterator), Acc1, Reference);
  intersection_decided(none, Acc, _Reference) ->
      Acc.
  
  remove_keys([K | Ks], Map) -> remove_keys(Ks, maps:remove(K, Map));
  remove_keys([], Map) -> Map.
  
  %% intersection([Set]) -> Set.
  %%  Return the intersection of the list of sets.
  