anchor.diff:                        F(Acc, K, V)
                 end, S, M).
   
  +forall(Pred, M) ->
  +    maps:fold(fun (K, V, true) ->
  +                      Pred(K, V);
  +                  (_K, _V, false) ->
  +                      false
  +              end, true, M).
  +
   isEmpty(#{}) -> true;
   isEmpty(_) -> false.
   
  
positive.code:          findKey/2,
           fold/3,
           % foldBack/3,
           % forall/2,
           isEmpty/1,
           % iter/2,
           map/2,
           % ofArray/1,
           % ofList/1,
           % ofSeq/1,
           % partition/3,
           % pick/2,
           remove/2,
           % toArray/1,
           toList/1,
           % toSeq/1,
           tryFind/2
           % tryFindKey/3,
           % tryPick/2
          ]).
  
  
  add(K, V, M) ->
      maps:put(K, V, M).
  
negative.code: toList(M) ->
      maps:to_list(M).
  
  toSeq(M) ->
      ?SEQ_MOD:seq(M).
  
  tryFind(K, M) ->
      maps:get(K, M, undefined).
  
  tryFindKey(K, M) ->
      maps:is_key(K, M).
  
  tryPick(Chooser, M) ->
      % TODO: optimise
      maps:fold(fun (K, V, undefined) ->
                        case Chooser(K, V) of
                            undefined -> undefined;
                            V -> V
                        end;
                    (_K, _V, Acc) -> Acc
                end, undefined, M).
  
  
  remove(K, M) ->
      maps:remove(K, M).
  
  -ifdef(TEST).
  -include_lib("eunit/include/eunit.hrl").
  
  ofSeq_test() ->
      Seq = ?SEQ_MOD:seq([{1,1}]),
      #{1 := 1} = ofSeq(Seq),
      ok.
  
  toSeq_test() ->
      [{1,1}] = ?SEQ_MOD:toList(toSeq(#{1 => 1})),
      ok.
  
  forall_test() ->
      Pred = fun (_, V) -> V < 5 end,
      true = forall(Pred, #{1 => 4}),
      false = forall(Pred, #{1 => 4, 2 => 5}),
      ok.
  
  
  -endif.
  