PLQ #8

Question 1 @ 2024-11-05 18:40

Consider this implementation of a recursive binder:

[(WRec bound-id named-expr bound-body)
(eval bound-body
(Some-Kind-of-Extend bound-id (eval named-expr env) env))]

What’s wrong with it?

A It is perfectly fine.
B It is fine, except for WRec which should be Rec.
C Impossible to tell without knowing how Some-Kind-of-Extend is implemented.
D It will lead to a type error: undefined value
E The named-expr is evaluated too early and with the previous environment.
F It can create an infinite loop.

Say that we enter the following in the Racket REPL:

> (define x (box 'red))
> (define y (box 'green))
> (set-box! x (set-box! y 'blue))
> (unbox x)

What is the result of the last expression?

Say that we enter the following in the Racket REPL:

> (define x (box #f))
> (define y (box #f))
> (set-box! x (set-box! y x))

Does this result in a cyclic structure?

(Reminder: choose the best answer!)

A Yes.
B Yes, x points to y, and vice versa.
C No.
D No, because the computation gets stuck in an infinite loop.
E Impossible to tell, since it depends on whether the language is lazy or eager.

Say that you’re working in a REPL of a Racket-like language, and you have a box value in x:

(define x (box 1))

Consider the following expression:

(list (set-box! x (add1 (unbox x)))
(unbox x))

Based on the result of this expression, you’ll be able to tell whether the language:

A
… evaluates left-to-right or right-to-left.
B
… is eager or lazy.
C
… uses lexical scope or dynamic scope.
D
… returns the new value, the old value, or some useless value as a result of varaible assignment.
E
… returns the new value, the old value, or some useless value as a result of a box mutation.
F
… is statically typed or dynamically typed.

During some random REPL-based hacking of a web page, I entered:

setInterval(() => f(), 1000)

What could be a reason that I used () => f() rather than just f?

Notes:

(Keep in mind that this is in the full Javascript language, equivalent to the full Racket language.)