# PLQ #6Done on:   Tuesday, November 3rd

## Question 1 @ 2020-11-03 18:07

What is the result of the following?

(define a (box 'b))
(define b (box 'b))
(list (eq? a b) (equal? a b))

(Reminder: `eq?` is pointer equality, and `equal?` is a recursive structural equality.)

1. (list #t #t)
2. (list #t #f)
3. (list #f #t)
4. (list #f #f)
5. An error, `equal?` of mutable values is nonsensical
6. Infinite loop, due to the cycle of pointers
7. An error, due to the cycle of pointers

## Question 2 @ 2020-11-03 18:10

Why do we use a box when implementing a cyclic data structure?

1. A box’s mutability allows us to continuously extend our data structure such that it behaves cyclically without creating a cycle.

2. A box’s I/O side effect (at least the “O” part) allows us to easily identify when we encounter a cycle.

3. A box’s mutability allows it to ultimately refer to itself via a cycle of pointers.

4. A box is particularly compatible with the “recursive function constructor” (the Y Combinator) which allows us to generate a cyclic data structure with ease.

5. We don’t use a box because it does not allow us to create a cycle of pointers.

6. We can’t use a box because of its lack of subtyping.

## Question 3 @ 2020-11-03 18:14

We have seen in the past Racket’s `let` local binder, and an example that shows how it respects lexical scope:

(let ([x 1] [y 2])
(let ([x y] [y x])
(list 'x= x 'y= y)))
=>
'(x= 2 y= 1)

There is also `let*` which is shorthand for nesting each binding at a time as if it’s in its own `let`:

(let ([x 1] [y 2])
(let* ([x y] [y x])
(list 'x= x 'y= y)))
=>
'(x= 2 y= 2)

And last week we also added `letrec` as a new kind of binder, one that creates a recursive environment. Ignoring types, what would we get from:

(let ([x 1] [y 2])
(letrec ([x y] [y x])
(list 'x= x 'y= y)))

?

1. In this case, it behaves similarly to a `let`, so: ’(x= 2 y= 1)
2. In this case, it behaves similarly to a `let*`, so: ’(x= 2 y= 2)
3. ’(x= 1 y= 1)
4. ’(x= nil y= nil)
5. ’(x= ’y y= ’x)
6. A syntax error since `letrec` should always be used with function expressions (`lambda`s)
7. An evaluation error, since x and y are not initialized before use