### 3.2. Variables And Functions

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.

#### 3.2.1. Declaring 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) )

| ياداشت
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.

#### 3.2.2. What Is A Local Variable?

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.

#### 3.2.3. The General Syntax Of `let*`

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.

#### 3.2.4. White Space

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.

#### 3.2.5. Assigning A New Value To A Variable

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.

#### 3.2.6. Functions

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)

3. A Script-Fu Tutorial |  | 3.3. Lists, Lists And More Lists

Report a bug in GIMP Report a documentation error