Page History

...

1.  (40 pts.) Write an evaluator for arithmetic expressions as follows:
   • Write the (function) template for ArithExpr

   • Write a function to-list that maps an ArithExpr to the corresponding "list" representation in Racket. Numbers are unchanged. Some other examples include:

     Code Block
     (to-list 21) => 21 (to-list (make-sum (make-prod 4 7) 25)) => '(+ (* 4 7) 25) (to-list (make-quot (make-diff 4 7) 25)) => '(/ (- 4 7) 25)

     Notes:

     1. The notation  '(+ (* 4 7) 25) abbreviates  (list '+ (list '* 4 7) 25).

     2. You need to define the output type (named RacketExpr) for this function, but you can omit the template because this assignment does not include any functions that process this type.  There are several mathematically distinct definitions that are correct.  Some are more restrictive (narrower) than others but all are correct.  In general, narrow definitions are better because they imply stronger claims about the elements of the type.

     3. The notation  '(+ (* 4 7) 25) abbreviates  (list '+ (list '* 4 7) 25).

   • Write a function eval: ArithExpr -> number that evaluates an ArithExpr. Your evaluator should produce exactly the same result for an ArithExpr E that Racket evaluation would produce for the list representation  (to-list E).
     
     
2.  (40 pts.) Extend the definition of ArithExpr as follows:
   • Add a clause for variables represented as Racket symbols.
   • Write the (function) template for this extended definition; it should be similar to your template for ArithExpr from Problem 1.
   • Modify your definition of to-list to support the expanded definition of ArithExpr.

   • Given the Racket structure definition:

     Code Block
     (define-structure binding (var val))

     a binding is (make-binding s n) where s is a symbol and n is a number.  An environment is a (list-of binding).  Write a (function) template instantiation for processing an environment.

   • Define a top-level variable empty-env that is bound to the empty environment containing no bindings (i.e., the empty list).  Note that empty-env is really a constant since variables cannot be re-bound in our functional subset of Racket.

   • Write a function extend that takes environment env, a symbol s, and a number n , and returns an extended environment identical to env except that it adds the additional binding of s to n (as the most local [inner] binding).
     The definition of extend is trivial; it requires no recursion. As a result, extend satisfies the invariant

     Code Block
     (check-expect (extend empty-env s n) (list (make-binding s n)))

     where s is any symbol and n is any number.  Hence,

     Code Block
     (extend empty-env 'a 4) => (list (make-binding 'a 4))

     In the remainder of the problem, use empty-env and extend to define example environments for test cases.

   • Write a function lookup that takes a symbol s and an environment env and returns the first binding in env with a var component that equals s. If no match is found, lookup returns empty. Note that the return type of lookup is not simply binding because it can return empty. Define the new union type called option-binding for the return type.  You do not need to write a template for this type since it is a trivial union type.

   • Write a new eval function for the expanded definition of ArithExpr. The new eval takes two arguments: an ArithExpr E to evaluate and an environment envspecifying the values of free variables in E. For example,

     Code Block
     (eval 'x (extend empty-env 'x 17)) => 17 (eval (make-prod 4 7) (extend empty-env 'x 17)) = 28 (eval 'y (extend empty-env 'x 17)) => some form of run-time error

     If an ArithExpr E contains a free variable that is not bound in the environment env , then (eval E env) will naturally produce some form of run-time error if you have correctly coded eval. Do not explicitly test for this form of error since the behavioral contract for eval says nothing about detecting errors.

3.  (20 pts.) An environment is really a finite function (a finite set of ordered pairs).  It is finite in the sense that it can be completely defined by a finite table, which is not true of nearly all the primitive and library functions in Racket (and other programming languages). Even the identity function is not finite. For the purpose of this exercise, we redefine the type environment as (symbol -> option-binding) which includes infinite objects (since symbol is infinite).
   
   • Rewrite eval to use environment defined as the type (symbol -> option-binding) instead of as a (list-of option-binding).  If you cleanly coded your definition of eval in the preceding problem using lookup, make-binding, and extend, all that you have to do to your solution to the previous problem is redefine the bindings of lookup, empty-env, and extend, and revise your test cases for extend. You can literally copy the entire text of your solution to problem 2; change the definitions of lookup, empty-env, and extend ; update your documentation (annotations) concerning the environment type; and revise your tests for extend. Note that extend cannot be directly tested (since the result is a function!) but we can write indirect tests by using lookup to examine it. (Note: if you wrote a correct solution to problem 2, you can do this problem in less than 15 minutes!)
     Hint: you can use lambda-notation in Racket to define a constant function for empty-env, and extend can be defined as a functional that takes a function (representing an environment) and adds a new pair to the function--using an if embedded inside a lambda-abstraction.
4. Extra Credit  (50 pts.)  Add support for lambda-abstractions in your evaluator from Problem 2 as follows:
   • Extend the definition of ArithExpr by adding a clause for unary lambda-abstractions and a clause for unary applications of an ArithExpr (which can be a function!) to an ArithExpr. Use the name lam for the structure representing a lambda-abstraction and the names var and body for the accessors of this structure. Use the name app for the structure representing a unary application and the names rator and rand for the argument of this structure. Note that the rator of an app is an ArithExpr not a lam (which is a proper subtype of ArithExpr).
   • Write a template for this additional expansion of the definition of ArithExpr.
   • Extend the definition of to-list to support this expansion of the definition of ArithExpr. You print the corresponding "concrete" syntax that would be given as input to a compiler.  Hence,
          (to-list (make-lam 'x (make-plus 'x 'y))) => (list 'lambda (list 'x) '(+ x y)) = '(lambda (x) (+ x y))
   • Extend the definition of eval to support this expansion of ArithExpr. Note that eval can now return functions as well as numbers. Your biggest challenge is determining a good representation for function values. What does eval return as the value of a lam input?  That input may contain free variables. In principle, you could represent the value of the lam input by a revised lam (with no free variables) obtained by substituting the values for free variables from the environment input (just like we do in hand-evaluation). But this approach is tedious and computationally expensive. A better strategy is to define a structure type (called a closure) to represent a function value. The structure type must contain the original lam and a description of what substitution (of values for identifiersfree variables) would have been made, deferring the actual substitution just as eval defers substitutions by maintaining an environment.  For this problem, you can use brute force to describe the substitution, which makes constructing and applying closures nearly trivial to code.  In practice, there are much more computationally efficient approaches.