Linguaggi di Programmazione LISP

Linguaggi di Programmazione LISP Carlo Lepori Scuola di Ingegneria del Canton Ticino (STS)

Introduzione In questa parte del corso Linguaggi di programmazione affronteremo alcune 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 più importanti, in maniera meno condizionata. Il Lisp per la sua struttura semplice e per la sua versatilità è particolarmente adatto a questo tipo di approccio. La conoscenza del Lisp sarà vantaggiosa per la lezione Intelligenza artificiale. Prima di iniziare sembra opportuno riassumere le nostre conoscenze sui diversi 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. Poiché lo scopo di questo corso non è di imparare il Lisp nella sua completezza, 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 è anche possibile compilare i programmi, disponendo quindi contemporaneamente dell ambiente confortevole di un inteprete e della velocità 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 è che il Lisp è in attesa di una espressione da valutare. Egli cioè 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, può essere un atomo, 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 ricorsività della definizione: un elemento di una lista può essere a sua volta una lista, ecc. Il valore di un atomo numerico è il numero stesso: Lisp> 486 486 Un simbolo può 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 è legato alcun valore), l interprete si trova ora nello stato di debugging che permette una correzione interattiva del programma. L interpete, a seconda dell implementazione, può 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 scomodità è compensata da una notevole uniformità sintattica. Le funzioni matematiche usate in questi esempi, permettono anche un numero indeterminato di argomenti: grazie alla notazione a prefisso non ci sono ambiguità: Lisp> (* 25 4 12) 1200 Un altro vantaggio è la possibilità di avere argomenti che sono essi stessi espressioni:

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 5 Lisp> (+ (* 3 5) (- 10 6)) 19 Le funzioni primitive, cioè 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 possibiltà di definire nuove funzioni è 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 più espressioni: il valore della funzione sarà determinato dall ultima espressione. 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 collegamento: Lisp> (square (+ 2 5)) 49 È 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 realtà la risposta è di solito scritta maiuscola: il Common Lisp non distingue maiuscolo e minuscolo e archivia i simboli in maiuscolo. Noi useremo la scrittura minuscola per leggibilità.

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 6 Lisp> dieci 10 Si tratta evidentemente di una forma impropria 3 : il simbolo non viene valutato, anzi l importante è 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 è però di modificare il valore di un simbolo! Se si vuole mantenere il carattere strettamente funzionale del linguaggio, questo non è 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 necessità di alternare il lavoro nell editor e nel Lisp, è conveniente usare un editor incorporato. Esso può venire invocato con la funzione 4 (ed "nome-del-file") Normalmente si accede all editor con un comando di menù. L editor segnala la chiusura delle parentesi e permette di realizzare l indentazione, usando p. es. tab dopo return, per aumentare la leggibilità del programma (pretty-printing). Per caricare la funzione nel Lisp, prima bisogna selezionare tutta la definizione e poi bisogna valutarla, con i comandi appositi. Per salvare il lavoro fatto nell editor, si salverà 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) è un atomo che ha sé stesso come valore.

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 7 1.1.4 Espressioni condizionali e predicati Usando solo le funzioni viste, la nostra capacità espressiva è assai piccola. Per sempio ci è impossibile definire la funzione my-abs 5 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 più 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 elemento è detto antecedente e il resto conseguenza. L antecedente è un predicato: e cioè un espressione il cui valore può essere vero o falso. In Lisp, falso è 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 è falso, viene valutato il secondo predicato ecc., finché si trova un predicato che è vero, cioè che dà un valore non-nil: in questo caso si valutano le forme che compongono la conseguenza: il valore dell ultima è il valore di tutta l espressione condizionale. Se nessun predicato è vero, l espressione condizionale ha il valore nil. Anche se più predicati fossero veri, solo il primo di essi causa la valutazione della sua conseguenza: l ordine delle clausole è quindi importante! Un altro modo di definire il valore assoluto: (defun my-abs (x) (cond ((< x 0) (- x)) (t x))) Qui è stato usato il simbolo t che, essendo vero, fa scattare l esecuzione della forma corrispondente: è buona abitudine terminare la forma condizionale con una clausola che inizia con t. Ancora un altra possibilità: (defun my-abs (x) (if (< x 0) (- x) x)) 5 Volendo definire funzioni che sono già primitive Lisp, useremo nomi che iniziano con my- o nomi in italiano per evitare confusione. 6 Gli atomi nil e t hanno sé stessi come valore.

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 8 La forma impropria if valuta il primo argomento (il predicato): se è 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 più in dettaglio il meccanismo di valutazione usato normalmente 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 è quindi ricorsiva per natura: essa cioè contiene, come uno dei suoi passi, la necessità 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 argomento. 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))

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 9 poi si sostituisce il parametro formale a con il valore dell argomento (che in questo caso è 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 cioè 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 è 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 è sufficientemente potente per descrivere casi più complessi, in cui si accetti la mutabilità dei dati, come vedremo più avanti. Si parla talvolta di pure Lisp per indicare il sotto-insieme del linguaggio che aderisce a una visione strettamente funzionale. 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)))

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 10 (+ (* (+ 5 1) (+ 5 1)) (* (* 5 2) (* 5 2))) riducendosi poi a (+ (* 6 6) (* 10 10)) (+ 36 100) 136 Questo ordine di valutazione è detto normale (normal-order evaluation), in contrasto con quello visto prima, detto applicativo (applicative-order evaluation). Si può dimostrare che i due ordini di valutazione sono equivalenti, se è 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 può essere programmata in Lisp direttamente: (defun factorial (n) (if (= n 1) 1 (* n (factorial (- n 1))))) D altra parte, usando la prima definizione, si può procedere accumulando i valori delle successive moltiplicazioni e contando il numero di moltiplicazioni: prodotto contatore prodotto contatore contatore + 1

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 11 (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 definite invocando sé 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 quantità 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 è definita dal valore delle tre variabili del programma: un processo di questo tipo è detto linearmente iterativo (si veda la Tabella 1.2). Non si confonda la forma della definizione della funzione, con il tipo di processo 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 memoria inerente a un uso inutile di processi ricorsivi. Un buon Lisp dovrebbe

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 12 (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 strutture sintattiche iterative non è 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 è lineare ma ad albero (tree recursion). Un esempio molto semplice è il calcolo della successione detta di Fibonacci, in cui ogni numero è 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 può 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 seguito, con un processo che si biforca ad ogni passo. È un esempio interessante, ma naturalmente esistono metodi più efficienti per calcolare i numeri di Fibonacci: qui si ripetono continuamente calcoli

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 13 già fatti, per cui il processo impiega un tempo che cresce esponenzialmente con n; lo spazio richiesto invece cresce linearmente. Questo comportamento è 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 trasformazione simultanea a a + b b a dopo n trasformazioni b sará 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 è una iterazione lineare. Benché la differenza del tempo impiegato dai due metodi sia notevolissima, non si deve concludere che le ricorsioni ad albero siano inutili. In altri campi l approccio ricorsivo rappresenta un mezzo naturale e potente (Si ricordi che il funzionamento dell interprete è 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)

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 14 ma naturalmente questo sarebbe assai scomodo, essendo obbligati a lavorare al livello delle funzioni predefinite e senza la possiblità di esprimere il concetto dell elevazione alla terza potenza. Per questo i linguaggi, tranne i più primitivi, offrono la possibiltà di definire nuove funzioni. Un passo in avanti nel livello di astrazione è 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 f(n) = f(a) + + f(b) n=a Vorremmo definire anche in Lisp una funzione del tipo: (defun sum (f a step b)...

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 15 dove f è la funzione da applicare a ogni termine e step è il passo per calcolare il prossimo termine. Questo è possibile in Common Lisp ma è 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 è necessario avvertire l interprete che alcuni parametri sono da usare come funzioni; in Common Lisp questo avviene ponendo # prima del nome della funzione 7. Così, utilizzando la funzione Common Lisp + (che, usata con un solo argomento, restituisce l argomento stesso) si può ottenere l effetto di sum-int: Lisp> (sum # + 1 1 10) 55 È 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 già 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 è però scomodo dover definire col proprio nome funzioni che non hanno un utilità generale. Per definire pi-sum tramite sum sarebbe 7 In realtà si dovrebe usare la forma impropria function, ma per comodità di scrittura i caratteri # hanno un effetto equivalente: (function sin) e # sin sono la stessa cosa.

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 16 opportuno poter esprimere direttamente la funzione pi-f all interno di sum. Questo è possibile tramite la forma impropria lambda 8, 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 è una funzione come le altre (ma non ha un nome), e può essere usato negli stessi contesti: Lisp> ((lambda (x) (* x x)) 5) 25 1.3.2 Funzioni come valori In Lisp è possibile ottenere funzioni come valori di altre funzioni. Illustriamo questa possibilità con un esempio tratto dal calcolo infinitesimale: la derivata di x 3 è 3x 2. Questo può essere interpretato dicendo che derivata è un operatore che, applicato alla funzione x 3 dà come valore la funzione 3x 2. Definiamo la derivata tramite la formula (per il limite dx 0): f (x) = f(x + dx) f(x). dx Usando lambda possiamo esprimere questa formula con la funzione 9 : (lambda (x) (/ (- (funcall f (+ x dx)) (funcall f x)) dx)) Si può 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 computabilità delle funzioni. Non bisogna però 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 è possibile anche darne una definizione simbolica.

CHAPTER 1. LA FUNZIONE COME ASTRAZIONE 17 (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 è naturalmente 75): Lisp> (funcall (deriv # cube 0.0001) 5) 75.015 Anche in questo caso, in Common Lisp è 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 possibilità offerte dal calcolo della funzione derivata, vogliamo implementare l algoritmo di Newton per gli zeri di una funzione differenziabile. Se x 0 è una approssimazione dello zero, è una approssimazione migliore. x 1 = x 0 f(x 0) f (x 0 ) 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 eventualmente altre funzioni), ma un linguaggio evoluto deve dare la possibilità di usare forme più complesse di valori, i cosiddetti dati strutturati. La definizione di questo tipo di dati può essere difficoltosa: ripieghiamo sull approccio seguente: Devono esistere funzioni dette costruttori (constructors) che permettono di costruire il dato strutturato a partire da dati più semplici. Devono esistere funzioni dette selettori (selectors) che, a partire dal dato strutturato, permettono di estrarre i dati più semplici che li compongono. 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 è la lista 1 : essa è pure la forma sintattica fondamentale, realizzando la completa identità tra dati e programmi, tipica del Lisp. Abbiamo già definito la lista a pag. 3, dicendo che è un elenco di espressioni (simboliche) racchiuso da parentesi rotonde; un espressione a sua volta può 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 avrà un approccio ricorsivo 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 è una nuova lista. Per poter porre il primo elemento, bisogna aggiungerlo alla lista vuota; questa può essere rappresentata come () oppure come nil. nil è contemporaneamente un atomo (il simbolo il cui valore è 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 è primo; per costruire 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 può esser usato solo se il secondo argomento è 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 più diffusi per queste primitive sono car e cdr; in altri contesti si usano anche i nomi testa (head) e coda (tail), che non sono però predefiniti in Common Lisp.

CHAPTER 2. I DATI COME ASTRAZIONE 20 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! evidente che, per una lista qualsiasi, vale: Data la loro definizione è 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 è la possibilità di lavorare a livello simbolico: finora gli atomi visti erano numeri e i simboli avevano come valore un numero. Questa restrizione non è necessaria! Per poter operare con i simboli, dobbiamo superare una difficoltà: 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 è invece possibile costruire in questo modo la lista (a):

CHAPTER 2. I DATI COME ASTRAZIONE 21 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 problema 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 apice 3 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 è vero (t) se il suo unico argomento è un atomo (cioè non è una lista) 4 ; eq ha due argomenti (che dovrebbero essere atomi): esso è vero (t) se i due atomi sono identici 5. 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 è uno dei pochi predicati che non terminano con la lettera p. È anche disponibile il predicato listp che dà 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 è nil o la lista vuota, zerop controlla se un numero è zero, ecc.

CHAPTER 2. I DATI COME ASTRAZIONE 22 (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 è 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 è evidente. Che cos è una lista? In realtà il costruttore cons accetta come argomenti due espressioni qualsiasi e dà come valore una coppia detta puntata (dotted pair), i cui elementi possono essere selezionati con car e cdr 6 : 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 più adatto.

CHAPTER 2. I DATI COME ASTRAZIONE 23 Lisp> (cdr pair) b Un metodo di visualizzare questo fatto è 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 più atomi, a b (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 è in a nil a b c nil (a. nil) (a) (a. (b. (c. nil))) (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) può far parte di differenti strutture. La Fig. 2.3 mostra una lista nella quale la prima espressione è 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:

CHAPTER 2. I DATI COME ASTRAZIONE 24 a b nil 3 c nil ((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 libertà 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 implementazione (Si dovrà 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: benché siano talvolta più efficienti, il loro uso non è compatibile con un approccio puramente funzionale.

CHAPTER 2. I DATI COME ASTRAZIONE 25 lista1 nil (a b) a b (append lista1 lista2) lista2 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