check

book.tex

@@ -3253,8 +3253,8 @@ integers.
 \]
 \end{minipage}
 }
-\caption{The syntax of $R_2$, extending $R_1$ with Booleans and
-  conditionals.}
+\caption{The syntax of $R_2$, extending $R_1$
+  (Figure~\ref{fig:r1-syntax}) with Booleans and conditionals.}
 \label{fig:r2-syntax}
 \end{figure}
 
@@ -3317,8 +3317,6 @@ short-circuiting behavior in the order of evaluation of its arguments.
           (match v1
             [#t (match (recur e2) [#t #t] [#f #f])]
             [#f #f])]
-         [`(has-type ,e ,t)
-          (recur e)]
          [`(,op ,args ...)
           #:when (set-member? primitives op)
           (apply (interp-op op) (for/list ([e args]) (recur e)))]
@@ -4412,13 +4410,16 @@ $40$, to which we add the $2$, the element at index $0$ of the
   \Type &::=& \gray{\key{Integer} \mid \key{Boolean}}
   \mid (\key{Vector}\;\Type^{+}) \mid \key{Void}\\
   \itm{cmp} &::= & \gray{  \key{eq?} \mid \key{<} \mid \key{<=} \mid \key{>} \mid \key{>=}  } \\
-  \Exp &::=& \gray{  \Int \mid (\key{read}) \mid (\key{-}\;\Exp) \mid (\key{+} \; \Exp\;\Exp)  }  \\
+  \Exp &::=& \gray{  \Int \mid (\key{read}) \mid (\key{-}\;\Exp) \mid (\key{+} \; \Exp\;\Exp) \mid (\key{-}\;\Exp\;\Exp) }  \\
   &\mid&  \gray{  \Var \mid \LET{\Var}{\Exp}{\Exp}  }\\
-  &\mid& \gray{  \key{\#t} \mid \key{\#f}
-    \mid (\key{and}\;\Exp\;\Exp) \mid (\key{not}\;\Exp)  }\\
-  &\mid& \gray{  (\itm{cmp}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp}  } \\
-  &\mid& (\key{vector}\;\Exp^{+}) \mid
-    (\key{vector-ref}\;\Exp\;\Int) \\
+  &\mid& \gray{ \key{\#t} \mid \key{\#f} 
+   \mid (\key{and}\;\Exp\;\Exp) 
+   \mid (\key{or}\;\Exp\;\Exp)
+   \mid (\key{not}\;\Exp) } \\
+  &\mid& \gray{  (\itm{cmp}\;\Exp\;\Exp) 
+   \mid \IF{\Exp}{\Exp}{\Exp}  } \\
+  &\mid& (\key{vector}\;\Exp^{+}) 
+   \mid (\key{vector-ref}\;\Exp\;\Int) \\
   &\mid& (\key{vector-set!}\;\Exp\;\Int\;\Exp)\\
   &\mid& (\key{void}) \\
   R_3 &::=& (\key{program} \; \Exp)
@@ -4426,7 +4427,8 @@ $40$, to which we add the $2$, the element at index $0$ of the
 \]
 \end{minipage}
 }
-\caption{The syntax of $R_3$, extending $R_2$ with tuples.}
+\caption{The syntax of $R_3$, extending $R_2$
+  (Figure~\ref{fig:r2-syntax}) with tuples.}
 \label{fig:r3-syntax}
 \end{figure}
 
@@ -4809,8 +4811,8 @@ succeed.
 \end{lstlisting}
   The parameter \code{rootstack\_ptr} is a pointer to the top of the
   rootstack (which is an array of pointers).  The \code{cheney} function
-  also communicates with \code{collect} through several global
-  variables, the \code{fromspace\_begin} and \code{fromspace\_end}
+  also communicates with \code{collect} through the global
+  variables \code{fromspace\_begin} and \code{fromspace\_end}
   mentioned in Figure~\ref{fig:gc-header} as well as the pointers for
   the ToSpace:
 \begin{lstlisting}
@@ -5469,11 +5471,13 @@ inside each other.
   \Type &::=& \gray{ \key{Integer} \mid \key{Boolean}
          \mid (\key{Vector}\;\Type^{+}) \mid \key{Void}  } \mid (\Type^{*} \; \key{->}\; \Type) \\
 \itm{cmp} &::= & \gray{  \key{eq?} \mid \key{<} \mid \key{<=} \mid \key{>} \mid \key{>=}  } \\
-  \Exp &::=& \gray{ \Int \mid (\key{read}) \mid (\key{-}\;\Exp) \mid (\key{+} \; \Exp\;\Exp)}  \\
-     &\mid&  \gray{ \Var \mid \LET{\Var}{\Exp}{\Exp} }\\
-    &\mid& \gray{ \key{\#t} \mid \key{\#f} \mid
-      (\key{and}\;\Exp\;\Exp) \mid (\key{not}\;\Exp)} \\
-      &\mid& \gray{(\itm{cmp}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp}} \\
+  \Exp &::=& \gray{ \Int \mid (\key{read}) \mid (\key{-}\;\Exp) \mid (\key{+} \; \Exp\;\Exp) \mid (\key{-}\;\Exp\;\Exp)}  \\
+    &\mid&  \gray{ \Var \mid \LET{\Var}{\Exp}{\Exp} }\\
+    &\mid& \gray{ \key{\#t} \mid \key{\#f} 
+    \mid (\key{and}\;\Exp\;\Exp)
+    \mid (\key{or}\;\Exp\;\Exp)
+    \mid (\key{not}\;\Exp)} \\
+   &\mid& \gray{(\itm{cmp}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp}} \\
   &\mid& \gray{(\key{vector}\;\Exp^{+}) \mid
     (\key{vector-ref}\;\Exp\;\Int)} \\
   &\mid& \gray{(\key{vector-set!}\;\Exp\;\Int\;\Exp)\mid (\key{void})} \\
@@ -5484,7 +5488,8 @@ inside each other.
 \]
 \end{minipage}
 }
-\caption{Syntax of $R_4$, extending $R_3$ with functions.}
+\caption{Syntax of $R_4$, extending $R_3$ (Figure~\ref{fig:r3-syntax})
+  with functions.}
 \label{fig:r4-syntax}
 \end{figure}
 
@@ -6392,10 +6397,12 @@ $R_3$).
      \mid (\key{Vector}\;\Type^{+}) \mid \key{Void}
      \mid (\Type^{*} \; \key{->}\; \Type)} \\
   \Exp &::=& \gray{\Int \mid (\key{read}) \mid (\key{-}\;\Exp)
-     \mid (\key{+} \; \Exp\;\Exp)}  \\
-    &\mid&  \gray{\Var \mid \LET{\Var}{\Exp}{\Exp}
-     \mid \key{\#t} \mid \key{\#f} \mid
-           (\key{and}\;\Exp\;\Exp) \mid (\key{not}\;\Exp)} \\
+     \mid (\key{+} \; \Exp\;\Exp) \mid (\key{-} \; \Exp\;\Exp)}  \\
+    &\mid&  \gray{\Var \mid \LET{\Var}{\Exp}{\Exp}}\\
+    &\mid& \gray{\key{\#t} \mid \key{\#f} 
+     \mid (\key{and}\;\Exp\;\Exp) 
+     \mid (\key{or}\;\Exp\;\Exp) 
+     \mid (\key{not}\;\Exp) } \\
     &\mid& \gray{(\key{eq?}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp}} \\
     &\mid& \gray{(\key{vector}\;\Exp^{+}) \mid
           (\key{vector-ref}\;\Exp\;\Int)} \\
@@ -6408,7 +6415,8 @@ $R_3$).
 \]
 \end{minipage}
 }
-\caption{Syntax of $R_5$, extending $R_4$ with \key{lambda}.}
+\caption{Syntax of $R_5$, extending $R_4$ (Figure~\ref{fig:r4-syntax}) 
+  with \key{lambda}.}
 \label{fig:r5-syntax}
 \end{figure}
 
@@ -6772,7 +6780,103 @@ reference results in a run-time contract violation.
    (vector-ref (vector 42) #t)
 \end{lstlisting}
 
-Let us consider how we might compile Racket to x86, thinking about the
+\begin{figure}[tp]
+\centering
+\fbox{
+\begin{minipage}{0.97\textwidth}
+\[
+\begin{array}{rcl}
+  \itm{cmp} &::= & \key{eq?} \mid \key{<} \mid \key{<=} \mid \key{>} \mid \key{>=} \\
+\Exp &::=& \Int \mid (\key{read}) \mid (\key{-}\;\Exp) 
+      \mid (\key{+} \; \Exp\;\Exp) \mid (\key{-} \; \Exp\;\Exp)  \\
+     &\mid&  \Var \mid \LET{\Var}{\Exp}{\Exp} \\
+     &\mid& \key{\#t} \mid \key{\#f} 
+      \mid (\key{and}\;\Exp\;\Exp) 
+      \mid (\key{or}\;\Exp\;\Exp) 
+      \mid (\key{not}\;\Exp) \\
+     &\mid& (\itm{cmp}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp} \\
+     &\mid& (\key{vector}\;\Exp^{+}) \mid
+      (\key{vector-ref}\;\Exp\;\Exp) \\
+     &\mid& (\key{vector-set!}\;\Exp\;\Exp\;\Exp) \mid (\key{void}) \\
+     &\mid& (\Exp \; \Exp^{*}) \mid (\key{lambda}\; (\Var^{*}) \; \Exp) \\
+     & \mid & (\key{boolean?}\;\Exp) \mid (\key{integer?}\;\Exp)\\
+     & \mid & (\key{vector?}\;\Exp) \mid (\key{procedure?}\;\Exp) \mid (\key{void?}\;\Exp) \\
+  \Def &::=& (\key{define}\; (\Var \; \Var^{*}) \; \Exp) \\
+R_7  &::=& (\key{program} \; \Def^{*}\; \Exp)
+\end{array}
+\]
+\end{minipage}
+}
+\caption{Syntax of $R_7$, an untyped language (a subset of Racket).}
+\label{fig:r7-syntax}
+\end{figure}
+
+The syntax of $R_7$, our subset of Racket, is defined in
+Figure~\ref{fig:r7-syntax}.
+%
+The definitional interpreter for $R_7$ is given in
+Figure~\ref{fig:interp-R7}.
+
+\begin{figure}[tbp]
+\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
+(define (get-tagged-type v) (match v [`(tagged ,v1 ,ty) ty]))
+
+(define (valid-op? op) (member op '(+ - and or not)))
+
+(define (interp-r7 env)
+  (lambda (ast)
+    (define recur (interp-r7 env))
+    (match ast
+      [(? symbol?) (lookup ast env)]
+      [(? integer?) `(inject ,ast Integer)]
+      [#t `(inject #t Boolean)]
+      [#f `(inject #f Boolean)]
+      [`(read) `(inject ,(read-fixnum) Integer)]
+      [`(lambda (,xs ...) ,body)
+       `(inject (lambda ,xs ,body ,env) (,@(map (lambda (x) 'Any) xs) -> Any))]
+      [`(define (,f ,xs ...) ,body)
+       (mcons f `(lambda ,xs ,body))]
+      [`(program ,ds ... ,body)
+       (let ([top-level (for/list ([d ds]) ((interp-r7 '()) d))])
+         (for/list ([b top-level])
+           (set-mcdr! b (match (mcdr b)
+                          [`(lambda ,xs ,body)
+                           `(inject (lambda ,xs ,body ,top-level)
+                                    (,@(map (lambda (x) 'Any) xs) -> Any))])))
+         ((interp-r7 top-level) body))]
+      [`(vector ,(app recur elts) ...)
+       (define tys (map get-tagged-type elts))
+       `(inject ,(apply vector elts) (Vector ,@tys))]
+      [`(vector-set! ,(app recur v1) ,n ,(app recur v2))
+         (match v1
+           [`(inject ,vec ,ty)
+             (vector-set! vec n v2)
+            `(inject (void) Void)])]
+      [`(vector-ref ,(app recur v) ,n)
+       (match v [`(inject ,vec ,ty) (vector-ref vec n)])]
+      [`(let ([,x ,(app recur v)]) ,body)
+       ((interp-r7 (cons (cons x v) env)) body)]
+      [`(,op ,es ...) #:when (valid-op? op)
+       (interp-r7-op op (for/list ([e es]) (recur e)))]
+      [`(eq? ,(app recur l) ,(app recur r))
+       `(inject ,(equal? l r) Boolean)]
+      [`(if ,(app recur q) ,t ,f)
+       (match q
+         [`(inject #f Boolean) (recur f)]
+         [else (recur t)])]
+      [`(,(app recur f-val) ,(app recur vs) ...)
+       (match f-val
+         [`(inject (lambda (,xs ...) ,body ,lam-env) ,ty)
+          (define new-env (append (map cons xs vs) lam-env))
+          ((interp-r7 new-env) body)]
+         [else (error "interp-r7, expected function, not" f-val)])])))
+\end{lstlisting}
+\caption{Interpreter for the $R_7$ language. UPDATE ME -Jeremy}
+\label{fig:interp-R7}
+\end{figure}
+
+
+Let us consider how we might compile $R_7$ to x86, thinking about the
 first example above. Our bit-level representation of the Boolean
 \code{\#f} is zero and similarly for the integer \code{0}.  However,
 \code{(not \#f)} should produce \code{\#t} whereas \code{(not 0)}
@@ -6815,9 +6919,10 @@ define in Section~\ref{sec:r6-lang}. The $R_6$ language provides the
 fundamental support for polymorphism and runtime types that we need to
 support dynamic typing.
 
-We shall implement our untyped language $R_7$ by compiling it to
-$R_6$. We define $R_7$ in Section~\ref{sec:r7-lang} and describe the
-compilation of $R_6$ and $R_7$ in the remainder of this chapter.
+We shall implement our untyped language $R_7$ by compiling it to $R_6$
+(Section~\ref{sec:compile-r7}), but first we describe the how to
+extend our compiler to handle the new features of $R_6$
+(Sections~\ref{sec:shrink-r6} and \ref{sec:select-r6}).
 
 \section{The $R_6$ Language: Typed Racket $+$ \key{Any}}
 \label{sec:r6-lang}
@@ -6835,10 +6940,12 @@ compilation of $R_6$ and $R_7$ in the remainder of this chapter.
      \mid (\key{Any}^{*} \; \key{->}\; \key{Any})\\
   \itm{cmp} &::= & \key{eq?} \mid \key{<} \mid \key{<=} \mid \key{>} \mid \key{>=} \\
   \Exp &::=& \gray{\Int \mid (\key{read}) \mid (\key{-}\;\Exp)
-     \mid (\key{+} \; \Exp\;\Exp)}  \\
+     \mid (\key{+} \; \Exp\;\Exp) \mid (\key{-} \; \Exp\;\Exp)}  \\
     &\mid&  \gray{\Var \mid \LET{\Var}{\Exp}{\Exp}} \\
-    &\mid& \gray{\key{\#t} \mid \key{\#f} \mid
-           (\key{and}\;\Exp\;\Exp) \mid (\key{not}\;\Exp)} \\
+    &\mid& \gray{\key{\#t} \mid \key{\#f} 
+     \mid (\key{and}\;\Exp\;\Exp) 
+     \mid (\key{or}\;\Exp\;\Exp) 
+     \mid (\key{not}\;\Exp)} \\
     &\mid& \gray{(\itm{cmp}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp}} \\
     &\mid& \gray{(\key{vector}\;\Exp^{+}) \mid
           (\key{vector-ref}\;\Exp\;\Int)} \\
@@ -6854,7 +6961,8 @@ compilation of $R_6$ and $R_7$ in the remainder of this chapter.
 \]
 \end{minipage}
 }
-\caption{Syntax of $R_6$, extending $R_5$ with \key{Any}.}
+\caption{Syntax of $R_6$, extending $R_5$ (Figure~\ref{fig:r5-syntax})
+  with \key{Any}.}
 \label{fig:r6-syntax}
 \end{figure}
 
@@ -6871,73 +6979,49 @@ $(\key{boolean?}\,e)$ etc., expect a tagged value and return \key{\#t}
 if the tag corresponds to the predicate, and return \key{\#t}
 otherwise.
 %
-The type checker for $R_6$ is given in Figure~\ref{fig:typecheck-R6}.
+Selctions from the type checker for $R_6$ are shown in
+Figure~\ref{fig:typecheck-R6} and the definitional interpreter for
+$R_6$ is in Figure~\ref{fig:interp-R6}.
 
-\begin{figure}[tbp]
+\begin{figure}[btp]
 \begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
-(define type-predicates
-  (set 'boolean? 'integer? 'vector? 'procedure?))
-
 (define (typecheck-R6 env)
   (lambda (e)
     (define recur (typecheck-R6 env))
     (match e
-       [`(inject ,(app recur new-e e-ty) ,ty)
+       [`(inject ,e ,ty)
+        (define-values (new-e e-ty) (recur e))
         (cond
          [(equal? e-ty ty)
           (values `(inject ,new-e ,ty) 'Any)]
          [else
           (error "inject expected ~a to have type ~a" e ty)])]
-       [`(project ,(app recur new-e e-ty) ,ty)
+       [`(project ,e ,ty)
+        (define-values (new-e e-ty) (recur e))
         (cond
          [(equal? e-ty 'Any)
           (values `(project ,new-e ,ty) ty)]
          [else
           (error "project expected ~a to have type Any" e)])]
-       [`(,pred ,e) #:when (set-member? type-predicates pred)
+       [`(vector-ref ,e ,i)
         (define-values (new-e e-ty) (recur e))
-        (cond
-         [(equal? e-ty 'Any)
-          (values `(,pred ,new-e) 'Boolean)]
-         [else
-          (error "predicate expected arg of type Any, not" e-ty)])]
-       [`(vector-ref ,(app recur e t) ,i)
-        (match t
+        (match e-ty
           [`(Vector ,ts ...) ...]
-          [`(Vectorof ,t)
+          [`(Vectorof ,ty)
            (unless (exact-nonnegative-integer? i)
              (error 'type-check "invalid index ~a" i))
-           (values `(vector-ref ,e ,i) t)]
-          [else (error "expected a vector in vector-ref, not" t)])]
-       [`(vector-set! ,(app recur e-vec t-vec) ,i
-                       ,(app recur e-arg t-arg))
-        (match t-vec
-          [`(Vector ,ts ...) ...]
-          [`(Vectorof ,t)
-           (unless (exact-nonnegative-integer? i)
-             (error 'type-check "invalid index ~a" i))
-           (unless (equal? t t-arg)
-             (error 'type-check "type mismatch in vector-set! ~a ~a"
-                    t t-arg))
-           (values `(vector-set! ,e-vec ,i ,e-arg) 'Void)]
-          [else (error 'type-check
-                       "expected a vector in vector-set!, not ~a"
-                       t-vec)])]
+           (values `(vector-ref ,new-e ,i) ty)]
+          [else (error "expected a vector in vector-ref, not" e-ty)])]
         ...
       )))
 \end{lstlisting}
-\caption{Type checker for the $R_6$ language.}
+\caption{Type checker for parts of the $R_6$ language.}
 \label{fig:typecheck-R6}
 \end{figure}
 
 % to do: add rules for vector-ref, etc. for Vectorof
-
-
 %Also, \key{eq?} is extended to operate on values of type \key{Any}.
 
-Figure~\ref{fig:interp-R6} shows the definitional interpreter
-for $R_6$.
-
 \begin{figure}[tbp]
 \begin{lstlisting}
 (define primitives (set 'boolean? ...))
@@ -6973,101 +7057,8 @@ for $R_6$.
 
 \clearpage
 
-\section{The $R_7$ Language: Untyped Racket}
-\label{sec:r7-lang}
-
-\begin{figure}[tp]
-\centering
-\fbox{
-\begin{minipage}{0.97\textwidth}
-\[
-\begin{array}{rcl}
-  \itm{cmp} &::= & \key{eq?} \mid \key{<} \mid \key{<=} \mid \key{>} \mid \key{>=} \\
-\Exp &::=& \Int \mid (\key{read}) \mid (\key{-}\;\Exp) \mid (\key{+} \; \Exp\;\Exp)  \\
-     &\mid&  \Var \mid \LET{\Var}{\Exp}{\Exp} \\
-     &\mid& \key{\#t} \mid \key{\#f} \mid
-      (\key{and}\;\Exp\;\Exp) \mid (\key{not}\;\Exp) \\
-     &\mid& (\itm{cmp}\;\Exp\;\Exp) \mid \IF{\Exp}{\Exp}{\Exp} \\
-     &\mid& (\key{vector}\;\Exp^{+}) \mid
-      (\key{vector-ref}\;\Exp\;\Exp) \\
-     &\mid& (\key{vector-set!}\;\Exp\;\Exp\;\Exp) \mid (\key{void}) \\
-     &\mid& (\Exp \; \Exp^{*}) \mid (\key{lambda}\; (\Var^{*}) \; \Exp) \\
-     & \mid & (\key{boolean?}\;\Exp) \mid (\key{integer?}\;\Exp)\\
-     & \mid & (\key{vector?}\;\Exp) \mid (\key{procedure?}\;\Exp) \mid (\key{void?}\;\Exp) \\
-  \Def &::=& (\key{define}\; (\Var \; \Var^{*}) \; \Exp) \\
-R_7  &::=& (\key{program} \; \Def^{*}\; \Exp)
-\end{array}
-\]
-\end{minipage}
-}
-\caption{Syntax of $R_7$, an untyped language (a subset of Racket).}
-\label{fig:r7-syntax}
-\end{figure}
-
-The syntax of $R_7$, our subset of Racket, is defined in
-Figure~\ref{fig:r7-syntax}.
-%
-The definitional interpreter for $R_7$ is given in
-Figure~\ref{fig:interp-R7}.
-
-\begin{figure}[tbp]
-\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
-(define (get-tagged-type v) (match v [`(tagged ,v1 ,ty) ty]))
-
-(define (valid-op? op) (member op '(+ - and or not)))
-
-(define (interp-r7 env)
-  (lambda (ast)
-    (define recur (interp-r7 env))
-    (match ast
-      [(? symbol?) (lookup ast env)]
-      [(? integer?) `(inject ,ast Integer)]
-      [#t `(inject #t Boolean)]
-      [#f `(inject #f Boolean)]
-      [`(read) `(inject ,(read-fixnum) Integer)]
-      [`(lambda (,xs ...) ,body)
-       `(inject (lambda ,xs ,body ,env) (,@(map (lambda (x) 'Any) xs) -> Any))]
-      [`(define (,f ,xs ...) ,body)
-       (mcons f `(lambda ,xs ,body))]
-      [`(program ,ds ... ,body)
-       (let ([top-level (for/list ([d ds]) ((interp-r7 '()) d))])
-         (for/list ([b top-level])
-           (set-mcdr! b (match (mcdr b)
-                          [`(lambda ,xs ,body)
-                           `(inject (lambda ,xs ,body ,top-level)
-                                    (,@(map (lambda (x) 'Any) xs) -> Any))])))
-         ((interp-r7 top-level) body))]
-      [`(vector ,(app recur elts) ...)
-       (define tys (map get-tagged-type elts))
-       `(inject ,(apply vector elts) (Vector ,@tys))]
-      [`(vector-set! ,(app recur v1) ,n ,(app recur v2))
-         (match v1
-           [`(inject ,vec ,ty)
-             (vector-set! vec n v2)
-            `(inject (void) Void)])]
-      [`(vector-ref ,(app recur v) ,n)
-       (match v [`(inject ,vec ,ty) (vector-ref vec n)])]
-      [`(let ([,x ,(app recur v)]) ,body)
-       ((interp-r7 (cons (cons x v) env)) body)]
-      [`(,op ,es ...) #:when (valid-op? op)
-       (interp-r7-op op (for/list ([e es]) (recur e)))]
-      [`(eq? ,(app recur l) ,(app recur r))
-       `(inject ,(equal? l r) Boolean)]
-      [`(if ,(app recur q) ,t ,f)
-       (match q
-         [`(inject #f Boolean) (recur f)]
-         [else (recur t)])]
-      [`(,(app recur f-val) ,(app recur vs) ...)
-       (match f-val
-         [`(inject (lambda (,xs ...) ,body ,lam-env) ,ty)
-          (define new-env (append (map cons xs vs) lam-env))
-          ((interp-r7 new-env) body)]
-         [else (error "interp-r7, expected function, not" f-val)])])))
-\end{lstlisting}
-\caption{Interpreter for the $R_7$ language. UPDATE ME -Jeremy}
-\label{fig:interp-R7}
-\end{figure}
-
+%\section{The $R_7$ Language: Untyped Racket}
+%\label{sec:r7-lang}
 
 
 %% \section{Compiling $R_6$}