Scheme is a LISP "dialect" that is relatively small, nicely supports tail recursion, provides block structure and lexical scoping, and gives a variety of object types "first-class" status (e.g. - first class objects are namable and can be passed around as function arguments, results, or as list elements).
If Common LISP is considered analogous to C++ (which is not entirely unreasonable), Scheme would comparatively be analogous to C. Where Common LISP requires that the "rich functionality" (such as a wide variety of data structures and the Common Lisp Object System (CLOS)) come as an intrinsic part of the language, Scheme encourages the use of "libraries" to provide these sorts of additional functionality.
The Scheme libraries are small enough that programmers commonly construct functionality using primitive functions, where a LISP system might have something already defined. This gives additional opportunity either to tune performance or shoot oneself in the foot by reimplementing it poorly...
The Rice University implementation of Scheme; has cross-platform GUI using wxWindows, as well as extensions for processing XML and SrPersist to connect to relational databases using ODBC/SQL-CLI, and, with a more "Schemely" approach, SchemeQL. There are other PLT Scheme Libraries and Extensions, a FastCGI interface, an XML-RPC client, and likely more...
A Scheme implementation that does separate compilation of Scheme modules in much the same fashion as one would do with C modules. This allows linking C and Scheme code together.
A Scheme implementation implemented in C++ and intended to be easy to imbed into C++ applications. Available under the zlib license.
Pizza - a Scheme-to-Java-Bytecode compiler
A highly optimizing compiler of Scheme written by Jeffrey Siskind to handle relatively static code. It turns Scheme code into C.
An implementation of Lisp/Scheme for the PalmComputing Platform
People at University of Indiana have taken an approach described in SICP (Structure and Interpretation of Computer Programs, describing a Scheme implementation in hardware form. It is not clear that they have actually built the chip...
The University of Montreal implementation of Scheme.
This SRFI presents an object system to define classes, generic functions as well as to support some level of introspection. This object system is based on Meroon -V3 which is itself inspired by CLOS .
Transforming Scheme in various dialects into standard R5RS form.
This would, looking at a "Blue Sky" for instance, allow the gentle user to write an application using Bigloo's dependancy management scheme, and then transform it into a more standard form that could be compiled using STALIN into an insanely fast binary form.
Infer combines many (though not all) of the best features of Scheme and ML. Compared with latently-typed languages, such as Scheme , statically-typed languages, such as ML and Infer, sacrifice some expressive power in exchange for the ability to catch many errors at compile time, the possibility of more efficient execution, and some system-verified program documentation.
By supporting all of the forms and primitives procedures of Scheme , with a Scheme-like syntax, it is hoped Infer will prove accessible to Scheme programmers. Efficient compilation of Infer into Scheme is possible, thereby providing compatibility with Scheme programming environments.
Since Infer supports many features of the ML type system, plus a number of others, Infer may also be an attractive alternative to other languages supporting ML-style polymorphism.
The present Infer implementation, written in Infer, is well suited as a test bed for experimentation with a wide range of modern type systems that are based on "core" ML.
Apparently, Graham preferred this version of Scheme to Common Lisp.
An R5RS Scheme implementation intended to be efficient for writing small scripts.
Probably notable for running on Plan 9
An implementation of Scheme (R7RS) running atop the Section 10.1 virtual machine.
The garbage-collection algorithm used is a copying generational collection scheme with a young generation on the C-stack and a large static heap for the old generation. This follows mostly Henry Baker's approach as mentioned in his paper "Cheney on the MTA".
An environment for Win32 Scheme development that generates C code
I have this book; it is a wonderful introduction to the study of computer science, using Scheme as the implementation language for the computational approaches that it examines.
Structure and Interpretation of Computer Programs ; Harold Abelson, et al; Hardcover
It is also available on the web in full text form!
The Little Schemer ; Daniel P. Friedman, et al; Paperback
I have this book. Pedagogically interesting; you can learn from it, but it's not exactly going to lead you to "how to do mundane database stuff in Scheme."
This continues the story started in [ The Little Schemer]. Again, academically interesting, though a little bit shallow.
The Scheme Programming Language : ANSI Scheme ; R. Kent Dybvig; Paperback
I have this book, in both editions.
mzscheme -g makes symbols case sensitive.
So does evaluating (read-case-sensitive #t)
A book on programming from the makers of PLT Scheme
From the makers of PLT Scheme
An old set of MacTech columns on Scheme
Vector mapping functions
;;; The fast version (define vmap-1 (lambda (proc v) (let ((len (vector-length v))) (let ((new-v (make-vector len))) (let lp ((i 0)) (if (= i len) new-v (begin (vector-set! new-v i (proc (vector-ref v i))) (lp (+ i 1))))))))) ;;;; Slower and simpler... (define vmap (lambda (proc v) (list->vector (map proc (vector->list v)))))
The standard way of encoding style sheet controls in the recent "DSSSL" system happens to be as Scheme code. This is advantageous as Scheme is a fairly small, readily parsed, fairly efficient and readily embeddable language.
An approach to try to build more portable and useful libraries that are better coordinated between Scheme implementations.
They expect, among others, SRFIs for list handling, records, exception handling, foreign function interfaces, and object systems in the near future.
This package allows the programmer to write Scheme code that generates anything expressible in Postscript, and thereby generate Postscript output.
SLIB is a portable scheme library providing compatibility and utility functions for standard Scheme implementations.
FramerD is a portable distributed object-oriented database designed to support the maintenance and sharing of knowledge bases. Unlike other object-oriented databases, FramerD is optimized for the sort of pointer-intensive data structures used by semantic networks, frame systems, and many intelligent agent applications. FramerD databases readily include millions of searchable frames and may be distributed over multiple networked machines. FramerD includes an extensive scripting language based on Scheme with special support for web-based interfaces.
A discussion of ideas/issues in the design of module systems for Scheme.
Essence is a generator for LR(k) and SLR(k) parsers in Scheme. The generated parsers perform error recovery, and are highly efficient. Testing and debugging a parser does not require an edit-generate-compile-test cycle.
Rather, the parser generator results from a general parser which takes the input grammar as a parameter; no generation and recompilation is necessary to try out changes to a grammar.
The generated parsers result from the general parser by an automatic program transformation called partial evaluation. This guarantees consistency and ensures correctness. However, no specific knowledge of partial evaluation is required to use Essence.
The environment is like a "database" (or soup in NewtonScript). It does not follow any static scope of Scheme expressions, nor a dynamic scope of Scheme procedure activations. It is a (hierarchical) repository that any procedure may deposit things into, or request values associated with a name (a key-symbol).
A package that provides Prolog functionality atop Scheme.
This is a description of the Scmutils system, an integrated library of procedures, embedded in the programming language Scheme, and intended to support teaching and research in mathematical physics and electrical engineering. Scmutils and Scheme are particularly effective in work where the almost- functional nature of Scheme is advantageous, such as classical mechanics, where many of the procedures are most easily formulated as quite abstract manipulations of functions.
This is a CGI script to retrieve SIGMET Advisories and translate the OMF XML document into a simple HTML page; implemented in MzScheme as a sort of "ASP-like" application...
This Apache module provides a mean for communication between Apache server and an external process using Unix pipes. The idea behind is inspired by Oleg Kiselyov's work Writing agents in sh: conversing through a pipe and mod_pipe depends on his tool exec_with_piped.
The mod_pipe is designed for the inclusion of Scheme language instructions in the Apache -processed HTML files. Using mod_pipe Scheme interpreter may be started once and when acts as Scheme servlet engine.
Such an architecture reduces the per-request overhead, as the expensive start-up process is not required. Thus it possible, for example, to load a bulk of data at the interpreters start and query this data later including the reply in the pre-build HTML pages. The example provided includes in the HTML page the value of the variable scm-interpreter which is bound at the Scheme interpreter initialization time.
This project is devoted to the construction of high quality libraries for the Scheme language, and PLT Scheme in particular.
WB - Wanna B-tree
WB is a disk based, sorted associative array C library. WB has an optional interface to the SCM Scheme implementation which supports SLIB relational databases.
Guile, The Guile Architecture for Ubiquitous Computing, is a language based on Scheme that is targeted as an embeddable scripting language for applications by the FSF. There is both a Scheme-like syntax as well as a C-like syntax (that it appears that nobody uses).
This is the "official" location where experimental Guile source code resides.
(define (files-in-directory dirname) ;;; Generate list containing filenames (let ((dir (opendir dirname))) (let next ((f (readdir dir)) (files '())) (cond ((eof-object? f) (closedir dir) files) (else (next (readdir dir) (cons f files)))))))
Top-level Environments in Guile - a draft proposal for a new datatype for representing top-level environments in Guile.
guile-fltk is a module for Guile that binds the Fltk widget library to scheme.
A Guile -based simulation system for communications engineering and digital signal processing. Includes:
Schematic capture tool using GTK
Extension to allow Gossip to read VHDL files
(hosted at SourceForge )
This contains Scheme code (as well as code in various other languages) to perform the same functions found in "Perl Cookbook: Tips and Tricks for Perl Programmers" by Tom Christiansen and Nathan Torkington
Editing Sound using Snd - which uses Guile
If this was useful, let others know by an Affero rating