anchor.diff:        Map2 :: map().
   
   filter(Pred,Map) when is_function(Pred,2), is_map(Map) ->
  -    maps:from_list([{K,V}||{K,V}<-maps:to_list(Map),Pred(K,V)]);
  +    maps:from_list(filter_1(Pred, iterator(Map)));
   filter(Pred,Map) ->
       erlang:error(error_type(Map),[Pred,Map]).
   
  +filter_1(Pred, Iter) ->
  +    case next(Iter) of
  +        {K, V, NextIter} ->
  +            case Pred(K,V) of
  +                true ->
  +                    [{K,V} | filter_1(Pred, NextIter)];
  +                false ->
  +                    filter_1(Pred, NextIter)
  +            end;
  +        none ->
  +            []
  +    end.
   
   -spec fold(Fun,Init,Map) -> Acc when
       Fun :: fun((K, V, AccIn) -> AccOut),
  
positive.code: 
  with(Ks,Map1) when is_list(Ks), is_map(Map1) ->
      Fun = fun(K, List) ->
        case ?MODULE:find(K, Map1) of
            {ok, V} ->
                [{K, V} | List];
            error ->
                List
        end
      end,
      ?MODULE:from_list(lists:foldl(Fun, [], Ks));
  with(Ks,M) ->
      erlang:error(error_type(M),[Ks,M]).
  
  
negative.code:     V2 :: term().
  
  map(Fun,Map) when is_function(Fun, 2), is_map(Map) ->
      maps:from_list(map_1(Fun, iterator(Map)));
  map(Fun,Map) ->
      erlang:error(error_type(Map),[Fun,Map]).
  
  map_1(Fun, Iter) ->
      case next(Iter) of
          {K, V, NextIter} ->
              [{K, Fun(K, V)} | map_1(Fun, NextIter)];
          none ->
              []
      end.
  
  -spec size(Map) -> non_neg_integer() when
      Map :: map().
  