( Semantics

Info Catalog ( Overview of Scheme ( Overview of Scheme ( Syntax
 1.1 Semantics
 This section gives an overview of Scheme's semantics.  A detailed
 informal semantics is the subject of chapters  Basic concepts
 through  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 properly tail-recursive
 implementation, iteration can be expressed using the ordinary
 procedure-call mechanics, so that special iteration constructs are
 useful only as syntactic sugar.  See section  Proper tail
 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.
Info Catalog ( Overview of Scheme ( Overview of Scheme ( Syntax
automatically generated byinfo2html