Linguaggi di Programmazione avanzati Linguaggi funzionali

Transcript

1 Linguaggi di Programmazione avanzati Linguaggi funzionali Simone Martini Dipartimento di Scienze dell Informazione Università di Bologna Italy A.a / 95

2 Il paradigma funzionale puro Un lambda-calcolo esteso Strategie di riduzione Programmare in un linguaggio funzionale Zucchero sintattico Tipi e polimorfismo Aspetti imperativi La macchina SECD Monadi Outline Le continuazioni e la continuation passing transformation Continuazioni La CPS Le continuazioni come oggetti manipolabili: call/cc 2 / 95

3 Monadi: effetti collaterali in ambiente puro I In linguaggi call-by-value gli effetti collaterali sono aggiunti, ottenendo linguaggi impuri I Nei linguaggi puri, il flusso dei dati è totalmente esplicito I Talvolta questo è molto pesante, quando non impossibile I Discuteremo un esempio (P. Wadler, 1995) 46 / 95

4 Valutatore di espressioni I Sintassi Haskell-like I Il tipo dei termini data Term = Con Int Div Term Term ; I La funzione di valutazione eval :: Term -> Int eval ( Con n) = n eval ( Div t u) = ( eval t) / ( eval u) I Due termini ok = Div ( Div ( Con 2000) ( Con 2)) ( Con 5) ko = Div ( Con 2000) ( Con 0) I eval ok = 200 eval ko indefinito 47 / 95

5 Eccezioni I Per sollevare eccezioni dobbiamo estendere il tipo dei valori: eval può restituire un Int oppure un eccezione I type M a = Excp Value a I Excp e Value sono costruttori I M a è un tipo polimorfo. Per ogni tipo T abbiamo il tipo M T I A noi interessa M Int, i cui valori sono: I Excp I Value n I Il nuovo tipo di eval eval :: Term -> M Int 48 / 95

6 Valutatore con eccezioni I eval :: Term -> M Int eval ( Con a) = Value a eval ( Div t u) = case eval t of Excp -> Excp Value a -> case eval u of Excp -> Excp Value b -> if b = 0 then Excp else Value ( a/ b) I eval ok = Value 200 eval ko = Excp I Il risultato deve essere controllato ad ogni chiamata 49 / 95

7 Valutatore con I/O I Si vogliono stampare tutti i valori intermedi calcolati dal valutatore I Occorre estendere il tipo dei valori: eval restituisce sia un Int, sia l output (una stringa, per esempio) I data M a = ( Output, a) type Output = String I eval :: Term -> M Int eval ( Con a) = ( Con ++ ( showint a), a) eval ( Div t u ) = let (x, a) = eval t in let (y, b) = eval u in (x ++ y ++ Div ++ ( showint a/b), a/b) I showint :: Int -> String converte un intero in stringa 50 / 95

8 Valutatore con I/O, 2 I eval :: Term -> M Int eval ( Con a) = ( Con ++ ( showint a), a ) eval ( Div t u ) = let (x, a) = eval t in let (y, b) = eval u in (x ++ y ++ Div ++ ( showint a/b), a/b) I ok = Div (Div (Con 2000) (Con 2)) (Con 5) I eval ok = (x, 100) dove x è la stringa: Con 2000 Con 2 Div 1000 Con 5 Div 200 I Se volessimo ottenere la stampa a rovescio Div 200 Con 5 Div 1000 Con 2 Con 2000 basterebbe usare il termine Div ++ (showint a/b) ++ y ++ x 51 / 95

9 Valutatore con stato I Si vuole contare il numero di moltiplicazioni I Il tipo dei valori: data M a = State -> (a, State ) type State = Int Un valore è una funzione che prende lo stato iniziale e restituisce il valore calcolato e accoppiato allo stato finale. I eval :: Term -> M Int eval ( Con a) x = ( a, x) eval ( Div t u) x = let ( a, y) = eval t x in let ( b, z) = eval u y in (a/b, z + 1) 52 / 95

10 Impariamo dagli esempi I Un tratto comune degli esempi Invece di: eval :: Term -> Int Abbiamo: eval :: Term -> M Int I Intuitivamente: eval restituisce un Int, più gli effetti aggiuntivi descritti dall opportuno M. I Quali sono le operazioni che sono possibili sui valori di tipo M a? I Cerchiamo di capirlo guardando i nostri valutatori / 95

11 I Il valutatore con eccezioni: Operazioni sui tipi monadici, 1 eval :: Term -> M Int eval (Con a) = Value a eval ( Div t u) = case eval t of Excp -> Excp Value a -> case eval u of Excp -> Excp Value b -> if b == 0 then Excp else Value ( a/ b) I Usiamo un modo canonico per trasformare un valore di tipo Int nel corrispondente valore di tipo M Int. I Chiamiamo return :: a -> M a questa immersione return n = Value n 54 / 95

12 Operazioni sui tipi monadici, 2 I eval :: Term -> M Int eval ( Con a) = Value a eval ( Div t u) = case eval t of Excp -> Excp Value a ->... Value (a/ b) I eval t dà il risultato Value a dal quale estraiamo il valore a per usarlo successivamente (nella divisione a/b) I Una funzione g :: Int -> Int g = λ a.... Value (a/b) I eval t :: M Int I Dobbiamo applicare g al risultato di eval t (ma i tipi non tornano esattamente) 55 / 95

13 Operazioni sui tipi monadici, 3 I Ricapitolando: g :: Int -> Int, eval t :: M Int I In generale: applicare una funzione di tipo a -> M b ad una computazione di tipo M a I Abbiamo bisogno dunque di un operazione >>= :: M a -> (a -> M b) -> M b che scriviamo infissa t >>= g Osserva che t :: M a mentre g :: a -> M b I Nel caso delle eccezioni: t >>= g = case t of Excp -> Excp Value a -> g a 56 / 95

14 Monadi I Una monade è una tripla (M, return, >>=) dove: I M è un costruttore di tipo I return :: a -> M a I >>= :: M a -> (a -> M b) -> M b I Le due operazioni devono soddisfare tre leggi che vedremo tra poco 57 / 95

15 Valutatore monadico I Data una monade M, possiamo scrivere il generico valutatore su di essa I eval :: Term -> M Int eval ( Con a) = return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. return (a/b)) 58 / 95

16 Valutatore monadico per le eccezioni I Monade I type M a = Excp Value a I return :: a -> M a return a = Value a I >>= :: M a -> (a -> M b) -> M b I Valutatore t >>= g = case t of Excp -> Excp Value a -> g a eval :: Term -> M Int eval ( Con a) = return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. if b=0 then Excp else return ( a/ b)) 59 / 95

17 Monade dello I/O I Monade I type M a = (Output, a) I type Output = String I return :: a -> M a return a = (,a) I >>= :: M a -> (a -> M b) -> M b t >>= g = let (x, a) = t in let (y, b) = g a in (x ++ y, b) I out :: Output -> M () out e = (x, ()) 60 / 95

18 Valutatore monadico con I/O I Ricorda: t >>= g = let (x, a) = t in let (y, b) = g a in (x ++ y, b) out :: Output -> M () out e = (x, ()) I Valutatore eval :: Term -> M Int eval ( Con a) = out ( Con ++ ( showint a)) >>= λ(). return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. out ( Div ++( showint a/b)) >>= λ(). return (a/b) 61 / 95

19 Monade dello stato I Monade I type M a = State -> (a, State) I type State = Int I return :: a -> M a return a = λx.(a,x) I >>= :: M a -> (a -> M b) -> M b t >>= g = λx. let (a, y) = t x in let (b,z) = g a y in (b,z) I tick :: M () tick = λx.((), x +1) 62 / 95

20 Valutatore monadico con stato I Ricorda: t >>= g = λx. let (a, y) = t x in let (b,z) = g a y in (b,z) tick :: M () tick = λx.((), x +1) I Valutatore eval :: Term -> M Int eval ( Con a) = return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. tick >>= λ(). return ( a/ b) 63 / 95

21 Leggi I Neutro a sinistra return a >>= λb. n = n[ a/ b] I Neutro a destra m >>= λ a. return a = m I Associatività m >>= λ a. ( n >>= λ b. o) = ( m >>= λ a. n) >>= λ b. o Osserva che deve essere a 62 FV (o) I Esercizio: Verifica le leggi per le monadi introdotte I Le leggi servono per dimostrare proprietà dei programmi 64 / 95

22 Monadi: una variante I Una monade può essere definita anche come (M, return, join, map) con map :: (a -> b) -> (M a -> M b) join :: M (M a) -> M a e le leggi I map id = id map ( f g) = map f map g map f return = return f map f join = join map ( map f ) join return = id join map return = id join map join = join join 65 / 95

23 Le due definizioni sono equivalenti I Definiamo map e join in termini di >>= map f m = m >>= λa. return ( f a) join z = z >>= λm. m I Definiamo >>= in termini di map e join m >>= k = join ( map k m) I Esercizio: verificare le leggi in entrambi i casi. 66 / 95

24 La monade più semplice: Identità I Monade I type M a = a I return :: a -> M a return a = a I >>= :: M a -> (a -> M b) -> M b t >>= g = g t I Il generico valutatore monadico su questa monade concide col valutatore puro 67 / 95

25 Liste come monadi I Vedere le liste come monadi può essere utile I Monade I type L a = [a] Notazione Haskell: [Int] liste di interi I return :: a -> L a return a = [a] I >>= :: L a -> (a -> L b) -> L b I Esempio: l >>= g = concat (map g l) ha come risultato [10,20,30] >>= λx.[x, x +1] [10,11,20,21,30,31] 68 / 95

26 I Riprendiamo il valutatore con I/O Notazioni Haskell eval :: Term -> M Int eval ( Con a) = out ( Con ++ ( showint a)) >>= λ(). return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. out ( Div ++( showint a/b)) >>= λ(). return (a/b) I Alcune volte in m >>= g il valore di m non è usato I Notazione apposita: >> :: M a -> M b -> M b, definito come m >> n = m >>= λ().n I Così risparmiamo qualche λ / 95

27 I Il valutatore con I/O, ottimizzando i λ Notazione do eval ( Con a) = out ( Con ++ ( showint a)) >> return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. out ( Div ++( showint a/b)) >> return ( a/ b) I Osserva: >> è come ; in C >>= è simile ad un assegnamento. I La notazione do: eval ( Con a) = do out ( Con ++ ( showint a)) return a eval ( Div t u) = do a <- eval t b <- eval u out ( Div ++( showint a/b)) return ( a/ b) 70 / 95

28 Notazione do, 2 I Il valutatore con stato eval ( Con a) = return a eval ( Div t u) = eval t >>= (λ a. eval u >>= λ b. tick >> return (a/b) I Diviene: eval ( Con a) = do return a eval ( Div t u) = do a <- eval t b <- eval u tick return ( a/ b) 71 / 95