This section gives an overview of Scheme's semantics. A
detailed informal semantics is the subject of
section Basic concepts through section Standard procedures. For reference
purposes, section Formal semantics provides a formal
semantics of Scheme.

Following Algol, Scheme is a statically scoped programming
language. Each use of a variable is associated with a lexically
apparent binding of that variable.

Scheme has latent as opposed to manifest types. Types
are associated with values (also called objects)
rather than
with variables. (Some authors refer to languages with latent types as
weakly typed or dynamically typed languages.) Other languages with
latent types are APL, Snobol, and other dialects of Lisp. Languages
with manifest types (sometimes referred to as strongly typed or
statically typed languages) include Algol 60, Pascal, and C.

All objects created in the course of a Scheme computation, including
procedures and continuations, have unlimited extent.
No Scheme object is ever destroyed. The reason that
implementations of Scheme do not (usually!) run out of storage is that
they are permitted to reclaim the storage occupied by an object if
they can prove that the object cannot possibly matter to any future
computation. Other languages in which most objects have unlimited
extent include APL and other Lisp dialects.

Implementations of Scheme are required to be properly tail-recursive.
This allows the execution of an iterative computation in constant space,
even if the iterative computation is described by a syntactically
recursive procedure. Thus with a tail-recursive implementation,
iteration can be expressed using the ordinary procedure-call
mechanics, so that special iteration constructs are useful only as
syntactic sugar.

Scheme procedures are objects in their own right. Procedures can be
created dynamically, stored in data structures, returned as results of
procedures, and so on. Other languages with these properties include
Common Lisp and ML.

One distinguishing feature of Scheme is that continuations, which
in most other languages only operate behind the scenes, also have
"first-class" status. Continuations are useful for implementing a
wide variety of advanced control constructs, including non-local exits,
backtracking, and coroutines. See section Control features.

Arguments to Scheme procedures are always passed by value, which
means that the actual argument expressions are evaluated before the
procedure gains control, whether the procedure needs the result of the
evaluation or not. ML, C, and APL are three other languages that always
pass arguments by value.
This is distinct from the lazy-evaluation semantics of Haskell,
or the call-by-name semantics of Algol 60, where an argument
expression is not evaluated unless its value is needed by the
procedure.

Scheme's model of arithmetic is designed to remain as independent as
possible of the particular ways in which numbers are represented within a
computer. In Scheme, every integer is a rational number, every rational is a
real, and every real is a complex number. Thus the distinction between integer
and real arithmetic, so important to many programming languages, does not
appear in Scheme. In its place is a distinction between exact arithmetic,
which corresponds to the mathematical ideal, and inexact arithmetic on
approximations. As in Common Lisp, exact arithmetic is not limited to
integers.

Scheme, like most dialects of Lisp, employs a fully parenthesized prefix
notation for programs and (other) data; the grammar of Scheme generates a
sublanguage of the language used for data. An important
consequence of this simple, uniform representation is the susceptibility of
Scheme programs and data to uniform treatment by other Scheme programs.

The read
procedure performs syntactic as well as lexical decomposition of the
data it reads. The read procedure parses its input as data
(section External representations), not as program.

It is required that every implementation of Scheme support
features that are marked as being essential. Features not
explicitly marked as essential are not essential. Implementations are
free to omit non-essential features of Scheme or to add extensions,
provided the extensions are not in conflict with the language reported
here. In particular, implementations must support portable code by
providing a syntactic mode that preempts no lexical conventions of this
report and reserves no identifiers other than those listed as syntactic
keywords in section Identifiers.

When speaking of an error situation, this report uses the phrase "an
error is signalled" to indicate that implementations must detect and
report the error. If such wording does not appear in the discussion of
an error, then implementations are not required to detect or report the
error, though they are encouraged to do so. An error situation that
implementations are not required to detect is usually referred to simply
as "an error."

For example, it is an error for a procedure to be passed an argument that
the procedure is not explicitly specified to handle, even though such
domain errors are seldom mentioned in this report. Implementations may
extend a procedure's domain of definition to include such arguments.

This report uses the phrase "may report a violation of an
implementation restriction" to indicate circumstances under which an
implementation is permitted to report that it is unable to continue
execution of a correct program because of some restriction imposed by the
implementation. Implementation restrictions are of course discouraged,
but implementations are encouraged to report violations of implementation
restrictions.

For example, an implementation may report a violation of an
implementation restriction if it does not have enough storage to run a
program.

If the value of an expression is said to be "unspecified," then
the expression must evaluate to some object without signalling an error,
but the value depends on the implementation; this report explicitly does
not say what value should be returned.

section Expressions and section Standard procedures are organized
into entries. Each entry describes one language feature or a group of
related features, where a feature is either a syntactic construct or a
built-in procedure. An entry begins with one or more header lines of the form

{essential:category}template

if the feature is an essential feature, or simply

category:template

if the feature is not an essential feature.

If category is "syntax", the entry describes an expression
type, and the header line gives the syntax of the expression type.
Components of expressions are designated by syntactic variables, which
are written using angle brackets, for example, <expression>,
<variable>. Syntactic variables should be understood to denote segments of
program text; for example, <expression> stands for any string of
characters which is a syntactically valid expression. The notation

<thing 1> ...

indicates zero or more occurrences of a <thing>, and

<thing 1> <thing 2> ...

indicates one or more occurrences of a <thing>.

If category is "procedure", then the entry describes a procedure, and
the header line gives a template for a call to the procedure. Argument
names in the template are italicized. Thus the header line

indicate that in all implementations, the make-vector procedure
must be defined to take one argument, and some implementations will
extend it to take two arguments.

It is an error for an operation to be presented with an argument that it
is not specified to handle. For succinctness, we follow the convention
that if an argument name is also the name of a type listed in
section Disjointness of types, then that argument must be of the named type.
For example, the header line for vector-ref given above dictates that the
first argument to vector-ref must be a vector. The following naming
conventions also imply type restrictions:

The symbol "=>" used in program examples should be read
"evaluates to." For example,

(* 5 8) => 40

means that the expression (* 5 8) evaluates to the object 40.
Or, more precisely: the expression given by the sequence of characters
"(* 5 8)" evaluates, in the initial environment, to an object
that may be represented externally by the sequence of characters
"40". See section External representations for a
discussion of external
representations of objects.

By convention, the names of procedures that always return a boolean
value usually end
in "`?'". Such procedures are called predicates.

By convention, the names of procedures that store values into previously
allocated locations (see section Storage model) usually end in
"`!'".
Such procedures are called mutation procedures.
By convention, the value returned by a mutation procedure is unspecified.

By convention, "`->'" appears within the names of procedures that
take an object of one type and return an analogous object of another type.
For example, list->vector takes a list and returns a vector whose
elements are the same as those of the list.