Question 1 @ 2024-02-27 18:33

When using a recursive binder like letrec or our rec, what is the advantage of restricting its usage to binding only function values?

---

• A

  None, letrec (or rec) should be used on all functions.

• B

  None, it’s just an idiomatic requirement to bind all functions recursively.

• C

  The evaluator can assume that the binding is recursive, avoiding the need for more code when it isn’t.

• D

  It increases efficiency to know in advance that the value is a function.

• E

  When evaluating a fun expression, the body is evaluated first, therefore avoiding infinite loops.

• F

  When evaluating a fun expression, there is no evaluation of the body, so self references there would be safe.

Question 2 @ 2024-02-27 18:35

Is there ever any use for a non-function form in a named expression in a recursive letrec / rec binder?

---

• A

  It could be used when a function value is contained in an expression rather than being the whole expression.

• B

  Some recursive value definitions are useful too, like an AST type that is defined in terms of itself.

• C

  It’s useful when a function is made in a way other than a lambda / fun expression, as in currying or using H.O. functions like compose.

• D

  No – restricting recursive binders to function forms don’t affect what you can do with the language.

Question 3 @ 2024-02-27 18:38

Is there ever any reason to use a plain let for a function value?

(Or with, or even an internal define in idiomatic Racket)

---

• A

  Since function bodies are not evaluated immediately, there is never any difference between let and letrec.

• B

  When there’s no need for a recursive function, let makes it possible to compile function calls more efficiently.

• C

  It’s useful to use let when we want to implement the Y combinator itself.

• D

  It can be used to “wrap” functions in a local part of the code.

• E

  It is a bad idea since it can lead to name shadowing.

Question 4 @ 2024-02-27 18:40

Here is a verbose implementation of a xor function in Schlac:

What would be valid simplification of it?

---

• A (define xor (lambda (a b) (a (b a b) b)))
• B (define xor (lambda (a b) (a (b b a) (b a b))))
• C (define xor (lambda (a b) (a (not b) b)))
• D (define xor (lambda (a b) (a b #f)))
• E There is no way to simplify the above expression.

Question 5 @ 2024-02-27 18:43

What does (#t #f #t 1 2) reduce to using our Schlac encodings?

---

• t #t
• f #f
• 1 1
• 2 2
• E1 Error, since we never defined #t or #f in our encodings
• E2 Error, since booleans are strict and always require an if
• E3 Error, since we passed too many arguments to a function
• E4 Error, since we call a non-function value

Question 6 @ 2024-02-27 18:46

What is the core need for a practical implementation of recursion?

---

• A

  An environment that can point to itself.

• B

  An environment that can be mutated instead of extended.

• C

  Using Racket’s letrec.

• D

  Using local definitions in function bodies.