4.5 Definitions: define
A basic definition has the form
(define id expr)
in which case id is bound to the result of expr.
The define form also supports a shorthand for function definitions:
(define (id arg ...) body ...+)
which is a shorthand for
(define (greet first [surname "Smith"] #:hi [hi salutation]) (string-append hi ", " first " " surname))
> (greet "John")
"Hi, John Smith"
> (greet "John" #:hi "Hey")
"Hey, John Smith"
> (greet "John" "Doe")
"Hi, John Doe"
(define (id arg ... . rest-id) body ...+)
which is a shorthand
Consider the following make-add-suffix function that takes a string and returns another function that takes a string:
(define make-add-suffix (lambda (s2) (lambda (s) (string-append s s2))))
Although it’s not common, result of make-add-suffix could be called directly, like this:
> ((make-add-suffix "!") "hello")
In a sense, make-add-suffix is a function that takes two arguments, but it takes them one at a time. A function that takes some of its arguments and returns a function to consume more is sometimes called a curried function.
Using the function-shorthand form of define, make-add-suffix can be written equivalently as
(define (make-add-suffix s2) (lambda (s) (string-append s s2)))
This shorthand reflects the shape of the function call (make-add-suffix "!"). The define form further supports a shorthand for defining curried functions that reflects nested function calls:
The full syntax of the function shorthand for define is as follows:
(define (head args) body ...+)
head = id | (head args) args = arg ... | arg ... . rest-id
4.5.3 Multiple Values and define-values
A Racket expression normally produces a single result, but some expressions can produce multiple results. For example, quotient and remainder each produce a single value, but quotient/remainder produces the same two values at once:
> (quotient 13 3)
> (remainder 13 3)
> (quotient/remainder 13 3)
As shown above, the REPL prints each result value on its own line.
Multiple-valued functions can be implemented in terms of the values function, which takes any number of values and returns them as the results:
> (values 1 2 3)
The define-values form binds multiple identifiers at once to multiple results produced from a single expression:
(define-values (id ...) expr)
The number of results produced by the expr must match the number of ids.
(define-values (given surname) (split-name "Adam Smith")) > given
When the grammar for a syntactic form specifies body, then the corresponding form can be either a definition or an expression. A definition as a body is an internal definition.
Expressions and internal definitions in a body sequence can be mixed, as long as the last body is an expression.
For example, the syntax of lambda is
(lambda gen-formals body ...+)
so the following are valid instances of the grammar:
(lambda (f) ; no definitions (printf "running\n") (f 0)) (lambda (f) ; one definition (define (log-it what) (printf "~a\n" what)) (log-it "running") (f 0) (log-it "done")) (lambda (f n) ; two definitions (define (call n) (if (zero? n) (log-it "done") (begin (log-it "running") (f n) (call (- n 1))))) (define (log-it what) (printf "~a\n" what)) (call n))
Internal definitions in a particular body sequence are
mutually recursive; that is, any definition can refer to any other
A sequence of internal definitions using just define is easily translated to an equivalent letrec form (as introduced in the next section). However, other definition forms can appear as a body, including define-values, struct (see Programmer-Defined Datatypes) or define-syntax (see Macros).