anchor.diff:  
   get(#{?TYPE := ?M, map := Map}, Key, NotFound) ->
     Hash = clj_rt:hash(Key),
  -  {_, Val} = maps:get(Hash, Map, {Key, NotFound}),
  -  Val.
  +  case get_entry(Map, Hash, Key) of
  +    ?NIL -> NotFound;
  +    {_, Val} -> Val
  +  end.
   
   %% clojerl.IMap
   
   keys(#{?TYPE := ?M, map := Map}) ->
  -  [K || {K, _} <- maps:values(Map)].
  +  maps:fold(fun keys_fold/3, [], Map).
  +
  +keys_fold(_, {K, _}, Keys) ->
  +  [K | Keys];
  +keys_fold(_, KVs, Keys) ->
  +  [K || {K, _} <- KVs] ++ Keys.
   
   vals(#{?TYPE := ?M, map := Map}) ->
  -  [V || {_, V} <- maps:values(Map)].
  +  maps:fold(fun vals_fold/3, [], Map).
  +
  +vals_fold(_, {_, V}, Vals) ->
  +  [V | Vals];
  +vals_fold(_, KVs, Vals) ->
  +  [V || {_, V} <- KVs] ++ Vals.
   
   without(#{?TYPE := ?M, map := Map} = M, Key) ->
     Hash = clj_rt:hash(Key),
  -  M#{map => maps:remove(Hash, Map)}.
  +  M#{map => without_entry(Map, Hash, Key)}.
   
   %% clojerl.IMeta
   
  
positive.code: -type mappings() :: {map(), map()}.
  
  -type type() :: #{ ?TYPE => ?M
                   , keys  => map()
                   , vals  => map()
                   , meta  => ?NIL | any()
                   }.
  
  
negative.code: 
  '->erl'(#{?TYPE := ?M, map := Map}, Recursive) ->
    ErlMapFun = fun
                  (_, {Key0, Val0}, MapAcc) when Recursive ->
                    Key1 = clj_rt:'->erl'(Key0, Recursive),
                    Val1 = clj_rt:'->erl'(Val0, Recursive),
                    MapAcc#{Key1 => Val1};
                  (_, {Key0, Val0}, MapAcc) ->
                    MapAcc#{Key0 => Val0};
                  (_, KVs0, MapAcc) when Recursive ->
                    KVs1 = [ { clj_rt:'->erl'(K, Recursive)
                             , clj_rt:'->erl'(V, Recursive)
                             }
                             || {K, V} <- KVs0
                           ],
                    maps:merge(MapAcc, maps:from_list(KVs1));
                  (_, KVs, MapAcc) when Recursive ->
                    maps:merge(MapAcc, maps:from_list(KVs))
                end,
    maps:fold(ErlMapFun, #{}, Map).
  
  %% clojerl.IFn
  
  