PLQ #6Done on:   Tuesday, February 21st

Question 1 @ 2023-02-21 18:53

You’re running into a situation where a language that you need to implement is very different from the language you’re implementing it in.

What kind of evaluator would you likely implement for this language?

---

• A
  Syntactic evaluator
• B
  Meta evaluator
• C
  Meta-circular evaluator
• D
  Can go either way
• E
  None of the above

Question 2 @ 2023-02-21 18:59

We’ve seen how the core of the Y combinator leads to an inifinte nesting of calls to F:

What would we get if we’d change it to:

---

• 1
  (G (F (G (F ...))))
• 2
  (F (G (F (G ...))))
• 3
  (G (F (F (F ...))))
• 4
  (F (G (G (G ...))))
• 5
  It’s an infinite loop anyway, so it doesn’t matter

Question 3 @ 2023-02-21 19:02

Are the following two definitions of Y valid and equivalent?

---

• 1
  Yes.
• 2
  Yes, only if we’re using an eager language.
• 3
  Yes, only if we’re using an lazy language.
• 4
  They’re equivalent, but wrong.
• 5
  They’re equivalent, but wrong: both will loop infinitely.

Question 4 @ 2023-02-21 19:05

Why do we need “protection” when writing our Y combinator?

---

• A
  Without it we get a free identifier instead of a recursive reference.
• B
  Avoids the problem of laziness.
• C
  Infinite loops due to eager evaluation.
• D
  Enables substitution when using lexical scope.
• E
  The Y combinator does not need protection.
• F
  Avoids losing recursive references when switching from dynamic to lexical scope.

Question 5 @ 2023-02-21 19:07

Which of these is NOT a combinator?

---

• 1
  (lambda (x) (x x))
• 2
  (lambda (x) (lambda (y) (x x)))
• 3
  (lambda (x) (lambda (y) ((x x) y)))
• 4
  (Y (lambda (x) (lambda (y) ((x x) y))))
• A
  All of the above are combinators.
• N
  None of the above are combinators.