anchor.diff:          true ->
             syntax_quote_coll(Form, undefined, Env)
         end;
  -    IsLiteral -> Form;
  -    true      -> clj_core:list([QuoteSymbol, Form])
  +    IsLiteral -> {Form, Env};
  +    true      -> {clj_core:list([QuoteSymbol, Form]), Env}
     end.
   
   flatten_map(Map) ->
  
positive.code:   case clj_core:namespace(Symbol) of
      undefined ->
        case clj_env:find_var(Env, Symbol) of
          {undefined, _Env1} ->
            CurrentNsName = clj_core:name(CurrentNsSym),
            NameStr = clj_core:name(Symbol),
            clj_core:symbol(CurrentNsName, NameStr);
          {Var, _Env1} ->
            VarNsSym = 'clojerl.Var':namespace(Var),
            VarNameSym = 'clojerl.Var':name(Var),
            clj_core:symbol(clj_core:name(VarNsSym), clj_core:name(VarNameSym))
        end;
      NamespaceStr ->
        case clj_env:resolve_ns(Env, clj_core:symbol(NamespaceStr)) of
          undefined ->
            Symbol;
          Ns ->
            NsNameSym = clj_namespace:name(Ns),
            NsNameStr = clj_core:name(NsNameSym),
            NameStr = clj_core:name(Symbol),
            clj_core:symbol(NsNameStr, NameStr)
        end
    end.
  
  syntax_quote_coll(List, undefined, Env) ->
    syntax_quote_coll(List, Env);
  syntax_quote_coll(List, FunSymbol, Env) ->
    ExpandedList = syntax_quote_coll(List, Env),
    ApplySymbol = clj_core:symbol(<<"clojure.core">>, <<"apply">>),
    clj_core:list([ApplySymbol, FunSymbol, ExpandedList]).
  
  syntax_quote_coll(List, Env) ->
    case clj_core:'empty?'(List) of
      true ->
        ListSymbol = clj_core:symbol(<<"clojure.core">>, <<"list">>),
        clj_core:list([ListSymbol]);
      false ->
        ExpandedItems = lists:reverse(expand_list(List, Env, [])),
        ConcatSymbol = clj_core:symbol(<<"clojure.core">>, <<"concat">>),
        clj_core:list([ConcatSymbol | ExpandedItems])
    end.
  
  expand_list(undefined, _Env, Result) ->
    Result;
  expand_list(List, Env, Result) ->
    Item = clj_core:first(List),
    ListSymbol = clj_core:symbol(<<"clojure.core">>, <<"list">>),
    NewItem = case {is_unquote(Item), is_unquote_splicing(Item)} of
                {true, _} -> clj_core:list([ListSymbol, clj_core:second(Item)]);
                {_, true} -> clj_core:second(Item);
                _ -> clj_core:list([ListSymbol, syntax_quote(Item, Env)])
              end,
    expand_list(clj_core:next(List), Env, [NewItem | Result]).
  
  add_meta(Form, Env, Result) ->
    case clj_core:'meta?'(Form) of
      true ->
        WithMetaSym = clj_core:symbol(<<"clojure.core">>, <<"with-meta">>),
        Meta = syntax_quote(clj_core:meta(Form), Env),
        clj_core:list([WithMetaSym, Result, Meta]);
      _ ->
        Result
    end.
  
  is_unquote(Form) ->
  
negative.code:   erlang:put(gensym_env, #{}),
    %% TODO: change syntax_quote/2 so that if it changes the env
    %%       (because of find var) we keep the changes.
    {QuotedForm, Env1}      = syntax_quote(Form, Env),
    {NewFormWithMeta, Env2} = add_meta(Form, Env1, QuotedForm),
    erlang:erase(gensym_env),
    push_form(NewFormWithMeta, NewState#{env => Env2}).
  
  syntax_quote(Form, Env) ->
    IsSpecial    = clj_analyzer:is_special(Form),
  