Case-Lambda

The case-lambda form creates a procedure that dispatches to a particular body of expressions based on the number of arguments it receives. This provides a mechanism for creating variable-arity procedures with more control and efficiency than using a ``rest arg'' -- e.g., the x in (lambda (a . x) ...) -- with a lambda expression.

A case-lambda expression has the form:

  (case-lambda
    (formals expr   )
      )

  formals is one of:
     variable
     (variable   ) 
     (variable    . identifer) 

Each (formals expr ) clause of a case-lambda expression is analogous to a lambda expression of the form (lambda formals expr ). The scope of the variables in each clause's formals includes only the same clause's exprs. The formals variables are bound to actual arguments in an application in the same way that lambda variables are bound in an application.

When a case-lambda procedure is invoked, one clause is selected and its exprs are evaluated for the application; the result of the last expr in the clause is the result of the application. The clause that is selected for an application is the first one with a formals specification that can accommodate the number of arguments in the application.

For example:

  (define f
     (case-lambda
        [(x) x]
        [(x y) (+ x y)]
        [(a . any) a]))
  (f 1) ; => 1
  (f 1 2) ; => 3
  (f 4 5 6 7) ; => 4
  (f) ; raises exn:application:arity 

The result of a case-lambda expression is a regular procedure. Thus, the procedure? predicate returns #t when applied to the result of a case-lambda expression.