6/3/20151 Domain Independent Componenti base di un Linguaggio LinguaggioFunzionale.

Presentazione sul tema: "6/3/20151 Domain Independent Componenti base di un Linguaggio LinguaggioFunzionale."— Transcript della presentazione:

1

2 6/3/20151 Domain Independent Componenti base di un Linguaggio LinguaggioFunzionale

3 6/3/20152 Componenti base n Funzioni n Espressioni n Tipi n Definizioni e ambienti n Condizionali n Matching n Ricorsione n Notazioni e programmi n Zucchero sintattico ed estensioni n Prove e induzione

4 6/3/20153Funzioni n Valori basici n Totali e parziali n Intesionalita’ ed estensionalita’

5 6/3/20154 Funzioni: Valori basici n Con le seguenti tre operazioni basiche AstrazioneAstrazione ApplicazioneApplicazione Punto fissoPunto fisso n Tutte formano espressioni X  Variabili E  Espressioni Fun x. E  Funzioni F  Funzioni E  Espressioni F E  Applicazioni f  Variabili E  Espressioni Y f.E  Funzioni

6 6/3/20155 Funzioni: Totali e parziali n Totali solo una parte delle calcolabili n Universalita’ richiede di esprimere anche le parziali n Parziali attraverso Punto fisso ovvero processi limite

7 6/3/20156 Funzioni: Intensionalita’ ed Estensionalita’ n Intensionale: definisce il processo di calcolo con cui ogni immagine puo’ essere individuata a partire dagli argomenti. fun x. x+2 Estensionale: definisce il comportamento esterno che la funzione ha, nel suo insieme. succ succ succ succ n Complementari –Intensionale per il calcolo –Estensionale per la dimostrazione (ancora un problema per LISP)

8 6/3/20157Espressioni n Sono la struttura fondamentale Combinano funzioni e valori (che includono funzioni) per ottenere valori n Trasparenza referenziale significato dipende solo dalla loro struttura (chiuse - combinatori) e dal contesto in cui sono definite (chiusure) e dal contesto in cui sono definite (chiusure)

9 6/3/20158Tipi n Classificare (categorizzare) n Strettamente tipato n Sistema di tipi MonomorfismoMonomorfismo Polimorfismo di sottotipoPolimorfismo di sottotipo Polimorfismo genericoPolimorfismo generico

10 6/3/20159 Tipi: Classificare n Solo espressioni Associare ad ogni espressione un tipoAssociare ad ogni espressione un tipo Un unico tipoUn unico tipo n Espressioni con comportamento diverso Una proprieta’ estensionale:Una proprieta’ estensionale: fun x. x+2 e succ succ hanno stesso tipo Espressioni compatibili:  |- x yEspressioni compatibili:  |- x y Proteggere da uso improprio ed errori:  |- x + yProteggere da uso improprio ed errori:  |- x + y Vincolare espressivita’: ordine 1, 2, …, Vincolare espressivita’: ordine 1, 2, …, 

11 6/3/201510 Tipi: Strettamente (o fortemente) tipato n Linguaggio con sistema dei tipi e analisi del programma (espressioni) garantisce che errori di calcolo non siano dovuti a errori di tipi n Type checking statico

12 6/3/201511 Tipi: Sistema dei tipi n Un sistema di tipi e’: – Struttura dei tipi – Regole per associare tipi alle strutture (espressioni) H.P. Barendregt, K. Hemerik (1990) Types in Lambda Calculi and Programming Languages, ESOP ‘90 (LNCS 432), pp 1-36

13 6/3/201512 Sistema di tipi: Struttura e regole n Struttura dei tipi: Esplicita (nel linguaggio) : fun x:int. x+2 (Curch 1941)Esplicita (nel linguaggio) : fun x:int. x+2 (Curch 1941) Implicita : fun x. x+2(Curry 1934) Piatta o menoPiatta o meno n Regole: CompletoCompleto ConsistenteConsistente

14 6/3/201513 Tipi: Monomorfismo n Un sistema di tipi semplice per controllo di tipi Tipi denotati conTipi denotati con Espressioni di costanti Consente di esprimere:Consente di esprimere: , Length:[int]->int, >:int->int->Bool, x:[int], y:[int] |- Length(x) > Length(y):Bool

15 6/3/201514 Tipi: Polimorfismo di sottotipo n Un sistema di tipi flessibile per maggiore espressività Classi di tipi e tipi denotati conClassi di tipi e tipi denotati con Espressioni di costanti e relazione di Espressioni di costanti e relazione disottoclasse Consente di esprimere:Consente di esprimere: , Length:Ord a => [int]->a, >:Ord b => b->b->Bool, x:[int], y:[int] |- Length(x) > Length(y):Bool

16 6/3/201515 Tipi: Polimorfismo generico n Un sistema di tipi flessibile (maggiore espressivita’ e codice riusabile) Tipi denotati conTipi denotati con Espressioni con Variabili quantificate Consente di esprimere:Consente di esprimere: , Length:  a.[a]->int, >:int->int->Bool, x:[int], y:[char] |- Length(x) > Length(y):Bool Combinando, consente di esprimere:Combinando, consente di esprimere: , Length:Ord b =>  a.[a]->b, >:Ord b => b->b->Bool, x:[int], y:[char] |- Length(x) > Length(y):Bool

17 6/3/201516 Analisi dei tipi n Regole di analisi: mediare tramediare tra –Espressivita’ fun p q z. p zfun p q z. p z fun p z. If (null z) then 0 else 1+ p (rest z)fun p z. If (null z) then 0 else 1+ p (rest z) –Controllo statico (  ->  ) x  x  -> (  ->  ) x  x  ->  (List(  )->Int) x List(  ) -> Int(List(  )->Int) x List(  ) -> Int – Fondatezza Fun p. p pFun p. p p Implementa il Sistema di tipiImplementa il Sistema di tipi La funzione True Un funzionale F che ha tra i punti fissi Length Un tipo di True in un opprtuno sistema Un tipo per il funzionale F Una forma che soddisfa la struttura delle espressioni

18 6/3/201517 Un primo sistema: monomorfo (2) n Struttura T= k | T  T | T  T k= Int | Bool |…. n Struttura T= k | T  T | T  T k= Int | Bool |…. Un sistema di tipi per  ordine

19 6/3/201518 Un primo sistema: monomorfo (3) I:introduce, E:elimina n Regole x:T |- x:T Id (variabili, costanti)  1,  2 |- F E: T 2  1 |- F:T 1 T 2  2 |- E:T 1  1 |- F:T 1  T 2  2 |- E:T 1 APP  |- \x->E : T 1 T 2  |- \x->E : T 1  T 2 , x:T 1 |- E:T 2 ABS  0,  1,  2 |- if B then E 1 else E 2 : T  0 |- B:Bool  1 |- E 1 :T  2 |- E 2 :T IF IF  1,  2 |- let x=F in E: T 2  1 |- F: T 1  2, x:T 1 |- E: T 2 LET I E  1,  2 |- (E 1,E n ):T 1  T 2  1 |- E 1 :T 1  2 |- E 2 :T 2 TUP  |- fst E:T 1  |- E :T 1  T 2 TUP/E1  |- snd E:T 2  |- E :T 1  T 2 TUP/E2  1,  2 |- let x=F in E: T 2  1, x:T 1 |- F: T 1  2, x:T 1 |- E: T 2 LETREC

20 6/3/201519 Un primo sistema: monomorfo (3) Il sistema di inferenza  = {c1:t1,…., cn:tn} Assersioni:  = {c1:t1,…., cn:tn} Join:  c = {c1:u1,…., cn:un},  a = {a1:v1,…., am:vm} =>  c,  a =  c   a sse ci = aj => ui = vj Complete 1 (lemma):  c   a and  c |- c:t =>  a |- c:t Complete 2 (lemma):  |- c:t => {x:u   | x  free(c))} |- c:t Complete 3 (lemma):  |- c:t and c ==>  R c’ =>  |- c’:t

21 6/3/201520 Inferiamo il tipo delle espressioni Forward reasoning dagli assiomi alle formule  1 |- +: Int x Int -> Int  2 |- 2: Int  3 |- x: Int  1,  2,  3 |- (x + 2): Int  4 |- ^: Int x Int -> Int  2 |- 2: Int  1,  2,  3,  4 |- (x + 2): Int app Dove:  1 = +: Int x Int -> Int  2 = 2: Int  3 = x: Int  4 = ^: Int x Int -> Int

22 6/3/201521 Esercizi (monomorfico) Utilizzando il sistema monomorfo introdotto 1. Lo si estenda per il costruttore di tipo unione disgiunta, indicato con +, e con operazioni di iniezione up1: A -> A+B e up2: B -> A+B. 2. Si mostri che il termine \x -> x x non è tipabile 3. Si calcoli il tipo di \x -> \y -> x y infine 4. Lo si estenda per i termini costruiti per punto fisso e lo si applichi al termine Yx -> \y -> x y

23 6/3/201522 Definizioni e ambienti n Definizioni legano nomi con valori (espressioni): next2= succ succ Insiemi di definizioni formano ambienti (contesti): next2= succ succ, x=5 |- next2 5 => 7 Insiemi di definizioni formano ambienti (contesti): next2= succ succ, x=5 |- next2 5 => 7 n Ambienti locali e Scope

24 6/3/201523 Definizioni e ambienti: Scope e Ambienti locali n Una definizione puo’ essere comune a piu’ espressioni o definizioni Ad ogni definizione e’ associato uno Scope (portata)Ad ogni definizione e’ associato uno Scope (portata) Costanti, variabili free e bound, espressioni aperte e chiuse: next2 xCostanti, variabili free e bound, espressioni aperte e chiuse: next2 x n Una definizione puo’ essere locale: next2= succ succ |- let x=5 in next2 x => 7 |- let next2= succ succ and x=5 in next2 x => 7 |- let next2= succ succ and x=5 in next2 x => 7

25 6/3/201524Condizionali n Sono espressioni Valori true e false + operatoriValori true e false + operatori Guardie per discriminare (case)Guardie per discriminare (case) fib n = if (n=0) or (n=1) fib n = if (n=0) or (n=1) then 1 else fib(n-1) + fib(n-2)

26 6/3/201525 Matching definizione per casi n Definizioni per casi (modello equazionale) cached_fib 1 = cached_fib 1 = cached_fib n = (let pair = cached_fib(n-1) in let cache = pair|1 and val = pair|2 in let cache = pair|1 and val = pair|2 in ) if n>1 in ) if n>1 fib 0 = 1 fib 1 = 1 fib n = (|1 cached_fib) n if n>1 Guardie: restringono l’applicabilita’ dell’equazione selezionata dal matching

27 6/3/201526 Matching selettori impliciti n Combina trasmissione e selezione in dati concreti append nil L2 = L2 append (x : L1) L2 = (x : (append L1 L2)) Seleziona e lega ad x il pri- mo elemento della lista cui la funzione e’applicata Seleziona e lega ad L1 il “seguito” della lista cui la funzione e’applicata

28 6/3/201527Ricorsione n Costrutto essenziale n Presente con differenti sintassi: EsplicitoEsplicito let rec fact n = if n=0 then 1 else n*fact(n-1) fact = Y f. fun n. if n=0 then 1 else n*f(n-1) ImplicitoImplicito fact 0 = 1 fact n+1 = (n+1)*fact(n)

29 6/3/201528 Notazione e Programmi espressioni n exp -> \ apat1... apatn -> exp (abstraction, n>=1) n | let decls in exp (let expression) n | if exp then exp else exp (conditional) n | case exp of {alts [;] } (case expression) n | fexp n alts -> alt1;... ;altn (n>=1) n alt -> pat -> exp [where decllist] n | pat gdpat [where decls] n gdpat -> gd -> exp [ gdpat ] n gd -> | exp n fexp -> [fexp] aexp (function application) n aexp -> qvar (bound variable) n | gcon (general constructor) n | ( exp ) (parenthesized expression) n | ( exp1,..., expk ) (tuple, k>=2) n apat/pat -> var (as pattern) Haskell http://www.haskell.org

30 6/3/201529 Notazione e Programmi definizioni n decls -> decl1 ;... ; decln (n>=0) n decl -> signdecl(explicit typing) n | valdef(expression naming) n signdecl -> vars :: type n vars -> var 1,..., var n (n>=1) n type -> btype [-> type] (function type) n btype -> [btype] atype (type application) n atype -> tyvar (type variable) n | gtype (ground type) n | ( type1,..., typek ) (tuple type, k>=2) n valdefs -> valdef1 ;... ; valdefn (n>=0) n valdef -> lhs = exp [where decls](simple definition) n | lhs gdrhs [where decls] (guarded definition) n lhs -> var (identifiers: naming) n | funlhs n funlhs -> var apat {apat} (identifiers: naming and parameters) n gdrhs -> gd = exp [gdrhs] (guarded espression)

31 6/3/201530 Programmazione: Applicazione alla definizione dello Scoping Free “x” ”\ apat 1... apat n -> exp” = | n>1  (x≠apat 1 ) =“\apat 1 ” ++ (Free “x” ”\apat 2...apat n -> exp”) | n==1  (x≠apat 1 ) =“\apat 1 ->” ++ (Free “x” ”exp”) | n==1  (x≠apat 1 ) =“\apat 1 ->” ++ (Free “x” ”exp”) | otherwise = “∆” | otherwise = “∆” nota: “--” come costruttori (giochiamo col meta) ∆ indica outscope ∆ indica outscope n (l’indice della lista) diventa un parametro n (l’indice della lista) diventa un parametro Free “x” ”let y=expy; decls in exp” = | x≠y  (Size decls > 0) =“let y=” ++(Free “x” ”expy”)++ De_let(Free “x” ”let decls in exp”) = | x≠y  (Size decls > 0) =“let y=” ++(Free “x” ”expy”)++ De_let(Free “x” ”let decls in exp”) where De_let “let decl in/; rest”= “decl in/; rest” where De_let “let decl in/; rest”= “decl in/; rest” | x≠y  (Size decls = 0) =“let y=” ++(Free “x” ”expy”)++“in”++(Free “x” ”exp”) | x≠y  (Size decls = 0) =“let y=” ++(Free “x” ”expy”)++“in”++(Free “x” ”exp”) | otherwise =“let y=” ++(Free “x” ”expy”)++“in ∆” | otherwise =“let y=” ++(Free “x” ”expy”)++“in ∆” Free “x” ”case exp p1->e1... pn->en” = ”case”++(Free “x” ”exp”)++(Locc “x” “p1->e1... pn->en”) where Locc “x” “”= “” where Locc “x” “”= “” Locc “x” “p1->e1 rest”= (Occ “x” “pn” ”en”) ++ ( Locc “x” “rest” ) where Occ “x” “p” ”e” = if (Free “x” ”p”)≠“∆” then ”p ->”++(Free “x” ”e”) Locc “x” “p1->e1 rest”= (Occ “x” “pn” ”en”) ++ ( Locc “x” “rest” ) where Occ “x” “p” ”e” = if (Free “x” ”p”)≠“∆” then ”p ->”++(Free “x” ”e”) else “∆ -> ∆” else “∆ -> ∆” da completare ed esprimere in Haskell Riflettere sulle differenze tra le due scritture

32 6/3/201531 Un esempio: n Free “x” ”let g = \zx. x div z ; z = 5 ; y = z+x in g(z*y)” “let g = \z∆; z = 5 ; y = z+x in g(z*y)” n Free “x” ”let g = \zx. x div z ; z = 5 ; y = z+x ; x = y*z in g(z*y)” “let g = \z∆; z = 5 ; y = z+x ; x = y*z in ∆”

33 6/3/201532 Programmazione: Applicazione alla definizione dello Scoping (2) Quando le definizioni nel let_in possono essere mutuamente ricorsive Free “x” ”let y1=e1;… ; yn=en in exp” = | (x≠y1 ...  x≠yn) =“let y1=E1 ;… ; yn=En in Exp” = | (x≠y1 ...  x≠yn) =“let y1=E1 ;… ; yn=En in Exp” | otherwise =“∆” | otherwise =“∆” where E1= Free “x” “e1” ;…; En= Free “x” “en” ; Exp= Free “x” “exp” Free “x” ”let g = \zx. x div z ; z = 5 ; y = z+x ; x = y*z in g(z*y)” “∆”

34 6/3/201533 Zucchero sintattico ed Estensioni n Zucchero: –Let Decls in Exp –Exp where Decls Estensione: Patterns Estensione: Patterns Streams Streams Tipi astratti Tipi astratti Monadi Monadi

35 6/3/201534 Zucchero sintattico ed Estensioni: zucchero o estensione? (\ x1…xn. Exp) E1…En where E1=E1,…,En=En independent where E1= E1;nested E2= (\ x1.E2) E1; E2= (\ x1.E2) E1;…. En= (\ x1… x k … x n-1.En) E1… E k … E n-1 En= (\ x1… x k … x n-1.En) E1… E k … E n-1 let x1=E1;…;xn =En in Exp Come cambia la complessita’ del controllo dei tipi nel caso independent e nested

36 6/3/201535 Prove: Ricorsione e Induzione n Definire per ricorsione vs. Provare per induzione n Ordinamento ben fondato n Regole di inferenza Riduzione di termini (espressioni)Riduzione di termini (espressioni) Deduzione di formuleDeduzione di formule

37 6/3/201536 Prove e Induzione: ordinamento ben fondato n N insieme arbitrario n Ordinamento parziale (N,<) : relazione binaria anti-simmetricaanti-simmetrica TransitivaTransitiva n Ordinamento ben fondato (N,<,0  N): – 0 = {z |  t  N : t<z} –  n  N,  k naturale, n < n 1 <…< n k  0

38 6/3/201537 Prove e Induzione: Regole di Inferenza (su N) n Induzione completa: P su (N,<,0) (N,<,0) |- (P(z),  z  0) base (N,<,0), (P(n),  n < t  N) |- P(t) induzione (N,<,0) |- (P(n),  n  N)

39 6/3/201538 Prove e Induzione: Regole di Inferenza (N non basta) n Non basta per: –Funzioni parziali (strette e non-strette) –Valori approssimabili (streams) n Considera: P: (  x:nat ) if x==0 then 3 else 3 = 3

40 6/3/201539 Prove e Induzione: Un esempio (problemi con N) (Nat) |- P(0): base (Nat) |- P(0): if 0==0 then 3 else 3 = 3 base (Nat), (P(n),  n < t  N) |- induzione (Nat), (P(n),  n < t  N) |- if t==0 then 3 else 3 = 3 induzione (N,<,0) |- (P(n),  n  N) Ma: f=\x:Nat -> f(x+1):Nat->Nat (f 0):Nat (f 0):Nat P(f 0) e’ falsa

41 6/3/201540 Prove e Induzione: Regole di Inferenza (su Parziali) n Induzione completa su N con funzioni parziali (N,<,0) |- (P(z),  z  0) f: finito (N,<,0), (P(n),  n < t  N) |- P(t) i: induzione (N,<,0) |- (P(n),  n  N) |- P(  ) p: parziale |- P(  ) p: parziale