anchor.diff:  %%  to a let. Might be useful in macros.
   
   comp_funcall([lambda,Las|Body]=F, As, Env, L, St) ->
  -    if length(Las) == length(As) ->        %Check right number of args
  -        %% Convert into a let. Would like to sequentialise eval of
  -        %% args here but leave that to let.
  -        Vbs = zipwith(fun (V, E) -> [V,E] end, Las, As),
  -        comp_let(Vbs, Body, Env, L, St);
  -       true ->                    %Catch arg mismatch at runtime
  -        comp_funcall_1(F, As, Env, L, St)
  +    if length(Las) == length(As) ->             %Check right number of args
  +            %% Convert into a let. Would like to sequentialise eval of
  +            %% args here but leave that to let.
  +            Vbs = zipwith(fun (V, E) -> [V,E] end, Las, As),
  +            comp_let(Vbs, Body, Env, L, St);
  +       true ->                                  %Catch arg mismatch at runtime
  +            comp_funcall_1(F, As, Env, L, St)
       end;
   comp_funcall(['match-lambda'|Cls]=F, As, Env, L, St0) ->
       case match_lambda_arity(Cls) == length(As) of
  -    true ->
  -        %% Expand comp_let as we need to special case body.
  -        {#c_fun{vars=Cvs,body=Cb},St1} = comp_match_lambda(Cls, Env, L, St0),
  -        {Ces,St2} = mapfoldl(fun (E, St) -> comp_expr(E, Env, L, St) end,
  -                 St1, As),
  -        {#c_let{anno=[L],
  -            vars=Cvs,
  -            arg=c_values(Ces),
  -            body=Cb},St2};
  -    false ->                %Catch arg mismatch at runtime
  -        comp_funcall_1(F, As, Env, L, St0)
  +        true ->
  +            %% Expand comp_let as we need to special case body.
  +            {Cf,St1} = comp_match_lambda(Cls, Env, L, St0),
  +            #c_fun{vars=Cvs,body=Cb} = Cf,
  +            Efun = fun (E, St) -> comp_expr(E, Env, L, St) end,
  +            {Ces,St2} = mapfoldl(Efun, St1, As),
  +            {c_let([L], Cvs, c_values(Ces), Cb),St2};
  +        false ->                %Catch arg mismatch at runtime
  +            comp_funcall_1(F, As, Env, L, St0)
       end;
   comp_funcall(F, As, Env, L, St0) ->
  -    comp_funcall_1(F, As, Env, L, St0).        %Naively just do it.
  +    comp_funcall_1(F, As, Env, L, St0).         %Naively just do it.
   
   comp_funcall_1(F, As, Env, L, St0) ->
  -    App = fun ([Cf|Cas], _, L, St) ->
  -                  Ann = line_file_anno(L, St),
  -                  {c_apply(Cf, Cas, Ann),St}
  +    App = fun ([Cf|Cas], _, Li, St) ->
  +                  Ann = line_file_anno(Li, St),
  +                  {c_apply(Ann, Cf, Cas),St}
             end,
       comp_args([F|As], App, Env, L, St0).
  -
  -%%     {[Cf|Cas],St1} = comp_args([F|As], Env, L, St0),
  -%%     {c_apply(Cf, Cas, [L]),St1}.
   
   %% comp_binary(Segs, Env, Line, State) -> {CbinaryExpr,State}.
   %% Compile a binary.
  
positive.code: %%          True = c_atom(true),
  %%          False = c_atom(false),
  %%          Omega = c_var(omega),
  %%          Ctrue = c_clause([True], True, Ctr, [L]),
  %%          Cfalse = c_clause([False], True, Cfa, [L]),
  %%          Cfail = c_clause([Omega], True, Omega,
  %%                           [L,compiler_generated]),
  %%          {c_case(Ctest, [Ctrue,Cfalse,Cfail], [L]),St}
  %%      end,
  %%     simple_seq([Cte], If, Env, L, St3).
  
  
negative.code:     Cv = c_var('Try'),
      Evs = [c_var('T'),c_var('R')],              %Why only two?
      False = c_atom(false),                      %Exception returns false
      {c_try([L], Ce, [Cv], Cv, Evs, False),St1}.
  
  %% comp_gtest(GuardTests, Env, Line, State) -> {CoreTest,State}.
  %%  Compile a guard test, making sure it returns a boolean value. We
  