anchor.diff:  
   unfold_recenv(RecEnv) ->
     es_env:map(RecEnv,
  -	     fun(_Var, {Formals, Body, Env}) ->
  -		 fun(Actuals) ->
  +	     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),
   		     RecEnv2 = unfold_recenv(RecEnv),
   		     Env2 = es_env:overlay(Env, RecEnv2),
   		     Env3 = bind_formals(Formals, Actuals, Env2),
  
positive.code:   interpret(case interpret(Pred, Env) of false -> Else; _ -> Then end, Env).
  
  interpret_lambda(Formals, Body, Env) ->
    fun(Actuals) ->
        interpret(Body, bind_formals(Formals, Actuals, Env))
    end.
  
  interpret_let(Bindings, Body, Env) ->
    interpret(Body, es_env:overlay(Env, interpret_let_bindings(Bindings, Env))).
  
negative.code:   do_apply(interpret(Fun, Env), [interpret(Arg, Env) || Arg <- Args]).
  
  do_apply(FVal, Actuals) ->
    es_apply:applyN(FVal, Actuals).
  
  interpret_define(Var, Expr, Env) ->
    %% This is restricted, by macro-expansion and parsing, to the top-level.
  