Merge pull request #21 from dvanhorn/next

Next

Author: dvanhorn

www/notes/extort.scrbl

@@ -21,6 +21,12 @@
 
 @title[#:tag "Extort"]{Extort: when errors exist}
 
+@emph{The greatest mistake is to imagine that we never err.}
+
+@table-of-contents[]
+
+@section{Errors}
+
 We have added multiple, disjoint types, but mostly swept issues of
 errors under the rug by considering type mismatches as meaningless.
 Now let's redesign the semantics to specify the error behavior of such
@@ -119,7 +125,7 @@ The statement of correctness stays the same, but now observe that
 there is no way to crash the interpreter with any @tt{Expr} value.
 
 
-@section{An Example of Extort compilation}
+@section{A Compiler for Extort}
 
 Suppose we want to compile @racket[(add1 #f)], what needs to happen?
 Just as in the interpreter, we need to check the integerness of the

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,32 +1,32 @@
 #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")
 
-;; Expr -> IExpr
-(define (translate e)
-  (translate-e e '()))
+;; type VEnv = (Listof Value)
 
-;; Expr LEnv -> IExpr
-(define (translate-e e r)
+;; Expr -> Answer
+(define (interp e)
+  (interp-env (translate e) '()))
+
+;; IExpr VEnv -> Answer
+(define (interp-env e r)
   (match e
     [(? value? v) v]
     [(list (? prim? p) e)
-     (list p (translate-e e r))]
+     (let ((a (interp-env e r)))
+       (interp-prim p a))]
     [`(if ,e0 ,e1 ,e2)
-     `(if ,(translate-e e0)
-          ,(translate-e e1)
-	  ,(translate-e e2))]
-    [(? symbol? x)
-     (lexical-address x r)]
-    [`(let ((,x ,e0)) ,e1)
-     `(let ((_ ,(translate e0 r)))
-       ,(translate 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 (length r)]
-       [#f (lexical-address x r)])]))
+     (match (interp-env e0 r)
+       ['err 'err]
+       [v
+        (if v
+            (interp-env e1 r)
+            (interp-env e2 r))])]
+    [`(address ,i)
+     (list-ref r i)]
+    [`(let ((_ ,e0)) ,e1)
+     (match (interp-env e0 r)
+       ['err 'err]
+       [v
+        (interp-env e1 (cons v r))])]))

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))])]))