Paradigma Funzionale Paradigma Imperativo: Programma = transizione di stato Paradigma Funzionale: Programma = valutazione di un’espressione La maggior parte dei linguaggi imperativi ha costrutti applicativi. Esempio: consideriamo la seguente grammatica LF 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.

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 [t1  ...  tn  t] = [[t1]  ...  [tn] P [t]]). Nel seguito useremo Value = tLType(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 Ignoriamo il trattamento di errore (cioè definiamo la semantica statica come funzione parziale) Envs = [LId(LF) P LType(LF) ]Fin [_]sD:LDecs(LF)  Envs  Envs P Envs [_]sE:LExps(LF)  EnvsP LType(LF)+ [_]sP:LProg(LF) P LType(LF) [dl eval e]sP = t [dl]sD([],[]) = r [e]sE (r) = t types(t x;)= t [d dl]sD (rg, rl) = r [d]sD(rg, rl) = rl’ [dl]sD(rg, rl’) = r types(t x; pl)= t tl types(pl)= tl [t x = e;]sD (rg, rl) = rl [t/x] xÏDom(rl) [e]sE(rg[rl]) = t [t f(pl){e}]sD (rg, rl) = rl[lt  t/f] fÏDom(rl) lt = types(pl) [e]sE(rg[rl][rl’]) = t [pl]sPD(rg[rl],[lt  t/f]) = rl’ [t x;]sPD (rg, rl) = rl[t/x] xÏDom(rl) [_]sPD:LPDecs(LF)  Envs  Envs P Envs

Semantica Statica 2 [x]sE (r) = t r(x) = t [f(es)]sD (r) = t [f]sE (r) = lt  t [es]sE (r) = lt [if (b) {e} else {e’}]sE(r) = t [e]sE(r) = t [e’]sE(r) = t [b]sE(r) = bool [e + e’]sE(r) = int [e]sE(r) = int [e’]sE(r) = int 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)))...

Semantica Dinamica (Denotazionale) Le dichiarazioni modificano l’ambiente: [_]Decs:LDecs(LF)  Env  Env dove Env = [LId(LF) P Value]Fin Le espressioni producono un valore: [_]Exps:L Exps(LF)  Env Value+ [dl eval e]P = v [dl]D([]) = r [e]E (r) = v [t x = e;]D (r) = r[v/x] [e]E(r) = v [d dl]D (r) = r” [d]D(r) = r’ [dl]D(r’) = r” [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: Rispetto a LW è sparito lo stato Il valore del parametro attuale è associato direttamente al nome del parametro formale Caso base Regola ad hoc per la chiamata di f F(v) = a [e](r[/f, v/x])= a [f(e)] (r[/f]) = a F(v) = a [e](r[/f]) = v

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 [e1 + e2]E(r) = a [e1]E(r) = v1 [e2]E(r) = v2 v1 + v2 = a Esercizio proposto: dare la semantica dinamica operazionale a piccoli passi (suggerimento: non cercare di individuare i termini che rappresentano valori - per i tipi funzionali non si può fare - ma dare solo la relazione di semplificazione; come configurazioni usare coppie termine+ambiente; un ambiente associa espressioni a identificatori; per gestire le funzioni sarà necessario estendere il linguaggio come nel caso imperativo)