Now that we know that every Scheme statement is enclosed in parentheses, and that the function name/operator is listed first, we need to know how to create and use variables, and how to create and use functions. We'll start with the variables.
Although there are a couple of different methods for declaring variables, the preferred method is to use the let* construct. If you're familiar with other programming languages, this construct is equivalent to defining a list of local variables and a scope in which they're active. As an example, to declare two variables, a and b, initialized to 1 and 2, respectively, you'd write:
(let* ( (a 1) (b 2) ) (+ a b) )
or, as one line:
(let* ( (a 1) (b 2) ) (+ a b) )
![]() |
Note |
---|---|
You'll have to put all of this on one line if you're using the console window. In general, however, you'll want to adopt a similar practice of indentation to help make your scripts more readable. We'll talk a bit more about this in the section on White Space. |
This declares two local variables, a and b, initializes them, then prints the sum of the two variables.
You'll notice that we wrote the summation (+ a b)
within
the parens of the let*
expression, not after it.
This is because the let*
statement defines an area in your script in which the declared
variables are usable; if you type the (+ a b)
statement after the (let* …)
statement,
you'll get an error, because the declared
variables are only valid within the context of the let*
statement; they are what programmers call local variables.
The general form of a let*
statement is:
(let* (variables
)expressions
)
where variables are declared within parens, e.g.,
(a 2)
, and
expressions are any valid Scheme expressions. Remember that the
variables declared here are only valid within the
let*
statement — they're local variables.
Previously, we mentioned the fact that you'll probably want to use indentation to help clarify and organize your scripts. This is a good policy to adopt, and is not a problem in Scheme — white space is ignored by the Scheme interpreter, and can thus be liberally applied to help clarify and organize the code within a script. However, if you're working in Script-Fu's Console window, you'll have to enter an entire expression on one line; that is, everything between the opening and closing parens of an expression must come on one line in the Script-Fu Console window.
Once you've initialized a variable, you might need to change its value
later on in the script. Use the set!
statement to change
the variable's value:
(let* ( (theNum 10) ) (set! theNum (+ theNum theNum)) )
Try to guess what the above statement will do, then go ahead and enter it in the Script-Fu Console window.
![]() |
Note |
---|---|
The « |
Now that you've got the hang of variables, let's get to work with some functions. You declare a function with the following syntax:
(define (name
param-list
)expressions
)
where name
is the name assigned to this
function, param-list
is a space-delimited
list of parameter names, and expressions
is a series of expressions that the function executes when it's
called. For example:
(define (AddXY inX inY) (+ inX inY) )
AddXY
is the function's name and
inX
and inY
are the variables. This function takes its two parameters and adds
them together.
If you've programmed in other imperative languages (like C/C++, Java, Pascal, etc.), you might notice that a couple of things are absent in this function definition when compared to other programming languages.
First, notice that the parameters don't have any « types » (that is, we didn't declare them as strings, or integers, etc.). Scheme is a type-less language. This is handy and allows for quicker script writing.
Second, notice that we don't need to worry about how to « return » the result of our function — the last statement is the value « returned » when calling this function. Type the function into the console, then try something like:
(AddXY (AddXY 5 6) 4)