Question 1 @ 2024-03-12 18:25

If S is a subtype of T, is (Boxof S) a subtype of (Boxof T)?

---

• A Yes, since S can be safely subsituted with T
• B Yes, since T can be safely subsituted with S
• C Yes, since Boxof works the same as Listof
• D No, it’s the other way: (Boxof T) is a subtype of (Boxof S)
• E No, since Boxof is an idempotent multivariadic type constructor
• F No, the type argument of Boxof is both covariant and contravariant
• G No, because S and T are arbitrary independent types

Question 2 @ 2024-03-12 18:28

Consider the following typed definition:

What is the type of (second blah)?

---

• A Number
• B Whatever Typed Racket calls “a small positive integer”
• C (U Number T)
• D (U Number (Rec T (List String (U Number T))))
• E (Rec T (U Number T))
• F It’s a polymorphic type, so impossible to have a specific answer

Question 3 @ 2024-03-12 18:31

You’re given a language that fulfils the following test:

Which of the following is a true statement about this language?

---

• A It cannot be compiled
• B It is dynamically scoped
• C It is Schlac
• D It is Schlac, extended by all of the encodings we’ve seen in class
• E It cannot be a statically typed language (like #lang pl)
• F It is an auto-curried language

Question 4 @ 2024-03-12 18:34

When we discussed extending TOY with a set! expression for mutations, we made it return a bogus value.

What is the advantage of doing this?

---

• A It allows you to chain set! assignments.
• B It allows use of the old value that is overwritten.
• C It allows side effects within an expression.
• D It has less overhead both in the implementation code.
• E It encourages being explicit about return values, resulting in more robust code.
• F It is a better choice for a purely functional language.

Question 5 @ 2024-03-12 18:37

Continuing with the mutation-extended Toy language, what would the following evaluate to, if we make set! return the newly assigned value instead?

---

• 6 6
• 7 7
• 9 9
• 10 10
• 12 12
• 14 14
• SE Syntax error
• RE Runtime error