FAQ: Scheme Frequently Asked Questions 1/1 [Monthly posting] 
Author Message
 FAQ: Scheme Frequently Asked Questions 1/1 [Monthly posting]

Archive-name: scheme-faq/part1
Last-Modified: Fri Feb 11 16:00:31 1994 by Mark Kantrowitz
Version: 1.10

;;; ****************************************************************
;;; Answers to Frequently Asked Questions about Scheme *************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin
;;; scheme_1.faq -- 70457 bytes

This post contains the Scheme FAQ.

If you think of questions that are appropriate for this FAQ, or would

Note that the lisp-faq mailing list is for discussion of the content
of the FAQ posting only.  It is not the place to ask questions about Scheme;


in one of those forums, it will get added to the FAQ list.

Topics Covered:
  [1-0]   What is the purpose of this newsgroup?
  [1-1]   What Scheme-related discussion groups and mailing lists exist?
  [1-2]   What is the difference between Scheme and Common Lisp?
  [1-3]   What documentation is available on Scheme? How can I learn Scheme?
  [1-4]   Where can I learn about implementing Scheme interpreters and
          compilers?
  [1-5]   Free Scheme implementations.
  [1-6]   Commercial Scheme implementations.
  [1-7]   Standards for Scheme -- What are R4RS and IEEE P1178?
  [1-8]   How do I do object-oriented programming in Scheme?
  [1-9]   Repositories of Scheme Software
  [1-10]  Publicly Redistributable Scheme Software
  [1-11]  Where can I get an implementation of Prolog in Scheme?
  [1-12]  What does SICP, SCOOPS, R4RS, CAR, CDR, ... mean?
  [1-13]  Why is there no EVAL in Scheme?

Search for \[#\] to get to question number # quickly.

Recent Changes:

;;; 1.10:
;;; 13-JAN-94 mk    Updated PCS/Geneva entry.
;;; 11-FEB-94 mk    Added [1-13] on why no eval in Scheme.
;;; 11-FEB-94 mk    Added review of Harvey & Wright's new Scheme text.

Introduction:

Certain questions and topics come up frequently in the various network
discussion groups devoted to and related to Scheme.  This file/article is
an attempt to gather these questions and their answers into a convenient
reference for Scheme programmers.  It (or a reference to it) is posted
periodically.  The hope is that this will cut down on the user time and
network bandwidth used to post, read and respond to the same questions
over and over, as well as providing education by answering questions
some readers may not even have thought to ask.

This is not a Scheme tutorial, nor is it an exhaustive list of all Scheme
intricacies.  Scheme is a very powerful and expressive language, but with
that power comes many complexities.  This list attempts to address the
ones that average Scheme programmers are likely to encounter.  If you are
new to Scheme, see the answer to the question "How can I learn
Scheme?" [1-3].

The latest version of this file is available via anonymous FTP from CMU
and Thinking Machines:

   To obtain the file from CMU, connect by anonymous ftp to any CMU CS
   machine (e.g., ftp.cs.cmu.edu [128.2.206.173]), using username

   is located in the directory
       /afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/scheme/
   [Note: You must cd to this directory in one atomic operation, as
   some of the superior directories on the path are protected from
   access by anonymous ftp.] If your site runs the Andrew File System,
   you can just cp the files directly without bothering with FTP.

   To obtain the files from Thinking Machines, ftp them from ftp.think.com,
   in the directory /public/think/lisp/. The file scheme-faq.text contains
   the latest version of the Scheme FAQ. In addition, specific
   versions of the FAQ are available as scheme-faq-<version>.text.

We've tried to minimize the overlap with the FAQ postings to the
comp.lang.lisp, comp.lang.clos and comp.ai newsgroups, so if you don't
find what you're looking for here, we suggest you try the FAQs for
those newsgroups. These FAQs should be available by anonymous ftp from
rtfm.mit.edu [18.70.0.209] in the lisp-faq/, ai-faq/ and scheme-faq/
subdirectories of /pub/usenet/news.answers/ or by email. For
instructions on email retrieval, send a mail message to

the body of the message.

----------------------------------------------------------------
Subject: [1-0] What is the purpose of this newsgroup?

The newsgroup comp.lang.scheme exists for general discussion of
topics related to the programming language Scheme. For example, possible
topics can include (but are not necessarily limited to):
   announcements of Scheme books and products
   discussion of programs and utilities written in Scheme
   discussion of portability issues
   questions about possible bugs in Scheme implementations
   problems porting an implementation to some architecture
Postings should be of general interest to the Scheme community. See also
question [1-1].

Questions about Common Lisp should be directed to the newsgroup
comp.lang.lisp.  Discussion of object oriented programming in Lisp to
the newsgroup comp.lang.clos. Discussion of functional programming
language issues in general should be directed to the newsgroup
comp.lang.functional.  Discussion of AI programs implemented in Scheme
should sometimes be cross-posted to the newsgroup comp.ai.

----------------------------------------------------------------
Subject: [1-1] What Scheme-related discussion groups and mailing lists exist?

Before posting to any discussion group, please read the rest
of this FAQ, to make sure your question isn't already answered.

See the Lisp FAQ for a list of Lisp-related discussion groups and
mailing lists. We list here only those newsgroups and mailing lists
directly associated with Scheme.

Newsgroups:

   comp.lang.scheme        General Scheme-related discussion.
                           This newsgroup is gatewayed to the

   comp.lang.scheme.c      Discussion of C-Scheme, a scheme dialect.
                           This newsgroup is gatewayed to the

   comp.lang.lisp.x        Discussion of XLISP, a dialect of Lisp, and XScheme.
   comp.lang.dylan         Discussion of Dylan (see [4-6]), Apple's
                           new Scheme-like programming language. Gatewayed to

We list several mailing lists below. In general, to be added to
a mailing list, send mail to the "-request" version of the address.
This avoids flooding the mailing list with annoying and trivial
administrative requests. [To subscribe to info-mcl, info-dylan, or
other mailing lists based at cambridge.apple.com, send a message to

message body. Likewise use "unsubscribe <list_name>" to cancel your
subscription and "help" to get help.]

General Scheme Mailing Lists:


                                   the comp.lang.scheme newsgroup.

Particular Flavors of Scheme:



                                   comp.lang.scheme.c newsgroup.




----------------------------------------------------------------
Subject: [1-2] What is the difference between Scheme and Common Lisp?

Scheme is a dialect of Lisp that stresses conceptual elegance and
simplicity. It is specified in R4RS and IEEE standard P1178. (See
question [1-7] for details on standards for Scheme.) Scheme is much
smaller than Common Lisp; the specification is about 50 pages,
compared to Common Lisp's 1300 page draft standard. (See the Lisp FAQ
for details on standards for Common Lisp.) Advocates of Scheme often
find it amusing that the entire Scheme standard is shorter than the
index to Guy Steele's "Common Lisp: the Language, 2nd Edition".

Scheme is often used in computer science curricula and programming
language research, due to its ability to represent many programming
abstractions with its simple primitives. Common Lisp is often used for
real world programming because of its large library of utility
functions, a standard object-oriented programming facility (CLOS), and
a sophisticated condition handling system.

See question [1-8] for information about object-oriented programming
in Scheme.

In Common Lisp, a simple program would look something like the
following:

   (defun fact (n)
     (if (< n 2)
         1
         (* n (fact (1- n)))))

In Scheme, the equivalent program would like like this:

   (define fact
     (lambda (n)
       (if (< n 2)
           1
         (* n (fact (- n 1))))))

Experienced Lisp programmers might write this program as follows in order
to allow it to run in constant space:

   (defun fact (n)
     (labels ((tail-recursive-fact (counter accumulator)
                (if (> counter n)
                    accumulator
                    (tail-recursive-fact (1+ counter)
                                         (* counter accumulator)))))
       (tail-recursive-fact 1 1)))

Whereas in Scheme the same computation could be written as follows:

   (define fact
     (lambda (n)
       (letrec ((tail-recursive-fact
                 (lambda (counter accumulator)
                   (if (> counter n)
                       accumulator
                     (tail-recursive-fact (+ counter 1)
                                          (* counter accumulator))))))
               (tail-recursive-fact 1 1))))

or perhaps (using IEEE named LETs):

   (define fact
     (lambda (n)
       (let loop ((counter n)
                  (accumulator 1))
            (if (< counter 2)
                accumulator
              (loop (- counter 1)
                    (* accumulator counter))))))

Some Schemes allow one to use the syntax (define (fact n) ...) instead
of (define fact (lambda (n) ...)).

----------------------------------------------------------------
Subject: [1-3] What documentation is available on Scheme?
               How can I learn Scheme?

Introductions to Scheme:

   The following four books from MIT Press are listed in order of
   increasing difficulty. The first is good for the complete novice,
   the second for students with some previous exposure to programming,
   and the third and fourth for more advanced students. The third and
   fourth may also be used to learn a variety of powerful programming
   language concepts. One of these books will suit your needs.

   1. Daniel P. Friedman and M. Felleisen.
      "The Little LISPer"
      MIT Press (Cambridge, MA), 3rd printing, 1989. ISBN 0-262-56038-0.
      Science Research Associates (Chicago), 3rd ed, 1989. 206 pages.

      Good for a quick introduction. Uses Scheme instead of Common Lisp.
      (The book uses a dialect of Scheme with footnotes about translating to
      Scheme or Common Lisp. The footnotes won't allow a non-expert to use
      Common Lisp for the advanced chapters because of the complexity.)

   2. Brian Harvey and Matthew Wright
      "Simply Scheme: Introducing Computer Science"
      MIT Press, Cambridge, MA, 1994. 583 pages.
      ISBN 0-262-08226-8. $49.95.

      This book is ideal for students with little or no previous exposure to
      programming. The book is designed to be used before SICP (the authors
      call it a SICP "prequel"), and makes Scheme fun by sheltering the
      students from potentially confusing technical details. Unlike Pascal
      or C, the emphasis is on ideas, not obscure matters of syntax and
      arbitrary rules of style.  High schools who have shied away from using
      Scheme because they found SICP to be too challenging should consider
      using this book instead.

      The text gradually and gently introduces students to some of the key
      concepts of programming in Scheme. It starts off with functions and
      function composition and continues with the notion of functions as
      data (first-class functions) and programs that write programs
      (higher-order functions).  Since the complexity of the language is
      hidden, students can get involved in some of the more interesting and
      fun aspects of the language earlier than in other texts.  Then the
      book progresses through the more complicated concepts of lambda,
      recursion, data abstraction and procedural abstraction, and concludes
      with sequential techniques, but with careful attention to topics
      students often find difficult.  There are five chapters on recursion
      alone! There's also a pitfalls section at the end of most chapters to
      help students recognize and avoid common errors.

      The book uses several programs as examples, including a tic-tac-toe
      program, a pattern matcher, a miniature spreadsheet, and a simple
      database program.  Source code for the programs is available by
      anonymous ftp from anarres.cs.berkeley.edu:pub/scheme/, or for $10 on
      IBM or Macintosh diskettes from the publisher.

   3. Harold Abelson and Gerald Jay Sussman, with Julie Sussman.
      "Structure and Interpretation of Computer Programs"
      MIT Press (Cambridge, MA) and McGraw-Hill (New York), 1985.
      542 pages. ISBN 0-262-01077-1. The teacher's manual, which is
      also available from MIT Press, does NOT contain solutions to the
      exercises, but does contain hints on teaching with the book.

      Starts off introductory, but rapidly gets into powerful
      Lisp-particular constructs, such as using closures and engines,
      building interpreters, compilers and object-oriented systems.  Often
      referred to by its acronym, SICP, which is pronounced "Sick-Pee". This
      is the classical text for teaching program design using Scheme. MIT
      problem sets are available from the repositories, and materials from
      Gustavus Adolphus College are available from ftp.gac.edu:pub/SICP/.

   4. George Springer and Daniel P. Friedman
      "Scheme and the Art of Programming"
      MIT Press and McGraw Hill, 1990, 596 pages.

      Introduces basic concepts of programming in Scheme. Also deals with
      object oriented programming, co-routining, continuations.  Gives
      numerous examples. Has more of an emphasis on teaching Scheme than
      SICP, and can be seen as an alternative to SICP.  Source code from the
      chapters is available from the nexus.yorku.ca repository in
      pub/scheme/lit/sap/.

Older Introductions to Scheme:

   1. Smith, Jerry D.
      "Introduction to Scheme"
       Prentice Hall (Englewood Cliffs, NJ), 1988, 324 pages.
           Focuses on PC Scheme.

   2. Michael Eisenberg
      "Programming in Scheme"
      Scientific Press (Redwood City, CA), 1988. 304 pages.

   3. Two articles in BYTE Magazine, February 1988, by Abelson and
      Sussman, and Clinger.

Online Introductions to Scheme:

   1. The Ken{*filter*}ey article, "The Scheme Programming Language", in
      COMPUTER LANGUAGES magazine, June 1992, is available from the
      Scheme Repository at nexus.yorku.ca:/pub/scheme/txt/intro.txt
      The Revised^4 Report on the Algorithmic Language Scheme is also
      available from the Scheme Repository.

   2. The Info files from the MIT Scheme implementation.

   3. "Introductory Scheme" by Joseph W. Lavinus and James D. Arthur,

       Repository as ftp.cs.cmu.edu:user/ai/lang/scheme/doc/intro/
       as schemedoc.tar.gz.

Scheme and Artificial Intelligence:

   1. Wolfgang Kreutzer and Bruce McKenzie
      "Programming for Artificial Intelligence:
       Methods, Tools and Applications"
      Addison-Wesley (Reading, MA), 1990. 682 pages.
      ISBN 0-201-41621-2.
           Discusses Scheme, Prolog, and Smalltalk, gives an overview of
           the history and philosophy of AI, surveys three major
           programming paradigms (procedural, declarative, and
           object-oriented), and metaphors to AI programming.
           Source code from the chapters is available from
           nexus.yorku.ca in pub/scheme/lit/ as aibook.tar.Z. Some of
           the programs will only run under MacScheme.

General Scheme reference books include:

   1. K. Dybvig
      "The Scheme programming language"
      Prentice Hall, 1987.
         Good reference for Scheme.

Scheme-related periodicals include:

   1. LISP Pointers.
      Published by ACM SIGPLAN six times a year. Volume 1, Number 1
      was April-May 1987.
      Subscriptions: ACM Members $12; ACM Student Members $7; Non-ACM
      members $25. Mail checks payable to the ACM to ACM Inc., PO Box
      12115, Church Street Station, New York, NY 10249.

   2. LISP and Symbolic Computation, Kluwer Academic Press. Volume 1

      Subscriptions: Institutions $169; Individuals $80. Add $8 for
      air mail. Kluwer Academic Publishers, PO Box 322, 3300 AH Dordrecht,
      The Netherlands, or Kluwer Academic Publishers, PO Box 358, Accord
      Station, Hingham, MA 02018-0358.

   3. Proceedings of the biannual ACM Lisp and Functional Programming
      Conference. (First one was in 1980.)

   4. Proceedings of the annual Lisp Users and Vendors Conference.

See also the Scheme Bibliography from the Scheme Repository
(nexus.yorku.ca:pub/scheme/) for additional readings. A large number
of technical reports on Scheme are now available in the text section
(scheme/txt/).

----------------------------------------------------------------
Subject: [1-4] Where can I learn about implementing Scheme interpreters  
               and compilers?

There is no single book that is really comprehensive, so you will have
to combine reading the sources to the various free implementations
(e.g., Gambit [Feeley] and S48 [Rees]) with bits and pieces of tech
reports and various books.

Books about Scheme implementation include:

   1. John Allen
      "Anatomy of Lisp"
      McGraw-Hill, 1978. 446 pages. ISBN 0-07-001115-X

   2. Samuel Kamin
      "Programming Languages, An Interpreter-Based Approach"
      Addison-Wesley, Reading, Mass., 1990. ISBN 0-201-06824-9
           Includes sources to several interpreters for Lisp-like
           languages, and a pointer to sources via anonymous ftp.

   3. Sharam Hekmatpour
      "Lisp: A Portable Implementation"
      Prentice Hall, 1985. ISBN 0-13-537490-X.
           Describes a portable implementation of a small dynamic
           Lisp interpreter (including C source code).

   4. Peter Henderson
      "Functional Programming: Application and Implementation"
      Prentice-Hall (Englewood Cliffs, NJ), 1980. 355 pages.

   5. Peter M. Kogge
      "The Architecture of Symbolic Computers"
      McGraw-Hill, 1991. ISBN 0-07-035596-7.
           Includes sections on memory management, the SECD and
           Warren Abstract Machines, and overviews of the various
           Lisp Machine architectures.

   6. Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes
      "Essentials of Programming Languages"
      MIT Press, 1992, 536 pages. ISBN 0-262-06145-7.
           Teaches fundamental concepts of programming language
           design by using small interpreters as examples. Covers
           most of the features of Scheme. Includes a discussion
           of parameter passing techniques, object oriented languages,
           and techniques for transforming interpreters to allow
           their implementation in terms of any low-level language.
           Also discusses scanners, parsers, and the derivation of
           a compiler and virtual machine from an interpreter.
           Source files available by anonymous ftp from cs.indiana.edu
           in the directory /pub/eopl (129.79.254.191) or from the
           Scheme Repository.

   7. Peter Lee, editor, "Topics in Advanced Language Implementation",
      The MIT Press, Cambridge, Mass., 1991.
           Articles relevant to the implementation of functional
           programming languages.

   8. Also see the proceedings of the biannual ACM Lisp and Functional
      Programming conferences, the implementation notes for CMU Common Lisp,
      Peter Norvig's book ("Paradigms of AI Programming: Case Studies
      in Common Lisp", Morgan Kaufmann, 1992. 946 pages. ISBN
      1-55860-191-0), and SICP (Abelson & Sussman).

Technical reports and journal articles about Scheme implementation include:

   Mitchell Wand and Daniel P. Friedman, "Compiling Lambda Expressions
   Using Continuations and Factorizations", Journal of Computer Languages
   3(1978), 241-263.

   Guy Lewis Steele Jr., "Rabbit: A Compiler for Scheme", MIT AI Memo
   474, Massachusetts Institute of Technology, Cambridge, MA, May 1978.

   Guy Lewis Steele Jr., "Compiler Optimization Based on Viewing LAMBDA
   as RENAME + GOTO", in "Artificial Intelligence: An MIT Perspective",
   Patrick Henry Winston and Richard Henry Brown (eds.), MIT Press,
   Cambridge, MA, 1980.

   Jonathan A. Rees and Norman I. Adams, "T: A Dialect of Lisp or,
   LAMBDA: The Ultimate Software Tool", Conference Record of the 1982 ACM
   Symposium on Lisp and Functional Programming, 1982, 114-122.

   R. Kent Dybvig, "C-Scheme", Computer Science Department Technical
   Report #149 (MS Thesis), Indiana University, Bloomington, IA, 1983.

   William Clinger, "The Scheme 311 compiler: An Exercise in Denotational
   Semantics", Conference Record of the 1984 ACM Symposium on Lisp and
   Functional Programming, 1984, 356-364.

   Guillermo J. Rozas, "Liar, an Algol-like Compiler for Scheme", S.B.
   Thesis, Department of Electrical Engineering and Computer Science,
   Massachusetts Institute of Technology, January 1984.

   David H. Bartley and John C. Jensen, "The Implementation of PC
   Scheme", Proceedings of the 1986 ACM Conference on Lisp and Functional
   Programming, 1986, 86-93.

   David Kranz, Richard Kelsey, Jonathan A. Rees, Paul Hudak, James
   Philbin and Norman I. Adams, "Orbit: An Optimizing Compiler for
   Scheme", Proceedings of the SIGPLAN Notices '86 Symposium on Compiler
   Construction, June 1986, 219-233.  Published as SIGPLAN Notices 21(7),
   July 1986.

   Marc Feeley, "Deux Approches a' L'implantation du Language Scheme",
   M.Sc. Thesis, De'partement d'Informatique et de Recherche
   Ope'rationelle, University of Montreal, May 1986.

   R. Kent Dybvig, "Three Implementation Models for Scheme", Department
   of Computer Science Technical Report #87-011 (Ph.D. Dissertation),
   University of North Carolina at Chapel Hill, Chapel Hill, North
   Carolina, April 1987.

   William D. Clinger, Anne H. Hartheimer and Eric M. Ost,
   "Implementation Strategies for Continuations", Conference Record of
   the 1988 ACM Conference on Lisp and Functional Programming, August
   1988, 124-131.

   David Kranz, "Orbit: An Optimizing Compiler for Scheme", Computer
   Science Technical report #632 (Ph.D. Dissertation), Yale University,
   1988.

   Joel F. Bartlett, "SCHEME->C a Portable Scheme-to-C Compiler",
   Research Report 89/1, Dec. Western Research Laboratory, Palo Alto, CA,
   January 1989.

   Marc Feeley and James S. Miller, "A Parallel Virtual Machine for
   Efficient Scheme Compilation", Proceedings of the 1990 ACM Conference
   on Lisp and Functional Programming, Nice, France, June 1990.

   Chris Hanson, "Efficient Stack Allocation for Tail-Recursive
   Languages", Proceedings of the 1990 ACM Conference on Lisp and
   Functional Programming, Nice, France, June 1990.

   Robert Hieb, R. Kent Dybvig and Carl Bruggeman, "Representing Control
   in the Presence of First-Class Continuations", Proceedings of the
   SIGPLAN Notices '90 Conference on Programming Language Design and
   Implementation, White Plains, New York, June 1990, 66-77.

   Guillermo Rozas, "Taming the Y Operator", Proceedings of the 1992 ACM
   Conference on Lisp and Functional Programming, San Francisco, CA,
   June 1992, 226-234.

   Dan Teodosiu, "HARE: An Optimizing Portable Compiler for Scheme", ACM
   Sigplan Notices 26(1), January 1991.

----------------------------------------------------------------
Subject: [1-5] Free Scheme implementations.

Repositories of Scheme source code are described in the answer to
question [1-9].

Remember, when ftping compressed or compacted files (.Z, .z, .arc, .fit,
etc.) to use binary mode for retrieving the files.

Files that end with a .z suffix were compressed with the patent-free
gzip (no relation to zip). Source for gzip is available from:
   prep.ai.mit.edu:pub/gnu/{gzip-1.0.7.shar,gzip-1.0.7.tar}

Repositories of Scheme implementations:

   Many free Scheme implementations are available from altdorf.ai.mit.edu
   [18.43.0.246]. See also the Scheme Repository described below.

   The Scheme Repository contains a Scheme bibliography, copies of the
   R4RS report, sample Scheme code for a variety of purposes, several
   utilities, and most free implementations.  (Implementations of Scheme
   available from the repository include elk, gambit, scm, fools, rabbit,
   s48, scheme84, scheme88, pseudo, xscheme, umb-scheme, siod, vscm, and
   pixiescheme.) The repository is maintained by Ozan S. Yigit,

   at nexus.yorku.ca [130.63.9.66] in the directory pub/scheme/.
   The repository is mirrored in INRIA, courtesy of Christian Queinnec
   [Ecole Polytechnique and INRIA-Rocquencourt], ftp.inria.fr:lang/Scheme.
   (See also [1-9] below.)

Scheme implementations:

   PC-Scheme, free by anonymous ftp from altdorf.ai.mit.edu in the
   directory /archive/pc-scheme/.  Written by Texas Instruments. Runs on
   MS-DOS 286/386 IBM PCs and compatibles.  Includes an optimizing
   compiler, an emacs-like editor, inspector, de{*filter*}, performance
   testing, foreign function interface, window system and an
   object-oriented subsystem.  Conforms to the Revised^3 Report on
   Scheme. Also supports the dialect used in Abelson and Sussman's SICP.
   The official commercialized implementation costs $95 and includes a
   reference manual and user's guide. Write to: Texas Instruments, 12501
   Research Boulevard, MS 2151, Austin, TX 78759 and order TI Part number
   #2537900-0001, or call 1-800-TI-PARTS and order it using your Visa or
   Mastercard.  [NOTE: Ibuki announced on July 13, 1992, that it has
   purchased the rights to PC Scheme from TI and intends to make it also
   available on 486 PCs and under Windows 3.1. For more information,
   contact IBUKI, PO Box 1627, Los Altos, CA 94022, phone (415) 961-4996,

   comes with the student edition, doesn't run on the 486, but the free
   upgrade (pcscm3_3.exe in altdorf) works fine, as does the full
   version 3.03.

   PCS/Geneva is a cleaned-up version of Texas Instrument's PC Scheme
   developed at the University of Geneva. The main extensions to PC
   Scheme are 486 support, BGI graphics, LIM-EMS pagination support, line
   editing, mouse support, assembly-level interfacing, and several
   powerful Scheme-oriented editors. (TI's PC Scheme gives users full
   Revised^3 support along with many primitives for DOS, Graphics and
   Text Windows. A powerful built-in optimizing compiler produces fast
   code.) PCS/Geneva 4.02PL1 has been tested on XTs, ATs, AT386s and
   AT486s under various DOS and OS/2 versions. It even runs on
   Hewlett-Packard's HP95LX. It also runs on Suns with a DOS emulator.
   PCS/Geneva is available free by anonymous ftp from
      cui.unige.ch:PUBLIC/pcs/pcscheme.{doc,exe,fil,taz} [129.194.70.1]


   like to know their public and will inform you when a new release is
   available. This is also the email address for bug reports or if you
   need any kind of help. This product may be distributed freely and
   used without restrictions except for military purposes.


   MIT Scheme (aka C-Scheme), free by anonymous FTP from
   altdorf.ai.mit.edu in the directory pub/scheme-7.1 (for the
   architectures MC68020/30/40, HP Prevision Architecture, MIPS, VAX,
   Sparc (SunOS), Intel 386/486, and DEC Alpha).  Directory scheme-7.2
   contains preliminary *alpha* versions of the next release of MIT
   C-Scheme for the MIPS and Intel 386/486 (MS-DOS, Windows 3.x and Unix)
   architectures. (The port includes Edwin, Scheme's Emacs-like editor
   and Liar, the Scheme compiler. If you acquire the alpha release

   so they know to send you updates and bug reports. Bugs in the DOS

   have a convenient foreign function interface yet. FTP distribution
   includes MIT C-Scheme Reference and User manuals, as well as the
   Revised^4 Report on Scheme.  Send bug reports to

   (includes printed copies of manuals), send $95.00 (payable in U.S.
   funds to "Scheme Distribution") to cover costs of distribution to
   Scheme Distribution, c/o Prof. Hal Abelson, 545 Technology Sq. rm 410,
   Cambridge MA 02139, USA.
   |
   On the NeXT, MIT Scheme is available as part of the Schematik
   package, which provides an editor/front-end user interface,
   graphics, and "robotics" support for Lego and the like.  Schematik is
   free and is available for anonymous ftp from ftp.gac.edu in the
   pub/next/scheme directory. Europeans can get it more locally from
   ftp.informatik.uni-muenchen.de, in the directory /pub/next/ProgLang;
   start with Schematik-1.1.5.1.README .  Schematik is also apparently
   included on NeXT's "Educational Software Sampler" CD-ROM.
   |
   A preliminary unofficial port of C-Scheme to the Linux is available
   from artemide.dei.unipd.it:/linux/scheme-7.2/. Contact the author

   SCM, free by anonymous ftp from altdorf.ai.mit.edu:archive/scm/,
   prep.ai.mit.edu:pub/gnu/jacal/, nexus.yorku.ca:pub/scheme/new/, or
   ftp.maths.tcd.ie:pub/bosullvn/jacal/. Current version 4d3. Runs on
   Amiga, Atari-ST, MacOS, MS-DOS, OS/2, NOS/VE, VMS, Unix and similar
   systems. SCM conforms to the Revised^4 Report on the Algorithmic
   Language Scheme and the IEEE P1178 specification. Scm is written in C.
   ASCII and EBCDIC are supported. Written by Aubrey Jaffer.
      To receive an IBM PC floppy disk with the source files and MSDOS
   and i386 executables send $99 to Aubrey Jaffer, 84 Pleasant Street,

      SLIB is a portable Scheme library which SCM uses, and is
   available as the file slib1d5.tar.Z. Written by Aubrey Jaffer.
      JACAL is a symbolic math system written in Scheme, and is
   available as the file jacal1a4.tar.Z.
      SCMCONFIG contains additional files for the SCM distribution to build
   SCM on Unix machines using GNU autoconf.
      SLIB-PSD is a portable de{*filter*} for Scheme (requires emacs editor).
      TURTLSCM is a turtle graphics package which works with SCM on MSDOS


   (Also available from modeemi.cs.tut.fi:pub/scm/ as turtlegr.tar.gz,
   along with an already-compiled MSDOS binary of scm with turtlegraphics
   and slib in scm4c0_b.zip.)
      XSCM is an X Windows interface to Xlib and the Motif and
   OpenLook toolkits for the SCM interpreter. It requires scm4a10 or
   later. It should be available at any archive of alt.sources, or on
   altdorf, prep and nexus as the file xscm1.05.tar.Z.

      SMG-SCM is a package that adds VMS SMG screen management routines
   to SCM. It is available from altdorf, prep and nexus as the file
   sgm-scm2a1.zip. (A VMS version of Unzip is available by anonymous
   FTP from ftp.spc.edu:[ANONYMOUS.MACRO32]UNZIP.EXE.) This file
   contains the source code, documentation, and example code. Send


      WB is a disk based, sorted associative array C library.  These
   associative arrays consist of variable length (less that 256 bytes)
   keys and values.  WB comes with an interface to SCM. Basic
   operations are creation, destruction, opening and closing of
   diskfiles and arrays, insertion, deletion, retrieval, successor, and
   predecessor (with respect to dictionary order of keys).  Functional
   application of find-next, deletion, and modification over a range of
   consecutive key values is supported. Multiple associative arrays
   can be stored in one disk file. Simultaneous access to multiple
   disk files is supported.  A structure checker, garbage collector
   are included.  A repair program and ram-disk type file (for
   temporary structures) are in developement. The current WB
   implementation has a file size limit of 2^32 * block size (default
   2048) = 2^43 bytes (8796 Gbytes). WB does its own memory and disk
   management. WB is available on altdorf, prep, and nexus as wb1a1.tar.z.

   A Windows version of Scheme called WinScm is forthcoming from
   Vincent Manis of Langara College of BC, Canada.

   Hobbit is a Scheme-to-C compiler that works with the SCM Scheme
   interpreter. It treats SCM as a C library and integrates compiled
   functions into SCM as new primitives. Hobbit release 2 works with SCM
   release 4b4. Future releases of SCM and Hobbit will be coordinated.
   Hobbit imposes strong restrictions on the higher-order features of
   Scheme. For example, it does not support continuations.  The main aim
   of hobbit is to produce maximally fast C programs which would retain
   most of the original Scheme program structure, making the output C
   program readable and modifiable. Hobbit is written in Scheme and is
   able to self-compile. Hobbit can be obtained via anonymous ftp from
      altdorf.ai.mit.edu:archive/scm/hobbit2.tar.Z
      prep.ai.mit.edu:pub/gnu/jacal/hobbit2.tar.Z
      nexus.yorku.ca:pub/scheme/new/hobbit2.tar.Z
   For further information, contact the author, Tanel Tammet, at

   Sciences, Chalmers University of Technology, S-41296 Go"teborg, Sweden.

   Gambit is an optimizing Scheme compiler/system. It conforms to the
   IEEE-Scheme standard (IEEE P1178) and the Revised^4 Report on Scheme
   (R4RS). The system supports the whole numeric tower (i.e. integer,
   rational, real and complex numbers). It also has several extensions to
   the standards including: weak pairs, string ports, property lists,
   futures, pretty printer, de{*filter*}, compiler and multitasking. Gambit
   runs on M680x0 based machines only (including Sun3, Apollo,
   HP9000/3xx, BBN GP1000 multiprocessor, Amiga, NeXT, and the Apple
   Macintosh). The latest version for UNIX based machines (including the
   Macintosh running A/UX) is release 1.9. The latest version for the Mac
   running the normal System/Finder is MacGambit release 1.9.1. The
   distribution contains the interpreter and optimizing native code
   compiler and all the sources required to build the system (the sources
   for MacGambit are for THINK-C 5.0). MacGambit's specific features
   include: a Scheme interface to several Toolbox routines (mostly
   QuickDraw), a drawing window for simple graphics, an online help
   system containing R4RS and a Scheme oriented editor with an emacs
   compatibility mode. Gambit Scheme is available by anonymous ftp from
   ftp.iro.umontreal.ca:/pub/parallele/gambit/ [132.204.32.22].
   Versions 1.7, 1.7.1, 1.8.2, 1.9.1 and 2.0 may be found in this
   directory. Version 2.0 is in the files gambit20.tar.Z (Unix source),
   macgambit-2.0-interpreter.hqx (MacGambit interpreter),
   macgambit-2.0-sources1.hqx (sources needed to build the interpreter
   using Think-C 5.0), and macgambit-2.0-sources2.hqx (Scheme source
   files for runtime and compiler, and DEC's Thomas interpreter).
   Copies may also be found in the Scheme Repository on
   nexus.yorku.ca:pub/scheme/imp/, but the most recent version will
   always be available from ftp.iro.umontreal.ca. MacGambit may also be
   obtained from the directory
        /afs/umich.edu/group/itd/archive/mac/development/languages/
   if your site runs the Andrew File System, or by anonymous ftp from
   mac.archive.umich.edu. For more information about Gambit, send email


   copyright 1992, Universite de Montreal. The programs may be
   distributed to others as long as they are not sold or transferred for
   compensation (other than a reasonable duplication fee).

   T3.1 is a Scheme-like language developed at Yale. Available by
   anonymous ftp from ftp.ai.mit.edu in the directory pub/systems/t3.1.
   (T may be obtained in Europe from nic.funet.fi in the directory
   pub/unix/languages/scheme/t3.1 or from ftp.diku.dk in the directory
   pub/t3.1) Runs on DecStations (MIPS processor) and SGI Iris, Sun4
   (SPARC), Sun3, Vax/Unix. Includes a copy of the online version of the
   T manual and release notes for T3.0 and T3.1. All implementations
   include a foreign function (C) interface. To be informed of fixes, new


   T (for Encore Multimax) is available from masala.lcs.mit.edu:/pub/mult.
   [The sources were last modified November 22, 1991.]

   Oaklisp is an seamless integration of Scheme with an object-oriented
   substrate. Available by anonymous ftp from f.gp.cs.cmu.edu
   [128.2.250.164] in the directory /usr/bap/oak/ftpable, or from
   ftp.cs.cmu.edu in /afs/cs.cmu.edu/user/bap/oak/ftpable, and includes
   reference and implementation manuals. Written by Barak Pearlmutter

   Elk (Extension Language Kit) is a Scheme interpreter designed to be
   used as a general extension language for applications written in C or
   C++. Elk can also be used as a stand-alone implementation of the
   Scheme programming language. It is mostly R4RS and P1178 conformant
   (with the exception of the number system and a few minor details).  It
   has interfaces to Clib, Xt, and the Athena and OSF/Motif widget sets.
   It includes dynamic linking of C object files, an optional foreign
   function interface, and a generational garbage collector (by Marco

   from tub.cs.tu-berlin.de:pub/elk/. It also available from the Scheme
   Repository in nexus.yorku.ca:/pub/scheme/imp/ and in the X contrib
   directory on ftp.x.org (formerly export.lcs.mit.edu). Runs on Unix,
   SunOs, and Ultrix based platforms, including VAX, Sun3, Sun4 (Sparc),
   680x0, 80386, MIPS, IBM RT, IBM RS/6000, HP9000/700, SGI, and Sony

   Scheme->C is an R4RS compliant Scheme system that is centered around
   a compiler that compiles Scheme to C.  Besides the base language,
   the system includes "expansion passing style" macros, a foreign function
   call capability, records, weak pointers, 3 X11 interfaces, call/cc, and a
   generational, conservative, copying garbage collector. The result is a
   system that is portable, efficient, and able to build applications that
   contain a mix of compiled and interpreted Scheme, and compiled code
   from C, C++ and other languages.  The current release of Scheme->C runs
   on the following systems: Digital Alpha AXP systems with OSF/1, MIPS
   based DECstations, VAXen with ULTRIX, MIPS based SGI systems, PC's
   running Microsoft Windows 3.1, Apple Macintosh's running system 7.1,
   HP 9000/300, HP 9000/700, Sony News, Harris Nighthawk and other m88k
   systems, linux, and Sun SPARC.  Earlier releases also run on Sun3,
   DNx500, DN1000, 386's running Unix, DNx500, and DN1000 systems.  The
   software is available for anonymous ftp from gatekeeper.dec.com
   [16.1.0.2] from the directory pub/DEC/Scheme-to-C.  There are three
   interfaces to X11, all written in Scheme, available from gatekeeper.
   The first is a complete set of stubs to Xlib included in the base
   system.  The second is an alternative to Xlib called SCIX, found in
   pub/X11/contrib.  The third, ezd, allows programs to easily produce
   interactive, structured graphics and is found in pub/DEC/ezd.  Those
   without ftp access can also obtain Scheme->C and ezd from the Prime Time
   Freeware CD, Vol. 1, No. 2.  Additional information is available from
   the author at Digital Equipment Corporation's Western Research Lab:

   SIOD (Scheme in One Defun), free by anonymous ftp from
        nexus.yorku.ca:pub/scheme/imp/siod-v2.9-shar
        world.std.com:src/lisp/siod-v2.9-shar
   or in any comp.sources.unix archive.  Runs on VAX/VMS, VAX UNIX, Sun3,
   Sun4, Amiga, Macintosh, MIPS, Cray.  Small scheme implementation in C
   arranged as a set of subroutines that can be called from any main
   program for the purpose of introducing an interpreted extension
   language.  Compiles to ~20K bytes of executable.  Lisp calls C and C

   XScheme is available free by anonymous ftp from ftp.uu.net in the
   directories MSDOS/languages/X-scheme and amiga-sources/xscheme.20.zoo.
   It includes an object system and is R3RS compliant.
   It was written by David Michael Betz, 167 Villa Avenue #11, Los Gatos,

   XScheme is discussed in the newsgroup comp.lang.lisp.x.  It may also
   be found in the Scheme Repository.

   Fools' Lisp is a small Scheme interpreter that is R4RS conformant, and
   is available by anonymous ftp from scam.berkeley.edu [128.32.138.1] in
   the directory src/local/fools.tar.Z. Runs on Sun3 and Sun4 (SunOs),
   DecStation 3100s, Vax (Ultrix), Sequent, and Apollo. Implemented by

   Scheme48. The entry on Scheme48 has been temporarily removed, per
   Jonathan Rees, 11/25/92. Scheme48 was an alpha release, and it was not
   possible for a general user to reconstruct the system from sources.
   When the distribution is complete we will restore the Scheme48 blurb.

   UMB Scheme is a R4RS Scheme available by anonymous ftp from
   ftp.cs.umb.edu in pub/scheme/umb-scheme-2.10.tar.Z and also in the Scheme
   Repository. It includes a simple editor, de{*filter*}, Written by William

   VSCM is a R4RS Scheme available by anonymous ftp from the Scheme Repository,
      nexus.yorku.ca:pub/scheme/imp/vscmV0r1.tar.Z [130.63.9.66]

   implementation is based on a virtual machine design with heavy support
   for most of the sophisticated features of Scheme. The virtual machine
   is written in ANSI-C to aid in its portability. The bytecode compiler
   is written in Scheme itself.

   Pixie Scheme for the Macintosh is a nearly complete implementation of
   R3RS available by anonymous ftp from
   rascal.ics.utexas.edu:/misc/mac/programming/
     Pixie.Goodies.SIT.bin
     Pixie.NoFPP.world.SIT.bin
     Pixie.world.SIT.bin
     PixieScheme.NoFPP.SIT.bin  ; for macs without floating-point coprocessor
     PixieScheme.SIT.bin        ; for macs with FPP
     Pixie_Scheme_Help.SIT.bin
     Pixie_intro

   Palo Alto, CA, 94306-0628. A copy may also be obtained from
     /afs/umich.edu/group/itd/archive/mac/development/languages
   as the file pixiescheme.cpt.hqx if your site runs the Andrew File System,
   or by anonymous ftp from mac.archive.umich.edu.

   HELP (a lazy Scheme) is available by anonymous ftp from
   sumex-aim.stanford.edu:/info-mac/lang/lazy-scheme.hqx.  Written by

   efficient Scheme-like functional lazy Lisp interpreter.  It works only
   on 68020 (or more) based Macintoshes. It has a 'friendly' interface
   (parenthesis matcher, auto-indent), uses a full call-by-need semantics
   and includes many examples, including a symbolic compiler for the
   680x0. Efficiency is good and lazyness is fully parametrizable (you
   may turn Help into a strict Scheme-like language if you like). French
   AND English updated docs are included in Word4 and plain text formats.

   Similix is a Self-Applicable Partial Evaluator for a Subset of Scheme.
   Written by Anders Bondorf, Olivier Danvy, and Jesper J{\o}rgensen. It
   is available by anonymous ftp from nexus.yorku.ca:/pub/scheme/imp/ as
   similix.tar.Z or from ftp.diku.dk:pub/diku/dists/Similix.tar.Z. For more
   information, contact Anders Bondorf, DIKU, Department of Computer
   Science, University of Copenhagen, Universitetsparken 1, DK-2100

   to the IEEE and R4RS standards, but also runs under R3RS Scheme. It
   runs in SCM, Chez Scheme and T3.1.

   FDU Scheme is a R3RS implementation of Scheme for the Prime
   50-series under Primos. It is available by anonymous ftp from
   fdumad.fdu.edu [132.238.1.1] (username "anonymous", password
   <RETURN>). Attach to the Scheme subdirectory (cd '*>scheme') and
   transfer all files in it and its subdirectories using file type
   binary.  For more information, contact Peter Falley,

   BIGLOO is a Scheme interpreter and compiler. It conforms to the
   IEEE-Scheme standard (IEEE P1178) with some extensions, such as
   regular expression parsing (RGC) and a pattern matching compiler.  The
   main goal of Bigloo is to deliver small and fast stand alone
   applications.  Bigloo produces ANSI C and hence should be easy to
   port. It runs on Sparc (1, 2, 10), SONY-NEWS (MIPS R3000), IRIS Indigo
   (MIPS R3000), Sun 3/60, DecStation 3100, PC-486 (linux), and HP-PA (730).
   It is available by anonymous ftp from
      ftp.inria.fr:/INRIA/Projects/icsla/Implementations/bigloo1.5.tar.gz

   write to Manuel Serrano (equipe ICSLA, Bat 8), INRIA-Rocquencourt,
   BP 105, 78153, Le Chesnay CEDEX, FRANCE, or call 39-63-57-32.

Free Scheme Implementations implemented in Lisp:  

   Peter Norvig's book "Paradigms of AI Programming" has a chapters about
   Scheme interpreters and compilers, both written in Common Lisp. The
   software from the book is available by anonymous ftp from
   unix.sri.com:pub/norvig and on disk in Macintosh or DOS format from
   the publisher, Morgan Kaufmann.  For more information, contact: Morgan
   Kaufmann, Dept. P1, 2929 Campus Drive, Suite 260, San Mateo CA 94403,
   or call Toll free tel: (800) 745-7323; FAX: (415) 578-0672

   PseudoScheme is available free by anonymous ftp from
   altdorf.ai.mit.edu:/archive/pseudo/pseudo-2-8.tar.Z. It is Scheme
   implemented on top of Common Lisp, and runs in Lucid, Symbolics CL,
   VAX Lisp under VMS, and Explorer CL. It should be easy to port to


   to be put on a mailing list for announcements. Conforms to R3RS except
   for lacking a correct implementation of call/cc. It works by running
   the Scheme code through a preprocessor, which generates Common Lisp code.

   Scheme84 is in the public domain, and available by mail from Indiana
   University. It runs on the VAX in Franz Lisp under either VMS or BSD Unix.
   To receive a copy, send a tape and return postage to: Scheme84
   Distribution, Nancy Garrett, c/o Dan Friedman, Department of Computer
   Science, Indiana University, Bloomington, Indiana. Call 1-812-335-9770

   Scheme88 is available by anonymous ftp from rice.edu:public/scheme88.sh
   and also from the Scheme Repository.

----------------------------------------------------------------
Subject: [1-6] Commercial Scheme implementations.

   Chez Scheme is fully compatible with the IEEE and R4RS standards for the
   Scheme programming language and includes an incremental compiler, object
   inspector, multitasking with engines, and a foreign function interface. It
   runs on Sparc and Sun3 (SunOs), Vax and DecStation (Ultrix), NeXT, Silicon
   Graphics, and Motorola Delta 88000, costs approximately $2000 and requires
   4-8mb RAM.  Implemented by Kent Dybvig, Robert Hieb, and Carl Bruggeman.
   Write to: Cadence Research Systems, 620 Park Ridge Road, Bloomington, IN
   47408, call (812) 333-9269, or fax (812) 332-4688.

   MacScheme is a Scheme interpreter and compiler for the Apple Macintosh, and
   includes an editor, de{*filter*} and object system.  MacScheme costs $125
   (includes compiler) and Scheme Express costs $70 (interpreter only). It
   requires 1mb RAM. A development environment (MacScheme+Toolsmith) costs
   $495. Conforms to the Revised^4 Report on the Algorithmic Language Scheme.
   MacScheme+Toolsmith includes support for menus, windows, and interfaces to
   the Macintosh Toolbox, and can create small standalone Macintosh
   executables. Implemented by Will Clinger, John Ulrich, Liz Heller and Eric
   Ost.  Write to: Lightship Software, PO Box 1636, Beaverton, OR 97075, or
   call (503) 292-8765. They're moving to California. The temporary phone
   number is 415-940-4008 (Liz Heller). The new phone number will be
   415-694-7799. MacScheme is distributed by ACS, 2015 East 3300
   South, Salt Lake City, UT 84109-2630, 1-800-531-3227 (801-484-3923).

   EdScheme runs on Macintosh, DOS and Atari ST and costs $50.  It
   includes an incremental compiler, editor, and turtle graphics
   interface, and is a close match to the IEEE standard. Implemented by
   Iain Ferguson, Edward Martin, and Burt Kaufman.  The book (The
   Schemer's Guide) is 328 pages long costs $30.  Write to: Schemers
   Inc., 2136 NE 68th Street, Suite 401, Fort Lauderdale, FL 33308, call
   (305) 776-7376, or fax (305) 776-6174. You can also send email to

   platform which is only available through their European distributor,
   Lambda Publications, who is reachable by phone at 44-793-695296 or by

----------------------------------------------------------------
Subject: [1-7] Standards for Scheme -- What are R4RS and IEEE P1178?

R4RS is the Revised^4 Report on the Algorithmic Language Scheme,
edited by W. Clinger and J. Rees. It appeared in ACM Lisp Pointers IV,
July-September 1991, and also as MIT AI Memo 848b. It serves as a kind
of standard for the language. It can be obtained by anonymous ftp at
the two Scheme Repositories, altdorf.ai.mit.edu and nexus.yorku.ca.

IEEE P1178 is IEEE Standard 1178-1990, "IEEE Standard for the Scheme
Programming Language", published by IEEE in 1991. ISBN 1-55937-125-0.
It is now also an ANSI standard. It may be ordered from IEEE by
calling 1-800-678-IEEE or 908-981-1393 or writing IEEE Service
Center, 445 Hoes Lane, P.O. Box 1331, Piscataway, NJ 08855-1331,
and using order number SH14209 ($28 for IEEE members, $40 others).

----------------------------------------------------------------
Subject: [1-8] How do I do object-oriented programming in Scheme?

Some Scheme implementations (for example, MacScheme, Feel, Oaklisp, XScheme,
and PC-Scheme) include built-in object-oriented extensions.  

SCOOPS (Scheme Object Oriented Programming System) is an object system
for Scheme written by Amitabh Srivastava/Texas Instruments with

address bounced 7/7/93.] This package needs first-class environments.
It is available from the Scheme Repository as /pub/scheme/scm/scoops.sha.

MEROON is a package written in Scheme to provide the basic facilities
of an object-oriented programming style through three macros:
define-class, define-generic, and define-method. MEROON offers simple
inheritance, reflective metaclasses and simple dispatching generic
functions. MEROON also offers indexed fields subsuming Scheme vectors
without inheritance restrictions. Meroon runs in Scheme->C, PC-Scheme,
Chez Scheme, Elk, Gambit. MEROON sources and documentation may be
found in the Scheme Repository as
   nexus.yorku.ca:pub/scheme/new/meroon.*.tar.Z
and also from
   ftp.inria.fr:pub/INRIA/icsla/meroon*.tar.Z. [128.93.1.26]

YASOS (Yet Another Scheme Object System) is fairly functional in style
and uses delegation.  The implementation includes multiple inheritance
and "send to super" and is much smaller than class-based OO systems.
See Ken{*filter*}ey, "Scheming with Objects", AI Expert 7(10):24-33,
October 1992. A copy of the article and YASOS code is available from
the Scheme Repository in /pub/scheme/txt/swob.txt. YASOS is also
included as part of SLIB. For further information, contact Ken{*filter*}ey

Tiny CLOS is a Scheme implementation of a `kernelized' CLOS, with a
metaobject protocol. The implementation is even simpler than the
simple CLOS found in `The Art of the Metaobject Protocol,' weighing in
at around 850 lines of code, including (some) comments and
documentation. Tiny CLOS is available by anonymous ftp from
parcftp.xerox.com:/pub/mops/. Tiny CLOS runs in MIT Scheme 11.74 and
should run with only minor modifications in other Schemes as well. If

(technical questions and discussion only), send mail to Gregor Kiczales

----------------------------------------------------------------
Subject: [1-9] Repositories of Scheme Software

There are several repositories of publicly redistributable and
public domain Scheme code.

   The Scheme Repository contains a Scheme bibliography, copies of the
   R4RS report, IEEE P1178 specification and other papers, sample Scheme
   code for a variety of purposes, several utilities, and some
   implementations. The Scheme code includes code for calendar
   calculations, Earley parser, FORMAT for Scheme, a scheme version of
   the Gabriel benchmarks, Marc Feeley's minimal object support for
   Scheme, a Scheme pretty-printer, a Prolog interpreter written in
   Scheme, a random number generator in Scheme, an implementation of
   SCOOPS, code from Abelson and Sussman's SICP book, Aubrey Jaffer's
   IEEE/R^3.99RS compliance test, an implementation of matrices, a Scheme
   implementation of the Common Lisp FORMAT function, a Scheme front
   end to Adobe Illustrator postscript, and a LALR(1) parser (ZEBU).

   The repository is accessible by anonymous ftp at nexus.yorku.ca
   [130.63.9.66] in the directory pub/scheme/. The repository is
   mirrored in INRIA, courtesy of Christian Queinnec [Ecole Polytechnique
   and INRIA-Rocquencourt], ftp.inria.fr:lang/Scheme.

   Scheme Implementations may also be found at altdorf.ai.mit.edu:/archive/
   The R4RS report is available in altdorf.ai.mit.edu:/archive/scheme-reports/

   The altdorf archive includes SCOOPS, CL2Scheme, extend-syntax,
   btree, Gabriel benchmarks, FORMAT for Scheme, etc.

   The GI (German Computer Science Society) Scheme Archive contains a
   variety of scheme programs, utilities, code from theses, and other
   materials. It also mirrors the Nexus Scheme Repository.  It is
   accessible by anonymous ftp to faui80.informatik.uni-erlangen.de
   (login as 'ftp', giving your email address as the password).
      pub/scheme/gi                # GI Scheme Archive
      pub/scheme/yorku             # Internet Scheme Repository

   The GI Scheme Archive is supported by the German Computer Society Special
   Interest Group on AI programming and sponsored by the Bavarian AI Center
   FORWISS -- Research Institute for Knowledge Based Systems.

----------------------------------------------------------------
Subject: [1-10] Publicly Redistributable Scheme Software

   SLIB is a portable scheme library that provides compatibility and
   utility functions for many of the standard scheme implementations,
   including Chez, ELK 1.5, GAMBIT, MITScheme, scheme->C, Scheme48,
   T3.1 and Scm4b. It is available by anonymous ftp from
       altdorf.ai.mit.edu:archive/scm/slib1d0.tar.Z
       prep.ai.mit.edu:pub/gnu/jacal/slib1d0.tar.Z
       nexus.yorku.ca:pub/scheme/new/slib1d0.tar.Z

   TEST.SCM is an IEEE and R4RS conformance test suite.  It is available
   from
      altdorf.ai.mit.edu:archive/scm/test.scm
      prep.ai.mit.edu:pub/gnu/jacal/test.scm
      nexus.yorku.ca:pub/scheme/new/test.scm

   PSD (Portable Scheme De{*filter*}) is available by anonymous ftp
   from Tampere University of Technology, Finland,
      cs.tut.fi:/pub/src/languages/schemes/psd-1.1.tar.Z
   With PSD, you can run a Scheme program in an Emacs buffer, set
   breakpoints, single step evaluation and access and modify the
   program's variables. It works by instrumenting the original source
   code, so it should run with any R4RS compliant Scheme. It has been
   tested with SCM and Elk 1.5, but should work with other Schemes with a
   minimal amount of porting, if at all. Includes documentation and

   SCLINT is a lint-like program for Scheme. It checks for consistency of
   indentation, syntax of special forms, and the number of arguments to
   primitive and most user-defined procedures. This is not a full
   implementation, but rather a quick hack. It is used in teaching
   programming at the Tampere University of Technology. It is available
   by anonymous ftp from cs.tut.fi:/pub/src/languages/schemes/sclint-0.9.tar.Z.

   A bibliography of work in functional programming can be obtained by
   anonymous ftp from tamdhu.dcs.st-andrews.ac.uk:/pub/staple/pubs.txt
   (138.251.192.40). It uses a refer-like format with %T for title, %A
   for authors %I for a unique index entry %S for source (possibly a
   reference to another index) %K for keywords and %C for comments.

   Scheme Utilities -- brokaw.lcs.mit.edu:/pub/scmutils.tar  18.30.0.33
   [This collection seems to no longer be located on brokaw -- does
   anybody know the current location?]

   A collection of Scheme implementations of data structures and
   algorithms is available by anonymous ftp from cs.tut.fi in the
   directory /pub/src/languages/schemes/ as the file scheme-algorithms.tar.

   6.001. The User's Manual, example code, and problem sets from MIT's
   course "Structure and Interpretation of Computer Programs" are
   available by anonymous ftp from martigny.ai.mit.edu:archive/6.001/
   [18.43.0.152].

   Steele's Constraint System. Chris Hanson's implementation of Steele's
   constraint system is available for anonymous ftp from
      martigny.ai.mit.edu:archive/cph/constraint.tar [18.43.0.152]
      nexus.yorku.ca:pub/scheme/new/constraint.tar.Z
   A compressed version is also stored there. The software is source code
   for MIT Scheme. It should run in release 7.1.3. Most of the MIT Scheme
   dependencies could be eliminated, but it also uses the following
   procedures which aren't in standard Scheme: error, bkpt, macros,
   dynamic binding, and string output ports. The code corresponds pretty
   closely to Guy Steele's PhD thesis implementation, which you can
   obtain in printed form from the MIT AI Lab publications office as

   information). For more information, send email to Chris Hanson

   JACAL is a symbolic mathematics system for the simplification and
   manipulation of equations and single and multiple valued algebraic
   expressions constructed of numbers, variables, radicals, and algebraic
   functions, differential, and holonomic functions. In addition, vectors
   and matrices of the above objects are included.  JACAL is written in
   Scheme and requires SLIB. JACAL source is available via anonymous FTP
   from
      altdorf.ai.mit.edu:archive/scm/jacal1a0.tar.Z,
      prep.ai.mit.edu:pub/gnu/jacal/jacal1a0.tar.Z, and
      nexus.yorku.ca:pub/scheme/new/jacal1a0.tar.Z

   Zebu 0.9 is an LALR(1) parser generator for Scheme written by
   William M. Wells III. It lives in the Scheme Repository nexus.yorku.ca
   in the scm directory and works with PC-Scheme from TI and MIT C-Scheme 6.2
   (but not with anything after 7.0).

   Thomas is a compiler for the Dylan programming language.  The Thomas
   system is written in Scheme and runs under MIT's CScheme, DEC's
   Scheme->C, and Marc Feeley's Gambit.  It can run on a wide range of
   machines including the Macintosh, PC compatibles, Vax, MIPS, Alpha,
   and 680x0.  Thomas generates IEEE compatible Scheme code.  Thomas is
   available to the public by anonymous ftp at
      crl.dec.com:pub/DEC/Thomas
      gatekeeper.pa.dec.com:pub/DEC/Thomas
      altdorf.ai.mit.edu:archive/Thomas
   For more information on Thomas and Dylan, see part 4 of the Lisp FAQ.

   MATCH is a pattern matching macro package for Scheme.  Pattern
   matching allows complicated control decisions based on data structure
   to be expressed in a concise manner. This document describes several
   pattern matching macros for Scheme, and an associated mechanism for
   defining new forms of structured data. This macro package works with
   any Scheme that supports defmacro (which is obtainable by loading
   SLIB), such as Chez Scheme (release 4 or greater). MATCH is available
   by anonymous ftp from titan.cs.rice.edu:public/wright/match.tar.Z
   [128.42.1.30] and includes the macro source code and documentation. A
   copy should be available from the Scheme repository shortly.  For

   STk is a graphical package which relies on Tk and the Scheme
   programming language. It is similar to Ousterhout's Tk package but
   with the Tcl language replaced with Scheme. Mostly R4RS compliant.
   (Some number procedures are not implemented, over-simplified call/cc,
   symbol case is significative.) All of the commands defined by the Tk
   toolkit are available to the STk interpreter, and Tk variables are
   reflected back into Scheme as Scheme variables. Callback is expressed
   in Scheme. Includes a CLOS-like OO extensions.  A set of classes have
   been defined to manipulate Tk commands (menu, buttons, scales, canvas,
   canvas items) as Scheme objects. STk runs on Sparc (SUNOS 4.1.x),
   Dec 5xxx (Ultrix 4.2), SGI (Irix 4.05, 5.1.1), and DEC Alpha. STk
   is available by anonymous ftp from
      kaolin.unice.fr:/pub/STk-2.0.tar.gz [193.48.229.225]
   Please send bug reports, comments, and questions to Erick Gallesio,

   URA 1376 - Bat 4, 250, avenue Albert Einstein, 06560 Valbonne -
   Sophia Antipolis, phone (33) 92-94-26-04, fax (33) 92-94-28-98.

----------------------------------------------------------------
Subject: [6-6] Formatting code in{*filter*}

SLaTeX is a R4RS-compliant Scheme program that allows you to write
program code "as is" in your{*filter*}or TeX source.  It is particularly
geared to the programming languages Scheme and Common Lisp, and has
been tested in Chez Scheme, Common Lisp, MIT C Scheme, Elk, Scheme->C,
SCM and UMB Scheme on Unix; and MIT C Scheme and SCM on MSDOS.  The
formatting of the code includes assigning appropriate fonts to the
various tokens in the code (keywords, variables, constants, data), at
the same time retaining the proper indentation when going to the
non-monospace (non-typewriter) provided by TeX.  SLaTeX comes with two
databases that recognize the standard keywords/variables/constants of
Scheme and Common Lisp respectively.  These can be modified by the
user using easy TeX commands.  In addition, the user can inform SLaTeX
to typeset arbitrary identifiers as specially suited TeX expressions
(i.e., beyond just fonting them).  The code-typesetting program SLaTeX
is available by anonymous ftp from cs.rice.edu as the file

SchemeWEB is a Unix filter that translates SchemeWEB source into{*filter*}
source or Scheme source.  Originally developed for the Scheme dialect
of Lisp, it can easily be used with most other dialects.
Posted to comp.sources.unix, Volume 26, Issue 82, by John D.

----------------------------------------------------------------
Subject: [1-11] Where can I get an implementation of Prolog in Scheme?

   Prolog in Scheme is a collection of macros that expand syntax for
   clauses, elations, and so on. It is written in Scheme and has support
   for delayed goals and interval arithmetic. It is known to run in Chez
   Scheme and in Elk, and is intended to be portable to other Scheme
   implementations. It relies on continuations, and so is not easily
   ported to Common Lisp. Available from the University of Calgary by
   anonymous ftp from
      ftp.cpsc.ucalgary.ca:pub/prolog1.2/prolog12.tar.Z
   Questions and comments may be addressed to Alan Dewar

   An implementation of prolog for Chez Scheme is available by anonymous
   ftp from titan.cs.rice.edu:public/dorai/schelog2.tar.Z. It is a
   collection of macros that expand syntax for clauses, elations, and
   so on into pure Scheme. It should be easily portable to other
   Schemes.  Its use of higher-order continuations is probably a major
   obstacle to porting it to Common Lisp.  For more information,

----------------------------------------------------------------
Subject: [1-12]  What does SICP, SCOOPS, R4RS, CAR, CDR, ... mean?

Glossary of acronyms:
   CAR             Originally meant "Contents of Address portion of Register",
                   which is what CAR actually did on the IBM 704.
   CDR             Originally meant "Contents of Decrement portion of
                   Register", which is what CDR actually did
                   on the IBM 704. Pronounced "Cudder".
   ANSI            American National Standards Institute
   SICP            Abelson and Sussman's book "Structure and
                   Interpretation of Computer Programs".
   EOPL            Essentials of Programming Languages
   SCOOPS          An experimental object-oriented programming
                   language for Scheme.
   R3RS            Revised^3 Report on the Algorithmic Language Scheme.
   R4RS            Revised^4 Report on the Algorithmic Language Scheme.

----------------------------------------------------------------
Subject: [1-13] Why is there no EVAL in Scheme?

The answer to this question is based on information provided by
Guillermo J. Rozas and Aubrey Jaffer.

There are three major positions in the Scheme community regarding EVAL:

   1. No EVAL: EVAL is antithetical to a Pascal-like (compiler based,
      externally statically linked) implementation for Scheme, such as
      some people have or wish to see.

   2. Single Argument: There is a single distinguished top-level
      environment, and EVAL always evaluates its argument there.
      (This is the approach taken in Common Lisp, where EVAL evaluates
      its argument in the current dynamic environment and in a null
      lexical environment.)

   3. Two Arguments: There are multiple environments in which
      the user might want to evaluate expressions, so EVAL should take
      two arguments, the second being an environment.  In particular,
      in some systems with first-class environments, there is no
      a-priori single distinguished top-level environment, and
      defaulting the environment does not fit those dialects well.

Not every dialect of Scheme has EVAL. Most do, but some with different
names and arguments. Jaffer's SLIB package uses LOAD as defined in
R4RS to define EVAL for those implementations that don't support EVAL
(e.g., by writing the code out to a file and then loading it).
Rozas's compromise proposal for EVAL was accepted for R5RS, but it is
unclear whether there will ever be a R5RS.

----------------------------------------------------------------
;;; *EOF*



Thu, 01 Aug 1996 16:02:32 GMT  
 
 [ 1 post ] 

 Relevant Pages 

1. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

2. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

3. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

4. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

5. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

6. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

7. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

8. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

9. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

10. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

11. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

12. FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

 

 
Powered by phpBB® Forum Software