Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 9 (Dynamische und Statische Semantik)

Transkript

1 Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 9 (Dynamische und Statische Semantik) Hinweis: Dieses Übungsblatt enthält von den Tutoren für das Wiederholungstutorium erstellte Aufgaben. Die Aufgaben und die damit abgedeckten Themenbereiche sind für die Klausur weder relevant noch irrelevant. Aufgabe 9.1 (Umgebungen) Schreiben Sie die folgenden Prozeduren für Umgebungen: (a) adjoin: α env α env α env, die 2 Umgebungen f und g vereinigt. (b) return: id α α env, die eine Umgebung ausgibt, in der ein Bezeichner x gebunden ist. (c) unbind: α env id α env, die einen Bezeichner x aus einer Umgebung entfernt. Lösung 9.1: fun adjoin f g = fn y g y handle Unbound _ f y fun return x v = update empty x v fun unbind env x = fn y if x = y then raise Unbound y else env y Aufgabe 9.2 (Teilausdrücke) Schreiben Sie die folgenden Prozeduren: (a) BV: exp id list, die alle Variablen auflistet, die in einem Ausdruck vorkommen, aber nicht frei sind. (b) subexp: exp exp bool, die prüft, ob e den Ausdruck e syntaktisch enthält. (c) countsubexp: exp exp int. Analog zu subexp, nur dass nun die Auftreten gezählt werden. (d) freesubexp: exp exp bool. Analog zu subexp, nur dass ein Ausdruck nur genau dann als Unterausdruck gilt, wenn die in e vorkommenden freien Variablen auch an dieser Stelle frei in e sind. Knifflig! Lösung 9.2: (a) fun BV ( Con c) = [] BV (Id x) = [] BV ( Opr (opr,e1,e2 )) = BV BV e2 BV (If(e1,e2,e3 )) = BV BV BV e3 BV ( App (e1,e2 )) = BV BV e2 BV ( Abs (x,t,e)) = x :: BV e (b) fun subexp s e = s = e orelse case e of ( Opr ( opr, e1, e2 )) subexp s e1 orelse subexp s e2 (If(e1,e2,e3 )) subexp s e1 orelse subexp s e2 orelse subexp s e3 ( App ( e1, e2 )) subexp s e1 orelse subexp s e2 ( Abs (x,t,e)) subexp s e 1

2 _ false (c) fun countsubexp s e = if s = e then 1 else 0 + case e of ( Opr ( opr, e1, e2 )) countsubexp s e1 + countsubexp s e2 ( If( e1, e2, e3 )) countsubexp s e1 + countsubexp s e2 + countsubexp s e3 ( App ( e1, e2 )) countsubexp s e1 + countsubexp s e2 ( Abs (x,t,e)) countsubexp s e _ 0 (d) Zu dieser Aufgabe gibt es noch keine Beispiellösung. Aufgabe 9.3 (Konkrete und Abstrakte Darstellung I ) Geben Sie die zu den folgenden Ausdrücken passenden abstrakten Darstellungen an. (a) *2 (b) if 1 y then g y else 32 (c) fn x: int x * x (d) fn h: bool int int h true Lösung 9.3: (a) Opr(Add, Opr(Add, Con(IC 4), Con (IC 8)), Opr(Mul, Con(IC 10), Con(IC 2))) (b) If(Opr(Leq, Con(IC 1), Id y ), App(Id g, Id y ), Con(IC 32)) (c) Abs(Id x, Int, Opr(Mul, Id x, Id x )) (d) Abs (Id h, Arrow(Bool, Arrow(Int, Int)), App (Id h, True)) Aufgabe 9.4 (Konkrete und Abstrakte Darstellung II ) Geben Sie die zu den folgenden abstrakten Darstellungen die passenden Ausdrücke an. (a) If (Con (False), Con (True),Con (False)) (b) Arrow(Int,Arrow(Bool,Bool)) (c) Abs(Id g, Arrow(Int,Int), Opr(Mul, Con (IC 1), Opr(Add, Con (IC 28), Con (IC 4)))) Lösung 9.4: (a) if false then true else false (b) int bool bool (c) fn g : int int 1 * ) 2

3 Aufgabe 9.5 (Offen oder Geschlossen?) (a) Sind die folgenden Ausdrücke geschlossen oder offen? Wie sind Sie vorgegangen beim Prüfen der Ausdrücke? fn x:int => x * fn x:int => fn y:int => if b then x * y Abs (Id a, Int, Con(IC 2)) Abs (Id z, Bool, Id y ) Abs (Id x, Int, Abs (Id f, Arrow(Int,Int), App(Id f, Id x ))) (b) Schreiben Sie eine Prozedur bound : exp id list bool, die testet, ob alle freien Bezeichner eines Ausdrucks in einer Bezeichnerliste vorkommen. Sie dürfen member : α α list bool benutzen. (c) Schreiben Sie eine Prozedur cl : exp bool, die testet, ob ein Ausdruck geschlossen ist. Hinweis: Benutzen Sie bound Lösung 9.5: (a) Allgemein schaut man sich zuerst die Abstraktionen an, denn in F können nur dort neue Bezeichner eingeführt werden. Als nächstes vergleicht man dann, ob im Code-Teil der Abstraktion Bezeichner auftreten, welche vorher noch nicht gebunden wurden. Geschlossen. Offen, da Bezeichner b nicht gebunden. Geschlossen. Offen, da Bezeichner y nicht gebunden. Geschlossen. fun bound ( Con c) l = true bound ( Id i) l = member i l bound ( Opr ( o, x, y)) l = bound x l andalso bound y l bound ( If ( b, x, y)) l = bound b l andalso bound x l andalso bound y l bound ( Abs (i,t,e)) l = bound e (i::l) bound ( App ( f, x) ) l = bound f l andalso bound x l bound = raise Error (b) (c) fun cl e = bound e nil 1 Elaborierung und Evaluierung Aufgabe 9.6 (Zahlen und Wahrheitswerte) Wir wollen einen Elaborierer für Zahlen und Wahrheitswerte schreiben. Seien die abstrakte Syntax z Z c Con = false true z e Exp = c und der Konstruktortyp con gegeben als datatype con = C of int True False. (a) Geben Sie die Zahl 456 mithilfe von con wieder. Geben Sie false mithilfe von con wieder. (b) Sei T y = int bool. Konstruiere einen Konstruktortyp ty, der Typen für con gemäß der abstrakten Syntax darstellt. 3

4 (c) Schreiben Sie eine Prozedur integer: con bool, die für eine Eingabe entscheidet, ob es sich um eine Zahl handelt. (d) Ergänzen Sie folgende Inferenzregeln für den Elaborierer: Snum T z : int Strue T true : Sfalse T : (e) Schreiben Sie eine Prozedur elabcon: con ty, die für eine Eingabe den Typ bestimmt. Wir wollen nun den Konstruktortyp con evaluieren. Werte, bestehend aus Integerwerten, seien wie folgt gegeben: v Val = Z datatype value = IV of int 4

5 (f) Ergänzen Sie die folgenden Inferenzregeln für die dynamische Semantik von con: Dnum V z Z z Dtrue V 1 Dfalse V (g) Schreiben Sie einen Evaluierer evalcon: con value, der Zahlen und Wahrheitswerte aus unserer Grammatik auswertet. Orientiere dich an den Inferenzregeln. Lösung 9.6: (a) 456 entspricht C 456 und false entspricht False. (b) datatype ty = Int Bool (c) fun integer ( C _) = true integer _ = false (d) z Z Snum T z : Int (e) fun elabcon ( C _) = Int elabcon True = Bool elabcon False = Bool (f) Strue T true : bool Sfalse T false : bool Dnum V z Z z z Dtrue V true 1 Dfalse V false 0 (g) fun evalcon ( C x) = IV x evalcon True = IV 1 evalcon False = IV 0 Aufgabe 9.7 (Operatoranwendungen) Sei die abstrakte Syntax gegeben durch o Opr = + t T y = bool int e Exp =... e o e Seien zusätzlich die Konstruktortypen ty und opr wie folgt deklariert: datatype ty = Bool Int datatype opr = Add Sub Mul Leq Wir wollen nun den Konstruktortyp opr elaborieren. 5

6 (a) Ergänzen Sie die folgendn Inferenzregeln für den Elaborierer: Soai o [+,, ] T : T : T e 1 o e 2 : T e 1 : T e 2 : Soab T e 1 e 2 : (b) Schreiben Sie eine Prozedur evalopr: opr ty ty ty, die, gemäß den Inferenzregeln aus (a), für einen Operatorausdruck den Typ bestimmt. Für alle unzulässigen Operationen, soll die Ausnahme Error geworfen werden. Wir wollen nun den Konstruktortyp opr evaluieren. Werte, bestehend aus Integerwerten, seien wie folgt gegeben: v Val = Z datatype value = IV of int (c) Ergänzen Sie die folgenden Inferenzregeln für den Evaluierer: D+ V e 1 V e 2 z = V e 1 + e 2 z D- D* V V e 1 e 2 e 1 e 2 D V z = if then else e 1 e 2 (d) Schreiben Sie eine Prozedur evalopr: opr value value value, die zu einem Operatorausdruck den Wert berechnet. Für alle unzulässigen Operationen soll die Ausnahme Error geworfen werden. Lösung 9.7: (a) Soai o [+,, ] T e 1 : int T e 2 : int T e 1 o e 2 : int T e 1 : int T e 2 : int Soab T e 1 e 2 : bool (b) fun elabopr Add Int Int = Int elabopr Sub Int Int = Int elabopr Mul Int Int = Int elabopr Leq Int Int = Bool elabopr _ = raise Error (c) D+ V e 1 z 1 V e 2 z 2 z = z 1 + z 2 V e 1 + e 2 z D- V e 1 z 1 V e 2 z 2 z = z 1 z 2 V e 1 e 2 z D* V e 1 z 1 V e 2 z 2 z = z 1 z 2 V e 1 e 2 z D V e 1 z 1 V e 2 z 2 z = if z 1 z 2 then 1 else 0 V e 1 e 2 z 6

7 (d) fun evalopr Add (IV x) (IV y) = IV (x+y) evalopr Sub (IV x) (IV y) = IV (x y) evalopr Mul (IV x) (IV y) = IV (x*y) evalopr Leq ( IV x) ( IV y) = if x<=y then IV 1 else IV 0 evalopr _ = raise Error Aufgabe 9.8 (Ausdrücke) Sei die abstrakte Syntax von F gegeben durch z Z c Con = false true z x Id = N o Opr = + t T y = bool int e Exp = c x eoe if e then e else e fn x : t e ee Seien die Konstruktortypen opr, con wie in den vorherigen Aufgaben deklariert. Zusätzlich sei id für Bezeichner und ty für Typen wie folgt definiert: type id = string datatype ty = Bool Int Arrow of ty * ty Wir wollen jetzt einen Elaborierer für Ausdrücke gemäß F schreiben. (a) Umgebungen sollen durch folgenden Typ env dargestellt werden: type α env = id α Stellen Sie die leere Umgebung durch eine Prozedur empty dar, die für jeden Bezeicher x die Ausnahme Unbound x wirft. Deklarieren Sie auch eine Prozedur update: α env id α α env, die eine gegebene Umgebung um einen Bezeichner und einen Wert erweitert. (b) Ergänzen Sie die Deklaration des Konstruktortyps exp für Ausdrücke. datatype exp = Con of Id of Opr of * * If of * * Abs of * * App of * (c) Ergänzen Sie die folgende Inferenzregel für den Elaborierer: Sid T x : t Sif T : bool T : T : T if then else : t T [ ] e Sabs T fn : t e : Sapp T e 1 : T e 2 : T e 1 e 2 : t 7

8 (d) Schreiben Sie einen Elaborierer elab: ty env exp ty, der, gemäß der Inferenzeregeln, einen Typ für einen Audruck und eine Typumgebung ableitet und bei einem Typfehler die Ausnahme Error wirft. Sie dürfen elabcon, elabopr aus den vorherigen Aufgaben benutzen. 8

9 Wir wollen jetzt einen Evaluierer für Ausdrücke gemäß F schreiben. Werte, bestehend aus Integerwerten und Prozedurtripeln, seien wie folgt gegeben: v Val = Z P ro P ro = Id Exp V E datatype value = IV of int Proc of id * exp * value env (e) Ergänzen Sie die folgenden Inferenzregeln für den Evaluierer: Did V x v V V Diftrue V if then else v V V Diffalse V if then else v Dabs V fn : t e Dapp V e 1 V e 2 V [ ] e V e 1 e 2 v (f) Schreiben Sie einen Evaluierer eval: value env exp value, der, gemäß der Inferenzregelen, einen Wert für einen Ausdruck und eine Werteumgebung ableitet und bei einem Fehler die Ausnahme Error wirft. Sie dürfen evalcon, evalopr aus den vorherigen Aufgaben benutzen. Lösung 9.8: (a) exception Unbound of int fun empty x = raise Unbound x fun update f x a = fn y if x=y then a else f y (b) datatype exp = Con of con Id of id Opr of opr * exp * exp If of exp * exp * exp Abs of id * ty * exp App of exp * exp (c) T x = t Sid T x : t Sif T e 1 : bool T e 2 : t T e 3 : t T if e 1 then e 2 else e 3 : t T [x := t] e : t Sabs T fnx : t e : t t Sapp T e 1 : t t T e 2 : t T e 1 e 2 : t 9

10 (d) fun elab f ( Con c) = elabcon c elab f (Id x) = f x elab f ( Opr (opr,e1,e2 )) = elabopr opr ( elab f e1) ( elab f e2) elab f (If(e1,e2,e3 )) = ( case ( elab f e1, elab f e2, elab f e3) of ( Bool, t2, t3) if t2=t3 then t2 else raise Error _ raise Error ) elab f ( Abs (x,t,e)) = Arrow (t, elab ( update f x t) e) elab f ( App (e1,e2 )) = ( case elab f e1 of ( Arrow (t,t )) if t = elab f e2 then t else raise Error _ raise Error ) (e) V x = v Did V x v V e 1 1 V e 2 v Diftrue V if e1 then e 2 else e 3 v V e 1 0 V e 3 v Diffalse V if e1 then e 2 else e 3 v Dabs V fn x : t e x, e, V Dapp V e 1 x, e, V V e 2 v 2 V [x := v 2 ] e v V e 1 e 2 v (f) fun eval f ( Con c) = evalcon c eval f (Id x) = f x eval f ( Opr (opr,e1,e2 )) = evalopr opr ( eval f e1) ( eval f e2) eval f (If(e1,e2,e3 )) = ( case eval f e1 of ( IV 1) eval f e2 ( IV 0) eval f e3 _ raise Error ) eval f ( Abs (x,t,e)) = Proc (x, e, f) eval f ( App (e1,e2 )) = ( case ( eval f e1, eval f e2) of ( Proc (x,e,f ), v) eval ( update f x v) e _ raise Error ) 2 Erweiterungen für F Sie sollen F im Folgenden um interessante Konstrukte erweitern. Dafür ist jeweils die neue abstrakte Syntax und gegebenenfalls eine Beschreibung angegeben. Geben Sie dazu jeweils, falls nicht bereits geschehen, die Erweiterungen an bzw. ergänzen Sie passend für: (a) Ausdrücke (in SML: exp) (b) Typen (in SML: ty) (c) Werte (in SML: value) (d) Inferenzregeln für die statische Semantik (e) Inferenzegeln für die dynamische Semantik 10

11 (f) elab (g) eval (h) eine möglichst geringe Zahl an Ausdrücken der Erweiterung, sodass jede Regel von elab und eval mindestens einmal genutzt wird Aufgabe 9.9 (Paare) In der Vorlesung wurde F eingeführt, eine Sprache, die einen Teil von SML enthält. Beispielsweise unterstützt F if -Ausdrücke und Abstraktionen. Wir wollen F um Paare erweitern. Ausdrücke von F werden mit dem Konstruktortyp exp gebildet. Die Typen von F werden durch den Konstruktortyp ty beschrieben. (a) Geben Sie einen zusätzlichen Konstruktor für exp an, der es erlaubt, Paare aus beliebigen Ausdrücken von F zu bilden. (b) Geben Sie einen zusätzlichen Konstruktor für ty an, der es erlaubt, Paare als solche zu typen. (c) Für F gibt es bereits einen Elaborierer, elab: ty env exp ty. Geben Sie für elab ein zusätzliches Muster an, dass Paaren richtig ihren Typ zuordnet. Lösung 9.9: (a) P of exp * exp (b) B of ty * ty (c) elab f (P(x,y)) = B(elab f x, elab f y) Aufgabe 9.10 (Sequentialisierung) Erweitern Sie die Sprache F um die Sequentialisierung. Die erweiterte abstrakte Sprache ist dabei wie folgt gegeben: e Exp =... (e; e) und datatype exp =... Seq of exp * exp. Beachten Sie, dass bei der Sequenzialisierung beide Ausdrücke der Reihe nach ausgewertet werden, aber nur der letzte Ausdruck Wert und Typ des Gesamtausdruckes bestimmt. Lösung 9.10: (a) (b) T e : t T e : t T (e; e ) : t V e v V e v V (e; e ) v SSeq DSeq (c) datatype exp =... Seq of exp * exp fun elab f... elab f ( Seq (e, e )) = ( elab f e; elab f e ) fun eval f... eval f ( Seq (e, e )) = ( eval f e; eval f e ) Aufgabe 9.11 (Unär) Erweiteren Sie eval um 4 unäre Operatoren: (a) : Z Z, welche das Vorzeichen einer ganzen Zahl umkehrt. (b)! : B B, welche die boolesche Negation berechnet. (c) +1 : Z Z, welche eine Ganzzahl um 1 erhöht (Inkrementierung). (d) 1 : Z Z, welche eine Ganzzahl um 1 verkleinert (Dekrementierung). Gehen Sie beim Lösen der Aufgabe strukturiert vor: 11

12 Erweitern Sie formal die abstrakte Grammatik für die abstrakte Syntax von F. (Siehe S. 243 Abbildung 12.2) Erweitern Sie nun die Typdeklarationen für die abstrakte Syntax von F. Geben Sie die Inferenzregeln für die dynamische Semantik der neuen unären Operatoren an. Erweitern Sie nun die Deklaration der Prozedur eval. Lösung 9.11: Gehen wir strukturiert vor, so erhalten wir folgende Schritte: Wir erweitern die abstrakte Grammatik für die abstrakte Syntax von F wie folgt: o U nopr =! Unäre Operatoren Wir erweitern die Typdeklaration für die abstrakte Syntax von F wie folgt: datatype unopr = Neg Not Inkr Dekr... datatype exp =... UnOpr of unopr * exp Wir erhalten folgende Inferenzregeln: Aus den Inferenzregeln folgt die Erweiterung: fun eval f... eval f ( UnOpr ( unopr,e)) = ( case ( unopr, eval f e) of (Neg, IV n) IV ( n) ( Not, IV 0) IV 1 ( Not, IV 1) IV 0 (Inkr, IV n) IV (n+1) (Dekr, IV n) IV (n 1) s raise Error T UnOpr ) V e 1 DnotT V!e 0 V e 0 DnotF V!e 1 V e v Dneg V e v V e v DInkr V +1e v + 1 V e v DDekr V 1e v 1 Aufgabe 9.12 (Boole sche Ausdrücke) Erweitern Sie eval um die Boole sche Verundung ( ), Veroderung ( ) und Negation ( ). Gehen Sie dabei folgendermaßen vor: (a) Erweitern Sie den Konstruktortyp exp. (b) Geben Sie die Regeln mit den Namen Dand, Dor und Dneg für die dynamische Semantik an. (c) Erweitern Sie die Prozedur eval: value env exp value (Buch S. 253) um die Boole sche Verundung, Veroderung und Negation. 12

13 Lösung 9.12: (a) datatype exp =... And of exp * exp Or of exp * exp Neg of exp (b) V e 1 z 1 V e 2 z 2 z = if z 1 = 1 z 2 = 1 then 1 else 0 V e 1 e 2 z V e 1 z 1 V e 2 z 2 z = if z 1 = 0 z 2 = 0 then 0 else 1 V e 1 e 2 z V e z z = if z = 0 then 1 else 0 V e bool Dneg Dand Dor (c) fun eval f ( And (e1,e2 )) = ( case ( eval f e1, eval f e2) of (IV 1, IV 1) (IV 1) _ (IV 0)) eval f (Or(e1,e2 )) = ( case ( eval f e1, eval f e2) of (IV 0, IV 0) (IV 0) _ (IV 1)) eval f ( Neg e) = if eval f e = ( IV 1) then ( IV 0) else ( IV 1) Aufgabe 9.13 (Switch) Erweitern Sie die Sprache F um einen switch-ausdruck. Dieses Konstrukt arbeitet ähnlich zum if -Ausdruck. Er erlaubt es, in Abhängigkeit von einem Ausdruck, der zu einer natürlichen Zahl auswertet, einen bestimmten Ausdruck auszuführen. Ist für die entsprechende Zahl kein Fall definiert, wird ein zuvor angegebener default- Ausdruck ausgewertet. Der Einfachheit halber wird davon ausgegangen, dass in einem switch, das n Fälle definiert, diese Fälle mit den Zahlen 1 bis n angesprochen werden. Die erweiterte abstrakte Sprache ist dabei wie folgt gegeben: e Exp =... switch e of (1 : e, 2 : e,..., n : e, default : e) Typ und Wert des switch-ausdruckes werden durch den Ausdruck des ausgewählten Falles bestimmt. Bedenken Sie, dass ein switch-ausdruck einen eindeutigen Typ haben muss und beliebig viele Fälle haben darf. Lösung 9.13: (a) T e : int T e1 : t T e2 : t... T en : t T e : t T switch e of (1 : e1, 2 : e2,..., n : en, default : e ) : t SSeq (b) V e z V e1 v1 V e2 v2... V en vn V e v if(z <= n) then v = vz else v = v V switch e of (1 : e1, 2 : e2,..., n : en, default : e ) v DSeq (c) datatype exp =... Switch of exp *( exp list )* exp fun elab f... elab f ( Switch (e, el, e )) = case ( elab f e, elab f e ) of (Int, t) if ( List. all (fn x t = x) ( map elab f el )) then t else raise Error " SSwitch1 " _ raise Error " SSwitch2 " fun eval f... eval f ( Switch (e, el, e )) = case ( eval f e) of (IV i) ( eval f ( List. nth (el, i ))) handle Subscript eval f e _ raise Error " DSwitch " 13

14 Aufgabe 9.14 (n-stellige Tupel) Erweitern Sie F um n-stellige Tupel. Die erweiterte abstrakte Grammatik ist wie folgt gegeben: t Ty =... t t e Exp =... (e,..., e) #i e Val = Z Proc Val mit i N Lösung 9.14: Neue Abstrakte Syntax: Exp =... (e,..., e) #c e... Hinzugefügte Ausdrücke: exp =... Tupel of exp list Proj of int * Tupel... Hinzugefügte Werte: TV of value list Regeln für die statische Semantik: T e 1 : t 1... T e n : t n T (e 1,..., e n ) : t 1 t n n 0, STup T e : t 1... t i... t n T #i e : t i SPro Regeln für die dynamische Semantik: V e 1 v 1... V e n v n V (e 1,..., e n ) T V [v 1,..., v n ] n 0, DTup V e T V [v 1,..., v n ] V #i e v i DPro Inferenz-Bootcamp Aufgabe 9.15 (Statische Semantik) Bestimmen Sie die Typen der folgenden Ausdrücke gemäß der statischen Semantik. (a) (fn x : int x + 2) 3 in der Umgebung (b) f 2 (fn x : bool 2) in der Umgebung [f := int (bool int) bool] (c) if x 6 then fn x : int g x else fn y : int true in der Umgebung [x := int, g := int bool] Lösung 9.15: Aus Platzgründen auf einer neuen Seite. Aufgabe 9.16 (Dynamische Semantik) Bestimmen Sie die Werte der folgenden Ausdrücke gemäß der dynamischen Semantik. (a) in der Umgebung (b) if false then 5 6 else 3 + x in der Umgebung [x := 6] (c) if 42 0 then else fn x : int 42 in der Umgebung (d) (fn x : bool x + 3) 2 in der Umgebung (e) (fn x : int 4 x 3) y in der Umgebung [y := 2] (f) (fn x : int int x 5)(fn y : int y + 3) in der Umgebung (g) ((fn x : int => x + 5)x) 5 in der Umgebung [y := 4, z := 2] (h) (fn x : bool int y true) g in der Umgebung [g := x, bool, if x then 1 else 2 ]. Lösung 9.16: Aus Platzgründen auf neuer Seite. 14

15 Lösung zu Aufgabe 11.14: (a) (x, int) [x := int] Sid [x := int] x : int Soai 2 Z Snum [x := int] 2 : int [x := int] x + 2 : int Sabs fn x : int x + 2 : int int Sapp (fn x : int x + 2) 3 : int 3 Z Snum 3 : int (b) (f, int (bool int) bool) [f := int (bool int) bool] 2 Z 2 Z Sid Snum Snum [f := int (bool int) bool] f : int (bool int) bool [f := int (bool int) bool] 2 : int [f := int (bool int) bool, x := bool] 2 : int Sapp Sabs [f := int (bool int) bool] f 2 : (bool int) bool [f := int (bool int) bool] fn x : bool 2 : bool int Sapp [f := int (bool int) bool] f 2 (fn x : bool 2) : bool (c) (int bool) T [x := int] (x, int) T [x := int] Sid Sid (x, int) T T [x := int] g : int bool T [x := int] x : int 6 Z Sid Snum Sapp Strue T x : int T 6 : int T [x := int] g x : bool T [y := int] true : bool Soab Sabs Sabs T x 6 : bool T fn x : int g x : int bool T fn y : int true : int bool Sif T := [x := int, g := int bool] if x 6 then fn x : int g x else fn y : int true : int bool Lösung zu Aufgabe 11.15: (a) 24 Z Dnum D+ D 5 Z Dnum = Z Dnum D* 2 Z Dnum = = if then 1 else Z [x := 6]x = 6 Dnum Did [x := 6] 3 3 [x := 6] x 6 9 = (b) Dfalse D+ [x := 6] false 0 [x := 6] 3 + x 9 Diffalse [x := 6] if false then 5 6 else 3 + x 9 (c) 42 Z Dnum D* Diffalse 0 Z Dnum = 42 0 Dabs fn x : int 42 x, 42, if 42 0 then else fn x : int 42 x, 42,

16 (x, 2) [x := 2] Did (d) 2 Z [x := 2] x 2 Dabs Dnum D+ fn x : bool x + 3 x, x + 3, 2 2 Dapp (fn x : bool x + 3) Z Dnum [x := 2] = [x := 2] x (e) 4 Z [y := 2, x := 2] x = 2 Dnum Did [y := 2, x := 2] 4 4 [y := 2, x := 2] x 2 8 = Z D* Dnum [y := 2] y = 2 [y := 2, x := 2] 4 x 8 [y := 2, x := 2] = 8 3 Dabs Did D- [y := 2] fn x : int 4 x 3 x, 4 x 3, [y := 2] y 2 [y := 2][x := 2] 4 x 3 5 Dapp [y := 2] (fn x : int 4 x 3) y 5 [x := y, y + 3, ] x = y, y + 3, 5 Z Did Dnum [x := y, y + 3, ] x y, y + 3, [x := y, y + 3, ] 5 5 Dabs Dabs Dapp fn x : int int x 5 x, x 5, fn y : int y + 3 y, y + 3, [x := y, y + 3, ] x 5 8 Dapp (fn x : int int => x 5)(fn y : int => y + 3) 8 (f) Hilfsbaum [y := 5] y = 5 Did [y := 5] y 5 D+ Hilfsbaum: 3 Z Dnum [y := 5] = [y := 5] y + 3 8

17 (g) Baum 1: Dabs [y := 4, z := 2] fn x : int x + 5 x, x + 5, [y := 4, z := 2] [y := 4, z := 2]x =? Bez. ungeb. Did y := 4, z := 2 x? D+ [y := 4, z := 2][x :=?] x + 5? Dapp [y := 4, z := 2] (fn x : int x + 5)x Baum 2: D* 5 Z Dnum s. Baum 1 [y := 4, z := 2] 5 5? 5 =? [y := 4, z := 2] ((fn x : int x + 5)x) 5? (h) (x, 1) V [x := 1] 1 Z (y, x, bool, if x then 1 else 2 ) V Did V Dnum [x := 1] x 1 V [x := 1] 1 1 Did (g, x, bool, if x then 1 else 2 ) V V Dtrue y x, bool, if x then 1 else 2 V Diftrue true 1 V [x := 1] if x then 1 else 2 1 Dabs Did Dapp V fn x : bool int y true y, bool int, y true V g x, bool, if x then 1 else 2 ] V [y := x, bool, if x then 1 else 2 ] y true 1 Dapp [g := x, bool, if x then 1 else 2 ] (fn y : bool int y true) g 1

18 18