Prenumele, numele s, i grupa:

Programare declarativaExamen scris

24 ianuarie 2015

1. (3 puncte) Date structurate (DATA-IMP)

(a) (11/2 puncte) (Sub)Tipuri. Calculat, i s, i demonstrat, i tipul pentru expresia:
(fun (x : {p:{q: int }}) > x.p.q) {a = 3; p = {q = 2; r = 7}}

Rezolvare
(0,1p/prima folosire a unei reguli; 0,05p pentru urmatoarele)
` fun (x : {p : {q : int}}) x.p.q : {p : {q : int}} int
` {a = 3; p = {q = 2; r = 7}} : {p : {q : int}}
(tApp)
` (fun (x : {p : {q : int}}) x.p.q){a = 3; p = {q = 2; r = 7}} : int

(tVar)
x
:
{p
:
{q
:
int}}
`
x : {p : {q : int}}
(tField)
x : {p : {q : int}} ` x.p : {q : int}
(tField)
x : {p : {q : int}} ` x.p.q : int
(tFun)
` fun (x : {p : {q : int}}) x.p.q : {p : {q : int}} int


(tInt)
(tInt)

`
2
:
int
`
7
: int
(tInt)
(tRecord)
` 3 : int
` {q = 2; r = 7} : {q : int; r : int}
(tRecord)
` {a = 3; p = {q = 2; r = 7}} : {a : int; p : {q : int; r : int}}
(subSUM)
` {a = 3; p = {q = 2; r = 7}} : {p : {q : int}}
{a : int; p : {q : int; r : int}} <: {a : int; p : {q : int}} {a : int; p : {q : int}} <: {p : {q : int}}
(sTran)
{a : int; p : {q : int; r : int}} <: {p : {q : int}}


(sRefl)
(sRecordWidth)
int <: int
{q : int; r : int} <: {q : int}
(sRecordDepth)
{a : int; p : {q : int; r : int}} <: {a : int; p : {q : int}}


(sRecordOrder)
(sRecordWidth)
{a : int; p : {q : int}} <: {p : {q : int}; a : int}
{p : {q : int}; a : int} <: {p : {q : int}}
(sTran)
{a : int; p : {q : int}} <: {p : {q : int}}
(b) (11/2 puncte) Scriet, i arborii de demonstrat, ie pentru primii 4 pas, i din execut, ia expresiei
let x = ref ref 5 in !x := !! x + 1

Rezolvare

n starea init, iala .

(0,2p/prima folosire a unei reguli; 0,15p pentru urmatoarele)


href 5, i
hl0 , {l0 7 5}i
(RefS)
href ref 5, i
href l0 , {l0 7 5}i
(LetS)
hlet x = ref ref 5 in !x :=!!x + 1, i
hlet x = ref l0 in !x :=!!x + 1, {l0 7 5}i

(Ref)
href l0 , {l0 7 5}i
hl1 , {l0 7 5, l1 7 l0 }i
(LetS)
hlet x = ref l0 in !x :=!!x + 1, {l0 7 5}i
hlet x = l1 in !x :=!!x + 1, {l0 7 5, l1 7 l0 }i

(Let)
hlet x = l1 in !x :=!!x + 1, {l0 7 5, l1 7 l0 }i
h!l1 :=!!l1 + 1, {l0 7 5, l1 7 l0 }i

(Loc)
h!l1 , {l0 7 5, l1 7 l0 }i
hl0 , {l0 7 5, l1 7 l0 }i
(AtribS)
h!l1 :=!!l1 + 1, {l0 7 5, l1 7 l0 }i
hl0 :=!!l1 + 1, {l0 7 5, l1 7 l0 }i
(Ref)

2. (3 puncte) IMP+FOR. Vrem sa adaugam instruct, iunea for la limbajul IMP, cu sintaxa
for (e1 ; e2 ; e3 ) e
unde: e1 este o instruct, iune (de init, ializare) care se executa nainte de intrarea n ciclu;
e2 este condit, ia de continuare a ciclului; e3 este o instruct, iune care se executa la finalul
fiecarui ciclu; iar e este corpul ciclului. Semantica intuitiva este:
Se executa e1 , apoi ct t, imp e2 este adevarata, se executa e urmat de e3 .
(a) (1 punct) Semantica. Scriet, i regulile de deduct, ie pentru execut, ia programelor cu for
Rezolvare
Folosind while (1p):
(For)

hfor (e1 ; e2 ; e3 ) e, si
he1 ; while e2 do e ; e3 done, si

Sau direct (0,5p/regula):

(ForS)
(For)

he1 , si
he01 , s0 i
hfor (e1 ; e2 ; e3 ) e, si
hfor (e01 ; e2 ; e3 ) e, s0 i

hfor (() ; e2 ; e3 ) e, si
hif e2 then (e ; e3 ; for (() ; e2 ; e3 ) e) else (()), si
(b) (1 punct) Tipuri. Scriet, i regulile de tipuri pentru for
Rezolvare
(tFor)

` e1 : unit ` e2 : bool ` e3 : unit ` e : unit

` for (e1 ; e2 ; e3 ) e : unit

(c) (1 punct) Sigurant, a . Aratat, i ca IMP+FOR are proprietatea de conservare a tipurilor.

Reamintirea ideii de demonstrat, ie (nu trebuia scrisa):
Fie P proprietatea definita de
de f

P(he, si
he0 , s0 i) = , T.
` e : T Dom() Dom(s) = ` e0 : T Dom() Dom(s0 )
Demonstram ca P e adevarata pentru ntreg sistemul de tranzit, ie asociat semanticii
IMP+FOR prin induct, ie asupra definit, iei sistemului de tranzit, ie.
Pentru regulile lui IMP, demonstrat, ia e aceeas, i. Demonstram pentru regula For de mai
sus:
(For)

hfor (e1 ; e2 ; e3 ) e, si
he1 ; while e2 do e ; e3 done, si

Rezolvare
(Explicitarea ipotezei: 0,1p/ipoteza) Fie , T astfel nct ` for (e1 ; e2 ; e3 ) e : T s, i Dom Dom s.
(Deducerea tipurilor pentru subexpresii s, i a tipului T: 0,1p/subexpresie sau T) Deoarece tFor e singura regula care se poate
aplica, deducem ca ` e1 : unit, ` e2 : bool, ` e3 : unit, ` e : unit s, i T =unit.
(Derivarea tipului rezultat: 0,1p/regula folosita) Demonstram concluzia:
` e : unit ` e3 : unit
` e ; e3 : unit
` e1 : unit (tWhile)
` while e2 do e ; e3 done : unit
` e1 ; while e2 do e ; e3 done : unit
` e2 : bool

(tSecv)

(tSecv)

3. (3 puncte) Funct, ii
(a) (1 punct) Variabile. Subliniat, i aparit, iile libere s, i indicat, i legatura fiecarei aparit, ii
legate printr-o sageata catre parametrul care o leaga pentru expresiile:
fun (x : int) (fun (x : int) x + (fun (y : int) x + y) y) z + x
let x = x + 1 in let y = x + y in y
let rec x : int = x + 1 in let y = x + y in y + x
Barem:

1
p
15

pe variabila corect identificata

(b) (1 punct) Tipuri. Calculat, i s, i demonstrat, i tipul expresiei:

fun (x: int ) > (fun (x:bool) > if x then 1 else 0) (0 <= x)

Rezolvare
(tFun)
(tApp)
(tFun)

(tVar)
(tIf)

(0,15p pentru prima folosire a unei reguli; 0,025p pentru urmatoarele)

x : bool ` if x then 1 else 0 : int

x : int ` 0 <= x : bool
x : int ` fun (x :bool) if x then 1 else 0 : bool int
x : int ` (fun (x :bool) if x then 1 else 0) (0 <= x) : int
` fun (x : int) (fun (x :bool) if x then 1 else 0) (0 <= x) : intint


(tInt)
(tInt)
x : bool ` x : bool
x : bool ` 1 : int
x : bool ` if x then 1 else 0 : int
(tInt)
(tOp)


x : bool ` 0 : int



(tVar)
x : bool ` 0 : int
x : bool ` x : bool
x : int ` 0 <= x : bool

(c) (1 punct) Evaluare. Efectuat, i primii 4 pas, i din evaluarea non-stricta a expresiei.
Pentru fiecare pas indicat, i pe sageata axioma folosita. Daca e necesara redenumirea
variabilelor, scriet, i acest lucru ca un pas adit, ional.
let x = 3 in let x = (x + x) + y in let y = x + x in y + y

0,2p pe tranzit, ie; 0,2p -echivalent, a

Rezolvare
let x = 3 in let x = (x + x) + y in let y = x + x in y + y
NSLet

let x = (3 + 3) + y in let y = x + x in y + y

let x = (3 + 3) + y in let z = x + x in z + z

NSLet

let z = ((3 + 3) + y) + ((3 + 3) + y) in z + z

NSLet

(((3 + 3) + y) + ((3 + 3) + y)) + (((3 + 3) + y) + ((3 + 3) + y))

Op+

(((6) + y) + ((3 + 3) + y)) + (((3 + 3) + y) + ((3 + 3) + y))

Ciorna