PLQ #7Done on:   Tuesday, March 8th

Question 1 @ 2022-03-08 18:56

In Schlac, using our definitions and encoded values, what does the following code block evaluate to?

---

• 1
  It evaluates both results in parallel, giving us just 15 from the second branch.
• 2
  It evaluates to the encoded value of 15; since Schlac is a lazy language.
• 3
  It would never terminate, since evaluating the omega-combinator results in an infinite loop.
• 4
  It’s a syntax error: a curried language means that we would need to use ((* 3) 5) as the second expression.
• 5
  This is not a valid Church encoding.

Question 2 @ 2022-03-08 18:59

Which of the following is the combinator version of the Church encoding for the cdr function?

---

• 1
  (lambda (a b) (a b a))
• 2
  (lambda (x) (x (lambda (x y) x)))
• 3
  (lambda (x) (x (lambda (x y) y)))
• 4
  (lambda (x y) (lambda (s) (s x y)))
• 5
  (lambda (n) (lambda (f x) (f (n f x))))
• 6
  (lambda (x) (x x))

Question 3 @ 2022-03-08 19:01

In class, we briefly discussed the difference the functionality of bind and and bind* from HW#8. What would the following code snippet evaluate to?

---

• 1
  1
• 2
  2
• 3
  3
• 4
  Unbound identifier
• 5
  None of the above

Question 4 @ 2022-03-08 19:04

How can the following Racket code be fixed so that we actually get the factorial of 4?

---

• 1
  It already work fine!
• 2
  We need to repeat the binding at least 4 times.
• 3
  Do nothing; dynamic scoping would make recursion immediately available.
• 4
  Replace the let with a letrec.
• 5
  Replace the let with a let*.
• 6
  We must define it as a locally recursive function, otherwise it won’t work.

Question 5 @ 2022-03-08 19:07

In class last week, we briefly discussed letrec and its differences from let* and let. Which of the following answers is true about our extended FLANG language that has a proper rec recursive binder with no tricks and no Y combinator complexity?

---

• 1
  The implementation requires code with side effects.
• 2
  Recursive subtype declarations are needed to make it work.
• 3
  {rec {x E1} E2} is equivalent to {call {fun {x} E2} E1}.
• 4
  The environment must be functional so it can refer to itself.
• 5
  The evaluator must be lazy.
• 6
  We no longer need environments for the implementation.