anchor.diff:      Exp = exp_prefix(Abody),
       {yes,Exp,St};
   exp_predef(['?'|As], _, St) ->
  +    Omega = [omega,omega],
       Exp = case As of
  -              [To,Def] -> ['receive',['omega','omega'],['after',To,Def]];
  -              [To] -> ['?',To,[exit,?Q(timeout)]];
  -              [] -> ['receive',['omega','omega']]
  +              [To,Def] -> ['receive',Omega,['after',To,Def]];
  +              [To] -> ['receive',Omega,['after',To,[exit,?Q(timeout)]]];
  +              [] -> ['receive',Omega]
             end,
       {yes,Exp, St};
   exp_predef(['list*'|As], _, St) ->
  -    Exp = case As of
  -              [E] -> E;
  -              [E|Es] -> [cons,E,['list*'|Es]];
  -              [] -> []
  -          end,
  +    Exp = exp_list_star(As),
       {yes,Exp,St};
   exp_predef(['let*'|Lbody], _, St) ->
  -    Exp = case Lbody of
  -              [[Vb|Vbs]|B] -> ['let',[Vb],['let*',Vbs|B]];
  -              [[]|B] -> ['progn'|B];
  -              [Vb|B] -> ['let',Vb|B]            %Pass error to let for lint.
  -          end,
  +    Exp = exp_let_star(Lbody),
       {yes,Exp,St};
   exp_predef(['flet*'|Lbody], _, St) ->
  -    Exp = case Lbody of
  -              [[Fb|Fbs]|B] -> ['flet',[Fb],['flet*',Fbs|B]];
  -              [[]|B] -> ['progn'|B];
  -              [Fb|B] -> ['flet',Fb|B]           %Pass error to flet for lint.
  -          end,
  +    Exp = exp_flet_star(Lbody),
       {yes,Exp,St};
   exp_predef(['cond'|Cbody], _, St) ->
  -    Exp = case Cbody of
  -              [['else'|B]] -> ['progn'|B];
  -              [[['?=',P,E]|B]|Cond] ->
  -                  ['case',E,[P|B],['_',['cond'|Cond]]];
  -              [[['?=',P,['when'|_]=G,E]|B]|Cond] ->
  -                  ['case',E,[P,G|B],['_',['cond'|Cond]]];
  -              [[Test|B]|Cond] ->
  -                  ['if',Test,['progn'|B],['cond'|Cond]];
  -              [] -> ?Q(false)
  -          end,
  +    Exp = exp_cond(Cbody),
       {yes,Exp,St};
   exp_predef(['do'|Dbody], _, St0) ->
       %% (do ((v i c) ...) (test val) . body) but of limited use as it
  
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.
  
  
negative.code: exp_prefix([[N|Ns]|Es]) when is_number(N) -> [cons,N,['++*',Ns|Es]];
  exp_prefix([[]|Es]) -> ['++*'|Es];
  exp_prefix(Args) -> exp_append(Args).
  
  %% exp_list_star(ListBody) -> Cons.
  
  exp_list_star([E]) -> E;
  exp_list_star([E|Es]) ->
      [cons,E,exp_list_star(Es)];
  exp_list_star([]) -> [].
  
  %% exp_let_star(FletBody) -> Flets.
  
  exp_let_star([[Vb|Vbs]|B]) ->
      ['let',[Vb],exp_let_star([Vbs|B])];
  exp_let_star([[]|B]) -> [progn|B];
  exp_let_star([Vb|B]) -> ['let',Vb|B].           %Pass error to let for lint.
  
  %% exp_flet_star(FletBody) -> Flets.
  
  exp_flet_star([[Fb|Fbs]|B]) ->
      [flet,[Fb],exp_flet_star([Fbs|B])];
  exp_flet_star([[]|B]) -> [progn|B];
  exp_flet_star([Fb|B]) -> [flet,Fb|B].           %Pass error to flet for lint
  
  %% exp_cond(CondBody) -> Tests.
  %%  Expand a cond body to a sequence of if/case tests.
  
  exp_cond([['else'|B]]) -> [progn|B];
  exp_cond([[['?=',P,E]|B]|Cond]) ->
      ['case',E,[P|B],['_',exp_cond(Cond)]];
  exp_cond([[['?=',P,['when'|_]=G,E]|B]|Cond]) ->
      ['case',E,[P,G|B],['_',exp_cond(Cond)]];
  exp_cond([[Test|B]|Cond]) ->                    %Test and body
      ['if',Test,[progn|B],exp_cond(Cond)];
  exp_cond([Test|Cond]) ->                        %Naked test
      ['if',Test,?Q(true),exp_cond(Cond)];
  exp_cond([]) -> ?Q(false).
  
  %% exp_andalso(AndAlsoBody) -> Ifs.
  %% exp_orelse(OrElseBody) -> Ifs.
  
  exp_andalso([E]) -> E;                          %Let user check last call
  exp_andalso([E|Es]) ->
      ['if',E,exp_andalso(Es),?Q(false)];
  exp_andalso([]) -> ?Q(true).
  
  exp_orelse([E]) -> E;                           %Let user check last call
  exp_orelse([E|Es]) -> ['if',E,?Q(true),exp_orelse(Es)];
  exp_orelse([]) -> ?Q(false).
  
  %% exp_defun(Name, Def) -> Lambda | Match-Lambda.
  %%  Educated guess whether traditional (defun name (a1 a2 ...) ...)
  