Haskell: Higher Order & Combinator Programming Linguaggi Funzionali /aa. 03 - M.Bellia Haskell: Higher Order & Combinator Programming Funzioni come valori Applicazioni parziali Termini chiusi: Combinatori Valori Funzionali Esempi di programmi: rote 90, indicizzazione Verifica: estensionalità, HO, trasformazioni Esercizi 5/10/2019

Funzioni come valori. HO: vantaggi HO: meccanismi lingustici per Riusabilità di codice (tipi polimorfi) Estendibilità della struttura dei: costrutti di controllo e delle strutture di dati Trasformazione di programmi HO: meccanismi lingustici per Parametri funzione Applicazioni parziali Valori funzionali 5/10/2019

Linguaggi Funzionali /aa. 03 - M.Bellia Parametri funzione Astrazioni funzionali: E(F,x) E(Fact,lista)  Ym. if (null lista) then [] else fact(head lista):m(tail lista) astrazione (di valore) E(Fact)  Ym.\x-> if (null x) then [] else fact(head x):m(tail x) astrazione funzionale E()=E  Ym.\x-> \f -> if (null x) then [] else f(head x):m(tail x) Otteniamo la map (quasi, confronta le scritture) map = Ym.\f-> \x -> if (null x) then [] else f(head x):m(tail x) 5/10/2019

Applicazioni parziali Linguaggi Funzionali /aa. 03 - M.Bellia Applicazioni parziali Currying: E lista:: (a->b)->[b] map fact:: [int] -> [int] Riduzione di termine (ottengo nuovi valori -- E [2,3,4]): Ym. \f -> (f 2):(m [3,4])  …  Ym. \f -> (f 2):(f 3):(f 4):m[]   \f -> [(f 2),(f 3), (f 4)]  E[2,3,4] 5/10/2019

Applicazioni parziali: Combinatori Linguaggi Funzionali /aa. 03 - M.Bellia Applicazioni parziali: Combinatori Termini chiusi E[2,3,4] è semanticamente equivalente a \f -> map f [2,3,4] ma: più espressiva Ancora più espressiva di \f -> [(f 2),(f 3),(f 4)] e può essere formalmente introdotta nel calcolo (programma) mediante la definizione seguente: E:: [a] -> (a->b) -> [b] E [] _ = [] E (x:xs) f = (f x):(E xs f) Espressività: ora possiamo usare E_liste e scoprire che si comportano come liste normali rispetto a head e tail ma non rispetto a : e ++ 5/10/2019

Linguaggi Funzionali /aa. 03 - M.Bellia Valori Funzionali Sono espresse in forme diverse con diversa espressività: Definizione (in varie forme e portate: equazioni condizionali, matching..,let, where) f >.> g = g.f -- sequenzializzazione-pipelining Astratto (definizione=naming+astratto) \f -> \g -> g.f Applicazioni parziali :[]:: a -> [a] (:[]).head:: [a] -> [a] Tutte insieme iter1:: Int -> (a -> a) -> a -> a iter1 = \n->\f-> if (n<=0) then (\x->x) else f.iter (n-1) f iter2:: Int -> (Int -> a -> a) -> a -> a iter2 = \n->\f-> if (n<=0) then (\x->x) else (f n).iter (n-1) f iter3:: Int -> b -> (Int -> b -> a -> b) -> a -> b iter3 = \n-> \r -> \f-> \a -> if (n<=0) then r else iter3 (n-1) (f n r a) f a 5/10/2019

Esempi: rote90 z = snd(size p) Utiliziamo: iter3 e sequenzializzazione - pipelining iter3:: Int -> b -> (Int -> b -> a -> b) -> a -> b iter3 = \n-> \r -> \f-> \a -> if (n<=0) then r else iter3 (n-1) (f n r a) f a rote90 p = iter4 z [] p (\n \r -> map (!! n) >.> reverse >.> (: r) ) where z = snd(size p) size = \p -> (length p, length(head p)) iter4 = \x -> \y -> \u -> \v -> iter3 x y v u 5/10/2019

Esempi: Indexing Utiliziamo: sequenzializzazione - pipelining (da Craft/2 pag. 188) Problema: Dato un (file di) testo generare l’indicizzazione che associa ad ogni “parola” occorrente nel testo, la lista dehli indici (di riga) in cui tale parola occorre: Una soluzione: scomponiamo in componenti base del sistema: lines: individuare le linee del testo: doc -> [Line] numLines: linea con posizione nel testo: [Line] -> [(Int,Line)] allWords: parole-posizione di linea in ogni linea: [(Int,Line)] -> [(Int,Word)] sortLs: ordinare lessicograficamente e rimuovere doppioni: [(Int,Word)] -> [(Int,Word)] makeList: rimpiazzare nella lista intero con lista di inter: [(Int,Word)] -> [((Int),Word)] amalgamate: mergere le liste per le diverse linee: [((Int),Word)] -> [((Int),Word)] shorten: rimuovere parole “brevi”: [((Int),Word)] -> [((Int),Word)] Una implementazione: makeIndex = lines >.> numLines >.> allWords >.> sortLs >.> makeList >.> amalgamate >.> shorten 5/10/2019

Verifica: estensionalità riduzione equazionale induzione strutturale assioma di estensionalità ( x::T) (f x)::T’  (g x)::T’  f::T->T’  g::T->T’ 5/10/2019

Proof: A | C --- reverse.reverese = id reverse (x:xs) = reverse xs ++ [x] [] ++ ys = ys (x:xs) ++ ys = x:(xs ++ ys) (1) (2) (3) (4) da A: segue C: (reverse.reverse) = id Proof: (assioma di estensionalità) (1) Dimostriamo: xs  D[a] --- (Dominio dei valori di tipo lista di valori di tipo a) A |- (reverse.reverse) xs = xs *** prova già data *** Abbiamo completato? Abbiamo considerato tutti i termini di tipo lista? f x = 1 + (f x) Che tipo ha [f 0] ? -- Valore poco interessante ma di tipo [int] (2) Dimostriamo:  --- (calcolo divergente di tipo a) A |- (reverse.reverse)  =  A |- (reverse.reverse) :xs = :xs A |- (reverse.reverse) x: = x: Un valore interessante: let f = \x->x:(f (x+1)) in f 0 5/10/2019

Trasformazione di programmi reverse.reverse = id map (f . g) = (map f) . (map g) filter p . map f = map f . filter (p . f) Tutte possono diventare equazioni aggiuntive Sebbene non come parte della definizione 5/10/2019

Briciole: numerali sono funzioni Numerali di Church: [0]C = \f -> \x -> x [n+1]C = \f -> \x -> f…(f x)…) -- n+1 applicazioni di f a x Numerali di Barendregt: [0]B = \x -> x [n+1]B = <false,[n]B> where true = \f -> \g -> f false = \f -> \g -> g <u,v> = \pred -> pred u v Esempi [3]B = <false,<false,<false,\x->x>>> [3]C = \f -> \x -> f (f (f x))) 5/10/2019

Esercizi: makeIndex: scrivere in Haskell le funzioni lines,…, shorten utilizzate nella definizione data per makeIndex, implementare la funzione makeIndex, ed applicarla au un testo a scelta. makePositions: modificare makeIndex in modo tale che per ogni parola fornisca linea e posizione all’interno della linea: chiaramente, ora, multiple occorrenze di una parola in una stessa line devono essere registrate. Verifica:(craft2- 10.33) dimostare che la composizione di funzione è associativa. Verifica: si commenti la proprietà nel linguaggio Java. Numerals di Church: si implementino in Haskell i numerali di Church e si scrivano le operazioni sommaC e prodottoC Numerals di Barendregt: si implementino in Haskell i numerali di Barendregt e si scrivano le operazioni sommaB e prodottoB Numerals isZero: si implementino le funzioni isZeroC e isZeroB, nei due calcoli, per il test sullo zero (hint: si provveda prima a definire la segnatura dei booleani in ciascun calcolo) Numerals: si confrontino le due forme di numerali: somiglianze e differenze. Scrivere una funzione di conversione. 5/10/2019