3.2. Variabili e funzioni
| 3. Una guida su Script-Fu |

### 3.2. Variabili e funzioni

Ora che si sa che ogni istruzione Scheme va racchiusa tra parentesi e che il nome della funzione/operatore viene per primo si deve conoscere come creare ed usale le variabili e come creare ed invocare le funzioni. Si inizia con le variabili.

#### 3.2.1. Dichiarare le variabili

Anche se ci sono un paio di metodi diversi per dichiarare le variabili il metodo preferito è quello di utilizzare il costrutto let*. Se si conoscono altri linguaggi di programmazione questo costrutto equivale alla dichiarazione di una lista di variabili locali e di uno intervallo di visibilità in cui esse sono utilizzabili. Ad esempio per dichiarare due variabili, a e b, inizializzate rispettivamente a 1 e 2 si scrive:

            (let*
               (
                  (a 1)
                  (b 2)
               )
               (+ a b)
            )

oppure su una sola linea

    (let* ( (a 1) (b 2) ) (+ a b) )

| Nota
Si deve mettere tutto su una linea se si sta utilizzando la finestra della console. In generale tuttavia si potrebbe adottare una simile pratica di indentazione per rendere i propri script più leggibili. Si approfondirà l'argomento nel capitolo dedicato agli spazi bianchi.

Questo dichiara due variabili, a e b, le inizializza poi stampa la somma delle due variabili.

#### 3.2.2. Cos'è una variabile locale?

Si noterà che l'addizione `(+ a b)` è stata scritta all'interno delle parentesi dell'espressione `let*` e non dopo di essa.

Ciò perchè l'istruzione `let*` definisce un'area nello script in cui le variabili dichiarate sono utilizzabili; se si digita l'istruzione (+ a b) dopo l'istruzione (let* ...) si ottiene un errore poichè le variabili dichiarate sono valide unicamente nel contesto dell'istruzione `let*`, sono quelle che i programmatori chiamano variabili locali.

#### 3.2.3. La sintassi generale di `let*`

La forma generale dell'istruzione `let*` è:

            (let* ( variables )
              expressions )

dove variabili sono dichiarate all'interno delle parentesi, per ad esempio (a 2), e in espressioni vi può essere una qualsiasi espressione valida in Scheme. Si ricordi che le variabili qui dichiarate sono valide all'interno dell'istruzione `let*`, sono variabili locali.

#### 3.2.4. Spazi bianchi

Si è menzionato precedentemente che si può utilizzare l'indentazione per rendere più chiari ed organizzare i propri scripts. È una buona pratica da adottare e non crea problemi in Scheme -- gli spazi bianchi sono ignorati dall'interprete Scheme -- può quindi essere adottata per organizzare il codice all'interno di uno script. Tuttavia se si lavora nella finestra della console di Script-fu si deve immettere una intera espressione su un unica linea; tutto tra la parentesi iniziale e finale di una espressione deve essere sulla stessa linea nella finestra della console di Script-Fu.

#### 3.2.5. Assegnare un nuovo valore ad una variabile

Una volta che si è inizializzata una variabile si può dover cambiare il valore più avanti nello script. Si usi l'istruzione set! per cambiare il valore della variabile:

            (let* ( (theNum 10) ) (set! theNum (+ theNum theNum)) )

Si indovini cosa fa l'istruzione riportata sopra poi la si immetta nella finestra della console Script-Fu.

| Nota
La «\» indica che non c'è una interruzione di riga. La si ignori (non la si digiti nella console Script-Fu e non si prema Invio) continuando con la linea successiva.

#### 3.2.6. Funzioni

Ora che si è appreso l'uso delle variabili si proceda con le funzioni. Le funzioni si dichiarano con la seguente sintassi:

            (define
               (
                  name
                  param-list
               )
               expressions
            )

dove `name` è il nome assegnato alla funzione, `param-list` è una lista di parametri separati da spazi e `expressions` è una serie di espressioni che la funzione esegue quando viene chiamata. Ad esempio:

    (define (AddXY inX inY) (+ inX inY) )

`AddXY` è il nome della funzione e `inX` e `inY` sono le variabili. Questa funzione prende i suoi due parametri e li somma.

Se si è programmato in altri linguaggi imperativi (come C/C++, Java, Pascal, ecc.), si può notare come manchino un paio di cose a questa definizione di funzione rispetto agli altri linguaggi di programmazione.

- Per prima cosa si noti che i parametri non hanno un "tipo" (non si devono dichiarare come stringhe o interi, ecc.). Scheme è un linguaggio non tipizzato. Questo risulta più comodo e permette una scrittura veloce degli script.

- Secondo, si noti che non ci si deve preoccupare di "ritornare" il risultato della funzione -- l'ultima istruzione è il valore ritornato al chiamante della funzione. Si immetta la funzione nella console e poi si provi a digitare:

      (AddXY (AddXY 5 6) 4)

3. Una guida su Script-Fu |  | 3.3. Liste, liste e ancora liste