Final Exam

CS 320, Spring 2017

Student id: Name:

Instructions: You have 180 minutes to complete this closed-book, closed-note, closed-computer exam. Please
write all answers in the provided space. Korean students should write your answers in Korean.

1) (4pts) Summarize what you learned from this course in one sentence.

2) (6pts) Write what you learned from the following video lectures in one sentence each.
– “Growing a Language”

– “Journey to Find Bugs in JavaScript Web Applications in the Wild”

3) (5pts) Suppose a garbage-collected interepreter uses the following five kinds of records:

– Tag 1: a record containing two pointers

– Tag 2: a record containing one pointer and one integer
– Tag 3: a record containing one integer
– Tag 4: a record containing one integer and one pointer
– Tag 99: forwarding pointer (to to-space)

The interpreter has one register, which always contains a pointer, and a memory pool of size 26. The
allocator/collector is a two-space copying collector, so each space is of size 13. Records are allocated
consecutively in to-space, starting from the first memory location, 0.
The following is a snapshot of memory just before a collection where all memory has been allocated:

– Register: 8
– From space: 1 3 8 3 0 4 7 3 2 0 8 3 42

What are the values in the register, the from-space, and the to-space after collection? Assume that
unallocated memory in to-space contains 0.

– Register:

– From space:

– To space:

1
4) (10pts) The Swift programming language uses the reference counting garbage collection algorithm.

a) What is the correct order?

(ㄱ) When a count is decremented to 0, decrement counts for other records referenced by the
record, then free it
(ㄴ) When replacing a pointer to a record, decrement its count
(ㄷ) Attatch a count to every record, starting at 0
(ㄹ) When installing a pointer to a record, increment its count

b) Provide an example that shows why the order matters.

c) Describe good and bad things about the reference counting algorithm.

2
5) (5pts) The following web servlet implementation (main handler plus helper function) uses web-read,
which takes only a prompt and uses let/cc internally to obtain a continuation. Note that course-handler
gets the course tree information from a user starting from "CS101" to recommended courses until un-
known courses, and it shows the course tree via the show-tree function.

(define (web-read prompt)

(let/cc cont
(local [(define key (remember cont))]
(error ’web-read "~a; to continue, call resume with ~a and value" prompt key))))
(define (resume key val)
(local [(define cont (lookup key))]
(cont val)))
(define table empty)
(define (remember v)
(local [(define n (length table))]
(begin
(set! table (append table (list v)))
n)))
(define (lookup key) (list-ref table key))

(define (course-handler)
(show-tree (get-course "CS101")))
(define (get-course from)
(local [(define to (web-read from))]
(if (equal? to "unknown")
"???"
(list to
(get-course (format "first course after ~a" to))
(get-course (format "second course after ~a" to))))))
(define (show-tree t) t)

(course-handler)

a) (2pts) What is the result of evaluating the code?

b) (3pts) What is the final result of evaluating the following series of calls?
(resume 0 "CS109")
(resume 1 "CS206")
(resume 2 "unknown")
(resume 3 "unknown")
(resume 4 "CS220")
(resume 5 "unknown")
(resume 6 "unknown")

3
6) (5pts) What is the evaluation result of the following code?

(define table empty)

(define (remember v)
(local [(define n (length table))]
(begin (set! table (append table (list v)))
n)))
(define (lookup key) (list-ref table key))

(define (web-read prompt)

(let/cc cont
(local [(define key (remember cont))]
(error ’web-read "~a; to continue, call resume with ~a and value" prompt key))))

(define (web-read-each prompts)

(map web-read prompts))

(define (m)
(apply format "my ~a saw a ~a rock" (web-read-each ‘("noun" "adjective"))))

(m)

7) (5pts) Consider the following partial implementation of the compile function:

; compile : FAE CDefrdSub -> CFAE

(define (compile fae ds)
(type-case FAE fae
...
[id (name) (cid (locate name ds))]
[fun (param body)
(cfun (compile body (aCSub param ds)))]
...))

(define (locate name ds)

(type-case CDefrdSub ds
[mtCSub () (error ’locate "free variable")]
[aCSub (sub-name rest-ds)
(if (symbol=? sub-name name)
0
(+ 1 (locate name rest-ds)))]))

What is the result of calling the compile function with the following expression:
{{{{fun {x} {fun {y} {fun {z} {+ x {+ y z}}}}} 8} 42} 320}

4
8) (5pts) Fill in the following “type unification” algorithm. Write clearly whether the case “succeeds,”
“fails,” or “unifies types.”

Unify a type variable T with a type τ2:

– If T is set to τ1, _____________________________________.
– If τ2 is already equivalent to T, _________________________.
– If τ2 contains T, ____________________________________.
– Otherwise, ________________________________________.
Unify a type τ1 to type τ2:
– If τ2 is a type variable T, ______________________________.
– If τ1 and τ2 are both num or bool, succeed.
– If τ1 is (τ3 → τ4) and τ2 is (τ5 → τ6), then
∗ unify τ3 with τ5
∗ unify τ4 with τ6

5
9) (10pts) Consider the following language:

p ::= m∗ e program consists of 0 or more function declarations followed by an expression

m ::= fun f (x : τ ) = e function declaration
e ::= n number v ::= n number
| b boolean | b boolean
| e+e addition τ ::= num type of numbers
| not e negation | bool type of booleans
| x identifier
| f e function application
x∈ Id f ∈ FunctionName
n∈ Number b ∈ Boolean
v∈ Val σ ∈ Id → Val

The language supports multiple function declarations with the same name. The static and dynamic
semantics of the language are as follows:

∅ ` n : num ∅ ` b : bool

noDuplicate(m∗ ) m∗ , ∅ ` e ⇒ v
∗
m∗ , σ ` n ⇒ n m∗ , σ ` b ⇒ b
∅`m e⇒v

m∗ , σ ` e1 ⇒ v1 m ∗ , σ ` e 2 ⇒ v2 m∗ , σ ` e ⇒ b x ∈ Dom(σ)
m∗ , σ ` e1 + e2 ⇒ v1 + v2 m∗ , σ ` not e ⇒ ¬b ∗
m , σ ` x ⇒ σ(x)

findDecl (m∗ , f ) = {fun f (x1 : τ1 ) = e1 , · · · , fun f (xn : τn ) = en }

m∗ , σ ` e ⇒ v ∅`v:τ τ = τi m∗ , [xi 7→ v] ` ei ⇒ v 0
m∗ , σ ` f e ⇒ v 0

where noDuplicate(m∗ ) checks that any two function declarations in m∗ have either different names or
different parameter types, and findDecl (m∗ , f ) returns a set of all the function declarations among m∗
of the name f .
Draw the semantics derivation of the following program:

fun f(x: num) = g x

fun g(y: bool) = not y
fun g(z: num) = z + 42
f 8

6
7
10) (5pts) Rewrite the following code using explicit annotation of polymorphic types with tyfun and @ to
replace all the occurrences of ? with types and to make function calls to take explicit type arguments.

Γ[α] ` e : τ Γ ` τ0 Γ ` e : (∀α τ1 )
Γ ` [tyfun [α] e] : (∀α τ ) Γ ` [@ e τ0 ] : τ1 [α ← τ0 ]

Γ[α] ` τ
[. . . α . . .] ` α
Γ ` (∀α τ )

{with {f : ? {fun {g : ?} {fun {v : ?} {g v}}}}

{with {g : ? {fun {x : ?} x}}
{{f g} 10}}}

8
11) (10pts) Given the following grammar:

e ::= n number
| x identifier
| e+e addition of two numbers
| ref e location construction with a given initial value
| !e dereferencing
| e := e assignment evaluating the right-hand side (RHS) first, producing the value of RHS
| e;e sequencing
| let x = e in e name binding
v ::= n number
| l location
τ ::= num type of numbers
| ref τ type of locations that contain values of type τ

x∈ Id
l∈ Loc
v∈ Val
σ∈ Id → Loc
M∈ Loc → Val

a) (5pts) Write the operational semantics of the form σ, M ` e ⇒ v, M for the expressions.

9
b) (5pts) Write the typing rules of the form Γ ` e : τ for the expressions. Assignments should not
change the types of the values at a given location.

10
12) (10pts) Given the following grammar and the partial typing rules:

e ::= n
| b x:σ∈Γ στ
| {seqn e e} Γ`x:τ
| x
| {fun {x} e} Γ[x : τ ] ` e : τ 0
| {e e} Γ ` {fun {x} e} : (τ → τ 0 )
| {with {x e} e}
τ ::= num Γ ` e1 : (τ → τ 0 ) Γ ` e2 : τ
| bool Γ ` {e1 e2 } : τ 0
| (τ -> τ )
| α Γ ` e1 : τ Γ[x : Gen Γ (τ )] ` e2 : τ 0
σ ::= τ Γ ` {with {x e1 } e2 } : τ 0
| (∀α σ)

στ iff σ = (∀α1 (· · · (∀αn τ0 )) · · · ) ∧ τ = τ0 [αi ← τi ] where 1 ≤ i ≤ n

Gen Γ (τ ) = (∀α1 (· · · (∀αn τ )) · · · ) where {α1 , · · · , αn } = FTV (τ ) \ FTV (Γ)

FTV (num) = ∅
FTV ((τ1 → τ2 )) = FTV (τ1 ) ∪ FTV (τ2 )
FTV (α) = {α}
S
FTV (Γ) = x:σ∈Γ FTV (σ)
FTV ((∀α σ)) = FTV (σ) \ {α}

a) Draw the type derivation of the following expression:

{with {x {fun {z} z}} {seqn {x 42} {x true}}}

11
b) Draw the type derivation of the following expression:
{{fun {x} {seqn {x 42} {x true}}} {fun {z} z}}

12
13) (20pts) We’d like to allow the following expression:

{withtype {{alpha list} {empty num}

{cons (alpha * {alpha list})}}
{rec {len : (forall alpha ({alpha list} -> num))
[tyfun [alpha]
{fun {l : {alpha list}}
{cases {alpha list} l
{empty {n} 0}
{cons {fxr}
{+ 1 {len {snd fxr}}}}}}]}
{+ {[@ len num] {[@ cons num] {pair 1 {[@ empty num] 0}}}}
{[@ len (num -> num)] {[@ empty (num -> num)] 0}}}}}

and of course the following as well:

{withtype {fruit {banana num} {apple bool}}

{{fun {x : fruit} {cases fruit x {banana {n} {+ n 9}} {apple {b} 76}}}
{banana 2}}}

a) (5pts) Define the language syntax.

13
b) (4pts) Write the operational semantics of the form σ ` e ⇒ v for the expressions withtype,
cases, and applications.

c) (6pts) Write the typing rules of the form Γ ` e : τ for the expressions withtype and cases and
the well-formedness of the types.

14
d) (5pts) Consider the following expression:

{withtype {fruit {apple num} {banana num}}

{{withtype {color {apple num} {banana num}}
{fun {x : fruit}
{cases fruit x
{apple {a} {apple {+ a 1}}}
{banana {b} {banana {+ b 1}}}}}}
{apple 42}}}
If the result of type checking the expression is fruit, explain why in detail. Otherwise, revise the
typing rules to make it fruit.

15