Progetto per il corso di Linguaggi di Programmazione e Compilatori A.A ML--

Transcript

1 Progetto per il corso di Linguaggi di Programmazione e Compilatori A.A ML-- Luca Padovani lpadovan@cs.unibo.it 1 Introduzione Scopo del progetto è scrivere un compilatore per un linguaggio funzionale (in pratica un sottoinsieme di OCaml con pochissime differenze sintattiche). La semantica del linguaggio è sostanzialmente la stessa degli analoghi costrutti presenti in OCaml, in particolare la strategia di valutazione è la call-by-value. Il compilatore deve generare un codice oggetto per la macchina astratta SECD descritta nella sezione 4. Si deve quindi scrivere un interprete per la macchina astratta e verificare la corretta esecuzione dei programmi compilati. In alcuni punti della specifica compaiono dei paragrafi che suggeriscono possibili estensioni al linguaggio e/o alla macchina astratta. Le estensioni sono marcate da uno o più asterischi che ne indicano la difficoltà. Pur non essendo obbligatorio implementarle (è possibile ottenere il massimo del punteggio anche senza implementarne alcuna) i gruppi sono invitati a studiarne le problematiche relative, ed è possibile che in fase di discussione del progetto venga richiesto di ragionare su alcune di esse. La tabella 1 mostra la grammatica del linguaggio completo che il compilatore deve essere in grado di accettare. I token per le costanti (numeri interi, valori booleani, stringhe) e gli identificatori sono definiti esattamente come in OCaml. Il linguaggio ammette commenti che, come in OCaml, sono racchiusi dalle sequenze (* e *). La precedenza e l associatività degli operatori deve essere quella degli operatori analoghi (con lo stesso nome) del linguaggio OCaml. I costrutti presenti al livello del linguaggio completo essere implementati usando un insieme di costrutti più semplici che definiamo linguaggio minimale (tabella 2). È dunque conveniente espandere i costrutti del linguaggio completo in costrutti equivalenti (generalmente più voluminosi ) del linguaggio minimale e definire le regole di tipaggio e di compilazione sul linguaggio minimale in modo da semplificare la struttura del compilatore (e di questa specifica). Alcune delle espansioni non sono ottimali dal punto di vista dell efficienza, ma questi aspetti non sono rilevanti ai fini del progetto e quindi verranno quasi sempre ignorati. Estensione 1 (*) Arrichire la sintassi del linguaggio completo con un costrutto iterativo del tipo: expr ::= for var = expr to expr do expr done Codificare il costrutto senza arricchire il livello del linguaggio minimale e senza modificare la macchina astratta. 2 Dal linguaggio completo al linguaggio minimale Nelle sezioni seguenti descriveremo il processo di espansione (o codifica) dal linguaggio completo al linguaggio minmale. Indicheremo la codifica con il simbolo. Si intende che i passi di codifica debbano essere iterati fin quando possibile. 2.1 Codifica di coppie e liste Nel linguaggio completo una coppia ordinata si costruisce con l operatore virgola: E 1, E 2 (pair E 1 E 2 ) 1

2 Tabella 1: Grammatica del linguaggio completo global ::= #use "string" ;; let [rec] var 0 var 1 var n = expr ;; n 0 expr ;; const ::= int bool string expr ::= const var unop expr expr 1 binop expr 2 expr 1 ; expr 2 fun var 1 var n -> expr n 1 function rule 1 rule n n 1 begin expr end ( expr 1 expr n ) n 0 ( binop ) ( unop ) [ expr 1 expr n ] n 0 let [rec] var 0 var 1 var n = expr 1 in expr 2 n 0 if expr 1 then expr 2 [else expr 3 ] match expr with rule 1 rule n n 1 rule ::= pattern -> expr pattern ::= const () _ var ( pattern ) pattern 1, pattern 2 pattern 1 :: pattern 2 [ pattern 1 pattern n ] n 0 unop ::= not ~- $ write binop ::=, :: ^ + - * / & or && = <> <= < > >= 2

3 Tabella 2: Il linguaggio minimale. const ::= nil unit int bool string expr ::= const var ( unop expr ) ( binop expr 1 expr 2 ) fun var -> expr ( expr 1 expr 2 ) let [rec] var = expr 1 in expr 2 if expr 1 then expr 2 else expr 3 unop ::= first second head tail not to_string write fail binop ::= pair cons concat add sub mul div and or eq ne lt le A differenza di quanto avviene in OCaml, assumeremo che l operatore virgola abbia associatività a destra, cosicché un espressione del tipo E 1,E 2,E 3 stia ad indicare (E 1,(E 2,E 3 )). Una lista ha due possibili costruttori: [] rappresenta la lista vuota, mentre :: è il costruttore che dato un valore v ed una lista l rappresenta la lista v::l. Le espressioni di tipo lista vengono codificate come segue: [] nil E 1 ::E 2 (cons E 1 E 2 ) [E 1 E n ] E 1 :: ::E n ::[] In modo analogo i pattern sulle liste vengono codificati come segue: [] nil [P 1 P n ] P 1 :: ::P n ::[] La codifica dei pattern nel linguaggio minimale è discussa nella sezione 2.7. Estensione 2 (*) Estendere la sintassi delle espressioni e dei pattern in modo che sia possibile usare liste della forma [E 1 E n E n+1 ] che ha il significato di E 1 :: ::E n ::E n Funzioni ed applicazioni generalizzate Le funzioni del linguaggio completo ammettono un numero arbitrario di argomenti. Analogamente, le applicazioni ammettono un numero arbitrario di argomenti. Ecco come funzioni ed applicazioni del linguaggio completo vengono codificate nel linguaggio minimale, dove sia le funzioni che le applicazioni lavorano con un solo argomento: fun V 1 V n -> E fun V 1 -> -> fun V n -> E (E 1 E n ) ( (E 1 E 2 ) E n ) Il costrutto function permette di definire una funzione ad un argomento direttamente per pattern matching. Il costrutto viene codificato come segue: function M 1 M n fun V -> match V with M 1 M n dove V è una variabile fresh, cioè una variabile che non occorre libera in nessun M i. Inoltre, il costrutto di binding let ammette la definizione diretta di funzioni: let [rec] V 0 V 1 V n = E 1 in E 2 let [rec] V 0 = fun V 1 V n -> E 1 in E 2 Estensione 3 (**) Estendere il linguaggio completo in modo da ammettere la definizione simultanea di più valori (non ricorsivi), rimpiazzando la produzione per il costrutto let con: expr ::= let bind 1 and bind n in expr (n 1) bind ::= var 0 var 1 var n = expr (n 0) Assicurarsi che le regole di scoping degli identificatori definiti siano quelle desiderate. 2.3 Il valore unit L espressione E 1 ; E 2 valuta E 1 per prima, scarta il risultato (che per le regole di tipaggio deve essere ()) e poi valuta E 2. Il valore dell intera espressione è il valore di E 2. Nel linguaggio l unico operatore che produce un sideeffect è write, per cui la valutazione sequenziale 3

4 verrà in genere usata in congiunzione con questo operatore che ritorna come valore (): () unit E 1 ; E 2 let V = E 1 in E 2 if E 1 then E 2 if E 1 then E 2 else () dove V è una variabile fresh. 2.4 Operatori currificati Un espressione della forma ( unop ) indica una funzione ad un argomento che applica l operatore unario specificato. Analogamente un espressione della forma ( binop ) indica una funzione a due argomenti. La differenza fondamentale tra un operatore e la sua versione currificata è che quest ultima rappresenta un valore di prima classe che può essere passato come argomento, restituito come risultato, applicato parzialmente. Ad esempio, non è possibile applicare parzialmente l operatore di somma +, come in (+ 1), per indicare la funzione successore. È però possibile farlo con la versione currificata dell operatore (+). In particolare è possibile definire: let succ = ((+) 1) ;; Gli operatori currificati si codificano come segue: ( unop ) fun V -> unop V ( binop ) fun V 1 V 2 -> V 1 binop V Operatori booleani non stretti Gli operatori && e rappresentano le versioni non strette (o lazy) degli operatori & e or rispettivamente, in cui cioè il secondo operando viene valutato solo se necessario. Essi possono essere codificati come segue: E 1 && E 2 if E 1 then E 2 else false E 1 E 2 if E 1 then true else E Altri operatori La macchina astratta non ha istruzioni per eseguire confronti di tipo maggiore-di o maggiore-o-uguale-a, ma queste operazioni si codificano banalmente invertendo l ordine delle espressioni confrontate: E 1 > E 2 E 2 < E 1 E 1 >= E 2 E 2 <= E 1 Analogamente, la macchina astratta non ha un operazione per negare un numero intero: ~- E 0 - E L operatore prefisso $ del linguaggio completo corrisponde a to_string nel linguaggio minimale. 2.7 Codifica del costrutto di pattern match Il costrutto di pattern match lo si codifica come una catena di test della forma M(P, E 1, E 2, E 3 ) il cui significato intuitivo è: valuta l espressione E 1 e confronta il risultato con il pattern P. Se c è corrispondenza tra il valore dell espressione ed il pattern allora valuta E 2, altrimenti valuta E 3 : match E with P 1 -> E 1 P n -> E n M(P 1, E, E 1, ( (M(P n, E, E n, F)) )) Notare che l ultimo test ha in corrispondenza di E 3 un espressione F (fail "No match") mentre M(P, E 1, E 2, E 3 ) è definito per induzione sulla struttura del pattern P come mostrato in tabella 3. Estensione 4 (*) Nella codifica del costrutto di pattern match l espressione da esaminare (indicata con E 1 in tabella 3) viene valutata una volta per ogni pattern di tipo V o k o [], una o tre volte per ogni pattern di tipo P 1 ::P 2, e due volte per ogni pattern di tipo P 1,P 2. Migliorare la codifica in modo che E venga sempre valutata una volta sola per l intero costrutto. Estensione 5 (***) Arricchire la fase di analisi statica del compilatore in modo da determinare se un costrutto di pattern match non è esaustivo (cioè se non copre tutte le possibilità) e se vi sono dei pattern ridondanti (cioè se compaiono dei pattern già coperti da pattern che compaiono prima). In questi casi il compilatore deve emettere un messaggio di avvertimento. Estensione 6 (**) In alcuni casi l espansione del match genera molte copie dell espressione di fallimento E 3. Pensare ad una codifica alternativa che permette di evitare tale ridondanza. Suggerimento: l idea è di usare il costrutto let per definire la continuazione E 3 e al posto 4

5 Tabella 3: Espansione delle regole di pattern-matching. M(V, E 1, E 2, E 3 ) ((fun V -> E 2 ) E 1 ) M(, E 1, E 2, E 3 ) E 2 M(k, E 1, E 2, E 3 ) if (eq k E 1 ) then E 2 else E 3 M((), E 1, E 2, E 3 ) if (eq unit E 1 ) then E 2 else E 3 M([], E 1, E 2, E 3 ) if (eq nil E 1 ) then E 2 else E 3 M(P 1 ::P 2, E 1, E 2, E 3 ) if (eq nil E 1 ) then E 3 else M(P 1, (head E 1 ), M(P 2, (tail E 1 ), E 2, E 3 ), E 3 ) M(P 1,P 2, E 1, E 2, E 3 ) M(P 1, (first E 1 ), M(P 2, (second E 1 ), E 2, E 3 ), E 3 ) delle occorrenze di E 3 si sostituisce la chiamata alla continuazione. Per esempio, l espansione del pattern nel caso di una coppia diventerebbe M (P 1,P 2, E 1, E 2, E 3 ) let C = fun V -> E 3 in M(P 1,P 2, E 1, E 2, (C ())) in cui sia C che V sono identificatori fresh. In questo modo si duplica solo l invocazione della continuazione anziché l intera E 3 che, in generale, può essere molto grande. Un compilatore ottimizzante sarebbe poi in grado di semplificare ulterioremente le applicazioni (C ()), dal momento che il valore passato è () e che la variabile V non compare libera in E Esempio In questa sezione mostriamo un esempio di programma scritto nel linguaggio completo. Il programma definisce l algoritmo quicksort. let rec append l1 l2 = match l1 with [] -> l2 hd::tl -> hd::(append tl l2) ;; let filter f = let rec aux = function [] -> [] hd::tl -> if (f hd) then hd::(aux tl) else (aux tl) in aux ;; let rec quicksort = function [] -> [] hd::tl -> let l1 = (quicksort (filter ((>) hd) tl)) in let l2 = (quicksort (filter ((<=) hd) tl)) in (append l1 (append [hd] l2)) ;; 3 Tipi Presentiamo in questa sezione le regole di tipo dei costrutti del linguaggio minimale. Tali regole verranno usate per implementare l algoritmo di type-checking nella fase di analisi statica del compilatore. I tipi del linguaggio si distinguono in tipi semplici (unit, bool, int, string) e composti (list(t ), T 1 T 2, T 1 T 2 ). In quest ultimo caso list, e si dicono costruttori di tipo in quanto creano un tipo a partire da altri tipi. Possiamo pensare ai tipi semplici come a costruttori di tipo che non dipendono da altri tipi. Useremo lettere maiuscole per denotare tipi, e lettere greche minuscole per denotare variabili di tipo. Useremo la lettera per indicare un contesto, cioè un insieme di associazioni V : T dove V è il nome di una variabile e T è il tipo ad essa associata ed indicheremo con (V ) il tipo associato al simbolo V nel contesto. Il contesto iniziale 0 (tabella 4) contiene le dichiarazioni di tipo degli operatori predefiniti del linguaggio minimale nonché i tipi delle costanti. Si noti come molti operatori siano polimorfi, cioè in grado di operare su valori di qualsiasi tipo. Per esempio abbiamo che 0 (head) = α.list(α) α, ovvero head accetta come argomento una lista di valori di qualsiasi 5

6 Tabella 4: Costanti e operatori definiti nel contesto iniziale 0 del linguaggio minimale. S nil unit false, true n s first second head tail not to_string write fail fix pair cons concat add, sub, mul, div and, or eq, ne, lt, le 0 (S) α.list(α) unit bool int string α. β.α β α α. β.α β β α.list(α) α α.list(α) list(α) bool bool α.α string string unit α. β.α β α.(α α) α α. β.(α, β) α β α.(α, list(α)) list(α) (string, string) string (int, int) int (bool, bool) bool α.(α, α) bool tipo (α) e ritorna un valore di tipo α. Il quantificatore universale all inizio di ogni tipo polimorfo indica che per ogni occorrenza dell operatore si considera una nuova istanza del suo tipo, ovvero le variabili di tipo quantificate universalmente vengono sostituite da variabili fresh, che non compaiono altrove. Il tipo degli operatori binari è indicato come (T 1, T 3 ) T 3 in cui (T 1, T 3 ) sta a significare che l operatore accetta esattamente due argomenti. In particolare (T 1, T 3 ) e T 1 T 2 non sono lo stesso tipo. Il motivo di questa notazione per gli operatori binari diventerà chiaro nella sezione 4 in cui viene presentata la semantica operazionale degli operatori stessi. La tabella 5 mostra le regole di inferenza del linguaggio minimale. In questo senso ogni regola è da leggersi dall alto verso il basso: sopra la riga compaiono le premesse, sotto la riga la conclusione. Per esempio la regola [APP] E 1 : T 1 T 2 E 2 : T 1 (E 1 E 2 ) : T 2 stabilisce che se nel contesto l espressione E 1 ha tipo T 1 T 2 e, nello stesso contesto, l espressione E 2 ha tipo T 1, allora l espressione (E 1 E 2 ) ha tipo T 2. È chiaro che in molti casi il tipo della sorgente di E 1 ed il tipo di E 2 non coincideranno. Imporremo la loro uguaglianza unificandoli, con l algoritmo visto a lezione, e determinando quindi dei vincoli sulle variabili di tipo che compaiono in essi. Ad esempio, se sappiamo che il tipo di E 1 è α list(α) ed il tipo di E 2 è int unificheremo α con int ed il risultato sarà di tipo list(int). L unificazione fallisce in due casi: quando si tentano di unificare tipi incompatibili (es. int con bool oppure list(α) con α β); quando si tenta di unificare una variabile di tipo con un tipo che contiene quella variabile (es. α con α α). Le regole [CONST] e [VAR], che non hanno premesse, costituiscono gli assiomi del sistema di inferenza. Le regole [GEN] e [SPEC], che servono rispettivamente per quantificare le variabili generiche di un tipo e per istanziare un tipo, sono le uniche regole che possono essere applicate in posizioni arbitrarie di una derivazione, indipendentemente dalla forma dell espressione E considerata. Nell algoritmo di type-checking che presentiamo di seguito ammetteremo l impiego di queste due regole in posizioni ben precise. 3.1 Type checking In questa sezione presentiamo in modo informale l algoritmo di type-checking derivato dalle regole della tabella 5. L algoritmo deve calcolare il tipo di un espressione E in base alla struttura dell espressione stessa ed al contesto in cui E si trova. Il contesto determina il tipo di tutte le variabili libere che compaiono in E. Rispetto alla tabella 5 renderemo però espliciti i punti in cui intervengono le operazioni di generalizzazione [GEN] ed istanziazione [SPEC] dei tipi. Ad ogni passo dell algoritmo le informazioni da considerare sono: 1. l espressione di cui vogliamo calcolare il tipo; 2. il contesto che possiamo rappresentare con una lista di coppie nome, tipo in cui la prima occorrenza di una variabile V è l occorrenza visibile nello scope dell espressione considerata; 3. un contesto Γ analogo a ma che contiene solo la lista delle variabili legate da fun e 6

7 Tabella 5: Regole di type-checking per il linguaggio minimale. [CONST] k : (k) [VAR] V : (V ) [UNOP] unop : T 1 T 2 E : T 1 ( unop E) : T 2 [BINOP] binop : (T 1, T 2 ) T 3 E 1 : T 1 E 2 : T 2 ( binop E 1 E 2 ) : T 3 [FUN] + [V : T 1 ] E : T 2 fun V -> E : T 1 T 2 [IF] [APP] E 1 : bool E 2 : T E 3 : T if E 1 then E 2 else E 3 : T E 1 : T 1 T 2 E 2 : T 1 (E 1 E 2 ) : T 2 [GEN] [LET] [LETREC] E 1 : T 1 + [V : T 1 ] E 2 : T 2 let V = E 1 in E 2 : T 2 let V = (fix (fun V -> E 1 )) in E 2 : T let rec V = E 1 in E 1 : T E : T E : α.t (α non è libera in ) [SPEC] E : α.t E : T [β/α] che quindi determina l insieme variabili di tipo non generiche. Una variabile di tipo α è generica nel contesto Γ se α non compare in nessun tipo di alcuna variabile in Γ. Useremo le etichette che compaiono a sinistra delle regole nella tabella 5 come riferimento per la discussione dell algoritmo di type-checking. CONST Una costante k ha tipo 0 (k) come indicato in tabella 4. Notare che nel caso della costante nil il tipo sarà una istanza di α.list(α) ovvero sarà un tipo list(β) in cui β è una variabile di tipo fresh. VAR Il tipo di una variabile V deve essere reperito dal contesto ed istanziato. Più precisamente, siano α 1,..., α n le variabili di tipo che compaiono in (V ) e che sono generiche in Γ. Per ciascuna di esse si determina una istanza β 1,..., β n tale che ogni β i è fresh, ed il tipo di V risulta (V )[β 1 /α 1,, β n /α n ]. Le variabili di tipo non generiche che compaiono in (V ) non vengono istanziate. UNOP In un espressione ( unop E) il tipo di E deve essere unificato con il tipo dell argomento dell operatore unario (determinato dalla tabella 4). In caso l operatore sia polimorfo, il suo tipo deve essere istanziato prima dell unificazione. Il tipo dell intera espressione è il tipo del risultato dell operatore. BINOP In un espressione ( binop E 1 E 2 ) i tipi di E 1 ed E 2 devono essere unificati con i tipi dei due argomenti dell operatore binaro (determinati dalla tabella 4). In caso l operatore sia polimorfo, il suo tipo deve essere istanziato prima dell unificazione. Il tipo dell intera espressione è il tipo del risultato dell operatore. FUN Per calcolare il tipo di un espressione fun V -> E si introduce una variabile di tipo fresh, diciamo α, da associare a V. A questo punto si calcola il tipo T di E nei contesti + [V : α] e Γ + [V : α]. Il tipo dell intera espressione è α T. Si noti che nel calcolo del tipo di E la variabile di tipo α può venire unificata con un tipo più specifico. APP In un espressione (E 1 E 2 ) siano T 1 e T 2 i tipi di E 1 ed E 2 rispettivamente, e sia α una variabile di tipo fresh. Si unifica T 1 con il tipo T 2 α. Il tipo dell espressione è α. IF In un espressione if E 1 then E 2 else E 3 siano T 1, T 2 e T 3 i tipi di E 1, E 2 ed E 3 rispettivamente. Si unifica T 1 con bool e si uni- 7

8 fica T 2 con T 3. Il tipo dell espressione è T 2 (o equivalentemente T 3 ). LET In un espressione let V = E 1 in E 2 si determina innanzi tutto il tipo T 1 di E 1. Il tipo dell espressione è il tipo di E 2 nei contesti + [V : T 1 ] e Γ. Si noti che il contesto Γ rimane invariato: ciò significa che le variabili di tipo presenti in T 1 e che non sono presenti in Γ sono generiche in E 2. LETREC Il tipo di un espressione let rec V = fun V -> E 1 in E 2 viene determinato ottenendo il tipo dell espressione let V = (fix (fun V -> E 1 )) in E 2 che ne costituisce l espansione in cui viene utilizzato un ipotetico operatore di punto fisso fix il cui tipo è α.(α α) α. Si noti che questa espansione è valida solo ai fini del type-checking, mentre per la compilazione di una funzione ricorsiva si farà ricorso ad un operazione ad-hoc della macchina astratta (vedi sezione 5). Si noti inoltre che, per come è definita l espansione, il tipo di V non è polimorfo all interno di E 1, essendo V legata da un fun (vedi regola FUN). Esso può però diventare polimorfo (se contiene variabili di tipo non in Γ) in E 2. 4 La macchina SECD La tabella 6 definisce le istruzioni e la semantica della macchina astratta SECD che verrà usata per l esecuzione dei programmi compilati. 4.1 Valori La macchina astratta lavora con valori di cinque tipi: un valore booleano True o False. Il valore False oltre che rappresentare il valore booleano falso viene usato dal compilatore per rappresentare anche unit e nil. Il fatto che questi tre valori di tipo diverso siano indistinguibili per la macchina astratta non costituisce un problema se il programma compilato è ben tipato; un numero intero Int(n); una stringa di caratteri String(s); una coppia di valori (a, b). Le coppie vengono usate per codificare sia le coppie del linguaggio, ma anche le liste: una lista non vuota è composta da una sequenza di coppie in cui l ultima coppia ha come secondo valore False (la lista vuota). Ad esempio la lista [1 2 3] è rappresentata dal valore (Int(1), (Int(2), (Int(3), False))); una chiusura Closure(c, e). La chiusura rappresenta una funzione in attesa di essere valutata. La lista c è il codice della funzione, mentre la lista e è l ambiente che era attivo al momento di creazione della chiusura e che verrà ripristinato, previa aggiunta dell argomento passato alla funzione, al momento dell applicazione (istruzione APP). Estensione 7 (*) Estendere il livello del linguaggio completo, il livello del linguaggio minimale e la macchina SECD in modo da supportare i riferimenti (il tipo ref di OCaml). 4.2 Componenti Le quattro componenti fondamentali della macchina sono: Stack una pila di valori su cui vengono memorizzati i risultati della valutazione delle espressioni; Environment una lista di valori che rappresentano il valore delle variabili legate nello scope dell espressione che è in corso di valutazione. L accesso all ambiente lo si effettua con l istruzione LD(k) in cui k rappresenta l indice della variabile che si vuole accedere (1 rappresenta l indice della prima variabile, 2 l indice della seconda variabile e così via); Control la lista di istruzioni SECD in corso di esecuzione; Dump uno stack per memorizzare lo stato della macchina al momento dell invocazione di una funzione, in modo che l esecuzione possa riprendere dal punto di interruzione quando la funzione termina; Lo stato della macchina in un particolare istante è completamente descritto da una quadrupla (s, e, c, d). 8

9 4.3 Stato iniziale e terminazione Lo stato iniziale della macchina è costituito dalla quadrupla ([], [], c, []) in cui c è la lista di istruzioni da eseguire. La macchina termina in due casi: Fine calcolo: quando sia la lista di istruzioni da eseguire (componente Control) sia la lista nel Dump sono vuote; Eccezione: subito dopo l esecuzione di una istruzione FAIL o a causa di una divisione per zero. In questo caso la macchina termina con un errore e visualizza il valore in cima allo Stack. Il codice risultante da un programma ben tipato è corretto, nel senso che la macchina astratta non si troverà mai ad eseguire del codice in situazioni diverse da quelle presentate nella tabella 6. Ad esempio, non accadrà mai di eseguire l istruzione APP quando il valore in cima allo stack non è una chiusura. È però possibile che la macchina astratta sollevi un eccezione con l istruzione FAIL, ad esempio perché l insieme di pattern in un costrutto pattern match non è esaustivo. 4.4 Chiusure ricorsive Abbiamo visto che nel λ-calcolo il termine Y λf.((λx.(f (x x))) (λx.(f (x x)))) gode della proprietà (Y E) = (E (Y E)). Avendo a disposizione questo termine è possibile codificare una funzione ricorsiva. Per esempio indicando Y con fix potremmo espandere let rec fact = fun x -> if x = 0 then 1 else x * (fact (x - 1)) in let fact = (fix (fun f -> fun x -> if x = 0 then 1 else x * (f (x - 1)))) Tuttavia il termine Y non può essere usato se la strategia di riduzione è la call-by-value (che è proprio il caso del linguaggio che vogliamo compilare), e comunque la codifica risulterebbe particolarmente inefficiente. Per la macchina SECD ogni funzione diventa una chiusura Closure(c, e) ed e è l ambiente in cui compaiono i valori delle variabili libere riferite dal corpo della funzione. In particolare, se consideriamo l espressione (fix (fun f -> fun x -> if x = 0 then 1 else x * (f (x - 1)))) possiamo pensare che l operatore fix abbia l effetto di creare una chiusura circolare, cioè una chiusura per l espressione fun x -> if x = 0 then 1 else x * (f (x - 1)) in cui il primo valore nell ambiente, corrispondente al valore di f, è la chiusura stessa. In un equazione a = Closure(c, a :: e) In termini operazionali l effetto dell istruzione REC è quello di creare una struttura ciclica di questo tipo. 5 Il compilatore Indichiamo la funzione di compilazione con E l in cui E rappresenta l espressione da compilare e l la lista di variabili legate visibili in E. La funzione di compilazione restituisce una lista di istruzioni per la macchina SECD definita nella sezione 4. Useremo l per indicare la concatenazione di liste, l operatore :: per concatenare oggetti (valori o variabili) a liste (di valori o di variabili, rispettivamente) e [] per indicare la lista vuota. La funzione di compilazione è definita per induzione sulla struttura della espressione da compilare (tabella 7). Notare che il costrutto let rec può essere usato solo per definire funzioni ricorsive. Ogni tentativo di usare il costrutto per definire ricorsivamente ogni altro tipo di valore deve essere segnalato dal compilatore con un errore. La funzione fetch(v, l) ritorna la posizione della variabile V nella lista l, con base 1. Esempio. Il codice della funzione fattoriale ricorsiva è mostrato qui sotto. La sintassi usata è 9

10 Tabella 6: La macchina astratta. Stack Environment Control Dump s e LDC(C) :: c d C :: s e c d s a 1 ::... :: a k :: e LD(k) :: c d a k :: s a 1 ::... :: a k :: e c d s e FUN(c ) :: c d Closure(c, e) :: s e c d Closure(c, e ) :: s e REC :: c d (a = Closure(c, a :: e)) :: s e c d Closure(c, e ) :: a :: s e APP :: c d [] a :: e c (s, e, c) :: d a :: s e [] (s, e, c ) :: d a :: s e c d a :: [] e [] [] L esecuzione termina normalmente e viene stampato il valore a a :: s e FAIL :: c d L esecuzione termina con un errore e viene stampato il valore a b :: a :: s e PAIR :: c d (a, b) :: s e c d (a, b) :: s e FST :: c d a :: s e c d (a, b) :: s e SND :: c d b :: s e c d b 2 :: b 1 :: s e AND :: c d (b 1 and b 2 ) :: s e c d b 2 :: b 1 :: s e OR :: c d (b 1 or b 2 ) :: s e c d b :: s e NOT :: c d (not b) :: s e c d True :: s e SEL(c 1, c 2 ) :: c d [] e c 1 (s, e, c) :: d False :: s e SEL(c 1, c 2 ) :: c d [] e c 2 (s, e, c) :: d Int(n 2 ) :: Int(n 1 ) :: s e ADD :: c d Int(n 1 + n 2 ) :: s e c d Int(n 2 ) :: Int(n 1 ) :: s e SUB :: c d Int(n 1 n 2 ) :: s e c d Int(n 2 ) :: Int(n 1 ) :: s e MUL :: c d Int(n 1 n 2 ) :: s e c d Int(n 2 ) :: Int(n 1 ) :: s e DIV :: c d Int(n 1 /n 2 ) :: s e c d b :: a :: s e LE :: c d (a b) :: s e c d b :: a :: s e LT :: c d (a < b) :: s e c d b :: a :: s e EQ :: c d (a = b) :: s e c d b :: a :: s e NE :: c d (a b) :: s e c d String(b) :: String(a) :: s e CAT :: c d String(ab) :: s e c d a :: s e STR :: c d String(a) :: s e c d String(a) :: s e WRT :: c d False :: s e c d 10

11 Tabella 7: Specifica del compilatore. k l = LDC(k) :: [] V l = LD(fetch(V, l)) :: [] ( unop E) l = E unop ] ( binop E 1 E 2 ) l = E 1 E 2 binop ] fun V -> E l = FUN( E V ::l ) :: [] (E 1 E 2 ) l = E 2 E 1 let V = E 1 in E 2 l = ((fun V -> E 2 ) E 1 ) l = E 1 E 2 V ::l )]@[APP] let rec V = fun V -> E 1 in E 2 l = FUN( E 1 V ::V ::l) :: REC :: FUN( E 2 V ::l ) :: APP :: [] if E 1 then E 2 else E 3 l = E 1 E 2 l, E 3 l )] quella del linguaggio minimale per rendere evidente la corrispondenza con il codice prodotto dal compilatore: [6] L. Cardelli, Compiling a Functional Language, in LISP and Functional Programming, pages , 1984 let rec fact = fun x -> if (eq x 0) then 1 else (mul x (fact (sub x 1))) in (fact 3) ;; Questa espressione viene compilata in una lista c di istruzioni SECD come segue: c = FUN(l 1 ) :: REC :: FUN(l 2 ) :: APP :: [] l 1 = LD(1) :: LDC(0) :: EQ :: SEL(l 3, l 4 ) :: [] l 2 = LDC(3) :: LD(1) :: APP :: [] l 3 = LDC(1) :: [] l 4 = LD(1) :: LD(1) :: LDC(1) :: SUB :: LD(2) :: APP :: MUL :: [] Riferimenti bibliografici [1] The Caml language, [2] X. Leroy et. al., The Objective Caml system: Documentation and user s manual, man/index.html [3] A. V. Aho, R. Sethi, J. D. Ullman, Compilers: Principles, Techniques, and Tools, Addison-Wesley, [4] C. Reade, Elements of Functional Programming, Addison-Wesley, [5] L. Cardelli, Basic Polymorphic Typechecking, Science of Computer Programming 8/2, April