Scheme vs Lisp 
Author Message
 Scheme vs Lisp

 Could someone familar with both Scheme and Lisp please post a short
 summary of the major differences.


Mon, 26 May 1997 04:45:42 GMT  
 Scheme vs Lisp

Shaun>  Could someone familar with both Scheme and Lisp please post a
Shaun> short summary of the major differences.

Basically, Scheme is just a very well cleaned up, minimal subset of
lexically scoped Lisp.

Basically, starting from commonlisp:
- remove packages
- remove nearly all of the "library" type stuff
- remove CLOS
- remove dynamically scoped variables
- eliminate the distinction between value-cells and function cells of
  a symbol, and make functions a simple first class value
- add first class continuations, generated by call/cc
- remove "eval-it-twice" macros.  The replacement is in flux; there's
  a high level hygenic system in R4RS, but it's not really widely
  implemented. It is available from SLIB, a standard scheme library.

Do that, and you've pretty much got Scheme.

|| Mark Craig Chu-Carroll: <MC> || "There is no such thing as a problem
|| CIS Grad, U of Delaware      ||  without a gift for you in its hands. You
|| PGP Key Available, by finger ||  seek problems because you need their

Mon, 26 May 1997 22:39:34 GMT  
 Scheme vs Lisp
To the differences between Scheme and Common Lisp that were enumerated

Scheme guarantees that tail-recursive calls will be executed as gotos
that pass arguments, while Common Lisp does not (and most Common Lisp
compilers do not generate properly tail-recursive code in general,
although many will do so for various special cases).  Thus iteration
in Scheme can be expressed by tail-recursion.

Historically speaking, proper tail-recursion was what separated Scheme
from other languages in the Lisp family.  It resulted from Steele and
Sussman's efforts to understand Hewitt's "continuation-passing style"
(CPS), and led pretty directly to several of the differences that
Chu-Carroll listed:

  *  lexical instead of dynamic scope (because dynamic scope interferes
     with proper tail-recursion)
  *  functions are first class values (because they need to be first
     class for CPS, and they can be first class because of lexical scope)
  *  uniform evaluation rules (because the non-uniform evaluation rules
     of a first-order language, which treat "values" differently from
     "functions", are a real pain when manipulating the higher order
     (first class) functions needed for CPS)
  *  first class continuations (because people had to become aware of
     continuations in order to understand and to implement proper tail
  *  cleaned up and minimal (because you no longer need special features
     for iteration or escapes; uniform evaluation helps also; you then
     get a language that is so small that its designers became intrigued
     and wanted to see how small it could become without sacrificing
     power or efficiency)

William Clinger

Sat, 31 May 1997 00:59:21 GMT  
 [ 3 post ] 

 Relevant Pages 

1. Scheme vs Classical Lisp

2. Scheme vs. Lisp

3. Lisp vs. Scheme Emacs

4. Lisp vs. Scheme Emacs

5. Common Lisp vs Scheme

6. Scheme vs. (Common) Lisp

7. Common Lisp vs Scheme

8. Common Lisp vs specific Scheme implementations

9. LISP/SCHEME vs C for AI

10. Scheme vs. (Common) Lisp

11. Ada vs LISP vs C vs ...

12. Lisp vs Java vs C++ vs...


Powered by phpBB® Forum Software