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: 
  exp_append(Args) ->
      case Args of
  	%% Cases with quoted lists.
  	[?Q([A|As])|Es] -> [cons,?Q(A),['++',?Q(As)|Es]];
  	[?Q([])|Es] -> ['++'|Es];
  	%% Cases with explicit cons/list/list*.
  	[['list*',A]|Es] -> ['++',A|Es];
  	[['list*',A|As]|Es] -> [cons,A,['++',['list*'|As]|Es]];
  	[[list,A|As]|Es] -> [cons,A,['++',[list|As]|Es]];
  	[[list]|Es] -> ['++'|Es];
  	[[cons,H,T]|Es] -> [cons,H,['++',T|Es]];
  	[[]|Es] -> ['++'|Es];
  	%% Cases with lists of numbers (strings).
  	%% [[N|Ns]|Es] when is_number(N) -> [cons,N,['++',Ns|Es]];
  	%% Default cases with unquoted arg.
  	[E] -> E;                %Last arg not checked
  	[E|Es] -> exp_bif('++', [E,['++'|Es]]);
  	[] -> []
      end.
  
  %% exp_defun(Name, Def) -> Lambda | Match-Lambda.
  
negative.code: 
  exp_macro([Name|_]=Call, Env, St) ->
      case lfe_lib:is_core_form(Name) of
          true -> no;                             %Never expand core forms
          false ->
              case get_mbinding(Name, Env) of
                  {yes,Def} ->
                      %% User macro bindings.
                      exp_userdef_macro(Call, Def, Env, St);
                  no ->
                      %% Default macro bindings.
                      exp_predef_macro(Call, Env, St)
              end
      end.
  
  %% exp_userdef_macro(Call, Def, Env, State) -> {yes,Exp,State}.
  