Scheme

Introduction

Scheme is an elegant LISP dialect with a clean syntax. The language is easy to learn, yet very flexible and powerful. One noteworthy property of Scheme is that it supports tail call elimination, which allows the execution of many recursive algorithms in constant space.

There are various implementations of Scheme. Some implementations focus on embedding Scheme in larger projects, as a configuration or extension language. Other implementations focus on high performance, and yet other implementations focus on interactive use and development. Although not specified in the standard, many implementations provide a module system and a foreign function interface, allowing easy extension of Scheme and interoperability with other languages.

Some implementations of Scheme are scheme48, mzscheme, MIT Scheme, Bigloo, scm, chicken, guile, STKlos, and elk.

Simple Examples

These simple examples should provide you with a basic feeling of what Scheme looks and feels like.

Basic Types

This part introduces the fundamental data types of Scheme: booleans, characters, strings, numbers, and symbols. Their syntax, characteristics, and associated procedures are discussed.

Data Structures

Besides the fundamental data types (sometimes called atoms), Scheme has a few compound data structures. These are pairs, lists, and vectors.

Language Constructs

This part covers language constructs such as conditionals (if, cond and case), local and global variables (define, let, let*, and letrec), and anonymous procedures (lambda).

Macros

Lisp macros (and Scheme's hygienic macros in particular) are often ill-understood. Yet, if there is a single feature that makes the various Lisp dialects more powerful than other languages, it's macros. This part explains what macros are and how they work.

Additional Resources

No tutorial can possibly cover everything there is to know about Scheme. This section contains links to other places with useful information related to Scheme.