Homework #9

CS 341 - Principles of Programming Languages
Homework #9

Due: at the beginning of class 16

Note: This work is to be done in pairs. Each pair will submit one assignment. Although you may divide the work, both team members should be able to present/describe their partner's work upon request.

To submit this homework, change into the directory containing all necessary files: MiniScheme4.jj and supporting abstract syntax tree .java files, and enter the command "submit341 ms4".

MiniScheme Project Phase 4

In this phase of the project, you will extend phase 3 to include lambda expressions and procedure calls.

Notes:

Evaluation of a lambda AST node results in a new "closure" value containing the lambda AST node and the defining environment.
A procedure call results in
1. evaluation of the operator expression,
2. a check to see if the operator expression evaluation returned a closure,
  - If the operator expression evaluated to a non-closure, print "procedure application: expected procedure, given non-procedure" to the error stream and exit with code 7.
3. evaluation of each of the operand expressions left-to-right in the call environment,
4. a check to see if the procedure is given the expected number of operands,
  - If the wrong number of operands is provided, print "procedure expects <m> arguments, given <n>" to the error stream and exit with code 8, where <m> is the number of procedure parameters and <n> is the number of operand expressions
5. creation of a new local environment (extending the environment of the closure) assigning operand values to the procedure parameter variables,
6. evaluation of the procedure body with respect to this new local environment, and
7. return of the final expression value of the body with the surrounding call environment (discarding the local environment).
The eqv? operator is to be extended to call two closures equal if they are the same object in memory.

Grammar

Grammar notes:

Non-terminals are surrounded with angle brackets "<" and ">".
Terminals (e.g. "(" and ")" are represented as themselves without quotes, unless otherwise noted below).
--> denotes a right arrow. Choices to the right of the arrow are separated by a pipe (i.e. "|").
{ }* and { }+ denote a Kleene star and plus/cross, respectively. { }? denotes an optional subexpression.

<program> --> { <definition> | <expression> }*

<definition> --> ( define <variable> <expression> )

<variable> --> <any <identifier> that isn't also a keyword>
<identifier> --> <initial> { <subsequent> }*
<initial> --> [a-z!$%&*/:<=>?^_~]
<subsequent> --> <initial> | <digit> | [+-.@]
<digit> --> [0-9]

<expression> --> <variable>
| <literal>
| <conditional>
| <assignment>
| <derived expression>
| <lambda expression>
| <procedure call>

<literal> --> <integer> | <boolean>
<integer> --> { + | - }? { <digit> }+
<boolean> --> #t | #f

<conditional> --> ( if <expression> <expression> { <expression> }? )

<assignment> --> ( set! <variable> <expression> )

<derived expression> --> ( read )
| ( write <expression> )
| ( newline )
| ( + <expression> <expression> )
| ( - <expression> <expression> )
| ( * <expression> <expression> )
| ( quotient <expression> <expression> )
| ( let ( { <binding spec> }* ) <body> )
| ( and { <expression> }* )
| ( or { <expression> }* )
| ( not <expression> )
| ( eqv? <expression> <expression> )
| ( < <expression> <expression> )
| ( integer? <expression> )
| ( boolean? <expression> )

<binding spec> --> ( <variable> <expression> )
<lambda expression> --> ( lambda ( { <variable> }* ) <body> )
<body> --> { <definition> }* { <expression> }+
<procedure call> --> ( { <expression> }+ )