Question 1 @ 2024-10-22 18:31

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:

---

• GFGF (G (F (G (F …))))
• FGFG (F (G (F (G …))))
• GFFF (G (F (F (F …))))
• FGGG (F (G (G (G …))))
• Inf It’s an infinite loop anyway, so it doesn’t matter

Question 2 @ 2024-10-22 18:35

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 Avoids 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 3 @ 2024-10-22 18:36

Are the following two definitions of Y valid and equivalent?

---

• A Yes.
• B Yes, only if we’re using an eager language.
• C Yes, only if we’re using an lazy language.
• D They’re equivalent, but wrong.
• E They’re equivalent, but wrong: both will loop infinitely.

Question 4 @ 2024-10-22 18:39

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