anchor.diff:  from_expr({float,_,F}) -> F;
   from_expr({atom,_,A}) -> ?Q(A);			%Must quote here
   from_expr({string,_,S}) -> ?Q(S);		%Must quote here
  -from_expr({cons,_,H,T}) ->
  -    [cons,from_expr(H),from_expr(T)];
  +from_expr({cons,_,H0,T0}) ->
  +    H = from_expr(H0),
  +    case from_expr(T0) of			%Make it more elegant
  +	[list|T] -> [list,H|T];
  +	[] -> [list,H];
  +	T -> [cons,H,T]
  +    end;
   from_expr({tuple,_,Es}) ->
       [tuple|from_expr_list(Es)];
   from_expr({bin,_,Segs}) ->
  
positive.code: from_pat_list(Ps) -> [ from_pat(P) || P <- Ps ].
  
  %% to_vanilla(Sexp, LineNumber) -> AST.
  
  to_vanilla(S, L) ->
      %% Be very LOUD for the time being.
      case catch {ok,to_expr(S, L)} of
  	{ok,AST} -> AST;
  	Other ->
  	    io:format("BOOM: ~p\n", [Other]),
  	    error(Other)
      end.
  
  %% to_expr(Expr, LineNumber) -> Expr.
  
  to_expr([], L) -> {nil,L};
  to_expr(I, L) when is_integer(I) -> {integer,L,I};
  to_expr(F, L) when is_float(F) -> {float,L,F};
  to_expr(V, L) when is_atom(V) -> {var,L,V};	%Unquoted atom
  to_expr(T, L) when is_tuple(T) ->
      {tuple,L,to_expr_list(tuple_to_list(T), L)};
  to_expr(?Q(V), L) -> to_lit(V, L);
  to_expr([cons,H,T], L) ->
      {cons,L,to_expr(H, L),to_expr(T, L)};
  to_expr([car,E], L) -> {call,L,{atom,L,hd},[to_expr(E, L)]};
  to_expr([cdr,E], L) -> {call,L,{atom,L,tl},[to_expr(E, L)]};
  to_expr([list|Es], L) ->
      foldr(fun (E, T) -> {cons,L,to_expr(E, L),T} end, {nil,L}, Es);
  to_expr(['list*'|Es], L) ->			%Macro
      to_list_s(Es, L, fun to_expr/2);
  to_expr([tuple|Es], L) ->
      {tuple,L,to_expr_list(Es, L)};
  to_expr([binary|Segs], L) ->
      {bin,L,to_bitsegs(Segs, L)};
  %% Core closure special forms.
  to_expr([lambda,As|B], L) ->
      {'fun',L,{clauses,[to_fun_cl([As|B], L)]}};
  to_expr(['match-lambda'|Cls], L) ->
      {'fun',L,{clauses,to_fun_cls(Cls, L)}};
  to_expr(['fun',F,A], L) -> {'fun',L,{function,F,A}};
  to_expr(['fun',M,F,A], L) -> {'fun',L,{function,M,F,A}};
  to_expr(['let',Lbs0|B0], L) ->
      Lbs1 = to_let_bindings(Lbs0, L),
      B1 = to_body(B0, L),
      {block,L,Lbs1 ++ B1};
  %% Core control special forms.
  to_expr([progn|B], L) -> to_block(B, L);
  to_expr(['if',Test,True], L) ->
      to_expr(['if',Test,True,?Q(false)], L);
  to_expr(['if',Test,True,False], L) ->
      {'case',L,to_expr(Test, L),
       to_icrt_cls([[?Q(true),True],[?Q(false),False]], L)};
  to_expr(['case',E|Cls], L) ->
      {'case',L,to_expr(E, L),to_icrt_cls(Cls, L)};
  to_expr(['receive'|Cls0], L) ->
      %% Get the right receive form depending on whether there is an after.
      {Cls1,A} = splitwith(fun (['after'|_]) -> false; (_) -> true end, Cls0),
      case A of
  	[['after',T|B]] ->
  	    {'receive',L,to_icrt_cls(Cls1, L),to_expr(T, L),to_body(B, L)};
  	[] ->
  	    {'receive',L,to_icrt_cls(Cls1, L)}
      end;
  %% Special known macros.
  %% No record stuff here as they are macros which have been expanded.
  to_expr([lc,Qs0|Es], L) ->
      Qs1 = to_lc_quals(Qs0, L),
      {lc,L,to_block(Es, L),Qs1};
  %% General function calls.
  to_expr([call,?Q(erlang),?Q(F)|As], L) ->
      %% This is semantically the same but some tools behave differently
      %% (qlc_pt).
      case is_erl_op(F, length(As)) of
  	true -> list_to_tuple([op,L,F|to_expr_list(As, L)]);
  	false ->
  	    {call,L,{remote,{atom,L,erlang},{atom,L,F}},to_expr_list(As, L)}
      end;
  to_expr([call,M,F|As], L) ->
      {call,L,{remote,L,to_expr(M, L),to_expr(F, L)},to_expr_list(As, L)};
  to_expr([F|As], L) when is_atom(F) ->		%General function call
      case is_erl_op(F, length(As)) of
  	true -> list_to_tuple([op,L,F|to_expr_list(As, L)]);
  	false -> {call,L,{atom,L,F},to_expr_list(As, L)}
      end;
  to_expr(List, L) ->
      case is_integer_list(List) of
  	true -> {string,L,List};
  	false ->
  
negative.code: 
  -export([from_vanilla/1,to_vanilla/2]).
  
  -import(lists, [map/2,foldl/3,foldr/3,mapfoldl/3,mapfoldr/3,splitwith/2]).
  
  -import(orddict, [new/0,find/2,store/3]).
  
  -define(Q(E), [quote,E]).			%We do a lot of quoting
  
  