Update to Fraud.

Author: dvanhorn

www/notes/fraud.scrbl

@@ -20,6 +20,12 @@
 
 @title[#:tag "Fraud"]{Fraud: local binding and variables}
 
+@emph{To be is to be the value of a variable.}
+
+@table-of-contents[]
+
+@section{Variables}
+
 @;defmodule[(file "/Users/dvanhorn/git/cmsc430-www/www/notes/fraud/interp.rkt")]
 @;declare-exporting[(file "/Users/dvanhorn/git/cmsc430-www/www/notes/fraud/interp.rkt")]
 @;defidform/inline[interp]
@@ -373,22 +379,39 @@ address of a variable occurrence is count of variable names that occur
 before it in the list.  When a variable is bound (via-@racket[let])
 the list grows:
 
+@codeblock-include["fraud/translate.rkt"]
+
+Notice that @racket[translate] is a kind of mini-compiler that
+compiles @tt{Expr}s to @tt{IExpr}s.  It's only job is to eliminate
+variable names by replacing variable occurrences with their lexical
+addresses.  It does a minor amount of syntax checking while it's at it
+by raising a (compile-time) error in the case of unbound variables.
+
+The interpreter for @tt{IExpr}s will still have an environment data
+structure, however it will be simpler the association list we started
+with.  The run-time environment will consist only of a list of values;
+the lexical address of (what used to be a) variable indicates the
+position in this list.  When a value is bound by a @racket[let], the
+list grows:
+
 @codeblock-include["fraud/interp-lexical.rkt"]
 
+Try to convince yourself that the two version of @racket[interp]
+compute the same function.
 
 
 @section{An Example of Fraud compilation}
 
-Suppose we want to compile @racket['(let ((x 7)) (add1 x))].  There
-are two new forms we need to compile: the @racket['(let ((x ...))
-...)] part and the @racket['x] part in the body.
+Suppose we want to compile @racket[(let ((x 7)) (add1 x))].  There
+are two new forms we need to compile: the @racket[(let ((x ...))
+...)] part and the @racket[x] part in the body.
 
-We already know how to compile the @racket['(add1 ...)] part and the
+We already know how to compile the @racket[(add1 ...)] part and the
 @racket[7] part.
 
 What needs to happen?  Compiling the @racket[7] part will emit
 instructions that, when run, leave @racket[7] in the @racket['rax]
-register.  Compiling the @racket['(add1 ...)] part relies on the
+register.  Compiling the @racket[(add1 ...)] part relies on the
 result of evaluating it's subexpression to be in @racket['rax] when it
 increments it.  So, compile the variable binding needs to stash the
 @racket[7] somewhere and compiling the variable occurrence needs to
@@ -401,16 +424,16 @@ a let, after the right-hand side has been run, the result should be
 pushed.  When evaluating a variable occurrence, the bound value is on
 the stack.  After exiting the let, the stack can be popped.
 
-Suppose we want to compile @racket['(let ((x 7)) (let ((y 2)) (add1
+Suppose we want to compile @racket[(let ((x 7)) (let ((y 2)) (add1
 x)))].  Using the intuition developed so far, we should push 7, push
 8, and then run the body.  But notice that the value of @racket['x] is
-no longer on the top of the stack; @racket['y] is.  So to retrieve the
-value of @racket['x] we need jump past the @racket['y].  But
-calculating these offsets is pretty straightforward.  In this example
-there is one binding between the binding of @racket['x] and this
-occurrence.  Since we push every time we enter a let and pop every
-time we leave, the number of bindings between an occurrence and its
-binder is exactly the offset from the top of the stack we need use.
+no longer on the top of the stack; @racket[y] is.  So to retrieve the
+value of @racket[x] we need jump past the @racket[y].  But calculating
+these offsets is pretty straightforward.  In this example there is one
+binding between the binding of @racket[x] and this occurrence.  Since
+we push every time we enter a let and pop every time we leave, the
+number of bindings between an occurrence and its binder is exactly the
+offset from the top of the stack we need use.
 
 @filebox-include-fake[codeblock "fraud/asm/ast.rkt"]{
 #lang racket

www/notes/fraud/interp-lexical.rkt

@@ -1,34 +1,14 @@
 #lang racket
 (provide (all-defined-out))
-(require (only-in "interp.rkt" prim? value? interp-prim))
+(require (only-in "interp.rkt" prim? value? interp-prim)
+         "translate.rkt")
 
-;; type LEnv = (Listof Variable)
 ;; type VEnv = (Listof Value)
 
 ;; Expr -> Answer
 (define (interp e)
   (interp-env (translate e) '()))
 
-;; Expr -> IExpr
-(define (translate e)
-  (translate-e e '()))
-
-;; Expr LEnv -> IExpr
-(define (translate-e e r)
-  (match e
-    [(? value? v) v]
-    [(list (? prim? p) e)
-     (list p (translate-e e r))]
-    [`(if ,e0 ,e1 ,e2)
-     `(if ,(translate-e e0)
-          ,(translate-e e1)
-          ,(translate-e e2))]
-    [(? symbol? x)
-     `(address ,(lexical-address x r))]
-    [`(let ((,x ,e0)) ,e1)
-     `(let ((_ ,(translate-e e0 r)))
-       ,(translate-e e1 (cons x r)))]))
-
 ;; IExpr VEnv -> Answer
 (define (interp-env e r)
   (match e
@@ -50,31 +30,3 @@
        ['err 'err]
        [v
         (interp-env e1 (cons v r))])]))
-
-;; Variable LEnv -> Natural
-(define (lexical-address x r)
-  (match r
-    ['() (error "unbound variable")]
-    [(cons y r)
-     (match (symbol=? x y)
-       [#t 0]
-       [#f (add1 (lexical-address x r))])]))
-
-(module+ test
-  (require rackunit)
-  (check-equal? (translate '(let ((x 0)) x))
-                '(let ((_ 0)) (address 0)))
-  (check-equal? (translate '(let ((x 0)) (let ((y 1)) x)))
-                '(let ((_ 0)) (let ((_ 1)) (address 1))))
-  (check-equal? (translate '(let ((x 0)) (let ((y 1)) y)))
-                '(let ((_ 0)) (let ((_ 1)) (address 0))))
-  (check-equal? (translate '(let ((x 0))
-                              (let ((y x))
-                                y)))
-                '(let ((_ 0)) (let ((_ (address 0))) (address 0))))
-
-  (check-equal? (interp 5) 5)
-  (check-equal? (interp '(let ((x 0)) x)) 0)
-  (check-equal? (interp '(let ((x 0)) (let ((y 1)) x))) 0)
-  (check-equal? (interp '(let ((x 0)) (let ((y 1)) y))) 1)
-  (check-equal? (interp '(let ((x 0)) (let ((y x)) y))) 0))

www/notes/fraud/test/interp-lexical.rkt

@@ -0,0 +1,8 @@
+#lang racket
+(require rackunit)
+(require "../interp-lexical.rkt")
+(check-equal? (interp 5) 5)
+(check-equal? (interp '(let ((x 0)) x)) 0)
+(check-equal? (interp '(let ((x 0)) (let ((y 1)) x))) 0)
+(check-equal? (interp '(let ((x 0)) (let ((y 1)) y))) 1)
+(check-equal? (interp '(let ((x 0)) (let ((y x)) y))) 0)

www/notes/fraud/test/translate.rkt

@@ -0,0 +1,15 @@
+#lang racket
+(require "../translate.rkt")
+(require rackunit)
+(check-equal? (translate '(let ((x 0)) x))
+              '(let ((_ 0)) (address 0)))
+(check-equal? (translate '(let ((x 0)) (let ((y 1)) x)))
+              '(let ((_ 0)) (let ((_ 1)) (address 1))))
+(check-equal? (translate '(let ((x 0)) (let ((y 1)) y)))
+              '(let ((_ 0)) (let ((_ 1)) (address 0))))
+(check-equal? (translate '(let ((x 0))
+                            (let ((y x))
+                              y)))
+              '(let ((_ 0))
+                 (let ((_ (address 0)))
+                   (address 0))))

www/notes/fraud/translate.rkt

@@ -0,0 +1,34 @@
+#lang racket
+(provide (all-defined-out))
+(require (only-in "interp.rkt" prim? value? interp-prim))
+
+;; type LEnv = (Listof Variable)
+
+;; Expr -> IExpr
+(define (translate e)
+  (translate-e e '()))
+
+;; Expr LEnv -> IExpr
+(define (translate-e e r)
+  (match e
+    [(? value? v) v]
+    [(list (? prim? p) e)
+     (list p (translate-e e r))]
+    [`(if ,e0 ,e1 ,e2)
+     `(if ,(translate-e e0)
+          ,(translate-e e1)
+          ,(translate-e e2))]
+    [(? symbol? x)
+     `(address ,(lexical-address x r))]
+    [`(let ((,x ,e0)) ,e1)
+     `(let ((_ ,(translate-e e0 r)))
+       ,(translate-e e1 (cons x r)))]))
+
+;; Variable LEnv -> Natural
+(define (lexical-address x r)
+  (match r
+    ['() (error "unbound variable")]
+    [(cons y r)
+     (match (symbol=? x y)
+       [#t 0]
+       [#f (add1 (lexical-address x r))])]))