anchor.diff:                                , clj_rt:to_list(TypeModule:keys(Y))
                                 ),
         Fun = fun({Key, Hash}) ->
  -                maps:is_key(Hash, Keys) andalso
  -                  clj_rt:equiv(maps:get(Hash, Vals), TypeModule:get(Y, Key))
  +                maps:is_key(Hash, Map) andalso
  +                  clj_rt:equiv( maps:get(Hash, Map)
  +                              , {Key, TypeModule:get(Y, Key)}
  +                              )
               end,
  -      maps:size(Keys) =:= TypeModule:count(Y)
  +      maps:size(Map) =:= TypeModule:count(Y)
           andalso lists:all(Fun, KeyHashPairs);
       false -> false
     end.
   
   %% clojerl.IErl
   
  -'->erl'(#{?TYPE := ?M, keys := Keys, vals := Vals}, Recursive) ->
  +'->erl'(#{?TYPE := ?M, map := Map}, Recursive) ->
     ErlMapFun = fun
  -                ({Hash, Key0}, MapAcc) when Recursive ->
  -                  Val0 = maps:get(Hash, Vals),
  +                ({Key0, Val0}, MapAcc) when Recursive ->
                     Key1 = clj_rt:'->erl'(Key0, Recursive),
                     Val1 = clj_rt:'->erl'(Val0, Recursive),
                     MapAcc#{Key1 => Val1};
  -                ({Hash, Key0}, MapAcc) ->
  -                  MapAcc#{Key0 => maps:get(Hash, Vals)}
  +                ({Key0, Val0}, MapAcc) ->
  +                  MapAcc#{Key0 => Val0}
                 end,
  -  lists:foldl(ErlMapFun, #{}, maps:to_list(Keys)).
  +  lists:foldl(ErlMapFun, #{}, maps:values(Map)).
   
   %% clojerl.IFn
   
   apply(#{?TYPE := ?M} = M, [Key]) ->
     apply(M, [Key, ?NIL]);
  -apply(#{?TYPE := ?M, vals := Vals}, [Key, NotFound]) ->
  -  Hash = clj_rt:hash(Key),
  -  maps:get(Hash, Vals, NotFound);
  +apply(#{?TYPE := ?M, map := Map}, [Key, NotFound]) ->
  +  Hash = clj_rt:hash(Key),
  +  {_, Val} = maps:get(Hash, Map, {Key, NotFound}),
  +  Val;
   apply(_, Args) ->
     CountBin = integer_to_binary(length(Args)),
     throw(<<"Wrong number of args for map, got: ", CountBin/binary>>).
   
   %% clojerl.IColl
   
  -cons(#{?TYPE := ?M} = Map, ?NIL) ->
  -  Map;
  -cons(#{?TYPE := ?M} = Map, X) ->
  +cons(#{?TYPE := ?M} = M, ?NIL) ->
  +  M;
  +cons(#{?TYPE := ?M} = M, X) ->
     IsVector = clj_rt:'vector?'(X),
     IsMap    = clj_rt:'map?'(X),
     case clj_rt:to_list(X) of
       [K, V] when IsVector ->
  -      assoc(Map, K, V);
  -    KVs when IsMap ->
  +      assoc(M, K, V);
  +    Map when IsMap ->
         Fun = fun(KV, Acc) ->
                   [K, V] = clj_rt:to_list(KV),
                   assoc(Acc, K, V)
               end,
  -      lists:foldl(Fun, Map, KVs);
  +      lists:foldl(Fun, M, Map);
       _ ->
         ?ERROR([ <<"Can't conj something that is not a key/value pair or "
                  "another map to a map, got: ">>
  
positive.code: -spec ?CONSTRUCTOR(list()) -> type().
  ?CONSTRUCTOR(KeyValues) when is_list(KeyValues) ->
    KeyValuePairs = build_key_values([], KeyValues),
    {Keys, Vals} = lists:foldl(fun build_mappings/2, {#{}, #{}}, KeyValuePairs),
    #{ ?TYPE => ?M
     , keys  => Keys
     , vals  => Vals
     , meta  => ?NIL
     };
  ?CONSTRUCTOR(KeyValues) ->
  
negative.code: 
  %% clojerl.IAssociative
  
  contains_key(#{?TYPE := ?M, map := Map}, Key) ->
    maps:is_key(clj_rt:hash(Key), Map).
  
  entry_at(#{?TYPE := ?M, map := Map}, Key) ->
    Hash = clj_rt:hash(Key),
    case maps:is_key(Hash, Map) of
      true ->
        {KeyFound, Val} = maps:get(Hash, Map),
        clj_rt:vector([KeyFound, Val]);
      false -> ?NIL
    end.
  
  assoc(#{?TYPE := ?M, map := Map} = M, Key, Value) ->
    Hash = clj_rt:hash(Key),
    {Key1, _} = maps:get(Hash, Map, {Key, Value}),
    M#{map => Map#{Hash => {Key1, Value}}}.
  
  %% clojerl.ICounted
  
  count(#{?TYPE := ?M, map := Map}) ->
    maps:size(Map).
  
  %% clojerl.IEquiv
  
  equiv( #{?TYPE := ?M, map := MapX}
       , #{?TYPE := ?M, map := MapY}
       ) ->
    'erlang.Map':equiv(MapX, MapY);
  equiv(#{?TYPE := ?M, map := Map}, Y) ->
    case clj_rt:'map?'(Y) of
      true  ->
        TypeModule   = clj_rt:type_module(Y),
  