2 Disadvantages of Scheme

The Scheme standard is very minimalist, specifying only the core language. This means that there are many different implementations, each with their own incompatible extensions to the language and libraries. The Scheme Requests for Implementation (SRFI) process tries to remedy this.

Some see the fact that functions and variables lie in the same namespace as a disadvantage, because some functions have names that are common for variables. For example, list is the name of a function, so one often sees lst or lyst as variable names instead of the obvious "list".

Like functions and variables, macros are also in the same namespace. This makes it impossible to tell whether a piece of code is a macro invocation or a function application if the programmer is not familiar with the rest of the code. Consequently, it is not possible to be sure of the evaluation order, for example, of code the reader is not familiar with.

3 Standards

There are two standards that define the Scheme language: the official IEEE standard, and a de facto standard called the Revised^n-th Report on the Algorithmic Language Scheme, nearly always abbreviated RnRS, where n is the number of the revision. The latest RnRS version is R5RS, also available online.

A new language standardization process was begun at the 2003 Scheme workshop, which has so far produced no standards, but has the remit of producing an R6RS standard by January 2006. It breaks with the earlier RnRS approach of unanimity.

4 Language elements

4.1 Comments

Comments are preceded by a semicolon (;) and continue for the rest of the line...

4.2 Variables

Variables are dynamically typed. Variables are bound by a define, a let expression, and a few other Scheme forms. Variables bound at the top level with a define are in global scope.

(define var1 value)

Variables bound in a let are in scope for the body of the let.

(let ((var1 value)) ... scope of var1 ...)

4.3 Functions

Functions are first-class objects in Scheme. They can be assigned to variables. For example a function with two arguments arg1 and arg2 can be defined as

(define fun (lambda (arg1 arg2) ...))

which can be abbreviated as follows:

(define (fun arg1 arg2) ...)

Functions can be called with the following syntax:

(fun value1 value2)

Note that the function being called is in the first position of the list while the rest of the list contain the arguments. The apply function will take the first argument and apply the rest of the arguments to the first argument, so the previous function call can also be written as

(apply fun (list value1 value2))

In Scheme, functions are divided into two basic categories: the procedures and the primitives. All primitives are procedures, but not all procedures are primitives. Primitives are pre-defined functions in the Scheme language. These include +, -, *, /, set!, car, cdr, and other basic procedures. Procedures are user-defined functions. In several variations of Scheme, a user can redefine a primitive. For example, the code

(define (+ x y) (- x y)))

actually redefines the + primitive to subtract, rather than add. This code turns the + primitive into a + procedure.

4.4 Lists

Scheme uses the linked list data structure in the same form as it exists in Lisp.

4.5 Data types

Other common data types in Scheme besides functions and lists are: integer, rational, real, complex numbers, symbols, strings, ports. Most Scheme implementations also offer association lists, hash tables, vectors, arrays and structures. Since the IEEE Scheme standard and the R4RS Scheme standard, Scheme has asserted that all of the above types are disjoint, that is no value can belong to more than one of these types; however some older implementations of scheme predate these standards and have #f and '() to be the same value, as is the case in Common LISP.

Most Scheme implementations offer a full numerical tower as well as exact and inexact arithmetic .

True and false are represented by the symbols #t and #f. Actually only #f is really false when a Boolean type is required, everything else will be interpreted by Scheme as #t including the empty list.

Symbols can be defined in at least the following ways:

'symbol (string->symbol "symbol")

4.6 Equality

Scheme has three different types of equality:

eq?

Returns #t if the two objects are the exact same object, going as far as to check where they're stored in physical storage.

eqv?

Generally the same as eq? but treats some objects (eg. characters and numbers) specially so that numbers that are = are eqv? even if they're not eq?

equal?

Compares the content of data structures such as lists, vectors and strings to determine if they are the same.

Type dependent equivalence operations also exist in Scheme:

string=?

To compare two strings

char=?

To compare characters

=

To compare numbers

4.7 Control structures

4.7.1 Conditional evaluation

(cond (test1 expr1) (test2 expr2) ... (else exprn))

The first expression for which the test evaluates to true (anything other than #f counts as true) will be evaluated. If all test result in #f, the else clause is evaluated.

A variant of the cond clause is

(cond ... (test => expr) ...)

In this case, expr should evaluate to a function that takes one argument. If test evaluates to true, the function is called with the return value of test.

Scheme also has

(if test then-expr else-expr)

but it is used much less because cond is both more general and has overall better readability.

4.7.2 Loops

Loops in Scheme usually take the form of tail recursion. A classical example is the factorial function, which can be defined non-tail-recursively:

(define (factorial n) (cond ((= n 0) 1) (else (* n (factorial (- n 1)))))) (factorial 5) ;; => 120

or a higher order function like map which applies a function to every element of a list, and can be defined non-tail-recursively:

(define (map f lst) (cond ((null? lst) lst) (else (cons (f (car lst)) (map f (cdr lst)))))) (map (lambda (x) (* x x)) '(1 2 3 4)) ;; => (1 4 9 16)

We can define both of these tail-recursively as follows. The named let expression and the do statement are syntactic sugar which simplify tail-recursive definitions. To use factorial and map again to illustrate both forms:

(define (factorial n) (let loop ((fact 1) (n n)) (cond ((= n 0) fact) (else (loop (* n fact) (- n 1)))))) (factorial 5) ;; => 120

(define (map f lst) (do ((lst lst (cdr lst)) (res '() (cons (f (car lst)) res))) ((null? lst) (reverse res)))) (map (lambda (x) (* x x)) '(1 2 3 4)) ;; => (1 4 9 16)

Please note that in both cases the tail-recursive version is preferable due to its decreased use of space.

4.8 Input/output

Scheme has the concept of ports to read from or to write to. Scheme defines three default ports, accessible with the functions: current-input-port, current-output-port and current-error-port.

5 Hello World

(define hello-world (lambda () (display "Hello World") (newline))) (hello-world)

6 Examples

Scheme code can be found in the following Wikipedia articles:

• Arithmetic-geometric mean
• Currying
• Fibonacci number program
• Hello world program
• Tail recursion
• Queue

7 Implementations

• MIT/GNU Scheme is a free (GPL-licensed) implementation for the x86 architecture only. It runs on GNU/Linux, FreeBSD, IBM OS/2, and Microsoft Windows ( 95, 98, ME, NT, 2000, and XP)
• Chez Scheme is a proprietary freeware Scheme interpreter and commercial Scheme compiler for Microsoft Windows and several UNIX systems.
• Chicken is a Scheme-to-C compiler.
• Guile is the GNU project's official extension language. This Scheme interpreter is packaged as a library to provide scripting to applications. It can be found here.
• PLT Scheme is a suite of Scheme programs from Rice University for Windows, Mac, and Unix platforms including an interpreter (MzScheme), a graphical toolkit (MrEd), a pedagogically-oriented graphical editor (DrScheme), and various other components including Component object model and ODBC libraries.
• Gauche is an R5RS Scheme implementation developed to be a handy script interpreter. It can be found here.
• Bigloo is a Scheme-to-C and Scheme-to-Java compiler. It has much more to offer than just a compiler: Bigloo features a mediocre type system, which greatly improves readability and debugging of code. Bigloo is a good Scheme implementation if you are looking to write numerical applications.
• Kawa is a Scheme environment, written in Java, that compiles Scheme source code into Java bytecode. Any Java library can be easily used in Kawa.
• Jatha is a Java library that implements a fairly large subset of Common LISP
• Sisc (Second Interpreter of Scheme Code) is a Scheme environment written in Java, it doesn't compile Scheme. It also has a Java FFI.
• STklos is a Scheme implementation which provides an object system similar to CLOS and a simple interface to the GTK toolkit
• The GIMP includes a Scheme interpreter for scripted image manipulation.
• LispMe is an open-source Scheme environment for the PalmOS family of PDAs.
• Many more implementations are listed in the schemers.org FAQ.

8 Additional resources

• A large collection of Scheme resources.
  • The current scheme standardization process home.
• Scheme Requests for Implementation (SRFI).
• Structure and Interpretation of Computer Programs by Abelson, Sussman and Sussman, considered a classic computer science text.
• How to Design Programs by Felleisen et al. Intended to teach programming using Scheme.
• The Scheme Programming Language by R. Kent Dybvig. A useful language reference.
• A bibliography of Scheme-related research, with links to online versions of many academic papers, including all of the original Lambda Papers.
• Comprehensive Scheme Archive (Network) Here, a CSAN site has been started at the beginning of 2004.
• Perl5 binding for MzScheme includes mixing Perl5 and Scheme code in the same program.
• SPOD - POD for Scheme www.elemental-programming.org provides the Scheme Plain Old Documentation text processor.
• Community Scheme Wiki A wiki for all things Scheme.

Major programming languages ( more)

Ada | ALGOL | APL | AWK | BASIC | C | C++ | C# | COBOL | Delphi | Eiffel | Fortran | Haskell | IDL | Java | JavaScript | Lisp | LOGO | ML | Objective-C | Pascal | Perl | PHP | PL/I | Prolog | Python | Ruby | SAS | Scheme | sh | Simula | Smalltalk | SQL | Visual Basic

Dynamic programming languages Educational programming languages Functional languages LISP programming language family Programming languages Statically-typed programming languages

<Hide>