anchor.diff:      exp_bq_append([list|X], exp_backquote(Y, 0));
   exp_backquote([['unquote-splicing'|X]|Y], 0) ->
       exp_bq_append(['++'|X], exp_backquote(Y, 0));
  -exp_backquote([X|Y], N) ->            %The general list case
  +exp_backquote([X|Y], N) ->                      %The general list case
       exp_bq_cons(exp_backquote(X, N), exp_backquote(Y, N));
   exp_backquote(X, N) when is_tuple(X) ->
  -    %% Straight [list_to_tuple,exp_backquote(tuple_to_list(X), N)] inefficient
  -    %% and [tuple|tl(exp_backquote(tuple_to_list(X), N))] can't handle splicing!
  +    %% Straight [list_to_tuple,exp_backquote(tuple_to_list(X), N)]
  +    %% inefficient and [tuple|tl(exp_backquote(tuple_to_list(X), N))]
  +    %% can't handle splicing!
       case exp_backquote(tuple_to_list(X), N) of
  -    [list|Es] -> [tuple|Es];        %No splicing
  -    [cons|_]=E -> [list_to_tuple,E]        %Have splicing
  -    end;
  +        [list|Es] -> [tuple|Es];                %No splicing
  +        [cons|_]=E -> [list_to_tuple,E]         %Have splicing
  +    end;
  +exp_backquote(X, N) when ?IS_MAP(X) ->
  +    %% Splicing at top-level meaningless here, with [list|...] we have
  +    %% no splicing, while with [cons|...] we have splicing
  +    [list|KVs] = exp_bq_map_pairs(maps:to_list(X), N),
  +    [map|KVs];
   exp_backquote(X, _) when is_atom(X) -> [quote,X];
  -exp_backquote(X, _) -> X.            %Self quoting
  -
  -exp_bq_append(['++',L], R) ->            %Catch single unquote-splice
  +exp_backquote(X, _) -> X.                       %Self quoting
  +
  +exp_bq_append(['++',L], R) ->                   %Catch single unquote-splice
       exp_bq_append(L, R);
   exp_bq_append([], R) -> R;
   exp_bq_append(L, []) -> L;
  
positive.code:     %% structure.
      {Eqs,St1} = exp_qlc_quals(Qs, Env, St0),
      {Ees,St2} = exp_list(Es, Env, St1),
      %%lfe_io:format("Q0 = ~p\n", [[lc,Eqs|Ees]]),
      %% Now translate to vanilla AST, call qlc expand and then convert
      %% back to LFE.  lfe_qlc:expand/2 wants a list of conversions not
      %% a conversion of a list.
      Vlc = lfe_trans:to_expr([lc,Eqs|Ees], 42),
      Vos = map(fun (O) -> lfe_trans:to_expr(O, 42) end, Opts),
      %% io:put_chars([erl_pp:expr(Vlc),"\n"]),
      {ok,Vexp} = lfe_qlc:expand(Vlc, Vos),
      %%io:put_chars([erl_pp:expr(Vexp),"\n"]),
      Exp = lfe_trans:from_expr(Vexp),
      %%lfe_io:format("Q1 = ~p\n", [Exp]),
      {yes,Exp,St2}.
  
  exp_qlc_quals(Qs, Env, St) ->
  
negative.code: exp_predef([Fun|As], _, St) when is_atom(Fun) ->
      case string:tokens(atom_to_list(Fun), ":") of
          [M,F] ->
              %% Can we make symbols of them?
              case {lfe_scan:string(M),lfe_scan:string(F)} of
                  {{ok,[{symbol,_,Mn}],_},{ok,[{symbol,_,Fn}],_}} ->
                      {yes,[call,?Q(Mn),?Q(Fn)|As],St};
                  _ -> no
              end;
          _ -> no                                 %This will also catch a:b:c
      end;
  %% This was not a call to a predefined macro.
  