anchor.diff:    TT = do_quote(maps:to_list(Map), Q, E),
     {'%{}', [], TT};
   
  -do_escape(List, Q, E) when is_list(List) ->
  +do_escape([], _, _) -> [];
  +
  +do_escape([H | T], #elixir_quote{unquote=false} = Q, E) ->
  +  do_quote_simple_list(T, do_quote(H, Q, E), Q, E);
  +
  +do_escape([H | T], Q, E) ->
     %% The improper case is inefficient, but improper lists are rare.
  -  try lists:reverse(List) of
  +  try lists:reverse(T, [H]) of
       L -> do_quote_tail(L, Q, E)
     catch
       _:_ ->
  -      {L, R} = reverse_improper(List, []),
  +      {L, R} = reverse_improper(T, [H]),
         TL = do_quote_splice(L, Q, E, [], []),
         TR = do_quote(R, Q, E),
         update_last(TL, fun(X) -> {'|', [], [X, TR]} end)
  
positive.code:   TLeft = do_quote(Left, Q, E),
    TRight = do_quote(Right, Q, E),
    {'{}', [], [TLeft, meta(Meta, Q), TRight]}.
  
  do_quote_tail([{'|', Meta, [{unquote_splicing, _, [Left]}, Right]} | T], #elixir_quote{unquote=true} = Q, E) ->
    %% Process the remaining entries on the list.
  
negative.code:   Annotated = annotate(Tuple, Q#elixir_quote.context),
    do_quote_tuple(Annotated, Q, E);
  
  do_quote([], _, _) ->
    [];
  
  do_quote([H | T], #elixir_quote{unquote=false} = Q, E) ->
    do_quote_simple_list(T, do_quote(H, Q, E), Q, E);
  
  do_quote([H | T], Q, E) ->
    do_quote_tail(lists:reverse(T, [H]), Q, E);
  
  do_quote(Other, _, _) ->
    Other.
  