anchor.diff:  
   %% clojerl.IAssociative
   
  -contains_key(#{?TYPE := ?M, keys := Keys}, Key) ->
  -  maps:is_key(clj_rt:hash(Key), Keys).
  -
  -entry_at(#{?TYPE := ?M, keys := Keys, vals := Vals}, Key) ->
  -  Hash = clj_rt:hash(Key),
  -  case maps:is_key(Hash, Keys) of
  +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 = maps:get(Hash, Keys),
  -      Val      = maps:get(Hash, Vals),
  +      {KeyFound, Val} = maps:get(Hash, Map),
         clj_rt:vector([KeyFound, Val]);
       false -> ?NIL
     end.
   
  -assoc(#{?TYPE := ?M, keys := Keys, vals := Vals} = M, Key, Value) ->
  -  Hash = clj_rt:hash(Key),
  -  Key1 = case maps:is_key(Hash, Keys) of
  -           false -> Key;
  -           true  -> maps:get(Hash, Keys)
  -         end,
  -  M#{keys => Keys#{Hash => Key1}, vals => Vals#{Hash => Value}}.
  +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, keys := Keys}) ->
  -  maps:size(Keys).
  +count(#{?TYPE := ?M, map := Map}) ->
  +  maps:size(Map).
   
   %% clojerl.IEquiv
   
  -equiv( #{?TYPE := ?M, keys := KeysX, vals := ValsX}
  -     , #{?TYPE := ?M, keys := KeysY, vals := ValsY}
  +equiv( #{?TYPE := ?M, map := MapX}
  +     , #{?TYPE := ?M, map := MapY}
        ) ->
  -  'erlang.Map':equiv(KeysX, KeysY) andalso 'erlang.Map':equiv(ValsX, ValsY);
  -equiv(#{?TYPE := ?M, keys := Keys, vals := Vals}, Y) ->
  +  'erlang.Map':equiv(MapX, MapY);
  +equiv(#{?TYPE := ?M, map := Map}, Y) ->
     case clj_rt:'map?'(Y) of
       true  ->
         TypeModule   = clj_rt:type_module(Y),
  
positive.code: get(#{?TYPE := ?M} = Map, Key) ->
    get(Map, Key, ?NIL).
  
  get(#{?TYPE := ?M, vals := Vals}, Key, NotFound) ->
    Hash = clj_rt:hash(Key),
    maps:get(Hash, Vals, NotFound).
  
  %% clojerl.IMap
  
  keys(#{?TYPE := ?M, keys := Keys}) ->
    maps:values(Keys).
  
  vals(#{?TYPE := ?M, vals := Vals}) ->
    maps:values(Vals).
  
  without(#{?TYPE := ?M, keys := Keys, vals := Vals} = M, Key) ->
    Hash = clj_rt:hash(Key),
    M#{ keys => maps:remove(Hash, Keys)
      , vals => maps:remove(Hash, Vals)
      }.
  
  %% clojerl.IMeta
  
  meta(#{?TYPE := ?M, meta := Meta}) -> Meta.
  
  with_meta(#{?TYPE := ?M} = Map, Metadata) ->
    Map#{meta => Metadata}.
  
  %% clojerl.ISeqable
  
  
negative.code:     X -> X
    end.
  
  to_list(#{?TYPE := ?M, map := Map}) ->
    FoldFun = fun(_Hash, {K, V}, List) ->
                  ['clojerl.Vector':?CONSTRUCTOR([K, V]) | List]
              end,
    maps:fold(FoldFun, [], Map).
  
  %% clojerl.IStringable
  
  str(#{?TYPE := ?M} = M) ->
    clj_rt:print(M).
  