anchor.diff:  eval_expr(['map-update',M|As], Env) ->
       eval_expr([mupd,M|As], Env);
   %% Handle the Core closure special forms.
  -eval_expr([lambda|Body], Env) ->
  -    eval_lambda(Body, Env);
  -eval_expr(['match-lambda'|Cls], Env) ->
  -    eval_match_lambda(Cls, Env);
  +eval_expr([lambda|_]=Sexpr, Env) ->
  +    eval_lambda_expr(Sexpr, Env);
  +eval_expr(['match-lambda'|_]=Sexpr, Env) ->
  +    eval_lambda_expr(Sexpr, Env);
   eval_expr(['let'|Body], Env) ->
       eval_let(Body, Env);
   eval_expr(['let-function'|Body], Env) ->
  
positive.code: map_key(_, _) -> eval_error(illegal_mapkey).
  -endif.
  
  %% eval_lambda(LambdaBody, Env) -> Val.
  %%  Evaluate (lambda args ...).
  
  eval_lambda([Args|Body], Env) ->
      %% This is a really ugly hack! But it's the same hack as in erl_eval.
      case length(Args) of
          0 -> fun () -> apply_lambda([], Body, [], Env) end;
          1 -> fun (A) -> apply_lambda(Args, Body, [A], Env) end;
          2 -> fun (A,B) -> apply_lambda(Args, Body, [A,B], Env) end;
          3 -> fun (A,B,C) -> apply_lambda(Args, Body, [A,B,C], Env) end;
          4 -> fun (A,B,C,D) -> apply_lambda(Args, Body, [A,B,C,D], Env) end;
          5 -> fun (A,B,C,D,E) -> apply_lambda(Args, Body, [A,B,C,D,E], Env) end;
          6 -> fun (A,B,C,D,E,F) ->
                       apply_lambda(Args, Body, [A,B,C,D,E,F], Env) end;
          7 -> fun (A,B,C,D,E,F,G) ->
                       apply_lambda(Args, Body, [A,B,C,D,E,F,G], Env) end;
          8 -> fun (A,B,C,D,E,F,G,H) ->
                       apply_lambda(Args, Body, [A,B,C,D,E,F,G,H], Env) end;
          9 -> fun (A,B,C,D,E,F,G,H,I) ->
                       apply_lambda(Args, Body, [A,B,C,D,E,F,G,H,I], Env) end;
          10 -> fun (A,B,C,D,E,F,G,H,I,J) ->
                        apply_lambda(Args, Body, [A,B,C,D,E,F,G,H,I,J], Env) end;
          11 -> fun (A,B,C,D,E,F,G,H,I,J,K) ->
                        apply_lambda(Args, Body,
                                     [A,B,C,D,E,F,G,H,I,J,K], Env) end;
          12 -> fun (A,B,C,D,E,F,G,H,I,J,K,L) ->
                        apply_lambda(Args, Body,
                                     [A,B,C,D,E,F,G,H,I,J,K,L], Env) end;
          13 -> fun (A,B,C,D,E,F,G,H,I,J,K,L,M) ->
                        apply_lambda(Args, Body,
                                     [A,B,C,D,E,F,G,H,I,J,K,L,M], Env) end;
          14 -> fun (A,B,C,D,E,F,G,H,I,J,K,L,M,N) ->
                        apply_lambda(Args, Body,
                                     [A,B,C,D,E,F,G,H,I,J,K,L,M,N], Env) end;
          15 -> fun (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) ->
                        apply_lambda(Args, Body,
                                     [A,B,C,D,E,F,G,H,I,J,K,L,M,N,O], Env) end
      end.
  
  apply_lambda(Args, Body, Vals, Env0) ->
  
negative.code: bind_args([A|As], [E|Es], Env) when is_atom(A) ->
      bind_args(As, Es, add_vbinding(A, E, Env));
  bind_args([], [], Env) -> Env.
  
  match_lambda_arity([[Pats|_]|_]) -> length(Pats).
  
  