SUMMARY OF ASSIGNMENT.

In this assignment you will make some modifications to the interpreter for L3. The interpreter has already been modified slightly for convenience. In particular, the annoying need for "dummy" variables to assign to, in order to return a value from a procedure, has been removed. Many of the commands have a "block" as a component, and where a block used to have a list of commands, it now allows both commands and expressions. This cleans up a bunch of examples.L3 has been updated with syntax for some new commands and expressions:

"for" loops, mutable pairs, and a "fluid let" construct. These will be further explained in the questions. Your job is to write evaluator clauses for these additions.

You should start by carefully reading *all* the supplied code *except* for the parser. The new L3 data type clauses have been indicated with a comment, but a few other parts have been changed a bit for your convenience in doing this assignment.

There are 3 equally-weighted questions. Each question describes the L3 addition you need to update the evaluator for. To make sure you've done everything, check that there are no more occurrences of "undefined" in this file. Test data can be found at the end of this file.

QUESTION 1. Standard "for" loops. Example:

r=1 n=5:
for i=1,n by 1 do r := *(i,r) end;
print(r)

computes n factorial for n=5. The "by" part say how much to increment i by each time through the loop. The "by" can be omitted if it's 1 as in this example. Note: i can be assigned to in the body of the loop, but any such value should be ignored at the start of each iteration.

QUESTION 2. "Fluid let." This is a command of the form

flet x = e

in b

where e is an expression and b is a block (bindings + commands). It is very different from the familiar "let". The variable x must *already* have a binding. The body b of the flet is evaluated in the same environment as the flet itself, i.e. a new reference is *not* created for x. Right at the start of evaluation of b, x's reference is updated to be the value of e. Right after the evaluation of b, x's reference is restored to the value it had at the start.

QUESTION 3. Mutable pairs (as in Lisp/Scheme). These are pairs that can have their components destructively modified. Pairs are created using "(,)", accessed using fst and snd, and destructively modified using setfst and setsnd. Example:

t = ( (0,1), (2,3) ):
print(t);
setfst(snd(t), 4);
print(t)

prints

((0, 1), (2, 3))
((0, 1), (4, 3))

The update for pairs to the type EVal indicates how such pairs should be implemented. Note that you will also need to update applyPrimitive for fst and snd. There is also a "null" constant added to L3 so that pairs can be used to represent lists (null is like nil or []).

Attachment:- assignment.rar