. navigate
The Scheme Environment    Page 27 left arrow
right arrow Page 29    The Scheme Environment
The Scheme Environment

LISP Pointers
Volume I, Number 1
April-May 1987

The Scheme Environment
page 28

Prev Article               Start of This Article               Next Article

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)
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)
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 R3RS. 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)
          (foo x (cdr y))))
is tail-recursive, unlike the call to foo in `
    (define (g x y)
      (1: (null? y)
          (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

Page Left left arrow         
right arrow Page Right
Vol. I, No. 1
Table of Contents

Home   Favorites   Computers   Map

IME logo Copyright © 2009, Mary S. Van Deusen