Scheme implementations Compiled by Jonathan Rees. Last updated 19 September 1991. Send corrections to jar@cs.cornell.edu. Send inquiries about the Scheme mailing list (scheme@mc.lcs.mit.edu -- it's the same as the comp.lang.scheme newsgroup) to scheme-request@mc.lcs.mit.edu. The "Revised^3 Report on the Algorithmic Language Scheme" is in SIGPLAN Notices 21(12), December 1986. The TeX source for the report is available by anonymous ftp from altdorf.ai.mit.edu and is included in the MIT Scheme distribution. It can also be ordered from: Publications Office, Room NE43-818 MIT Artifical Intelligence Laboratory 545 Technology Square Cambridge MA 02139 Ask for MIT AI Memo 848a, and enclose a check for $6.00 per copy (U.S. funds) payable to the MIT Artificial Intelligence Laboratory. Implementations listed here: MacScheme PC Scheme MIT Scheme T Chez Scheme Elk Scheme->C skim SIOD Pseudoscheme Scheme84 Vincennes Scheme XScheme Fools' Lisp FDU Scheme Gambit Pixie Scheme scm scheme88 UMB Scheme Oaklisp Implementation: MacScheme+Toolsmith, MacScheme, Scheme Express, MacScheme Student Edition Implemented by: Will Clinger, John Ulrich, Liz Heller, and Eric Ost Supported by: Lightship Software (formerly known as Semantic Microsystems) Hardware: Apple Macintosh family (except XL). Requires 1024K bytes RAM. Operating Systems: Finder/MultiFinder (Macintosh). Price/Availability: MacScheme+Toolsmith: $395, available since December 1986; MacScheme: $150, available since August 1985; Scheme Express: $69.95, available since February 1989; MacScheme Student Edition: available summer 1990, to be co-published by The Scientific Press and MIT Press. Implementation: MacScheme, MacScheme+Toolsmith: native code compiler with compatible byte code interpreter; Scheme Express, MacScheme Student Edition: byte code. Intended Use: MacScheme+Toolsmith: professional software development MacScheme: personal software development Scheme Express: personal computing MacScheme Student Edition: education Contact: Lightship Software P O Box 1636 Beaverton, OR 97075 (503) 643-6909 These implementations support all essential and most optional features of the Revised^4 Report on the Algorithmic Language Scheme, and will be updated to conform to the IEEE standard after it is approved. MacScheme and MacScheme+Toolsmith include a fairly decent native code compiler. Scheme Express and MacScheme Student Edition include only the byte code compiler/interpreter. MacScheme Student Edition is limited to approximately one megabyte of free storage. Each system includes a simple editor that understands Scheme syntax and makes good use of multiple windows and the mouse. Simple graphics are included also, as are facilities for breaking, tracing, and debugging. Most run-time errors can be repaired in the debugger. Pretty-printing and sorting procedures are provided. MacScheme+Toolsmith adds very high-level support for interactive menus, windows, and text editors, high-level support for Macintosh file i/o, and a comprehensive library of type declarations and Scheme procedures for calling the low-level Toolbox traps described in Inside Macintosh. MacScheme also features multi-tasking and a versatile interrupt system for handling events. Scheme source code is provided for the standard interrupt handlers and high-level objects, together with several examples that show how to program standard features of the Macintosh user interface. MacScheme+Toolsmith includes the ResEdit graphical resource editor, and features an Application Builder that creates "double-clickable" heap images from which unused procedures (the compiler, for example) have been removed through selective linking. No royalties are required to distribute these applications. [3-1-90] Implementation: PC Scheme Developed by: Texas Instruments Computer Science Lab Supported by: Texas Instruments Digital Systems Group Hardware: TI Professional and TI Business-Pro Computers, IBM PC, PC/XT, PC/AT and IBM compatibles Operating Systems: MS(tm)-DOS 2.1 (PC-DOS) or better (at least 320K, dual floppy) Price/Availability: List price - $95 Implementation: Incrementally compiled to byte-codes Intended Use: Education, research, and support of AI software on PCs PC Scheme is an implementation of Scheme for the TI Professional Computer and IBM(r) Personal Computer families. The product consists of an optimizing compiler, a byte-code interpreter, extensive run time support, an interactive, display-oriented editor, a language reference manual, and a user's guide. The system was developed on the TI Professional Computer in Scheme itself, with critical run time routines coded in C and assembly language for increased performance. PC Scheme provides all the essential and most of the optional features of the Revised Revised Report on Scheme. It fully supports the dialect used in the book "Structure and Interpretation of Computer Programs" by Abelson and Sussman as well as many extensions developed at Indiana University, MIT, and TI. These include first-class engines and environments and an experimental, object-oriented programming system with dynamic multiple inheritance called SCOOPS. Data type support includes symbols, lists, vectors, strings, fixnums, bignums, flonums (64 bit IEEE floating point), characters, closures, continuations, environments, and I/O ports. Evaluation is based on incremental compilation to byte-coded "virtual machine" code which is emulated using threaded code techniques. Informal benchmarks, including some of the Gabriel set, show PC Scheme programs to be about 3-10 times faster than interpreted IQLISP(tm) and 2-4 times faster than interpreted Golden Common LISP(tm). To order, write to Texas Instruments, 12501 Research Blvd., MS 2151, Austin, TX 78759 and ask for TI Part number #2537900-0001. You may also order by telephone using MasterCard or VISA by calling 1-(800)-TI-PARTS. Questions or comments on the product may be directed to the address given above. We also welcome less formal technical questions and comments, which may be directed via CSNET to Oxley@TI-CSL. [11-12-85] Implementation: MIT Scheme MIT Scheme is a large implementation (the code is over 1 MByte) with an extensive runtime library, suitable for large projects. It is used at MIT both for research and classroom work. MIT Scheme runs on most Unix machines and on VMS Vaxen; it is fairly portable but getting it running on other machines or operating systems requires some work. The version of MIT Scheme now being distributed is an interpreter; a native-code compiler and an Emacs-like editor are in beta-test. Currently the compiler is ported to the MC680x0 and the Vax, with an HP Precision Architecture port underway. For more information about MIT Scheme, or to be added to the MIT Scheme electronic mailing list, send internet mail to: info-cscheme-request@altdorf.ai.mit.edu or US Snail to: Scheme Distribution c/o Prof. Hal Abelson 545 Technology Sq. rm 410 Cambridge MA 02139 To obtain a copy of MIT Scheme: 1) If you have access to the internet, a "tar" file (for Unix) is available by anonymous ftp (user "anonymous", any password) from "altdorf.ai.mit.edu"; read the file "README" for instructions. 2) MIT Scheme is also available as part of the GNU Emacs distribution tape, available for $150 (plus 5% sales tax if in Massachusetts, or plus $15 for air mail if outside North America) from: Free Software Foundation, Inc. 675 Massachusetts Ave. Cambridge MA 02139 3) Otherwise send $200 to the "Scheme Distribution" address above, and specify what form of tape you want. We can currently provide: * 1600 bpi standard tar tape. * 1600 bpi standard VMS backup tape. * HP-UX cartridge tar tape. [1-17-90] Implementation: T The T language, developed at Yale University, includes an environment for Scheme which is at least 99% conformant to the Scheme standard, and there isn't any performance penalty for using T to run Scheme since the Scheme environment just allows a different set of names to be used for the underlying T functions. T also provides some useful extensions to Scheme. T has an optimizing compiler, and best of all it is available by anonymous ftp from wheaties.ai.mit.edu (128.52.32.6) in the pub/t3.1 directory. That directory contains binaries and sources for T3.1. Currently available versions are for Dec3100(pmax), Sun4(sparc),Sun3, Vax/Unix, Encore, Hp workstation, Apollo and Mac/Aux. The online version of the T manual is also there as well as release notes for T3.0 and T3.1. For Sun and Vax there is a C/Unix interface to T. The T compiler is described in a paper by Kranz et al. in the Proceedings of the 1986 SIGPLAN Compiler Construction Conference. In the pub/mult directory on wheaties you can get a T dialect extended for parallelism (uses the future construct) called Mul-T; it runs on the Encore Multimax. T is also distributed on the Gnu Emacs tape from the Free Software Foundation. If you can't get T this way, try to get it from someone who has it, or, as a last resort, Yale will mail you a tape for $200 (?). For more information, contact Linda Joyce at Yale (t-project@cs.yale.edu, 203-432-4715) or write to T Project Yale University Dept. of Computer Science PO Box 2158 Yale Station New Haven, CT 06520 [1-16-87] Implementation: Chez Scheme Written by: R. Kent Dybvig, Robert Hieb, and Carl Bruggeman Supported by: Cadence Research Systems Hardware: VAX (VMS, Ultrix, BSD UNIX), Sun-3 and Sun-4 (SunOs), MC68000-based Apollo (Domain/IX), various Motorola MC88000-based systems, etc. Implementation: incrementally compiled to native code Intended Use: general (education, research, systems development, etc.) Price: ranges from $1500 for one machine to $9,000 for site educational institutions receive 50% discount. Chez Scheme was first released in early 1985, and is in use at dozens of sites, mainly in the U.S., Canada, and Europe. Now in its third major released version, it supports all of the required features of the R3RS and nearly all optional features, and will be upgraded to support all of the features (required and optional) of the forthcoming R4RS and IEEE standard. It also supports all of the features in The Scheme Programming Language. The implementation is based on an incremental optimizing compiler with variable optimization levels. In addition to the features of the R3RS, Chez Scheme provides: * a foreign language interface that allows Scheme programs to dynamically load and call C procedures, with automatic conversion between Scheme and C data types * programmable error and exception handlers * multitasking with engines * tracing and statistics-gathering facilities * a high-level syntax-specification facility (extend-syntax) * separate compilation and fast-loading compiled files * (inexact) floating point numbers and (exact) arbitrary precision integers and ratios * support for first-class environments and compatibility with Structure and Interpretation of Computer Programs * support for complex numbers, ephemeral garbage collection, and new machine types (including the DecStation family) will be available by July 1990. Most of our development time has been spent making the implementation as reliable and as efficient as possible. In making the system efficient, we have concentrated on memory and disk utilization and storage management as well as on compiler speed and speed of generated code. For information contact Kent Dybvig at: Cadence Research Systems 620 Park Ridge Road Bloomington, IN 47408 812/333-9269 dyb@cadence.bloomington.in.us or dyb@iuvax.cs.indiana.edu Include your physical mailing address and phone number. [3-6-90] Implementation: Elk Implemented by: Oliver Laumann Hardware: VAX, Sun-3, Sun-4, ISI 680x0, Intel 80386, Mips, IBM/RT, and others Operating Systems: UNIX/SunOS/Ultrix Price/Availability: Free. Available as source code through the usual sources archives and by e-mail from the author Intended Use: Primarily as a general extension language Elk (Extension Language Kit) is a Scheme interpreter intended to be used as a general extension language; it is also useful as a stand-alone implementation of Scheme. One purpose of the Elk project is to end the recent proliferation of mutually incompatible Lisp-like extension languages. Instead of inventing and implementing yet another extension language, application programmers can link the Scheme interpreter into their application in order to make it extensible and highly customizable. The Elk project was started in 1987 to support ISOTEXT, an ODA-based document system (a WYSIWYG editor) that is being developed at the Technical University of Berlin. Elk has been successfully demonstrated as the extension language kernel of ISOTEXT, e.g. at the Hanover Fair 1989. The Elk Scheme interpreter is R^3RS compatible (with some minor exceptions listed in a separate document); future releases will conform to the R^4RS and/or P1178 as soon as the respective standards become available. Non-standard features of the Scheme implementation include: o dynamic loading of object files o creation of an executable image from the running interpreter (``unexec'') o a macro facility o environments as first-class objects o dynamic-wind, fluid-let o autoloading, provide/require The Scheme interpreter can easily be extended by application-specific new types and primitive procedures. Such extensions are typically written in C or C++ and dynamically loaded into the running interpreter. The current release of Elk includes several such extensions, e.g. interfaces to the X11 Xlib and to the application programmer interface of the Xt intrinsics, and interfaces to the Athena, HP, and Motif widget sets. [1-17-90] Scheme->C: a portable Scheme-to-C compiler Scheme->C is a Scheme-to-C compiler done at Digital Equipment Corporation's Western Research Laboratory. The compiler compiles Revised**3 Scheme to C that is then compiled by the native C compiler for the target machine. This design results in a portable system that allows either stand-alone Scheme programs or programs written in both compiled and interpreted Scheme and other languages. The Scheme->C system supports the essentials of Revised**3 and most of the optionals. Extensions include "expansion passing style" macros, a foreign function call capability, and interfaces to X11's Xlib. The system does provide call-with-current-continuation. Numbers are represented internally as 29-bit integers, or 64-bit floating point values, with integer overflow causing automatic conversion. The compiler is written in Scheme. Most of the runtime system (including an interpreter) is written in Scheme. The generational compacting garbage collector and a few other things are written in C. There is a small (< 100 lines) amount of assembly code. The system is known to run on VAX's and DECstation 3100's running Ultrix. Other ports should be straightforward. [Sun3, Sun4, and Apollo ports are available. - editor.] A research report describing this work can be obtained in either paper or Postscript forms by sending a message to the WRL document server. Send a message to "WRL-Techreports@decwrl.dec.com" with the word "help" in the subject line to receive detailed instructions. The system is available for anonymous ftp from 'gatekeeper.dec.com' [16.1.0.2]. The Scheme->C files are in '/pub/DEC/Scheme-to-C'. Those files include: README - overview and copyright notice. 23feb90.tar.Z - compressed tar file containing all source and documentation. Joel Bartlett bartlett@decwrl.dec.com [2-26-90] Name: skim (a low fat implementation of Scheme) Authors: A. Deutsch, R. Dumeur, C. Consel, J.D. Fekete. Runs-on: Sun[23], Vax, Orion under BSD Unix. Has: An interpreter and a compiler (vax only for now). Features: - R3RS compatibility (but misses complex, bignums and ratios); - extensible type system and operations; - stop/copy gc; - scode based interpreter. Availability: - the system has been registered; - binaries are available (we do not plan to distribute sources now). Performance: - the interpreter is quite fast (5 times faster that MIT-scheme). - the compiler is not an optimizing compiler. Contact: - ...mcvax!inria!litp!{ald|chac|jdf|red} Organization: L.I.T.P, Universite P7, PARIS [12-27-87] Implementation: SIOD (Scheme In One Defun) Implemented by: George Carrette (gjc@bu-it.bu.edu) Contact: gjc@bu-it.bu.edu Support: none Hardware: VAX,SUN,ENCORE,AMIGA,MACINTOSH,... Availability: anonymous ftp from bu-it.bu.edu src/gjc Get either siod-v2.3-shar or siod.* Dialect: Sufficient to run some S&ICP examples. Names have been kept in line with the most recent standards. Intended use: Education. The small size and straightforward implementation makes it possible to read and understand in a sitting. It can be used as a starting point for shells, command interpreters and window hacking interfaces. Implementation: "C" language with standard-io and the usual math and string library calls only. There is a single conditionalized section having to do with getting the process cpu runtime. A small amount of Scheme code is provided, including some macros and a streams implementation. Remarks: The synchronous GC, with respect to read/eval/print/gc, greatly simplifies the coding. It does however make it impractical for lengthy calculations. The SIOD name is historical. The following subroutine from the implementation should give you an idea of the simplicity. scan_newspace(newspace) struct obj *newspace; {register struct obj *ptr; for(ptr=newspace; ptr < heap; ++ptr) {switch TYPE(ptr) {case tc_cons: case tc_closure: CAR(ptr) = gc_relocate(CAR(ptr)); CDR(ptr) = gc_relocate(CDR(ptr)); break; case tc_symbol: VCELL(ptr) = gc_relocate(VCELL(ptr)); break; default: break;}}} [6-8-88, updated 12-15-89] Implementation: Pseudoscheme (Scheme embedded in Common Lisp) Implemented by: Jonathan Rees Support: Unsupported, although I'll probably continue to improve it. Hardware, etc.: Will run in any implementation of Common Lisp. Availability: Free. Distributed as source via anonymous FTP from altdorf.ai.mit.edu: archive/pseudo/pseudo-2-7.tar.Z. Dialect: Subset. Tail-recursion is not supported except in the special case that a loop is found statically, which is when the loop is written explicitly using LETREC or something that expands into LETREC (DO, named LET, internal DEFINE). Tail-recursion will of course be inherited from the host Common Lisp if it has it. All of the essential features of R^3 Scheme exist, except for a correct CALL-WITH-CURRENT-CONTINUATION (some of you will say that it's not Scheme at all, and I don't disagree) and number exactness; most of the non-essential features are there too. Intended use: Running most Scheme programs using any Common Lisp. Implementation: A preprocessor translates Scheme code into Common Lisp code, which is then interpreted or compiled by the host Common Lisp system. Remarks: I did this mostly for my own personal use. Maybe other people will find it useful too. Contact: Jonathan Rees (jar@altdorf.ai.mit.edu), MIT Artificial Intelligence Laboratory, 545 Technology Square, Cambridge MA 02139, (617) 253-8581. [2-27-86, updated 1-16-90] Implementation: Scheme84 Scheme84 is a version of Scheme that has been under development at Indiana University for the past few years, and is used there to support half a dozen different computer science courses. The system runs on the Vax under either VMS or Berkeley Unix. The developers of Scheme84 intend to supply a compatibility package that will allow the MIT materials to be run without modification. The Scheme84 software is in the public domain, and can be obtained by writing to Scheme84 Distribution Nancy Garrett c/o Dan Friedman Department of Computer Science Indiana University Bloomington, Indiana (812)-335-9770 E-mail address nlg@indiana The current distribution policy for Scheme84 is that Indiana University will supply it for free, if you send them a tape and return postage. (Please specify whether the system is to be for VMS or for Unix.) On the other hand, the University reserves the right to begin charging a fee to recover the cost of distribution, should this become necessary. [early 1985?] Implementation: Vincennes Scheme Vincennes Scheme is a version of Scheme written entirely in portable C, for Unix V7 and Berkeley 4.1 and 4.2. It runs on 32-bit machines (e.g. 68K or Vax) as well as on 16-bit machines (e.g. Z8000 in which it can fit in 128K). This Scheme is compatible with the MIT version, and includes an interpreter with the basic environment: debugger, history, break, stepper, where. A compiler that generates C code is available. For more information, contact Patrick Greussay Universite Paris-8-Vincennes 2 rue de la Liberte Saint-Denis CEDEX 02 93526 France [early 1985?] Date: Fri, 31 Aug 1990 12:55:55 PDT From: Patrick GREUSSAY To: rees@parc.xerox.com Subject: vincennes scheme The information is still correct. Implementation: xscheme See usenet newsgroup comp.lang.lisp.x for discussions of xscheme and xlisp. MSDOS/XScheme is on uunet.uu.net in the directory MSDOS/languages/X-scheme. From: Rusty Haddock Subject: XScheme 0.20 for the Amiga available on UUNET This morning (2/6) I put a Zoo file containing the sources, two binaries, and documentation for David Betz's XScheme 0.20 (yes, not even 1.0 yet) with my Amiga/Manx modifications onto UUNET.UU.NET (192.48.96.2) for anonymous ftp. The file was amiga-sources/xscheme.20.zoo The two binaries included, xscheme and xscheme.881, were compiled for using the IEEE math libraries and 68881/2 inline code, respectfully. Two things to remember: 1) Use binary mode for ftp'ing. 2) I simply ftp'ed this onto UUNET's disks without any specific permission to do so. As such, my file may disappear without warning. If this happens I'll find another way to keep this ftp'able. Enjoy! -- Rusty Haddock o {uunet,att,rutgers}!mimsy.umd.edu!fe2o3!rusty [2-6-90] From: Jonathan Lee Fools' lisp is a Scheme interpreter that follows all the RRRRS essentials and is reasonably small. It is written in C and Scheme. The design allows easy inclusion of new datatypes and primitives. It is available from scam.berkeley.edu (128.32.138.1) via anonymous ftp in src/local/fools.tar.Z (a compressed tar file, so remember to turn on binary mode). The interpreter runs on the following systems (it will probably run on any 4.3BSD based UNIX with little trouble): DECstation 3100 Ultrix 3.1 Sun3 and Sun4 SunOS 4.0.3 VAX Ultrix 3.1 and 4.3BSD Sequent Symmetry DYNIX(R) V3.0.12 Apollo DN3500 DomainOS Release 10.1 (bsd4.3) Let me know if you pick up a copy, and feel free to send me any comments. Thanks, Jonathan Lee (jonathan@scam.berkeley.edu) [2-24-90] Implementation: FDU Scheme Written & supported by: Peter Falley Hardware: Prime 50-series Operating System: Primos Source languages: PLP, F77, PMA Availability: Beta test version available via anonymous ftp or for a nominal charge (see below). Intended Use: Education & research Implementation: Primarily an interpreter. A compiler is included, but it has some limitations. Contact: Peter Falley Dept. of Math/CS/Physics Fairleigh Dickinson University Madison, NJ 07940 (201) 593-8680 falley@fdumad.fdu.edu FDU Scheme has been in use at FDU for several years. It meets all the requirements of R3RS and also includes almost all of the optional features. The only serious exception is the format option in number->string. Support of exact integer and rational arithmetic is of recent vintage and may still have some bugs. The system is under continuing development, and support for R4RS and the forthcoming IEEE standard are planned. Additional features are: * a macro facility. * dynamic wind, fluid-let, and engines. * a workspace editor. (However, you'll still need a good text editor with lisp mode, such as EMACS or vi.) * programmable error and quit handling. * Support for integers up to 8190 decimal digits. * Access to operating system facilities from within the interpreter. * trace and break debugging facilities. * A complete manual, including a brief introduction to Scheme. A beta test version of the system may be obtained by anonymous ftp (username: anonymous; password: anonymous) from fdumda.fdu.edu (132.238.1.1). Attach to the Scheme subdirectory and transfer all files in it and its subdirectories using file type binary. Transfer will be slow, since our network access is at 9600 baud. Alternatively, send a check for $30 made out to Fairleigh Dickinson University to the above address, and we'll send you a tape. [23 Aug 90] Implementation: Gambit Version 1.5 of the Gambit Scheme system is now available. A couple of minor bugs have been fixed from version 1.4. The support for parallelism has been greatly improved. The compiler now generates very efficient code for futures. There is also a new tool, gsx, for visualizing processor activity on the GP1000 parallel computer. You can get a copy of Gambit (release 1.5) via anonymous ftp from the machine acorn.cs.brandeis.edu (address 129.64.3.8). It is in the /dist directory and is compressed (about 400K). Don't forget to set binary mode when you transfer the system. For those who don't know about Gambit, here is a repeat of the previous annoucement: Gambit is an optimizing Scheme compiler/system under development at Brandeis university. It was designed with efficiency and portability as primary concerns. The current release has a back end which generates M68020 code that runs on M680x0 based unix machines (SUN3, HP300, BBN GP1000, etc). Gambit supports the IEEE Scheme standard and the `future' construct. Only exact arithmetic is implemented (bignums and ratnums but no flonums). The system contains an interpreter that offers a minimal debugging environment. When compiled with Gambit, Gabriel's benchmarks take (on the average) 50% and 70% of the run time required by code compiled with MIT-Scheme and T3.1, respectively. Please give me some feedback on the system if you do try it out. Marc -- feeley@cs.brandeis.edu [30 Dec 90] Date: 15 Jan 91 17:04:29 GMT From: "Jay R. Freeman" Subject: Shareware Scheme for Macintosh -- new release To: scheme@mc.lcs.mit.edu There is a 5 January 1991 upgrade of "Pixie Scheme", my shareware Macintosh Scheme interpreter, which is a rather complete (but slow) implementation of "R3"-dialect Scheme: Its main lack is numeric types beyond 32-bit signed integer and 32- and 80-bit floats. New this release is on-line help, a wimpy compiler, miscellaneous enhancements and some bug fixes. Pixie Scheme requires a Mac Plus or better, 1 MByte of RAM and Macintosh system software 6 or newer. The distribution includes two program versions (one uses 68020 / 68881 code) and a HyperCard help stack. It is too big to EMail -- 600 KBytes compressed, more after (eg) BinHex. I gave copies to BMUG and to Boston Computer Society Macintosh Group at the January 1991 MacWorld Expo. I mailed copies (postal service) to everyone I know who has put Pixie Scheme on a bulletin board or archive. Until 1 March 1991, I will mail you Pixie Scheme if you send me an 800 KByte disc, a mailer and return postage. (Non-US: about five international reply coupons.) If you take this offer you may ignore my (one-dollar) shareware donation request. USE A STOUT MAILER! Discs rub through plain envelopes in the mail, and stamp-cancelling machines damage them. Jay Reynolds Freeman P. O. Box 60628 Palo Alto, CA, 94306-0628, USA (I hope this announcement is appropriate use of the net; I do Pixie Scheme essentially as a public service.) [15 Jan 91] This message announces the availablility of a new implementation of Scheme scm1-1 and of a conformance test file for IEEE Scheme. Scm conforms to Revised^3.99 Report on the Algorithmic Language Scheme [Draft August 31, 1989] and the IEEE spec. Scm runs under Unix, VMS, and Microsoft C on IBM PCs. Scm is interpreted and has 30 bit immediate integers for numbers in version 1-1. Scm uses and garbage collects off the C-stack. This allows routines to be written in C without regard to GC visibility. Full call-with-current-continuations are supported except on VAX and SUN4. Stack (escape) call-with-current-continuations are supported on all machines. Documentation is included on the internal representation and how to extend or include scm in other programs. ftp altdorf.ai.mit.edu (anonymous) cd archive/scm This directory contains the distribution version 1.1 of scm. The file `scm1-1.exe' is an IBM PC executable of scm. `scm1-1.shar' is a shar file of the C code distribution. `scm1-1.tar.Z' is a compressed tar file of the C code distribution. `test.scm' is Scheme code which tests conformity with the IEEE spec. It is included in the shar and tar files. It does not yet test the input and output functions. I will include additions that are mailed to me. To receive an IBM PC floppy disk with the distribution and executable files send $50 to Aubrey Jaffer, 84 Pleasant St. Wakefield MA 01880, USA. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. [1-24-91] Oaklisp is an object-oriented superset of Scheme. Scheme is rebuilt upon an underlying substrate of object-oriented goop with first class types, making the integration between the Scheme and the object-oriented componants of the language seamless, and allowing lexically distributed method definitions, lexical scoping, and other conveniences lacking in most object-oriented lisp subsystems. The implementation, although bytecode-based, is surprisingly zippy, extremely portable (has been run on most everything), and amenable to augmentation with native-code compilers. References: "The Implementation of Oaklisp," in "Topics in Advanced Language Implementation" edited by Peter Lee, MIT Press, 1990. "Oaklisp: an Object-Oriented Dialect of Scheme," Lisp and Symbolic Computation v1n1, Klewer Associates, May 1988. "Oaklisp: an Object-Oriented Scheme with First Class Types," proceedings of OOPSLA-86 (published as a special issue of SIGPLAN Notices.) "The Oaklisp Language Manual" and "The Oaklisp Implementation Guide," available by FTP. A compressed tar file of the implementation is available by FTP, as are the language and implementation manuals: % ftp f.gp.cs.cmu.edu (128.2.250.164) Connected to f.gp.cs.cmu.edu. ftp> user anonymous barak@james.psych.yale.edu ftp> cd /usr/bap/oak/ftpable ftp> binary ftp> dir -rw-r--r-- 1 bap 151636 Nov 15 15:40 manuals.PS.tar.Z -rw-r--r-- 1 bap 62891 Nov 15 15:40 manuals.dvi.tar.Z -rw-r--r-- 1 bap 94565 Nov 15 15:40 manuals.src.tar.Z -rw-r--r-- 1 bap 1911374 Dec 15 16:10 release.tar.Z ftp> get release.tar.Z ftp> get manuals.PS.tar.Z [2-19-91] Date: 19 Mar 90 07:04:53 GMT From: Dorai Sitaram To: scheme@mc.lcs.mit.edu Subject: Re: Where can I Get Scheme-in-LISP? In article <22343@super.ORG> pcolsen@super.UUCP (Peter C Olsen) writes: > >I'm looking for an implementation of Scheme written in Common Lisp. how: anonymous ftp where: rice.edu file: public/scheme88.sh [3-19-90] Date: Thu, 2 Aug 90 09:32:33 -0700 From: rjk%sequent.uucp@uunet.UU.NET (Robert Kelley) To: rees%parc.xerox.com%uunet.uucp@uunet.UU.NET Subject: There's also UMB Scheme Cc: rjk@uunet.UU.NET by William R. Campbell, et. al. I found it on ucbarpa.berkeley.edu in pub/UMB_scheme.tar.Z [8-2-90] Date: 10 Mar 91 21:39:51 GMT From: Richard Pattis Organization: U of Washington, Computer Science, Seattle Subject: New Scheme Book/Implementation To: scheme@mc.lcs.mit.edu I met three fascinating gentleman at the ACM's SIGCSE conference. They all teach Scheme at the middle- and high-school level. Recently, they have self- published a book called "The Schemer's Guide"; this book is above the level of "The Little Lisper" but below that of Springer and Friedman. Besides gently introducing the concepts of symbolic manipulation, functional programming, and recursion, the book includes discussions of currying, accumulating/mapping/filtering, delayed evaluation, and call/cc. The book looks professionally done, and runs over 300 pages and they charge about $30. The authors are Iain Ferguson, Edward Martin, and Burt Kaufman. One of the authors (Iain) has written a Scheme interpreter (in C, called EdScheme) which is available on IBMs, Ataris, and in September on Macs. Look for a review of EdScheme in the May 1991 issue of the international edition of BYTE. It comes with a professionaly typeset 124 page guide and costs about $50. Both book and software are available on a 60 day money-back offer. These guys are truly committed to Scheme; I admire the lengths to which they have already gone to see their vision of how programming should be taught. I'd like to see their work become known in a wider context: their contacts in the Computer Science world (even K-12) are almost NIL. If you'd like to lend them some support and help them make contact with other instructors teaching Scheme, at any level but especially high-school/college, and make them a little more savy about the wide-world-of-Scheme, please contact Schemers Inc. 4250 Galt Ocean Mile, Suite 7-U Ft. Lauderdale, FL. 33308 (305) 776-7376 - this is one of the guy's home phone Rich Pattis (sorry this was so gushy, but I was really blown-away by these guys; I have no financial interest in their work: they offered my a free copy, but I figured they needed a boost, so I bought one). [3-10-91] Date: 12 Mar 91 05:29:48 GMT From: Richard Pattis I just found out that Schemers Inc. has an e-mail address. Because I've already received a few requests (and since I want to head off more), here it is: 71020.1774@compuserve.com I think the person receiving mail at this address is Burt Kaufman. Implementation: FDU Scheme Written & supported by: Peter Falley Hardware: Prime 50-series Operating System: Primos Source languages: PLP, F77, PMA Availability: Beta test version available via anonymous ftp (see below). Intended Use: Education & research Implementation: Primarily an interpreter. A compiler is included, but it has limitations. Contact: Peter Falley Dept. of Math/CS/Physics Fairleigh Dickinson University Madison, NJ 07940 (201) 593-8680 falley@fdumad.fdu.edu FDU Scheme has been in use at FDU for several years. It meets all the requirements of R3RS and also includes almost all of the optional features. The only serious exception is the format option in number->string. Support of exact integer and rational arithmetic is of recent vintage and may still have some bugs. The system may undergo further development to support R4RS and/or the new IEEE standard. Additional features are: * a macro facility. * dynamic wind, fluid-let, and engines. * a workspace editor. (However, you'll still need a good text editor with lisp mode, such as EMACS or vi.) * programmable error and quit handling. * Support for integers up to 8190 decimal digits. * Access to operating system facilities from within the interpreter. * trace and break debugging facilities. * A complete manual, including a brief introduction to Scheme. A beta test version of the system may be obtained by anonymous ftp (username: anonymous; password: ) from fdumda.fdu.edu (132.238.1.1). Attach to the Scheme subdirectory (cd '*>scheme') and transfer all files in it and its subdirectories using file type binary. [9-18-91]