# Functions \(Procedures\): `lambda` A `lambda` expression creates a function. In the simplest case, a `lambda` expression has the form ```racket (lambda (arg-id ...) body ...+) ``` A `lambda` form with _n_ `arg-id`s accepts _n_ arguments: ```racket > ((lambda (x) x) 1) 1 > ((lambda (x y) (+ x y)) 1 2) 3 > ((lambda (x y) (+ x y)) 1) #: arity mismatch; the expected number of arguments does not match the given number expected: 2 given: 1 arguments...: 1 ``` ## 1. Declaring a Rest Argument A `lambda` expression can also have the form ```racket (lambda rest-id body ...+) ``` That is, a `lambda` expression can have a single `rest-id` that is not surrounded by parentheses. The resulting function accepts any number of arguments, and the arguments are put into a list bound to `rest-id`. Examples: ```racket > ((lambda x x) 1 2 3) '(1 2 3) > ((lambda x x)) '() > ((lambda x (car x)) 1 2 3) 1 ``` Functions with a `rest-id` often use `apply` to call another function that accepts any number of arguments. > +\[missing\] describes `apply`. Examples: ```racket (define max-mag (lambda nums (apply max (map magnitude nums)))) > (max 1 -2 0) 1 > (max-mag 1 -2 0) 2 ``` The `lambda` form also supports required arguments combined with a `rest-id`: ```racket (lambda (arg-id ...+ . rest-id) body ...+) ``` The result of this form is a function that requires at least as many arguments as `arg-id`s, and also accepts any number of additional arguments. Examples: ```racket (define max-mag (lambda (num . nums) (apply max (map magnitude (cons num nums))))) > (max-mag 1 -2 0) 2 > (max-mag) max-mag: arity mismatch; the expected number of arguments does not match the given number expected: at least 1 given: 0 ``` A `rest-id` variable is sometimes called a _rest argument_, because it accepts the “rest” of the function arguments. ## 2. Declaring Optional Arguments Instead of just an identifier, an argument \(other than a rest argument\) in a `lambda` form can be specified with an identifier and a default value: ```racket (lambda gen-formals body ...+) gen-formals = (arg ...) | rest-id | (arg ...+ . rest-id) arg = arg-id | [arg-id default-expr] ``` An argument of the form `[arg-id default-expr]` is optional. When the argument is not supplied in an application, `default-expr` produces the default value. The `default-expr` can refer to any preceding `arg-id`, and every following `arg-id` must have a default as well. Examples: ```racket (define greet (lambda (given [surname "Smith"]) (string-append "Hello, " given " " surname))) > (greet "John") "Hello, John Smith" > (greet "John" "Doe") "Hello, John Doe" ``` ```racket (define greet (lambda (given [surname (if (equal? given "John") "Doe" "Smith")]) (string-append "Hello, " given " " surname))) ``` ```racket > (greet "John") "Hello, John Doe" > (greet "Adam") "Hello, Adam Smith" ``` ## 3. Declaring Keyword Arguments A `lambda` form can declare an argument to be passed by keyword, instead of position. Keyword arguments can be mixed with by-position arguments, and default-value expressions can be supplied for either kind of argument: > +\[missing\] introduces function calls with keywords. ```racket (lambda gen-formals body ...+) gen-formals = (arg ...) | rest-id | (arg ...+ . rest-id) arg = arg-id | [arg-id default-expr] | arg-keyword arg-id | arg-keyword [arg-id default-expr] ``` An argument specified as `arg-keyword arg-id` is supplied by an application using the same `arg-keyword`. The position of the keyword–identifier pair in the argument list does not matter for matching with arguments in an application, because it will be matched to an argument value by keyword instead of by position. ```racket (define greet (lambda (given #:last surname) (string-append "Hello, " given " " surname))) ``` ```racket > (greet "John" #:last "Smith") "Hello, John Smith" > (greet #:last "Doe" "John") "Hello, John Doe" ``` An `arg-keyword [arg-id default-expr]` argument specifies a keyword-based argument with a default value. Examples: ```racket (define greet (lambda (#:hi [hi "Hello"] given #:last [surname "Smith"]) (string-append hi ", " given " " surname))) > (greet "John") "Hello, John Smith" > (greet "Karl" #:last "Marx") "Hello, Karl Marx" > (greet "John" #:hi "Howdy") "Howdy, John Smith" > (greet "Karl" #:last "Marx" #:hi "Guten Tag") "Guten Tag, Karl Marx" ``` The `lambda` form does not directly support the creation of a function that accepts “rest” keywords. To construct a function that accepts all keyword arguments, use `make-keyword-procedure`. The function supplied to `make-keyword-procedure` receives keyword arguments through parallel lists in the first two \(by-position\) arguments, and then all by-position arguments from an application as the remaining by-position arguments. > +\[missing\] introduces `keyword-apply`. Examples: ```racket (define (trace-wrap f) (make-keyword-procedure (lambda (kws kw-args . rest) (printf "Called with ~s ~s ~s\n" kws kw-args rest) (keyword-apply f kws kw-args rest)))) > ((trace-wrap greet) "John" #:hi "Howdy") Called with (#:hi) ("Howdy") ("John") "Howdy, John Smith" ``` > +\[missing\] in \[missing\] provides more on function expressions. ## 4. Arity-Sensitive Functions: `case-lambda` The `case-lambda` form creates a function that can have completely different behaviors depending on the number of arguments that are supplied. A case-lambda expression has the form ```racket (case-lambda [formals body ...+] ...) formals = (arg-id ...) | rest-id | (arg-id ...+ . rest-id) ``` where each `[formals body ...+]` is analogous to `(lambda formals body ...+)`. Applying a function produced by `case-lambda` is like applying a `lambda` for the first case that matches the number of given arguments. Examples: ```racket (define greet (case-lambda [(name) (string-append "Hello, " name)] [(given surname) (string-append "Hello, " given " " surname)])) > (greet "John") "Hello, John" > (greet "John" "Smith") "Hello, John Smith" > (greet) greet: arity mismatch; the expected number of arguments does not match the given number given: 0 ``` A `case-lambda` function cannot directly support optional or keyword arguments.