anchor.diff:      Mdefs = map(fun ([Name|Rules]) -> exp_rules(Name, [], Rules) end, Defs),
       {yes,['let-macro',Mdefs|Body],St};
   exp_predef([prog1|Body], _, St0) ->
  +    %% We do a simple optimisation here.
  +    case Body of                                %Catch bad form here
  +        [Expr] -> {yes,Expr,St0};
  +        [First|Rest] ->
  +            {V,St1} = new_symb(St0),
  +            {yes,['let',[[V,First]]|Rest ++ [V]],St1}
  +    end;
  +exp_predef([prog2|Body], _, St) ->
       [First|Rest] = Body,                        %Catch bad form here
  -    {V,St1} = new_symb(St0),
  -    {yes,['let',[[V,First]]|Rest ++ [V]],St1};
  -exp_predef([prog2|Body], _, St0) ->
  -    [First,Second|Rest] = Body,                 %Catch bad form here
  -    {V,St1} = new_symb(St0),
  -    {yes,['let',[[V,[progn,First,Second]]]|Rest ++ [V]],St1};
  +    {yes,[progn,First,[prog1|Rest]],St};
   %% This has to go here for the time being so as to be able to macro
   %% expand body.
   exp_predef(['match-spec'|Body], Env, St0) ->
  
positive.code: %% Errors
  format_error({bad_form,Type}) ->
      lfe_io:format1("bad form: ~w", [Type]);
  format_error({expand_macro,Call,_}) ->
      %% Can be very big so only print limited depth.
      lfe_io:format1("error expanding ~P", [Call,10]).
  
negative.code: %%         {Fs1,Fbs1,Env1,St2} = pass_ewc(Fs0, Fbs0, Env0, St1),
  %%         {[F|Fs1],Fbs1,Env1,St2}
  %%     end;
  pass_ewc([['define-function',Name,Def]|Fs0], Fbs0, Env0, St0) ->
      case func_arity(Def) of
          {yes,Ar} ->                             %Definition not too bad
              Fb = {Name,Ar,Def},
              %% Env1 = lfe_eval:add_expr_func(Name, Ar, Def, Env0),
              pass_ewc(Fs0, [Fb|Fbs0], Env0, St0);
          no ->                                   %Definition really bad
              St1 = add_error({bad_env_form,function}, St0),
              pass_ewc(Fs0, Fbs0, Env0, St1)
      end;
  pass_ewc([F|Fs0], Fbs0, Env0, St0) ->
      %% First expand enough to test top form, if so process again.
  