Paradigma Funzionale Paradigma Imperativo: Programma = transizione di stato Paradigma Funzionale: Programma = valutazione di unespressione La maggior parte dei linguaggi imperativi ha costrutti applicativi. Prog::=Decs eval Exp. Decs::=Dec | Dec Decs. Dec::=CDec | FDec. CDec::=Type Id = Exp;. FDec::=Type Id(PDecs) {Exp}. PDecs::=PDec | PDec PDecs. PDec::=Type Id; Type::=int | bool | Types Type Types::=Type | Type Types Exp::=Id | Id(Exps) | Exp + Exp | … if (Exp) {Exp} else {Exp}. Exps ::=Exp | Exp, Exps. Esempio: consideriamo la seguente grammatica LF

Confronto con LW I costrutti di LF sono in gran parte simili a quelli di LW. Rispetto a LW, una (grossa) differenza è che oltre ai tipi base, compaiono dei tipi funzionali o higher-order. Quindi LF è un linguaggio per manipolare valori che possono essere base ( [int] = Z, [bool] = B ) o funzionali (definiti induttivamente da [t 1... t n t] = [ [t 1 ]... [t n ] P [t] ] ). Nel seguito useremo Value = t L Type (LF) [t]. I tipi higher-order sono cittadini di prima classe, cioè possono comparire in tutti i contesti in cui può comparire un tipo base (eg come argomenti e risultati di funzioni). Principale differenza con linguaggi funzionali reali: manca il polimorfismo e i tipi sono dichiarati invece che dedotti. La semantica di LF sarà molto simile a quella di LW, ma, non essendo necessaria la nozione di stato, tutto si semplificherà.

Semantica Statica Env s = [L Id (LF) P L Type (LF) ] Fin Ignoriamo il trattamento di errore (cioè definiamo la semantica statica come funzione parziale) [_] s D :L Decs (LF) Env s Env s P Env s [_] s E :L Exps (LF) Env s P L Type (LF) + [_] s P :L Prog (LF) P L Type (LF) [dl eval e] s P = t [dl] s D ([],[]) = [e] s E ( ) = t [d dl] s D ( g, l ) = [d] s D ( g, l ) = l [dl] s D ( g, l ) = [t x = e;] s D ( g, l ) = l [t/x] x Dom( l ) [e] s E ( g [ l ]) = t [t f(pl){e}] s D ( g, l ) = l [lt t/f] f Dom( l ) lt = types(pl) [e] s E ( g [ l ][ l ]) = t[pl] s PD ( g [ l ],[lt t/f]) = l types(t x; pl)= t tl types(pl)= tl types(t x;)= t [t x;] s PD ( g, l ) = l [t/x] x Dom( l ) [_] s PD :L PDecs (LF) Env s Env s P Env s

Semantica Statica 2 [x] s E ( ) = t (x) = t [f(es)] s D ( ) = t [f] s E ( ) = lt t[es] s E ( ) = lt [if (b) {e} else {e}] s E ( ) = t [e] s E ( ) = t [b] s E ( ) = bool Esercizio proposto: aggiungere altri costrutti base al linguaggio, ad esempio costrutti per la funzione identica, composizione di funzioni, tipi prodotto, pairing (se f: A B e g: C D, allora (f,g): A C B D è definita da (f,g)(a,c) = (f(a),g(b)))... [e + e] s E ( ) = int [e] s E ( ) = int

Semantica Dinamica (Denotazionale) [dl eval e] P = v [dl] D ([]) = r[e] E (r) = v [d dl] D (r) = r [d] D (r) = r[dl] D (r) = r [t x = e;] D (r) = r[v/x] [e] E (r) = v Le dichiarazioni modificano lambiente: [_] Decs :L Decs (LF) Env Env dove Env = [L Id (LF) P Value] Fin Le espressioni producono un valore: [_] Exps :L Exps (LF) Env Value + [RT f(T x) {e}] D (r) = r[F/f] Dove F : [T] [RT] è definita induttivamente da tutte le regole della semantica più le seguenti due: [f(e)] (r[ /f]) = a F(v) = a[e](r[ /f]) = v Caso baseRegola ad hoc per la chiamata di f F(v) = a [e](r[ /f, v/x] ) = a Rispetto a LW è sparito lo stato Il valore del parametro attuale è associato direttamente al nome del parametro formale

Semantica Dinamica (2) [e es] E (r) = v lv [e] E (r) = v[es] E (r) = lv [x] E (r) = r(x) [f(es)] E (r) = r(f)(lv) [es] E (r) = lv v 1 + v 2 = a [e 1 + e 2 ] E (r) = a [e 1 ] E (r) = v 1 [e 2 ] E (r) = v 2