XVed*font: 7x12  # The default size - rather small for some.
XVed*font: 9x15  # A bigger size, which you may like better.

You can also change the font of a particular window by doing

<enter> window font font.

The Scheme Language

Typographic conventions used in these Lectures

All expressions and other constructs of the Scheme language which occur in these lectures are set in a typewriter font, An example of typewriter font is (define pi 3.14159) .

Typewriter fonts are characterised by being fixed-width (every letter occupies the same amount of space on the page). In the HTML browser which is being constructed to let you view these lectures from within UMASS Scheme, Scheme expressions will appear in red, since the VED editor always uses a single fixed-width font and provides no means of distinguishing text by using a different font, only by making variants on a given font.

Where it is important to make an expression of the language stand out, it will be placed indented as a line or lines of text separated from the English commentary. For example:

    (define pi 3.14159)

Grammatical constructs are specified using a bold version of the typewriter font. For example, we specify one form of the Scheme define statement by

    (define  variable  expression)

Here, because variable is in a bold font it means that you can write any Scheme variable in place of it; likewise because expression is in a bold font it means that you can write any Scheme expression in place of it. So, the previous statement:

    (define pi 3.14159)

    (define  variable  expression)

Simple values in Scheme

Scheme operates on the usual simple data-objects, that is to say data-objects that can best be thought of as having no internal structure.

integers: These are of arbitrary precision that is they are only limited in size by the total amount of memory you have!

rationals: Scheme can and will compute with fractions. If you divide one integer by another you will get a rational. You should usually avoid rational computations, unless you are doing symbolic algebra!

reals: These are represented by floating point numbers.

booleans: These are #f (false) and #t (true). [NOTE for experts: unlike non IEEE Schemes and most Lisps, the empty list '() is not a false truth value.]

23   is an integer
3.4  is a real
3/4  is a rational (WARNING - UMASS Scheme does not currently input rationals
                    but it will generate them and print them out).

Variables in Scheme

A scheme variable is a sequence of letters (a..z A..Z) or digits (0..9) or signs (+ - * / ...) which are terminated by "white-space" or by certain special characters, of which parentheses are the most important. In fact, most combinations of non-whitespace characters which Scheme does not recognise as being a number are treated as a variable. Usually, people will choose helpful names for variables.

For example the following are variables:

        x y x_23 34x the-fat-cat + +1

Warning - Scheme gives some variables initial values, for example +, *, / . It is not a good idea to use these variables for your own purposes!

define creates a new variable, gives it a value

Variables usually have values. We say that a variable is bound to a value when it is associated with the value. Scheme has a statement which creates a new variable and binds it to the value of an expression

    (define  variable  expression)

For example:

    (define pi 3.14159)

binds the variable pi to have the value 3.14159

Expressions in Scheme

Expressions have a very uniform syntax in Scheme. An expression can be a constant or a variable, or it can be a sequence of expressions enclosed in parentheses (sometimes called a combination).

In the case of a combination, the first expression is regarded as a function while the others are its arguments. Thus:

     (+ 3 4)

is an expression, whose function is '+' and whose arguments are 3 and 4.

When Scheme evaluates an expression of this form, it evaluates the function and arguments, and then applies the function to the arguments. Evaluating the above expression we get

7

(- 5 4)

means "the result of subtracting 4 from 5", or in ordinary mathematical notation 5-4.

A more complicated example is:

(+ 3 (* 4 5))

Here we evaluate (* 4 5) to get 20, and then add 3 to get 23.

So what are functions in Scheme?

Well, actually functions are pieces of machine code (in effect subroutines for those who have taken CMPSCI 201). So the value of the variable '+' is a piece of code for doing addition.

[Note you can actually redefine Scheme standard functions. This is NOT recommended for novices, for you may lose important capabilities]

Making your very own function

A Scheme function is specified by the syntax

    (lambda  formals  body)

here formals is (usually) a sequence of variables enclosed in parentheses, and body is a sequence of expressions. For the functional use of Scheme, only one expression is needed in the body.

Note that this is not an application of the function lambda, but is what is called a "special form" in Scheme.

For example

(lambda (x) (* x x))

is the function which squares its argument. So

( (lambda (x) (* x x)) 3)

evaluates to 9.

The rule for evaluation of a lambda-function applied to arguments is to (a) evaluate all the arguments, and (b) strip off the 'lambda' and substitute the values of each argument for the corresponding formals, (c) evaluate the body of the lambda with the values substituted.

   ( (lambda (x) (* x x)) (+ 3 4))

Evaluate the argument

( (lambda (x) (* x x)) 7)

Strip and substitute for corresponding formals (x=7) :

(* 7 7)

Evaluate body

49

This may seem a funny way of defining functions - in Pascal we would give the corresponding function a name, like "square". In Scheme, this is easily done

(define square (lambda(x) (* x x)) )

Scheme responds:

<Compiled function: square>

and now we can use it

    (square 4)

Scheme responds:

    16

An example of a lambda expression with more than one argument is

    (lambda (x y) (+ x (* 2 y))

And an example of its use is:

    ((lambda (x y) (+ x (* 2 y))) (+ 4 3) 5)

Evaluate the arguments

    ((lambda (x y) (+ x (* 2 y))) 7 5)

Strip and substitute, x=7, y=5:

     (+ 7 (* 2 5)))

and evaluate

     (+ 7 10)

     17

The Debugger

This is accessed by hitting the "Debugger" button on the Scheme Control Panel. It is operated by a panel which contains the following buttons:

Generate Debug Code:

This is normally true, so that Scheme generates code for the debugger by default. Turn it off to create smaller, faster programs.

Stop at All Breakpoints:

This is normally false. When set true, Scheme will stop after it evaluates every compound expression such as (+ x 2). It will print out "frames" for the top n functions you are currently executing, where n is set by the "Number of Frames" slider.

Number of Frames:

This slider determines how many function-frames you will see.

Go To Next Breakpoint:

Execution continues until the next (automatically generated) breakpoint. Breakpoints occur after an expression has been evaluated.

Skip Current Function:

The execution of the current function will be completed without stopping at any breakpoints.

Help:

Prints out help information about the debugger.

The function load loads a file of Scheme code.

The function application (load "file") will load any file as Scheme program.