Copyright (C) 2009 by Steve Litt
Note: All materials in Steve's Scheme Society are provided AS IS. By reading the
materials in Steve's Scheme Society you are agreeing to assume all risks involved
in the use of the materials, and you are agreeing to absolve the
owners, and anyone else involved with Steve's Scheme Society of any
for the outcome of any use of these materials, even in the case of
and/or omissions in the materials. If you do not agree to this, you
not read these materials.
To the 99.9% of you honest readers who take responsibility for your own
actions, I'm truly sorry it is necessary to subject all readers to the
Scheme is a programming language. Scheme's statements are postfix. That means every statement looks like this:
(operator operand operand operand)
The number of operands is defined by the operator. Here are just a few examples:
- (display "Hello world\n")
- (+ 20 4 3 2 1)
- (- 20 4 3 2 1)
Most statements returns some sort of value. For instance, the
operator returns the sum of all numbers following it.
You can easily make your own operators and in so doing define how many operands they take.
Consider this statement:
(display (+ 3 4))
The first (innermost) statement adds three and four, and the result is fed to the
operator, so 7 is written on the screen. Here's another example:
(* 5 (+ 3 4))
The innermost statement evaluates to 7, and its return value is
multipled by 5 to produce 35, although it's not written because there's
no display statement. The following is a formula for a hypotinuse,
given the lengths of the two sides adjacent to the right angle:
(sqrt (+ (* adj1 adj1) (* adj2 adj2)))There
are two innermost statements, each of which squares one of the adjacent
sides. The next statement out adds those two squares, and the statement
outside of that takes the square root.
Other Ways of Explaining SchemeOperators
are pretty much equivalent to functions, procedures or subroutines in
other languages, and the operands are equivalent to arguments to those
functions. The value of a statement is just like the return value of a
function in other languages.
Line FormatThe following are all equivalent:
(display (* (+ 3 4) (+ 5 6)))
cares nothing about lines -- it's all about the parentheses. There is
one exception: An unquoted, unescaped semicolon is used to indicate
that the rest of the line is a comment.
CommentsThere are two types of comments:
- Semicolons are used to comment out the remainder of the line.
- Multiline or partial line comments are implemented by #! at the beginning and !# at the end of the comment.
programming is yet another programming paradigm. More than languages
like C, Java, Perl, C++ and the like, Scheme is compatible with
The idea of functional programming is
that for a given function, its behavior depends only on its arguments,
its effects are available only through the function return, and state
has no place in the computations. The following hypotinuse formula is
completely consistent with functional programming:
(sqrt (+ (* adj1 adj1) (* adj2 adj2)))The
return values of the multiplication operations depend only on their
operands. The only effect of the multiplication operations is the
return value. The sum operator takes as arguments the returns of the
multiplications, depending only on them, and its only effect is its
return, which is used by sqrt. All the way up the chain, every
operation's action is defined exclusively by its arguments (operands),
and the sole effect of each operation is its return value. If there
were a variable elsewhere in the program, that variable could not
possibly influence the hypotinuse formula. Therefore the formula
doesn't depend on state.
Notice that this is the diametric
opposite of OOP, where state is everything, and functions are mere
methods whose purpose is to change or express the state of the object.
it can be used, stateless programming is often simpler and more
understandable. We all know how nasty break logic gets, or worse, state
machines. When that stuff is necessary it must be used, but sometimes
everything can be accomplished by simple functions, especially when
you're free to do recursion.
Recursion is sort of an end-run
around the "no-state" rule. Because each recursive instance keeps its
own argument values, it does keep some state, although looking at it
from a purely design viewpoint it's not dependent on state.
"no state" rule isn't practical, but when programming Scheme, endeavor
to use as few variables and state information as possible, making use
instead of function arguments and returns.
Scheme is Doggedly Consistent and Easy to RememberOf
all the languages I ever learned, Scheme is the most consistent and
therefore the easiest to remember. Every statement is an operator and
its operands immediately surrounded by parentheses. Most statements
return a value, and therefore can be used anywhere a value can be used,
like as an operand in another statements. Thus statements are nested,
with the outer ones calling more inner ones.
is a language, and Guile is a Scheme interpreter that comes with most
Linux distributions. Guile is authored and maintained by the GNU team.
Guyle also has special modules so it can be used as a front end to C
programs designed with libraries interfacing to Guile. Through Guile
you can use Scheme as an extension language for your applications. The
C program can start Guile, from which Scheme commands can be read
interactively or through a file.