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.
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 si noterà che questo costrutto equivale alla dichiarazione di una lista di variabili locali e di un 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 |
---|---|
Se si sta utilizzando la finestra della console è necessario mettere tutto ciò su una singola riga. In generale tuttavia si potrebbe voler adottare una forma di indentazione per rendere i propri script più leggibili. Si approfondirà quest'argomento nel capitolo dedicato agli spazi bianchi. |
Questo dichiara due variabili, a e b, le inizializza poi stampa la somma delle due variabili.
Si noterà che l'addizione (+ a b)
è stata scritta all'interno delle parentesi dell'espressione let*
e non dopo di essa.
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.
La forma generale dell'istruzione let*
è:
(let* (variabili
)espressioni
)
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.
Una volta che si è inizializzata una variabile, può essere necessario doverne cambiare il valore più avanti nello script. In tal caso 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.
Ora che si è appreso l'uso delle variabili si proceda con le funzioni. Le funzioni si dichiarano con la seguente sintassi:
(define (nome
elenco parametri
)espressioni
)
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.
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)