Follow

Come in ogni linguaggio di programmazione, una delle cose essenziali per scrivere un qualunque programma è la  gestione delle condizioni. Una condizione consiste, come penso sappiate, nell’eseguire un blocco di comandi a seconda se sia rispettata o meno una data condizione.

In Scheme la gestione delle condizioni è molto completa. Iniziamo quindi a vedere uno dei costrutti più famosi anche se in Scheme non viene molto usato: l’if.

IF

1
2
3
(if condizione

    espressione_nel_caso_la_condizione_sia_vera

    eventuale_espressione_nel_caso_la_condizione_sia_falsa)

Questa è la struttura dell’if. Viene valutata condizione e a seconda se sia vera o falsa viene eseguito rispettivamente il primo o il secondo blocco di espressioni. Guardiamo un piccolo esempio:

1
2
3
4
5
6
7
; TESTIF: Verifica se A è uguale a Zero.

(define (testif a)

 (if (= a 0) (display "Il valore inserito è uguale a zero.")

         (display "Il valore inserito NON è uguale a zero.")

 )

 (newline)

)

Questa funzione non fa altro che dire se il valore passato per parametro è zero oppure no. Potete subito constatare che questo costrutto è del tutto simile agli if presenti negli altri linguaggi.

COND

COND è il costrutto condizionale più utilizzato a causa della sua versatilità. Esso è infatti in grado di simulare abilmente sia un IF sia un CASE. Vediamo come è strutturato.

1
2
3
4
5
(cond

(prima_condizione espressione)

(seconda_condizione espressione)

...

(else espressione))

Ad ogni sua applicazione vengono valutate le condizioni a partire dalla prima fino all’ultima e viene eseguito il blocco di istruzioni corrispondente alla condizione vera. Se nessuna condizione è vera viene eseguito il ramo else. Vediamo un esempio:

1
2
3
4
5
6
7
8
; TESTCOND: Verifica se B è uguale a 0 o a 1.

(define (testcond b)

    (cond ((= b 0) (display "B = 0"))

        ((= b 1) (display "B = 1"))

        (else (display "NONE"))

    )

    (newline)

)

Questa funzione verifica se il parametro è 0 oppure 1 e in caso contrario risponde con NONE.

CASE

Questo è l’ultimo costrutto decisionale in Scheme. Si comporta in modo molto simile allo switch…case presente in molti altri linguaggi.

1
2
3
4
5
(case espressione_che_viene_valutata

   ((val1) espressione)

   ((val2) espressione)

   ...

   (else espressione))

Viene innanzitutto valutata l’espressione. Dopodichè il valore risultante viene confrontato con la lista di valori val1, se il valore è contenuto in val1 viene eseguita l’espressione corrispondente altrimenti si passa a val2. Così via fino a else che viene eseguita in ogni caso.

1
2
3
4
5
6
7
8
9
; TESTCASE: Verifica se C è pari o dispari compreso fra 0 e 10.

(define (testcase c)

 (case c

     ((1 3 5 7 9) (display "C = DISPARI"))

     ((2 4 6 8 10) (display "C = PARI"))

     (else (display "NONE"))

 )

 (newline)

)

RICAPITOLANDO:

• IF esegue un espressione se la condizione è vera, ne esegue un altra se è falsa.
• COND esegue l’espressione corrispondente alla condizione vera o a else se nessuna è vera.
• CASE calcola un espressione ed esegue i comandi associati alla lista che contiene tale valore.