4.5.1Function Shorthand🔗 i

The define form also supports a shorthand for function definitions:

(define (idarg...)body...+)

which is a shorthand for

(define id(lambda (arg... )body...+))

(define (greetfirst[surname"Smith"]#:hi[hisalutation])

(string-append hi", "first" "surname))

> (greet"John")

"Hi, John Smith"

> (greet"John"#:hi"Hey")

"Hey, John Smith"

> (greet"John""Doe")

"Hi, John Doe"

The function shorthand via define also supports a rest argument (i.e., a final argument to collect extra arguments in a list):

(define (idarg.... rest-id)body...+)

which is a shorthand

(define id(lambda (arg... . rest-id)body...+))

4.5.2Curried Function Shorthand🔗 i

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 ss2))))

Although it’s not common, the result of make-add-suffix could be called directly, like this:

> ((make-add-suffix"!")"hello")

"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-suffixs2)

(lambda (s)(string-append ss2)))

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 (headargs)body...+)

head = id

| (headargs)

args = arg...

| arg....rest-id

The expansion of this shorthand has one nested lambda form for each head in the definition, where the innermost head corresponds to the outermost lambda .

4.5.3Multiple Values and define-values 🔗 i

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 133)

4

> (remainder 133)

1

> (quotient/remainder 133)

4

1

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:

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.

A define form (that is not a function shorthand) is equivalent to a define-values form with a single id.

+Definitions: define, define-syntax, ... in The Racket Reference provides more on definitions.

4.5.4Internal Definitions🔗 i

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")

(f0))

(lambda (f);one definition

(define (log-itwhat)

(printf "~a\n"what))

(log-it"running")

(f0)

(log-it"done"))

(lambda (fn);two definitions

(define (calln)

(if (zero? n)

(log-it"done")

(begin

(log-it"running")

(fn)

(call(- n1)))))

(define (log-itwhat)

(printf "~a\n"what))

(calln))

Internal definitions in a particular body sequence are mutually recursive; that is, any definition can refer to any other definition—as long as the reference isn’t actually evaluated before its definition takes place. If a definition is referenced too early, an error occurs.

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).

+Internal Definitions in The Racket Reference documents the fine points of internal definitions.