Interpreter 6: Define and Lambda

This is a "pair" assignment, which means that you and your partner should use the pair programming model. You should be physically together, sharing a computer and both looking at the same screen.

Each partner has an active role to play during pair programming - please review the instructions on Moodle about pair programming, and make sure you understand what you should be doing when you are the navigator and when you are the driver. You should make sure that over the course of an assignment that you each spend roughly the same amount of time "driving." My recommendation is to set a timer and switch drivers every 10-15 minute.

For the interpreter project, you are permitted to do a limited amount of debugging separate from your partner. If you do this, you should be sure that you're each contributing similar amounts: it's not fair, either in terms of time or in terms of learning, if one person does all the debugging. Before debuggging on your own, make sure that your partner is onboard with that. Also, make sure to share what you found with your partner afterwards.

If pair programming in real-time just doesn't work for you and your partner, then you will need to amicably split up and work individually. If you choose this option, you must communicate that to me [Anna] and send me an email with a zip file containing the code checkpoint of any work you did together (if applicable).

If things are not going well with working with your partner or you find yourselves tempted to split up the work, please talk to me. While doing a limited amount of debugging separately is fine, you should be doing the initial design and coding together - if you or your partner cannot explain how part of your interpreter works, then you have not followed the pair programming policies for this class.

Download the folder with the starter code from the link below. Like for previous homeworks, unzip the folder and move it to where you'd like: most likely the folder for the Docker container. Then get started in VS Code.

If when running tests you run into a permissions error, you can fix this by running the following code in the terminal:

chmod a+x test-e test-m

This tells the computer that all users should be permitted to execute (run) the files test-e and test-m.

Click here to download the starter file

For this phase of the project, you must support the correct evaluation of the following types of Scheme expressions:

In addition to eval as described above, you will need to implement function application. To do this, create a function called apply:

SchemeItem *apply(SchemeItem *function, SchemeItem *args);

You should call this function after you've evaluated the function and the arguments. Here, function is a user-defined function (i.e., a closure). apply should apply the given function to the (already-evaluated) args by creating a new frame with the appropriate parent, binding the formal parameter(s) to these actual parameters, and then evaluating all bodies of the function sequentially, returning the result of evaluating the final body.

Note that you may need to handle binding the parameters slightly differently for the two versions of lambda described above.

Here's my new eval skeleton, modified to support function application:

SchemeItem *eval(SchemeItem *tree, Frame *frame) {
   switch (tree->type)  {
     case INT_TYPE: {
        ...
        break;
     }
     case ......: {
        ...
        break;
     }
     case SYMBOL_TYPE: {
        ... //Code to implement what should happen if we have a symbol
        break;
     }
     case CONS_TYPE: {
        SchemeItem *first = car(expr);
        SchemeItem *args = cdr(expr);

        // Some error checking here (omitted from sample code) before moving to cases

        if (!strcmp(first->s,"if")) {
            result = evalIf(args, frame);
        }

        // .. other special forms here...

        else {
           // User-defined functions get evaluated here - you'll be filling in this else!
           ...
        }
        break;
      }

      ....
    }    
    ....
}

When displaying a result, if an s-expression evaluates to a function, you should just output <#procedure>. Here is an example:

$ cat test-in-02.scm
(lambda (x) x)
$ ./interpreter < test-in-02.scm
#<procedure>

The files follow the same structure that they have for the previous assignments. The only change in the files I'm providing is the change to add a Closure structure and a VOID_TYPE to schemeitem.h, as described above. You'll then need to add in the files from your previous version, and/or switch over to using our binaries. But note that the binaries I provide only go through part 4 of the project; I am not providing a working if/let/quote interpreter. (The project gets too intermingled at this point for me to be able to supply complete partial work.)

Building and testing your code will work precisely the same as on the previous assignment.