12 Level-0 Defining, Special and Function-call Forms

Arguments

identifier :: A symbol naming an immutable top-lexical binding to be initialized with the value of form.
form :: The form whose value will be stored in the binding of identifier.

Remarks

The value of form is stored in the top-lexical binding of identifier. It is a violation to attempt to modify the binding of a defined constant.

12.1.3 t <symbol>

constant

Remarks

This may be used to denote the abstract boolean value true, but so may any other value than ().

12.1.4 symbol

syntax

The current lexical binding of symbol is returned. A symbol can also name a defined constant—that is, an immutable top-lexical binding.

12.1.5 deflocal

defining operator

12.1.5.1 Syntax

deflocal-form: → <object>

( deflocal local-name form )

local-name:

Arguments

identifier :: A symbol naming a binding containing the value of form.
form :: The form whose value will be stored in the binding of identifier.

Remarks

The value of form is stored in the top-lexical binding of identifier. The binding created by a deflocal form is mutable.

12.1.6.1 Syntax

quote-form: → object

( quote object )

’object

Arguments

object :: the object to be quoted.

Result

The result is object.

Remarks

The result of processing the expression (quote object) is object. The object can be any object having an external representation . The special form quote can be abbreviated using apostrophe — graphic representation ’ — so that (quote a) can be written ’a. These two notations are used to incorporate literal constants in programs. It is an error to modify a literal expression .

12.1.7 ’

syntax

Remarks

See quote.

12.2 Functions: creation, definition and application

12.2.1 lambda

special operator

12.2.1.1 Syntax

lambda-form: → <function>

( lambda lambda-list body )

lambda-list:

simple-list

rest-list

simple-list:

( identifier* )

rest-list:

( identifier* . identifier )

body:

form*

Arguments

lambda-list :: The parameter list of the function conforming to the syntax 12.2.1.1.
form :: An expression.

Result

A function with the specified lambda-list and sequence of forms.

Remarks

The function construction operator is lambda. Access to the lexical environment of definition is guaranteed. The syntax of lambda-list is defined in reflambda-syntax-table.

If lambda-list is an identifier, it is bound to a newly allocated list of the actual parameters. This binding has lexical scope and indefinite extent. If lambda-list is a simple-list, the arguments are bound to the corresponding identifier. Otherwise, lambda-list must be a rest-list. In this case, each identifier preceding the dot is bound to the corresponding argument and the identifier succeeding the dot is bound to a newly allocated list whose elements are the remaining arguments. These bindings have lexical scope and indefinite extent. It is a violation if the same identifier appears more than once in a lambda-list. It is an error to modify rest-list.

12.2.2 defsyntax

defining operator

12.2.2.1 Syntax

defsyntax-form: → <function>

( defsyntax syntax-operator-name lambda-list body )

syntax-operator-name:

Arguments

syntax-operator-name :: A symbol naming an immutable top-lexical binding to be initialized with a function having the specified lambda-list and body.
lambda-list :: The parameter list of the function conforming to the syntax specified under lambda.
body :: A sequence of forms.

Remarks

The defsyntax form defines a syntax operator named by syntax-operator-name and stores the definition as the top-lexical binding of syntax-operator-name . The interpretation of the lambda-list is as defined for lambda (see 12.2.1.1).

NOTE 1 A syntax operator is automatically exported from the the module which defines because it cannot be used in the module which defines it.

12.2.3.1 Syntax

defun-form: → <function>

simple-defun

setter-defun

simple-defun:

( defun function-name lambda-list

body )

setter-defun:

( defun ( setter function-name ) lambda-list

body )

function-name:

Arguments

function-name :: A symbol naming an immutable top-lexical binding to be initialized with a function having the specified lambda-list and body.
(setter function-name) :: An expression denoting the setter function to correspond to function-name.
lambda-list :: The parameter list of the function conforming to the syntax specified under lambda.
body :: A sequence of forms.

Remarks

The defun form defines a function named by function-name and stores the definition (i) as the top-lexical binding of function-name or (ii) as the setter function of function-name. The interpretation of the lambda-list is as defined for lambda.

12.2.3.2 Rewrite Rules

(defun identifier

lambda-list

≡

(defconstant identifier

body))

≡

((setter setter)

(lambda lambda-list

body))

12.2.4 function call

syntax

12.2.4.1 Syntax

function-call-form: → <object>

( operator operand* )

operator:

operand:

Arguments

operator :

This may be a symbol—being either the name of a special form, or a lexical variable—or a function call, which must result in an instance of <function>.

An error is signalled (condition class: <invalid-operator> ) if the operator is not a function.

operand* :

Each operand must be either an identifier, a literal, a special-form or a function-call-form.

Result

The result is the value of the application of operator to the evaluation of operand*.

Remarks

The operand expressions are evaluated in order from left to right. The operator expression may be evaluated at any time before, during or after the evaluation of the operands.

NOTE 2 The above rule for the evaluation of function calls was finally agreed upon for this version since it is in line with one strand of common practice, but it may be revised in a future version.

Initialization Options

invalid-operator object :: The object which was being used as an operator.
operand-list list :: The operands prepared for the operator.

Remarks

Signalled by function call if the operator is not an instance of <function>.

12.2.6 apply

function

12.2.6.1 Syntax

apply-form: → <object>

( apply function body )

function:

level-0-form

Arguments

function :: A form which must evaluate to an instance of <function>.
form₁ ... form_n-1 :: A sequence of expressions, which will be evaluated according to the rules given in function-call-form.
form_n :: An expression which must evaluate to a proper list. It is an error if obj_n is not a proper list.

Result

The result is the result of calling function with the actual parameter list created by appending form_n to a list of the arguments form₁ through form_n-1. An error is signalled (condition class: <invalid-operator>) if the first argument is not an instance of <function>.

12.3 Destructive Operations

An assignment operation modifies the contents of a binding named by a identifier—that is, a variable.

12.3.1 setq

special operator

12.3.1.1 Syntax

setq-form: → <object>

( setq identifier form )

Arguments

identifier :: The identifier whose lexical binding is to be updated.
form :: An expression whose value is to be stored in the binding of identifier.

Result

The result is the value of form.

Remarks

The form is evaluated and the result is stored in the closest lexical binding named by identifier. It is a violation to modify an immutable binding.

12.3.2 setter

function

Arguments

reader :: An expression which must evaluate to an instance of <function>.

Result

The writer corresponding to reader.

Remarks

A generalized place update facility is provided by setter. Given reader, setter returns the corresponding update function. If no such function is known to setter, an error is signalled (condition class: <no-setter>). Thus (setter car) returns the function to update the car of a pair. New update functions can be added by using setter’s update function, which is accessed by the expression (setter setter). Thus ((setter setter) a-reader a-writer) installs the function which is the value of a-writer as the writer of the reader function which is the value of a-reader. All writer functions in this definition and user-defined writers have the same immutable status as other standard functions, such that attempting to redefine such a function, for example ((setter setter) car a-new-value), signals an error (condition class: <cannot-update-setter>)

Initialization Options

object object :: The object given to setter.

Remarks

Signalled by setter if there is no updater for the given function.

12.3.4 <cannot-update-setter>

<general-condition> condition

Initialization Options

accessor object₁ :: The given accessor object.
updater object₂ :: The given updater object.

Remarks

Signalled by (setter setter) if the updater of the given accessor is immutable.

12.4 Conditional Expressions

12.4.1 if

special operator

12.4.1.1 Syntax

if-form: → <object>

antecedent:

consequent:

alternative:

Result

Either the value of consequent or alternative depending on the value of antecedent.

Remarks

The antecedent is evaluated. If the result is t the consequent is evaluated, otherwise the alternative is evaluated. Both consequent and alternative must be specified. The result of if is the result of the evaluation of whichever of consequent or alternative is chosen.

12.4.2 cond

special operator

12.4.2.1 Syntax

cond-form: → <object>

( cond

{( antecedent consequent* )}* )

Remarks

The cond syntax operator provides a convenient syntax for collections of if-then-elseif...else expressions.

12.4.2.2 Rewrite Rules

(cond)

≡

()

(cond (antecedent)

…)

≡

(or antecedent (cond …))

(antecedent₁)

(antecedent₂ consequent*)

…)

≡

(or	antecedent₁

(antecedent₂

consequent*)

…))

(antecedent₁ consequent*)

(antecedent₂ consequent*)

…)

≡

(if	antecedent₁

(progn consequent*)

(antecedent₂

consequent*)

…))

12.4.3 else <symbol>

constant

Remarks

This may be used to denote the default clause in cond and ?? forms and has the value t, i.e. it is an alias for t introduced to improve readability of the cond and ?? forms.

12.4.4 when

special operator

12.4.4.1 Syntax

when-form: → <object>

( when antecedent

consequent )

Result

The antecedent is evaluated and if the result is t the consequent is evaluated and returned otherwise () is returned.

12.4.4.2 Rewrite Rules

(when antecedent

consequent)

≡

(if	antecedent

consequent

())

12.4.5 unless

special operator

12.4.5.1 Syntax

unless-form: → <object>

( unless antecedent

consequent )

Result

The antecedent is evaluated and if the result is () the consequent is evaluated and returned otherwise () is returned.

12.4.5.2 Rewrite Rules

(unless antecedent

consequent)

≡

(if	antecedent

()

consequent)

12.4.6 and

special operator

12.4.6.1 Syntax

and-form: → <object>

( and consequent* )

Remarks

The expansion of an and form leads to the evaluation of the sequence of forms from left to right. The first form in the sequence that evaluates to () stops evaluation and none of the forms to its right will be evaluated—that is to say, it is non-strict. The result of (and) is t. If none of the forms evaluate to (), the value of the last form is returned.

12.4.6.2 Rewrite Rules

(and)

≡

(and form)

≡

form

(and form₁ form₂ …)

≡

(if

form₁

(and form₂ …)

())

12.4.7 or

special operator

12.4.7.1 Syntax

or-form: → <object>

( or form* )

Remarks

The expansion of an or form leads to the evaluation of the sequence of forms from left to right. The value of the first form that evaluates to t is the result of the or form and none of the forms to its right will be evaluated—that is to say, it is non-strict. If none of the forms evaluate to t, the value of the last form is returned.

12.4.7.2 Rewrite Rules

(or)

≡

()

(or form)

≡

form

(or form₁ form₂ …)

≡

(let (

(x form₁))

(if

(or form₂ …)))

Note that x does not occur free in any of form₂ …form_n.

12.5 Variable Binding and Sequences

12.5.1 let/cc

special operator

12.5.1.1 Syntax

let/cc-form: → <object>

( let/cc identifier body )

Arguments

identifier :: To be bound to the continuation of the let/cc form.
body :: A sequence of forms to evaluate.

Result

The result of evaluating the last form in body or the value of the argument given to the continuation bound to identifier.

Remarks

The identifier is bound to a new location, which is initialized with the continuation of the let/cc form. This binding is immutable and has lexical scope and indefinite extent. Each form in body is evaluated in order in the environment extended by the above binding. It is an error to call the continuation outside the dynamic extent of the let/cc form that created it. The continuation is a function of one argument. Calling the continuation causes the restoration of the lexical environment and dynamic environment that existed before entering the let/cc form.

Examples

An example of the use of let/cc is given in example 1. The function path-open takes a list of paths, the name of a file and list of options to pass to open. It tries to open the file by appending the name to each path in turn. Each time open fails, it signals a condition that the file was not found which is trapped by the handler function. That calls the continuation bound to fail to cause it to try the next path in the list. When open does find a file, the continuation bound to succeed is called with the stream as its argument, which is subsequently returned to the caller of path-open. If the path list is exhausted, map (section 16.2) terminates and an error (condition class: ??) is signalled.

Example 1:

using let/cc

(defun path-open (pathlist name . options)
  (let/cc succeed
    (map
      (lambda (path)
        (let/cc fail
          (with-handler
            (lambda (condition resume) (fail ()))
            (succeed
              (apply open
                (format () "~a/~a" path name)
                options)))))
      pathlist)
    (error
      (format ()
        "Cannot open stream for (~a) ~a"
        pathlist name)
      <cannot-open-path>)))

12.5.2.1 Syntax

block-form: → <object>

( block identifier body )

Remarks

The block expression is used to establish a statically scoped binding of an escape function. The block identifier is bound to the continuation of the block. The continuation can be invoked anywhere within the block by using return-from. The forms are evaluated in sequence and the value of the last one is returned as the value of the block form. See also let/cc.

12.5.2.2 Rewrite Rules

(block identifier)	≡	()
(block identifier	≡	(let/cc identifier
body)		body)

The rewrite for block does not prevent the block being exited from anywhere in its dynamic extent, since the function bound to identifier is a first-class item and can be passed as an argument like other values.

12.5.3.1 Syntax

return-from-form: → <object>

( return-from identifier formopt )

Remarks

In return-from, the identifier names the continuation of the (lexical) block from which to return. return-from is the invocation of the continuation of the block named by identifier. The form is evaluated and the value is returned as the value of the block named by identifier.

12.5.3.2 Rewrite Rules

(return-from identifier)

≡

(identifier ())

(return-from

identifier form)

≡

(identifier form)

12.5.4.1 Syntax

letfuns-form: → <object>

( letfuns

( function-definition* )

letfuns-body )

function-definition:

( identifier lambda-list body )

letfuns-body:

form*

Arguments

identifier :: A symbol naming a new inner-lexical binding to be initialized with the function having the lambda-list and body specified.
lambda-list :: The parameter list of the function conforming to the syntax specified below.
body :: A sequence of forms.
letfuns-body :: A sequence of forms.

Result

The letfuns operator provides for local mutually recursive function creation. Each identifier is bound to a new inner-lexical binding initialized with the function constructed from lambda-list and body. The scope of the identifiers is the entire letfuns form. The lambda-list is either a single variable or a list of variables—see lambda. Each form in letfuns-body is evaluated in order in the lexical environment extended with the bindings of the identifiers. The result of evaluating the last form in letfuns-body is returned as the result of the letfuns form.

12.5.5 let

special operator

12.5.5.1 Syntax

let-form: → <object>

( let identifieropt ( binding* )

body )

binding:

variable

( variable form )

variable:

identifier var:

variable

Remarks

The optional identifier denotes that the let form can be called from within its body. This is an abbreviation for letfuns form in which identifier is bound to a function whose parameters are the identifiers of the bindings of the let, whose body is that of the let and whose initial call passes the values of the initializing form of the bindings. A binding is specified by either an identifier or a two element list of an identifier and an initializing form. All the initializing forms are evaluated in order from left to right in the current environment and the variables named by the identifiers in the bindings are bound to new locations holding the results. Each form in body is evaluated in order in the environment extended by the above bindings. The result of evaluating the last form in body is returned as the result of the let form.

12.5.5.2 Rewrite Rules

(let () body)

≡

(progn body)

(let (

(var₁ form₁)

(var₂ form₂)

var₃

…)

≡

((lambda (var₁ var₂ var₃ …)

form₁ form₂ () …)

(let

var₀

(

(var₁ form₁)

var₂

…)

≡

(letfuns

(

(var₀ (var₁ var₂ …)

body))

(var₀ form₁ () …))

12.5.6 let*

special operator

12.5.6.1 Syntax

let-star-form: → <object>

( let* ( binding* )

body )

Remarks

A binding is specified by a two element list of a variable and an initializing form. The first initializing form is evaluated in the current environment and the corresponding variable is bound to a new location containing that result. Subsequent bindings are processed in turn, evaluating the initializing form in the environment extended by the previous binding. Each form in body is evaluated in order in the environment extended by the above bindings. The result of evaluating the last form is returned as the result of the let* form.

12.5.6.2 Rewrite Rules

(let* () body)

≡

(progn body)

(let* (

(var₁ form₁)

(var₂ form₂)

var₃

…)