anchor.diff:  unfold_recenv(RecEnv) ->
     es_env:map(RecEnv,
   	     fun (_Var, {Formals, Body, Env}) ->
  -		 %% This takes the easy route of treating every lambda as variadic.
  -		 %% Wrong-arity calls are caught by bind_formals/3.
  -		 fun (Arg) ->
  -		     Actuals = get_varargs(Arg),
  +		 make_function(
  +		   Formals,
  +		   fun (Actuals) ->
   		     RecEnv2 = unfold_recenv(RecEnv),
   		     Env2 = es_env:overlay(Env, RecEnv2),
  -		     Env3 = bind_formals(Formals, Actuals, Env2),
  -		     interpret(Body, Env3)
  -		 end
  +		     interpret_lambda_body(Formals, Actuals, Body, Env2)
  +		   end)
   	     end).
   
   interpret_letrec_binding({Var, Formals, Body}, Env, RecEnv) ->
  
positive.code:   interpret(case interpret(Pred, Env) of false -> Else; _ -> Then end, Env).
  
  interpret_lambda(Formals, Body, Env) ->
    %% This takes the easy route of treating every lambda as variadic.
    %% Wrong-arity calls are caught by bind_formals/3.
    fun (Arg) ->
        Actuals = get_varargs(Arg),
        interpret(Body, bind_formals(Formals, Actuals, Env))
    end.
  
  bind_formals([], [], Env) ->
    Env;
  bind_formals([F|Fs], [A|As], Env) ->
    bind_formals(Fs, As, es_env:enter(Env, F, A));
  bind_formals(F, As, Env) when is_atom(F) -> % rest parameter
    es_env:enter(Env, F, As).
  
  interpret_let(Bindings, Body, Env) ->
    interpret(Body, es_env:overlay(Env, interpret_let_bindings(Bindings, Env))).
  
negative.code: 
  interpret_quote(Value) ->
    Value.
  