Question 1 @ 2020-10-20 18:31
What environment diagram do we get when we evaluate the following
Racket code:
(define counter
(let ([n 0])
(lambda ()
(set! n (add1 n))
n)))
?
Question 2 @ 2020-10-20 18:43
For the same code,
(define counter
(let ([n 0])
(lambda ()
(set! n (add1 n))
n)))
what can we learn about Racket when we try this expression:
(list (counter) (counter) (counter) (counter))
?
(Remember to choose the best answer!)
- We can learn whether Racket uses eager evaluation or lazy.
- We can learn whether Racket evaluates its arguments left-to-right
or right-to-left.
- We can learn whether Racket is compiled or interpreted.
- We can learn whether Racket is dynamically-scoped or
lexically-scoped.
- We can learn whether Racket uses dynamic type-checking or static
type-checking.
Question 3 @ 2020-10-20 18:49
Still for the same code, with the experimental expression:
(define counter
(let ([n 0])
(lambda ()
(set! n (add1 n))
n)))
(list (counter) (counter) (counter) (counter))
what would we get if Racket had been dynamically scoped?
- We would get an error about unbound
counter.
- We would get an error about unbound
n.
- We would get an error about a bad type for
counter.
- We would get the list ’(0 0 0 0)
- We would get the list ’(1 1 1 1)
- We would get the list ’(1 2 3 4)
Question 4 @ 2020-10-20 19:20
For a variation of that code:
(define counter
(lambda ()
(let ([n 0])
(lambda ()
(set! n (add1 n))
n))))
(define c1 (counter))
(define c2 (counter))
What would we get from the following experiment
(list (counter) (c1) (c2) (c1) (c1) (c2))
?
- Type error because of the (counter) bit
- It would result in a list similar to: (list (error) 1 1 2 3 2)
- It would result in a list similar to: (list #procedure:blah 1 1 2 3 2)
- It would result in a list similar to: (list (error) 1 2 1 1 2)
- It would result in a list similar to: (list #procedure:blah 1 2 1 1 2)