PLQ #5

Question 1 @ 2025-02-11 18:40

Which of the following advantages of dynamic scope is correct?

A
Dynamic scope facilitates easier compilation due to its reliance on the lexical structure of programs.
B
Dynamic scope allows for easy configuration of variables at runtime, making it a perfect fit for Racket and other Lisps.
C
Dynamic scope allows for easy configuration of variables at runtime, making it possible to reuse code in unexpected ways.
D
Dynamic scope ensures that all functions are mutable, leading to a more flexible codebase.
E
Dynamic scope makes recursion easy, but not as much as lexical scope.

Which of the following features can be available in a dynamically-scoped language?

Now that surely you know how lexical scope works, you know that

(let ([x 1] [y 2])
(let ([y x] [x y])
(list x y)))

evaluates to '(2 1).

What would we get if we try that in a dynamically scoped language?

What would the following return when executed in our dynamically-scoped language?

(define (currify f)
(lambda (x) (lambda (y) (f x y))))

(let ([x 3] [y 4])
(((currify +) 1) 2))

3, 5, 7, Unbound-x, Unbound-y, Unbound-f, Infinite-loop

What would the following return when executed in our dynamically-scoped language?

(define x 100)

(define (f x) (+ x 1))

(let ([f (lambda (x) (f x))])
(f 5))

6, 101, Unbound-x, Unbound-f, Infinite-loop

We’ve seen one way to implement a lookup function in a substitution cache:

(define (lookup name sc)
(let ([cell (assq name sc)])
...))

Say that we change that by using

(assq name (reverse sc))

on the second line. Assuming this strategy (actually similar, since it’d need to handle multiple bindings on each level), what would we get for

(let ([x 1] [y 2])
(let ([y x] [x y])
(list x y)))