This manual is a detailed description of the MIT/GNU Scheme runtime system.
It is intended to be a reference document for programmers. It does not
describe how to run Scheme or how to interact with it — that is the
subject of the MIT/GNU Scheme User's Manual.
This chapter summarizes the semantics of Scheme, briefly describes the
MIT/GNU Scheme programming environment, and explains the syntactic and
lexical conventions of the language. Subsequent chapters describe
special forms, numerous data abstractions, and facilities for input and
Throughout this manual, we will make frequent references to
standard Scheme, which is the language defined by the document
Revised^4 Report on the Algorithmic Language Scheme, by William
Clinger, Jonathan Rees, et al., or by ieee Std. 1178-1990,
IEEE Standard for the Scheme Programming Language (in fact,
several parts of this document are copied from the Revised
Report). MIT/GNU Scheme is an extension of standard Scheme.
These are the significant semantic characteristics of the Scheme
- Variables are statically scoped
- Scheme is a statically scoped programming language, which means that
each use of a variable is associated with a lexically apparent binding
of that variable. Algol is another statically scoped language.
- Types are latent
- Scheme has latent types as opposed to manifest types, which
means that Scheme associates types with values (or objects) rather than
with variables. Other languages with latent types (also referred to as
weakly typed or dynamically typed languages) include 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.
- Objects have unlimited extent
- All objects created during a Scheme computation, including procedures
and continuations, have unlimited extent; no Scheme object is ever
destroyed. The system doesn't run out of memory because the garbage
collector reclaims the storage occupied by an object when the object
cannot possibly be needed by a future computation. Other languages in
which most objects have unlimited extent include APL and other Lisp
- Proper tail recursion
- Scheme is properly tail-recursive, which means that iterative
computation can occur in constant space, even if the iterative
computation is described by a syntactically recursive procedure. With a
tail-recursive implementation, you can express iteration using the
ordinary procedure-call mechanics; special iteration expressions are
provided only for syntactic convenience.
- Procedures are objects
- Scheme procedures are objects, which means that you can create them
dynamically, store them in data structures, return them as the results
of other procedures, and so on. Other languages with such procedure
objects include Common Lisp and ML.
- Continuations are explicit
- In most other languages, continuations operate behind the scenes. In
Scheme, continuations are objects; you can use continuations for
implementing a variety of advanced control constructs, including
non-local exits, backtracking, and coroutines.
- Arguments are passed by value
- Arguments to Scheme procedures are passed by value, which means that
Scheme evaluates the argument expressions before the procedure gains
control, whether or not the procedure needs the result of the
evaluations. ML, C, and APL are three other languages that pass
arguments by value. In languages such as SASL and Algol 60, argument
expressions are not evaluated unless the values are needed by the
Scheme uses a parenthesized-list Polish notation to describe programs
and (other) data. The syntax of Scheme, like that of most Lisp
dialects, provides for great expressive power, largely due to its
simplicity. An important consequence of this simplicity is the
susceptibility of Scheme programs and data to uniform treatment by other
Scheme programs. As with other Lisp dialects, the
parses its input; that is, it performs syntactic as well as lexical
decomposition of what it reads.