About the Scheme Implementation Choices

This web page is a catalogue of the choices that implementations of the Scheme programming language make.

Scheme is a wonderful and elegant dialect of Lisp, unparalleled in its simplicity and expressiveness. Perhaps because of its simplicity, and the appeal of its elegance, there are a myriad of different implementations of Scheme. For better or for worse, there has never been a central authority with the power to enforce uniformity among the different implementations, so writing code that is portable between different Schemes has always been a challenge. Consequently, popular implementations of Scheme have tended to accumulate their own libraries and tools, with little sharing of effort to create a common pool of Scheme libraries, with the effect that insofar as such a pool exists, it pales in comparison with the libraries available in other programming languages. The various Scheme standards help a great deal, but even they are ambiguous in places, and variably interpreted and implemented. The purpose of this project is to catalog the differences between implementations in one place, and serve as a tool toward the ideal of perfect portability across Schemes.

What is the scope of this project?

In principle, the sky is the limit, but for the time being, I am exploring differences specifically in the implementation of R5RS. When I started this project, I thought checking conformance to R5RS would be easy and I would quickly move on to more interesting things like the SRFIs, but it turned out that even differing interpretations of that Report make for an interesting catalogue. I am exploring R5RS as opposed to R6RS for now because the former is much simpler and more widely implemented.

How complete is it?

In a word: not. This is a spare-time project, so it moves in fits and starts. I'm not through covering R5RS, and I'm not even close to covering all the aspects of Scheme I would theoretically like to cover, but it seems I found enough stuff that it's interesting to hang on the web.

How does it work underneath?

I wrote a bunch of code that tests the behaviors of my Schemes, and accumulated a bunch (1054 as of this writing) of examples of Scheme expressions and what I expect them to evaluate to. My code will start up a Scheme interpreter, give it an s-expression to evaluate, read the results, and compare it to what I expect that s-expression to produce. If some Schemes do something I didn't expect, I investigate their differing treatments of the example, and related examples. If I can figure out what's going on, I write up an implementation choice, or several, and annotate my expectations for those examples to depend on the choices I defined. Those choices are presented in this catalogue.

Why these implementations?

I just took as a starting set all the Scheme implementations I actively use and all those for which I could find Ubuntu packages. Note that this means the versions I am reporting are those packaged by Ubuntu, which generally are not the latest releases of those implementations. I do not mean these choices to be normative: new implementations are pretty easy to add to my testing system, so I can do that on request.

Why these implementation choices?

These are just the choices that represent the behaviors I have classified so far.