EECS 321 Programming Languages: Homework 5

Due: Friday, February 20th, 2015, noon

Part 0 – Deferred Substitution

Start with the interpreter that uses deferred substitution for this assignment (see the lecture notes).

Here is the grammar that your parser should accept:

 FAE ::= {+ FAE FAE}
       | {- FAE FAE}
       | number
       | {with {ID FAE} FAE}
       | ID
       | {if0 FAE FAE FAE}
       | {fun {x x ...} FAE}
       | {FAE FAE FAE ...} ;; application expressions

Part 1 – Shorthands

Add with to the parser for the FAE language, according to this rule:

Add multiple argument functions to the parser for the FAE language, according to these rules:

Part 2 – Conditionals, again

Add if0 to your interpreter with the same syntax as homework 4 but, unlike homework 4, you must be careful that the test position can be any value at all, not just a number. If the test position is a procedure, it is treated the same as any other non-0 value (i.e., it is not an error; it takes the false branch).

Part 3 – Errors

There are three different kinds of errors that can occur (at runtime) in this language and for each error in the input program, your interpreter must signal an error that includes one of the following phrases:

free identifier
application expected procedure
numeric operation expected number

Note that each operation in the language that evaluates its sub-expressions immediately must evaluate them from left to write and must evaluate all of them before checking any error conditions. For example:

(test/exn (interp-expr (parse `{+ {fun {x} x}
                                  {1 2}}))
          "application expected procedure")

Part 4 – Numbers as functions

It is possible to represent numbers using functions. One way to do this is to represent

0 as	{fun {f} {fun {x} x}}
1 as	{fun {f} {fun {x} {f x}}}
2 as	{fun {f} {fun {x} {f {f x}}}}
3 as	{fun {f} {fun {x} {f {f {f x}}}}},

etc. In general the number N is represented as a function that accepts a function and returns a new function that iterates the original N times. Each of these functions has the type (X -> X) -> (X -> X). That is, if you pass in a function that consumes and produces objects of the same shape, then it returns to you a function that calls the input N times, to represent the number N. (Note that the functions don't have to have exactly that notation to represent numbers; they just have to behave as the ones above do.)

Write an FAE function that converts a natural number in the above representation into a number in the normal representation called f-to-n and write a FAE program that converts back, called n-to-f. The n-to-f function does not have to be well-defined if it gets a negative number (or a rational or complex, etc); that is, you can assume it is called only with natural numbers.

For example,

{with {n-to-f ...}
  {with {f-to-n ...}
    {f-to-n {n-to-f 4}}}}
 => 4

Part 5 – Addition and multiplication

Write the FAE functions plus and timesthat accept two numbers in the above representation and add/multiply them together. Neither of these FAE function can (indirectly or directly) use FAE's + or - operation (i.e., you cannot use n-to-f from part 4 and then add the numbers and call f-to-n).

For example,

{with {n-to-f ...}
  {with {f-to-n ...}
    {with {plus ...}
      {with {times ...}
        {f-to-n {plus {n-to-f 2} {n-to-f 3}}}}}}}
 => 5

{f-to-n {plus {n-to-f 0} {n-to-f 0}}} => 0
{f-to-n {plus {n-to-f 2} {n-to-f 0}}} => 2
{f-to-n {plus {n-to-f 0} {n-to-f 2}}} => 2
{f-to-n {times {n-to-f 1} {n-to-f 0}}} => 0
{f-to-n {times {n-to-f 0} {n-to-f 1}}} => 0
{f-to-n {times {n-to-f 3} {n-to-f 4}}} => 12

Part N – Handin instructions

The final program you handin should use this precise define-type definition for FAE.

(define-type FAE
  [num (n number?)]
  [add (lhs FAE?) (rhs FAE?)]
  [sub (lhs FAE?) (rhs FAE?)]
  [id (name symbol?)]
  [if0 (test FAE?) (then FAE?) (else FAE?)]
  [fun (param symbol?) (body FAE?)]
  [app (fun FAE?) (arg FAE?)])

Provide a definition of interp-expr : FAE -> number or 'procedure, as above. Note that interp-expr is a wrapper function around your main, recursive interpreter. It translates whatever you decide to use for your representation of values into either a number, or the symbol 'procedure. For example, these test cases should pass:

(test (interp-expr (num 10)) 10)
(test (interp-expr (fun 'x (id 'x))) 'procedure)

Provide a definition of parse : sexpression -> FAE, as above.

Bind your definitions of n-to-f, f-to-n, plus, and times to PLAI-level definitions of the same name, e.g.,

(define n-to-f `{fun {n} ...})
(define f-to-n `{fun {f} ...})
(define plus `{fun {f1 f2} ...})
(define times `{fun {f1 f2} ...})