Lisp

Linguaggi di Programmazione
LISP
Carlo Lepori
Scuola di Ingegneria del Canton Ticino
(STS)
Introduzione
In questa parte del corso “Linguaggi di programmazione” affronteremo al-
cune tematiche riguardanti la struttura e l’interpretazione dei programmi
per calcolatore, rifacendoci al testo: H. Abelson e G. Sussman, Structure
and Interpretation of Computer Programs, Mit Press. Altri temi, come
l’introduzione a linguaggi specifici (C++, C, ADA, ecc) e un’introduzione
alla teoria dei linguaggi formali (compilazione) sono sviluppati in altre parti
del corso.
Come nel testo citato, useremo il linguaggio Lisp, e questo per vari motivi:
• L’uso di un linguaggio non ancora conosciuto e di tipo diverso da quelli

noti, permette di cogliere gli aspetti più importanti, in maniera meno
condizionata.
• Il Lisp per la sua struttura semplice e per la sua versatilità è partico-
larmente adatto a questo tipo di approccio.
• La conoscenza del Lisp sarà vantaggiosa per la lezione “Intelligenza
artificiale”.
Prima di iniziare sembra opportuno riassumere le nostre conoscenze sui di-

versi linguaggi di programmazione: sono state proposte molte classificazioni
dei linguaggi:
imperativi: orientati alla descrizione di algoritmi; strettamente legati al

modello di macchina detto di von Neumann (questo gruppo comprende
quasi tutti i linguaggi noti);
dichiarativi: approccio matematico, legato al concetto di funzione, come
il Lisp, oppure in termini di relazioni logiche (calcolo dei predicati),
come il Prolog.
Si vedano anche la Tabella I.1 “Evoluzione storica” e la Tabella I.2 “Cinque

generazioni”.
1
2
definizione linguaggio uso

< ’54 Assembler generale
’54–’57 FORTRAN calcolo numerico
’58–’60 ALGOL 60 calcolo numerico
’59–’60 COBOL business DP
’56–’60 APL array processing
’56–’62 LISP manipolazione simbolica
’63–’64 BASIC generale/educativo
’63–’64 PL/I generale
’63–’68 ALGOL 68 generale
’71 Pascal generale/educativo
’72 PROLOG programmazione logica
’74 C programmazione di sistema
’75 Concurr. Pascal programmazione concorrente
’77 Modula programmazione concorrente
’80 Modula-2 generale, grandi sistemi
’83 Ada generale, grandi sistemi,
real-time
’84 Common Lisp generale, manipolazione simbolica
’86–’89 C++ C a oggetti (rel. 1 e 2)
’89 CLOS Lisp a oggetti
’95 Ada95 Ada a oggetti
Table I.1: Evoluzione storica
Table I.2: 5 generazioni di linguaggi
• prima: linguaggio macchina, assembler;
• seconda: linguaggi procedurali non strutturati: Fortran, Cobol;
• terza: linguaggi procedurali strutturati: Pascal, C, Modula-2, Ada;
• quarta: linguaggi applicativi, query languages;
• quinta: linguaggi logici, linguaggi funzionali: Prolog, Lisp.

Chapter 1
La funzione come astrazione
Per questo corso disponiamo di ambienti Lisp su PC (Allegro Common Lisp)

e su Macintosh (Macintosh Common Lisp) al momento non sono disponibili
versioni su AXP.
Poiché lo scopo di questo corso non è di imparare il Lisp nella sua com-
pletezza, gli elementi del linguaggio verranno introdotti man mano, lasciando
a chi si interessa di consultare testi e manuali per acquistare una maggiore
esperienza.
1.1 Il linguaggio Lisp

1.1.1 L’interprete
Il Lisp si presenta come interprete, ma è anche possibile compilare i pro-
grammi, disponendo quindi contemporaneamente dell’ambiente confortevole
di un inteprete e della velocità di un compilatore. Per accedere all’interprete
si lancia l’applicazione. L’interprete Lispsi annuncia con un messaggio e un
prompt (il testo del prompt naturalmente non ha nessuna importanza):
Lisp>
L’idea di fondo è che il Lisp è in attesa di una espressione da valutare.

Egli cioè legge un’espressione, la valuta e ne scrive il valore: si dice che
l’interprete si trova in una read-eval-print loop.
L’elemento base della sintassi del Lisp, l’espressione, può essere un ato-
mo, e si distinguono tra l’altro numeri e simboli, oppure una lista (elenco
di espressioni, senza virgola, racchiuse da parentesi rotonde). Si noti la
3
CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 4
ricorsività della definizione: un elemento di una lista può essere a sua volta
una lista, ecc.
Il valore di un atomo numerico è il numero stesso:
Lisp> 486
486
Un simbolo può avere un valore a esso legato (bound ), oppure no:
Lisp> pi
3.14 . . .
Lisp> a
error: unbound value . . .
Break 1>
A causa dell’errore precedente (la valutazione di un simbolo cui non è legato

alcun valore), l’interprete si trova ora nello stato di debugging che per-
mette una correzione interattiva del programma. L’interpete, a seconda
dell’implementazione, può essere settato in modo da reagire in altro modo.
Quando deve valutare un’espressione non atomica (detta anche una forma,
in questo contesto), il Lisp considera il primo elemento della lista come una
funzione e gli altri elementi come argomenti della funzione:
Lisp> (+ 317 349)

666
Lisp> (* 5 99)
495
Come si vede, il Lisp usa una notazione algebrica di tipo a prefisso e non
quella tradizionale di tipo a infisso: questa scomodità è compensata da
una notevole uniformità sintattica. Le funzioni matematiche usate in questi
esempi, permettono anche un numero indeterminato di argomenti: grazie
alla notazione a prefisso non ci sono ambiguità:
Lisp> (* 25 4 12)
1200
Un altro vantaggio è la possibilità di avere argomenti che sono essi stessi

espressioni:
Lisp> (+ (* 3 5) (- 10 6))
19
Le funzioni primitive, cioè predefinite nel sistema Lisp non comprendono

solo le funzioni aritmetiche fondamentali, ma anche molte altre che verranno
introdotte secondo il bisogno. Per es.:
Lisp> (sqrt 9.0)

3.0
Lisp> (sin (/ pi 6))

0.5
1.1.2 La definizione di funzioni (e simboli)

In Lisp la possibiltà di definire nuove funzioni è fondamentale! Si usa la
forma defun che prende come argomenti il nome della nuova funzione, la
lista dei suoi argomenti e il corpo (body) che la definisce, formato da una o
più espressioni: il valore della funzione sarà determinato dall’ultima espres-
sione. La forma defun non segue la sintassi ordinaria: i suoi argomenti non
vengono valutati, ma usati per modificare l’ambiente Lisp; forme di questo
tipo verranno chiamate improprie.1
Lisp> (defun square (x) (* x x))

square
Il Lisp restituisce sempre un valore!2 in questo caso il nome della funzione

definita. Ora questa funzione fa parte dell’interprete Lisp per tutto il col-
legamento:
Lisp> (square (+ 2 5))

49
È anche possibile definire un simbolo (o meglio: dargli un valore):
Lisp> (defvar dieci 10)

dieci
1
Il Common Lisp distingue forme speciali (special forms) predefinite, e macro, forme
improprie che possono essere definite dall’utente.
2
In realtà la risposta è di solito scritta maiuscola: il Common Lisp non distingue
maiuscolo e minuscolo e archivia i simboli in maiuscolo. Noi useremo la scrittura minuscola
per leggibilità.
Lisp> dieci
10
Si tratta evidentemente di una forma impropria3 : il simbolo non viene valu-

tato, anzi l’importante è proprio l’effetto collaterale (side-effect) di legare un
valore al simbolo! A questo scopo si usa anche la forma impropria setq, il
cui scopo è però di modificare il valore di un simbolo! Se si vuole mantenere
il carattere strettamente funzionale del linguaggio, questo non è permesso.
Lisp> (setq dieci 22)

22
Lisp> dieci
22
1.1.3 L’editor
Di solito le nuove funzioni non sono definite direttamente nell’interprete,
ma sono preparate in un editor e poi caricate nell’ambiente Lisp. Qualsiasi
editor va bene, ma dato il numero assai grande di parentesi che si possono
trovare in una definizione e la necessità di alternare il lavoro nell’editor e nel
Lisp, è conveniente usare un editor incorporato. Esso può venire invocato
con la funzione4
(ed "nome-del-file")
Normalmente si accede all’editor con un comando di menù. L’editor se-

gnala la chiusura delle parentesi e permette di realizzare l’indentazione,
usando p. es. tab dopo return, per aumentare la leggibilità del programma
(pretty-printing).
Per caricare la funzione nel Lisp, prima bisogna selezionare tutta la defini-
zione e poi bisogna valutarla, con i comandi appositi.
Per salvare il lavoro fatto nell’editor, si salverà su disco il buffer (finestra)
corrispondente.
3
Altre forme con lo stesso effetto, ma piccole differenze stilistiche sono: defparameter
e defconstant.
4
Una stringa (espressa in Common Lisp con le virgolette) è un atomo che ha sé stesso
come valore.
1.1.4 Espressioni condizionali e predicati

Usando solo le funzioni viste, la nostra capacità espressiva è assai piccola.
Per sempio ci è impossibile definire la funzione my-abs5 che calcoli il valore
assoluto di un numero. Per distinguere i vari casi possibili si usa la forma
impropria cond: come sempre in Lisp, anche cond restituisce un valore! Il
suo uso lo si capisce più facilmente con un esempio:
(defun my-abs (x)

(cond ((> x 0) x)
((= x 0) 0)
((< x 0) (- x))))
Gli argomenti di cond sono liste (dette clausole (clauses)) il cui primo ele-
mento è detto antecedente e il resto conseguenza. L’antecedente è un pre-
dicato: e cioè un’espressione il cui valore può essere vero o falso. In Lisp,
“falso” è il valore del simbolo nil, ogni altro valore viene considerato come
“vero”; talvolta si usa il simbolo t.6
La valutazione di un’espressione condizionale segue la seguente regola: viene
valutato il primo predicato; se esso è falso, viene valutato il secondo predicato
ecc. , finché si trova un predicato che è vero, cioè che dà un valore non-nil:
in questo caso si valutano le forme che compongono la conseguenza: il valore
dell’ultima è il valore di tutta l’espressione condizionale. Se nessun predicato
è vero, l’espressione condizionale ha il valore nil. Anche se più predicati
fossero veri, solo il primo di essi causa la valutazione della sua conseguenza:
l’ordine delle clausole è quindi importante!
Un altro modo di definire il valore assoluto:
(defun my-abs (x)

(cond ((< x 0) (- x))
(t x)))
Qui è stato usato il simbolo t che, essendo vero, fa scattare l’esecuzione della
forma corrispondente: è buona abitudine terminare la forma condizionale
con una clausola che inizia con t. Ancora un’altra possibilità:
(defun my-abs (x)

(if (< x 0) (- x) x))
5
Volendo definire funzioni che sono già primitive Lisp, useremo nomi che iniziano con
my- o nomi in italiano per evitare confusione.
6
Gli atomi nil e t hanno sé stessi come valore.
La forma impropria if valuta il primo argomento (il predicato): se è vero,

restituisce come valore il valore del secondo argomento, in caso contrario
quello del terzo (gli argomenti devono essere singole forme!).
1.1.5 L’applicazione di funzioni

Esaminiamo più in dettaglio il meccanismo di valutazione usato normal-
mente dall’interprete Lisp (escludendo quindi le forme improprie):
1. Tutte le sotto-espressioni della forma vengono valutate.
2. La funzione (il valore funzionale della prima sotto-espressione) viene

applicata agli argomenti (i valori delle altre sotto-espressioni).
Questa semplice regola presenta aspetti interessanti: il primo passo indica

che per valutare una forma si devono valutare i suoi elementi. La regola di
valutazione è quindi ricorsiva per natura: essa cioè contiene, come uno dei
suoi passi, la necessità di applicare la regola stessa!
Nel caso di funzioni che non sono primitive, viene valutato il loro corpo,
sostituendo ogni parametro formale con il corrispondente valore dell’argo-
mento. Si considerino le seguenti definizioni:
(defun sum-of-squares (x y)
(+ (square x) (square y)))
Lisp> (sum-of-squares 3 4)
25
(defun f (a)
(sum-of-squares (+ a 1) (* a 2)))
Lisp> (f 5)
136
Seguiamo in dettaglio il processo di valutazione per quest’ultimo esempio;

per valutare
(f 5)
si deve prima di tutto ricuperare il corpo di f:
(sum-of-squares (+ a 1) (* a 2))
poi si sostituisce il parametro formale a con il valore dell’argomento (che in

questo caso è 5, trattandosi di un numero):
(sum-of-squares (+ 5 1) (* 5 2))
Il processo continua: i valori degli argomenti (+ 5 1) e (* 5 2), e cioè 6 e

10, vengono sostituiti nel corpo di sum-of-squares:
(+ (square 6) (square 10))
Utilizzando la definizione di square, si ottiene:
(+ (* 6 6) (* 10 10))
che si riduce a
(+ 36 100)
e quindi a
136
Il processo qui descritto è detto modello di sostituzione (substitution model );

esso serve per dare un significato all’idea di applicazione di una funzione.
D’altra parte si tratta di un modello che non rispecchia necessariamente
il funzionamento reale dell’interprete e in ogni caso non è sufficientemente
potente per descrivere casi più complessi, in cui si accetti la mutabilità dei
dati, come vedremo più avanti. Si parla talvolta di pure Lisp per indicare
il sotto-insieme del linguaggio che aderisce a una visione strettamente fun-
zionale.
Si osservi che ci sono altre interpretazioni possibili: un’alternativa potrebbe
essere di espandere le definizioni di funzioni fino ad ottenere un’espressione
che contenga solo funzioni primitive e procedere solo allora alla valutazione.
(f 5)
diventerebbe successivamente
(sum-of-squares (+ 5 1) (* 5 2))
(+ (square (+ 5 1)) (square (* 5 2)))

(+ (* (+ 5 1) (+ 5 1)) (* (* 5 2) (* 5 2)))
riducendosi poi a
(+ (* 6 6) (* 10 10))
(+ 36 100)
136
Questo ordine di valutazione è detto normale (normal-order evaluation), in

contrasto con quello visto prima, detto applicativo (applicative-order evalu-
ation). Si può dimostrare che i due ordini di valutazione sono equivalenti,
se è valido il modello di sostituzione.
1.2 Funzioni e processi di calcolo

1.2.1 Ricorsione e iterazione lineari
Si consideri il comunissimo esempio della funzione fattoriale, definita come
segue:
n! = n · (n − 1) · (n − 2) · · · 3 · 2 · 1
Una definizione ricorsiva sarebbe:
n! = n · (n − 1)!
1! = 1
Questa definizione può essere programmata in Lisp direttamente:
(defun factorial (n)

(if (= n 1)
1
(* n (factorial (- n 1)))))
D’altra parte, usando la prima definizione, si può procedere accumulando i

valori delle successive moltiplicazioni e contando il numero di moltiplicazioni:
prodotto ← contatore · prodotto
contatore ← contatore + 1
(defun factorial (n)

(fact-iter 1 1 n))
(defun fact-iter (product counter max-count)

(if (> counter max-count)
product
(fact-iter (* counter product)
(+ counter 1)
max-count)))
Sebbene ambedue le definizioni abbiano forma ricorsiva (le funzioni sono de-
finite invocando sé stesse), i processi di calcolo creati dalle due funzioni sono
molto differenti: nel primo caso si ha un numero eventualmente elevato di
moltiplicazioni in sospeso: l’interprete ha bisogno di una quantità crescente
di memoria (proporzionale a n) per mantenere l’informazione necessaria: un
processo di questo tipo si dice linearmente ricorsivo (si veda la Tabella 1.1).
(factorial 6)
(* 6 (factorial 5))
(* 6 (* 5 (factorial 4)))
(* 6 (* 5 (* 4 (factorial 3))))
(* 6 (* 5 (* 4 (* 3 (factorial 2)))))
(* 6 (* 5 (* 4 (* 3 (* 2 (factorial 1))))))
(* 6 (* 5 (* 4 (* 3 (* 2 1)))))
(* 6 (* 5 (* 4 (* 3 2))))
(* 6 (* 5 (* 4 6)))
(* 6 (* 5 24))
(* 6 120)
720
Table 1.1: Processo ricorsivo
Nel secondo caso in ogni momento la situazione è definita dal valore delle
tre variabili del programma: un processo di questo tipo è detto linearmente
iterativo (si veda la Tabella 1.2).
Non si confonda la forma della definizione della funzione, con il tipo di pro-
cesso generato! Quando una funzione ricorsiva genera un processo iterativo,
si parla di tail recursion.
Nei linguaggi tradizionali un processo iterativo viene descritto con strutture
sintattiche apposite (esistono anche in Lisp), per evitare lo spreco di memo-
ria inerente a un uso inutile di processi ricorsivi. Un buon Lisp dovrebbe
(factorial 6)
(fact-iter 1 1 6)
(fact-iter 1 2 6)
(fact-iter 2 3 6)
(fact-iter 6 4 6)
(fact-iter 24 5 6)
(fact-iter 120 6 6)
(fact-iter 720 7 6)
720
Table 1.2: Processo iterativo
essere in grado di riconoscere la tail recursion e quindi la presenza di strut-

ture sintattiche iterative non è indispensabile. Strutture sintattiche magari
comode, ma non essenziali, sono dette sintactic sugar.
1.2.2 La ricorsione ad albero

In alcuni casi la ricorsione presente nella definizione di una funzione non è
lineare ma ad albero (tree recursion). Un esempio molto semplice è il calcolo
della successione detta di Fibonacci, in cui ogni numero è la somma dei due
precedenti:
0, 1, 1, 2, 3, 5, 8, 13, 21, . . .
In generale i numeri di Fibonacci possono essere definiti come segue:

 0
 se n = 0
F (n) = 1 se n = 1
F (n − 1) + F (n − 2) altrimenti


La definizione può essere tradotta immediatamente in una funzione ricorsiva:
(defun fib (n)

(cond ((= n 0) 0)
((= n 1) 1)
(t (+ (fib (- n 1))
(fib (- n 2))))))
Per calcolare (fib 5) si devono calcolare (fib 4) e (fib 3) e cosı̀ di se-

guito, con un processo che si biforca ad ogni passo.
È un esempio interessante, ma naturalmente esistono metodi più efficienti
per calcolare i numeri di Fibonacci: qui si ripetono continuamente calcoli
già fatti, per cui il processo impiega un tempo che cresce esponenzialmente
con n; lo spazio richiesto invece cresce linearmente. Questo comportamento
è tipico dei processi con ricorsione ad albero.
Un approccio iterativo a questo esempio, si basa sull’idea che partendo con
due numeri interi a e b inizializzati a 1 e 0 rispettivamente, con la trasfor-
mazione simultanea
a←a+b
b←a
dopo n trasformazioni b sará uguale a F (n).
(defun fib (n)

(fib-iter 1 0 n))
(defun fib-iter (a b count)

(if (= count 0)
b
(fib-iter (+ a b) a (- count 1))))
Questo metodo è una iterazione lineare. Benché la differenza del tempo im-
piegato dai due metodi sia notevolissima, non si deve concludere che le ricor-
sioni ad albero siano inutili. In altri campi l’approccio ricorsivo rappresenta
un mezzo naturale e potente (Si ricordi che il funzionamento dell’interprete
è stato descritto in questi termini!).
1.3 Funzioni di ordine superiore

Gli esempi visti finora riguardavano funzioni che hanno come argomenti dei
numeri. Definire una funzione rappresenta un’astrazione dai casi particolari,
rappresentati dai valori che gli argomenti possono prendere: cosı̀
(defun cube (x) (* x x x))
definisce come calcolare il cubo di un numero, a prescindere dal suo valore

contingente. Si potrebbero usare espressioni del tipo:
(* 3 3 3)
(* y y y)
ma naturalmente questo sarebbe assai scomodo, essendo obbligati a lavo-

rare al livello delle funzioni predefinite e senza la possiblità di esprimere il
concetto dell’elevazione alla terza potenza. Per questo i linguaggi, tranne i
più primitivi, offrono la possibiltà di definire nuove funzioni.
Un passo in avanti nel livello di astrazione è rappresentato da funzioni che
manipolano altre funzioni, come parametri o come risultati.
1.3.1 Funzioni come parametri

Si considerino le seguenti funzioni: la prima calcola la somma degli interi da
a a b:
(defun sum-int (a b)
(if (> a b)
0
(+ a (sum-int (+ a 1) b))))
La seconda calcola la somma dei cubi nell’intervallo definito:
(defun sum-cubes (a b)
(if (> a b)
0
(+ (cube a) (sum-cubes (+ a 1) b))))
La terza calcola un’approssimazione, non molto buona, di π/8:
(defun pi-sum (a b)
(if (> a b)
0
(+ (/ 1 (* a (+ a 2))) (pi-sum (+ a 4) b))))
Evidentemente questi tre esempi hanno una struttura simile; in matematica

si usa la notazione seguente:
b
X
f (n) = f (a) + · · · + f (b)
n=a
Vorremmo definire anche in Lisp una funzione del tipo:
(defun sum (f a step b)

...
dove f è la funzione da applicare a ogni termine e step è il passo per calcolare

il prossimo termine. Questo è possibile in Common Lisp ma è necessario
avvertire l’interprete quando si intende usare un parametro come funzione
tramite funcall:
(defun sum (f a step b)

(if (> a b)
0
(+ (funcall f a)
(sum f (+ step a) step b))))
Quando si usa sum è necessario avvertire l’interprete che alcuni parametri

sono da usare come funzioni; in Common Lisp questo avviene ponendo #’
prima del nome della funzione7 . Cosı̀, utilizzando la funzione Common Lisp
+ (che, usata con un solo argomento, restituisce l’argomento stesso) si può
ottenere l’effetto di sum-int:
Lisp> (sum #’+ 1 1 10)

55
È anche possibile definre sum-int tramite sum:
(defun sum-int (a b)
(sum #’+ a 1 b))
Per calcolare sum-cubes usiamo la funzione cube, che abbiamo già definito:
Lisp> (sum #’cube 1 1 10)

3025
Per il terzo esempio si dovrebbe definire la funzione pi-f:
(defun pi-f (n)

(/ 1 (* n (+ n 2))))
Lisp> (* 8 (sum #’pi-f 1 4 1000))

3.13959
In generale è però scomodo dover definire col proprio nome funzioni che
non hanno un’utilità generale. Per definire pi-sum tramite sum sarebbe
7
In realtà si dovrebe usare la forma impropria function, ma per comodità di scrittura
i caratteri #’ hanno un effetto equivalente: (function sin) e #’sin sono la stessa cosa.
opportuno poter esprimere direttamente la funzione pi-f all’interno di sum.

Questo è possibile tramite la forma impropria lambda8 , che serve a definire
funzioni anonime (usando la stessa sintassi di defun):
(defun pi-sum (a b)
(sum #’(lambda (n) (/ 1 (* n (+ n 2))))
a
4
b))
Lisp> (* 8 (pi-sum 1 1000))

3.13592
La funzione definita tramite lambda è una funzione come le altre (ma non
ha un nome), e può essere usato negli stessi contesti:
Lisp> ((lambda (x) (* x x)) 5)

25
1.3.2 Funzioni come valori

In Lisp è possibile ottenere funzioni come valori di altre funzioni. Illustria-
mo questa possibilità con un esempio tratto dal calcolo infinitesimale: “la
derivata di x3 è 3x2 .” Questo può essere interpretato dicendo che “derivata”
è un operatore che, applicato alla funzione x3 dà come valore la funzione 3x2 .
Definiamo la derivata tramite la formula (per il limite dx → 0):
f (x + dx) − f (x)
f 0 (x) = .
dx
Usando lambda possiamo esprimere questa formula con la funzione9 :
(lambda (x)
(/ (- (funcall f (+ x dx)) (funcall f x))
dx))
Si può andare oltre e definire la funzione deriv che prende come argomenti
una funzione f e un valore (piccolo) per dx e restituisce come valore la
derivata della funzione.
8
Il nome ha origine dalle teorie logiche sulla computabilità delle funzioni. Non bisogna
però lasciarsi spaventare: in Lisp serve solo allo scopo indicato!
9
Si tratta ancora di un calcolo numerico della derivata; vedremo in seguito che in Lisp
è possibile anche darne una definizione simbolica.
(defun deriv (f dx)

#’(lambda (x)
(/ (- (funcall f (+ x dx)) (funcall f x))
dx)))
Possiamo ora usare la funzione cosı̀ definita per calcolare la derivata della
funzione cube nel punto 5 (il valore esatto è naturalmente 75):
Lisp> (funcall (deriv #’cube 0.0001) 5)

75.015
Anche in questo caso, in Common Lisp è necessario usare funcall per

indicare l’applicazione di una funzione e #’ per evitare che venga usato il
valore dell’atomo cube.
Il metodo di Newton per gli zeri di una funzione
Per mostrare le possibilità offerte dal calcolo della funzione derivata, voglia-
mo implementare l’algoritmo di Newton per gli zeri di una funzione differen-
ziabile. Se x0 è una approssimazione dello zero,
f (x0 )
x1 = x0 −
f 0 (x0 )
è una approssimazione migliore.
L’approssimazione successiva, a partire da un valore iniziale (qui chiamato
guess), viene espressa in Lisp come segue:
(defun newton (f guess)

(if (< (abs (funcall f guess)) 0.00001)
guess
(newton f (improve-guess f guess))))
Il miglioramento dell’approssimazione avviene con la funzione deriv:
(defun improve-guess (f guess)

(- guess (/ (funcall f guess)
(funcall (deriv f 0.00001) guess))))
Possiamo ora controllare il funzionamento di newton:
Lisp> (newton #’(lambda (x) (- (cos x) x)) 1)

0.739
Chapter 2
I dati come astrazione
Finora abbiamo visto funzioni che hanno come valore numeri (o eventual-
mente altre funzioni), ma un linguaggio evoluto deve dare la possibilità di us-
are forme più complesse di valori, i cosiddetti dati strutturati. La definizione
di questo tipo di dati può essere difficoltosa: ripieghiamo sull’approccio
seguente:
• Devono esistere funzioni dette costruttori (constructors) che permet-

tono di costruire il dato strutturato a partire da dati più semplici.
• Devono esistere funzioni dette selettori (selectors) che, a partire dal

dato strutturato, permettono di estrarre i dati più semplici che li com-
pongono.
Studieremo prima di tutto le strutture tipiche del Lisp, per poi affrontare il
tema in generale.
2.1 La lista
La struttura di dati fondamentale nel linguaggio Lisp è la lista1 : essa è pure
la forma sintattica fondamentale, realizzando la completa identità tra dati e
programmi, tipica del Lisp. Abbiamo già definito la lista a pag. 3, dicendo
che è un elenco di espressioni (simboliche) racchiuso da parentesi rotonde;
un’espressione a sua volta può essere un atomo o una lista.
1
Lisp significa appunto LISt Processing (e non Lots of Insane and Stupid Parentheses,
come affermano i detrattori)
18
CHAPTER 2. I DATI COME ASTRAZIONE 19
Il costruttore: cons
Data la definizione ricorsiva di lista, il costruttore avrà un approccio ricor-
sivo alla costruzione: esso aggiunge un elemento in testa alla lista data.
Supponiamo che il valore di lis sia (5 7 9):
Lisp> lis
(5 7 9)
Lisp> (cons 3 lis)

(3 5 7 9)
Lisp> lis
(5 7 9)
Il costruttore non modifica l’argomento! In un certo senso il valore fornito

è una nuova lista. Per poter porre il primo elemento, bisogna aggiungerlo
alla lista vuota; questa può essere rappresentata come () oppure come nil.
nil è contemporaneamente un atomo (il simbolo il cui valore è nil) e una
lista (la lista vuota ()): questa (unica!) coincidenza rispecchia il ruolo di
nil come “elemento neutro” della costruzione di liste.
Lisp> (cons 1 ())
(1)
In questo modo si possono p.es. costruire liste di risultati: supponiamo di
disporre del predicato primep che verifica se un numero è primo; per costru-
ire la lista dei primi inferiori a n, definiamo la funzione seguente:
(defun prim-list (n)
(cond ((zerop n) ())
((primep n) (cons n (prim-list (1- n))))
(t (prim-list (1- n)))))
Si osservi che, per ora, cons può esser usato solo se il secondo argomento è
una lista!
I selettori: first e rest

I selettori eseguono il compito inverso a quello di cons: data una lista,
essi selezionano la prima espressione (first) e il resto della lista (rest)2 :
2
Per motivi storici, i nomi più diffusi per queste primitive sono car e cdr; in altri
contesti si usano anche i nomi testa (head) e coda (tail), che non sono però predefiniti in
Common Lisp.
l’argomento deve essere una lista!
Lisp> lis
(5 7 9)
Lisp> (first lis)

5
Lisp> (rest lis)

(7 9)
Lisp> lis
(5 7 9)
Anche i selettori non modificano l’argomento! Data la loro definizione è

evidente che, per una lista qualsiasi, vale:
Lisp> lis
(5 7 9)
Lisp> (cons (first lis) (rest lis))

(5 7 9)
Lisp> (first (cons 3 lis))

3
Lisp> (rest (cons 3 lis))

(5 7 9)
Le espressioni simboliche
Una caratteristica del Lisp è la possibilità di lavorare a livello simbolico:
finora gli atomi visti erano numeri e i simboli avevano come valore un nu-
mero. Questa restrizione non è necessaria! Per poter operare con i simboli,
dobbiamo superare una difficoltà: nell’esempio:
Lisp> (cons 1 ())

(1)
l’interprete segue la regola di valutazione e valuta gli argomenti, trovando 1

e nil; passa poi alla costruzione della lista. Non è invece possibile costruire
in questo modo la lista (a):
Lisp> (cons a ())

Error . . .
L’interprete vuole il valore di a! Dobbiamo quindi poter disporre di una

forma impropria che eviti la valutazione dell’espressione. Lo stesso prob-
lema lo si ritrova nel linguaggio di tutti i giorni: alla domanda “Dimmi
come ti chiami” ci aspettiamo un nome in risposta, ma all’invito “ripeti
‘Come ti chiami?’ per favore” vorremmo sentir ripetere la domanda citata
tra virgolette! Anche in Lisp si dice che un’espressione da non valutare viene
citata (quoted ) e si indica con un apice3 davanti ad essa:
Lisp> ’a
a
Lisp> ’(mele pere)

(mele pere)
Lisp> (defvar lista ’(mele pere noci))

lista
Lisp> (first lista)

mele
Lisp> (rest ’(mele pere noci))

(pere noci)
Per poter lavorare a livello simbolico sono indispensabili due predicati (che
insieme a cons, car e cdr formano le 5 funzioni base del Lisp): atom è vero
(t) se il suo unico argomento è un atomo (cioè non è una lista)4 ; eq ha due
argomenti (che dovrebbero essere atomi): esso è vero (t) se i due atomi sono
identici5 .
Sia per esempio da definire una funzione my-member che controlli se un
simbolo sia presente in una lista:
3
Si tratta di una stenografia per la forma impropria quote: (quote expr) e ’expr
sono la stessa cosa. Questi caratteri che influenzano il modo in cui l’interprete legge le
espressioni sono detti macro-characters (vedi anche la nota a pag. 15).
4
Attenzione: atom è uno dei pochi predicati che non terminano con la lettera p. È
anche disponibile il predicato listp che dà la risposta contraria.
5
Va usato solo per atomi simbolici: negli altri casi si usi equal e per i numeri =; sono
a disposizione anche predicati per casi particolari: null controlla se l’argomento è nil o
la lista vuota, zerop controlla se un numero è zero, ecc.
(defun my-member (at lis)

(cond ((null lis) nil)
((eq at (first lis)) t)
(t (my-member at (rest lis)))))
Questo esempio illustra il metodo per lavorare con una lista: prima si studia
il first della lista e poi il rest con una chiamata ricorsiva. Qual è il valore
della funzione boh?
(defun boh (lista)

(cond ((null lista) nil)
(t (cons (first lista) (boh (rest lista)))))
Due primitive molto utili, lavorando con liste, sono list e append. La
prima prende un numero variabile di espressioni come argomenti e crea una
lista che le contiene; la seconda prende un numero variabile di liste come
argomenti e ne fa una lista sola:
Lisp> (list ’miele ’zucchero ’saccarina)

(miele zucchero saccarina)
Lisp> (append ’(a b) ’(c d e) ’(f))

(a b c d e f)
Se ci si limita a due argomenti, la loro definizione a partire dalle primitive

fondamentali è evidente.
Che cos’è una lista?

In realtà il costruttore cons accetta come argomenti due espressioni qualsiasi
e dà come valore una coppia detta puntata (dotted pair ), i cui elementi
possono essere selezionati con car e cdr6 :
Lisp> (cons ’a ’b)

(a . b)
Lisp> (defvar pair (cons ’a ’b))

pair
Lisp> (car pair)

a
6
In questo contesto l’uso dei nomi storici sembra più adatto.
Lisp> (cdr pair)

b
Un metodo di visualizzare questo fatto è il seguente: gli atomi a e b vengono

rappresentati da celle: cons crea una nuova cella che contiene i puntatori
ai due atomi come si vede nella Fig. 2.1. Una lista di uno o più atomi,
r r
@ (a . b)
@
R
@
a b
Figure 2.1: Coppia puntata.
formata con l’applicazione successiva di cons, viene rappresentata come nella

Fig. 2.2. L’interprete usa la notazione con il punto solo quando non è in
r r
HH

j
H
r nil a r rH

HHj
a b r nil

c
(a . nil) (a . (b . (c . nil)))
(a) (a b c)
Figure 2.2: Liste di atomi.
grado di usare la notazione tipica con le liste. I selettori forniscono quindi

uno dei puntatori, senza modificare la struttura esistente! Lo stesso atomo
(o la stessa lista) può far parte di differenti strutture. La Fig. 2.3 mostra
una lista nella quale la prima espressione è a sua volta una lista. Questa
rappresentazione rende chiari alcuni meccanismi, altrimenti un po’ astrusi.
Il predicato eq per esempio considera uguali due oggetti identici: se si tiene
conto del fatto che cons costruisce in ogni caso una nuova cella, questi esempi
risulteranno chiari:
r rXX
XXX
9
z
X
r rH r nil

HH
j

a r c
nil

b
((a . (b . nil)) . (c . nil))
((a b) c)
Figure 2.3: Lista con sottolista.
Lisp> lista
(mele pere noci)
Lisp> (eq ’lista ’lista)

t
Lisp> (eq lista lista)

t
Lisp> (eq lista ’(mele pere noci))

nil
Lisp> (eq (car lista) ’mele)

t
Per i numeri il Common Lisp lascia libertà agli implementatori di usare

puntatori o rappresentazioni esplicite e permette l’uso di copie, per motivi
di efficienza: questo rende l’uso di eq con numeri dipendente dall’imple-
mentazione (Si dovrà quindi partire dall’idea che due numeri, anche con lo
stesso valore, non saranno necessariamente eq). La funzione append usa il
puntatore all’ultima lista; per le altre liste crea copie delle strutture, che si
riferiscono agli stessi atomi, per non modificare gli argomenti (vedi Fig. 2.4).
Cosı̀ lavora la maggior parte delle funzioni che operano su liste. Esistono
anche funzioni che modificano gli argomenti: benché siano talvolta più effi-
cienti, il loro uso non è compatibile con un approccio puramente funzionale.
lista1 - r r - r nil
(a b)
? ?
a b
6 6
(append lista1 lista2) - r r - r r
?
lista2 - r r - r nil
(c d)
? ?
c d
Figure 2.4: Effetto di append.

Contents
1 La funzione come astrazione 3

1.1 Il linguaggio Lisp . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 L’interprete . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2 La definizione di funzioni (e simboli) . . . . . . . . . . 5
1.1.3 L’editor . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.4 Espressioni condizionali e predicati . . . . . . . . . . . 7
1.1.5 L’applicazione di funzioni . . . . . . . . . . . . . . . . 8
1.2 Funzioni e processi di calcolo . . . . . . . . . . . . . . . . . . 10
1.2.1 Ricorsione e iterazione lineari . . . . . . . . . . . . . . 10
1.2.2 La ricorsione ad albero . . . . . . . . . . . . . . . . . . 12
1.3 Funzioni di ordine superiore . . . . . . . . . . . . . . . . . . . 13
1.3.1 Funzioni come parametri . . . . . . . . . . . . . . . . 14
1.3.2 Funzioni come valori . . . . . . . . . . . . . . . . . . . 16
2 I dati come astrazione 18

2.1 La lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
26

Lisp

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Lisp

Caricato da

Copyright:

Formati disponibili

Linguaggi di Programmazione

• L’uso di un linguaggio non ancora conosciuto e di tipo diverso da quelli

Prima di iniziare sembra opportuno riassumere le nostre conoscenze sui di-

imperativi: orientati alla descrizione di algoritmi; strettamente legati al

Si vedano anche la Tabella I.1 “Evoluzione storica” e la Tabella I.2 “Cinque

definizione linguaggio uso

Table I.1: Evoluzione storica

Table I.2: 5 generazioni di linguaggi

• prima: linguaggio macchina, assembler;

• seconda: linguaggi procedurali non strutturati: Fortran, Cobol;

• terza: linguaggi procedurali strutturati: Pascal, C, Modula-2, Ada;

• quarta: linguaggi applicativi, query languages;

• quinta: linguaggi logici, linguaggi funzionali: Prolog, Lisp.

La funzione come astrazione

Per questo corso disponiamo di ambienti Lisp su PC (Allegro Common Lisp)

1.1 Il linguaggio Lisp

L’idea di fondo è che il Lisp è in attesa di una espressione da valutare.

Un simbolo può avere un valore a esso legato (bound ), oppure no:

A causa dell’errore precedente (la valutazione di un simbolo cui non è legato

Lisp> (+ 317 349)

Un altro vantaggio è la possibilità di avere argomenti che sono essi stessi

Le funzioni primitive, cioè predefinite nel sistema Lisp non comprendono

Lisp> (sqrt 9.0)

Lisp> (sin (/ pi 6))

1.1.2 La definizione di funzioni (e simboli)

Lisp> (defun square (x) (* x x))

Il Lisp restituisce sempre un valore!2 in questo caso il nome della funzione

Lisp> (square (+ 2 5))

È anche possibile definire un simbolo (o meglio: dargli un valore):

Lisp> (defvar dieci 10)

Si tratta evidentemente di una forma impropria3 : il simbolo non viene valu-

Lisp> (setq dieci 22)

Normalmente si accede all’editor con un comando di menù. L’editor se-

1.1.4 Espressioni condizionali e predicati

(defun my-abs (x)

(defun my-abs (x)

(defun my-abs (x)

La forma impropria if valuta il primo argomento (il predicato): se è vero,

1.1.5 L’applicazione di funzioni

1. Tutte le sotto-espressioni della forma vengono valutate.

2. La funzione (il valore funzionale della prima sotto-espressione) viene

Questa semplice regola presenta aspetti interessanti: il primo passo indica

Seguiamo in dettaglio il processo di valutazione per quest’ultimo esempio;

si deve prima di tutto ricuperare il corpo di f:

poi si sostituisce il parametro formale a con il valore dell’argomento (che in

Il processo continua: i valori degli argomenti (+ 5 1) e (* 5 2), e cioè 6 e

(+ (square 6) (square 10))

Utilizzando la definizione di square, si ottiene:

Il processo qui descritto è detto modello di sostituzione (substitution model );

(+ (square (+ 5 1)) (square (* 5 2)))

Questo ordine di valutazione è detto normale (normal-order evaluation), in

1.2 Funzioni e processi di calcolo

(defun factorial (n)

D’altra parte, usando la prima definizione, si può procedere accumulando i

prodotto ← contatore · prodotto

(defun factorial (n)

(defun fact-iter (product counter max-count)

Table 1.1: Processo ricorsivo

Table 1.2: Processo iterativo

essere in grado di riconoscere la tail recursion e quindi la presenza di strut-

1.2.2 La ricorsione ad albero

La definizione può essere tradotta immediatamente in una funzione ricorsiva:

(defun fib (n)

Per calcolare (fib 5) si devono calcolare (fib 4) e (fib 3) e cosı̀ di se-