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:
formals is one of:
variable
(variable (case-lambda
(formals expr
)
)
)
(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.