PLQ #11

Question 1 @ 2025-04-01 18:40

At some point we’ve seen that we can end up with the wrong scope when we try to implement a lazy language.

How did we address this issue?

Consider the following type definition for VAL from our lazy Sloth language implementation:

(define-type VAL
[RktV Any]
[FunV (Listof Symbol) SLOTH ENV]
[ExprV SLOTH ENV (Boxof (U #f VAL))]
[PrimV ((Listof VAL) -> VAL)])

Is this from the version of Sloth that implements a call by name or a call by need language?

(Choose the best answer.)

A
Call by name, because we look up the value of each ExprV in the environment using its name.
B
Call by name, because the value of each ExprV is recalculated every time it is evaluated.
C
Call by need, because the value of each ExprV is cached after the first time it is evaluated.
D
Call by need, because strict is only called on an ExprV when we need to force it into a proper value.
E
Trick question: this is actually for an implementation of an eager language.
F
Impossible to tell.

Our first Sloth implementation was a “call by name” language, but then we switched to a “call by need” implementation.

Why?

A To avoid lexical redundancy.
B To avoid dynamic redundancy.
C To enable IO and other side-effects.
D To resolve the problem of using dynamic scope.
E To avoid a broken implementation that was mostly lazy but still had some eager cases.
F To avoid redundant errors.

We’ve talked about how a whole class of programming problems become much easier to handle with laziness. What is it?

Remember the type we used in class to represent IO operations in a lazy language:

(define-type IO
[Print String]
[ReadLine (String -> IO)]
[Begin2 IO IO])

Say that we want to add functionality to retrieve the contents of a URL. How should its representation (in the form of another IO variant) look like?

A
A lazy language cannot deal with such functionality, since the web is non-deterministic (even for the same URL).
B
[Fetch String]
C
[Fetch IO (String -> IO)]
D
[Fetch (IO -> String -> IO)]
E
[Fetch String (String -> IO)]
F
[Fetch IO (String -> IO)]