will content myself with listing the most widely used implementations of Scheme, the machines they run on, the implementation technique, and the distributor. Most implementations are based on a compiler, but not all compile to native code; "byte code" means the machine code of a fairly conventional but hypothetical Scheme machine, while "S code" means a linked list representation of byte code. Full addresses appear at the end of this article.

Name	Machine (OS)	Compiles to	Available from
Scheme-84	portable (Unix)	interpreter	Patrick Greussay
Vincennes Scheme	VAX (Unix, VMS)	S code	Indiana University
MIT C Scheme	VAX (Unix, VMS)	S code	MIT
MIT C Scheme	VAX (Unix, VMS) Sun HP (I-IP-UX)	S code	MIT
MIT 68000 Scheme	HP (Pascal)	S code	MIT
MacScheme	Apple Macintosh	byte code	Semantic Microsystems
PC Scheme	IBM PC, PC/XT, PC/AT   and compatibles TI Professional, etc.	byte code	Texas Instruments
Chez Scheme	VAX (Unix)	native code	Cadence Research
T3	VAX (Unix) Sun Apollo HP (HP-UX)	native code	Yale

If you would like to be added to the electronic mailing list for Scheme, send your request to Scheme-Request@MIT-MC.

* * *

Let's turn now to the technical term "tail-recursion", as it is used in the R³RS. This is a nice term to start with because it is simple and familiar yet leads naturally into a discussion of continuations, which are less widely understood.

A tail-recursive procedure call is a procedure call whose value, or result, will be returned as the result of the calling procedure. For example, the call to foo in

    (define (ct x y)
      (1: (null? y)
          x
          (foo x (cdr y))))
  

is tail-recursive, unlike the call to foo in `

    (define (g x y)
      (1: (null? y)
          x
          (car (foo x (cdr y)))))
  

In the definition of g the calling procedure g has to take the car of the result of the call to foo, but in the definition of f the calling procedure f has nothing more to do with the result than to return it to its caller. This means that it would be most efficient for foo to return the result directly to the caller of f rather than returning it to f.

Fortunately, foo will indeed return its result directly to the caller of f unless f goes to some extra trouble to intercept the result. Unfortunately, it is a wel1-established tradition among compilers that f should intercept the result of foo. Compilers that buck this tradition by preventing f from going to the extra trouble needed to intercept the result of foo are said to handle tail-recursion properly. Since compilers that handle tail-recursion properly