Start of project write-ups.

Author: dvanhorn

www/project.scrbl

@@ -1,7 +1,136 @@
 #lang scribble/manual
 @(require "defns.rkt")
+@(require "notes/ev.rkt")
+
 @title[#:style '(unnumbered)]{Project}
 
+The final assesment for this course consists of an individually
+completed project.
+
+Final deliverables are due by the end of the time schedule for the
+class's final exam as set by the registrar.
+
+Submissions should be made on Gradescope.
+
+There are several projects to choose from, described below.
+
+@section{Exceptions and Exception Handling}
+
+Exceptions and exception handling mechanisms are widely used in modern
+programming languages.  Implement Racket's @racket[raise] and
+@racket[with-handlers] forms to add exception handling.
+
+You may choose to implement this feature for any language that is
+@seclink["Iniquity"]{Iniquity} or later for a maximum 95% of the
+possible points.  For 100% you'll need to implement the feature for
+Perp and do the additional requirements below.
+
+@subsection{Requirements}
+
+Here are the key features that need to be added:
+
+@itemlist[
+
+@item{@racket[(raise _e)] will evaluate @racket[_e] and then ``raise''
+the value, side-stepping the usual flow of control and instead jump
+to the most recently installed exception handler.}
+
+@item{@racket[(with-handlers ([_p1 _f1] ...) _e)] will install a new
+exception handler during the evaluation of @racket[_e].  If
+@racket[_e] raises an exception that is not caught, the predicates
+should be applied to the raised value until finding the first
+@racket[_pi] that returns true, at which point the corresponding
+function @racket[_fi] is called with the raised value and the result
+of that application is the result of the entire @racket[with-handlers]
+expression.  If @racket[_e] does not raise an error, its value is the
+value of the @racket[with-handler] expression.}
+
+]
+
+Here are some examples to help illustrate:
+
+@ex[
+
+(with-handlers ([string? (λ (s) (cons "got" s))])
+  (raise "a string!"))
+
+(with-handlers ([string? (λ (s) (cons "got" s))]
+                [number? (λ (n) (+ n n))])
+  (raise 10))
+
+(with-handlers ([string? (λ (s) (cons "got" s))]
+                [number? (λ (n) (+ n n))])
+  (+ (raise 10) 30))
+
+(let ((f (λ (x) (raise 10))))
+  (with-handlers ([string? (λ (s) (cons "got" s))]
+                  [number? (λ (n) (+ n n))])
+    (+ (f 10) 30)))
+
+(with-handlers ([string? (λ (s) (cons "got" s))]
+                [number? (λ (n) (+ n n))])
+  'nothing-bad-happens)
+
+(with-handlers ([symbol? (λ (s) (cons 'reraised s))])
+  (with-handlers ([string? (λ (s) (cons "got" s))]
+                  [number? (λ (n) (+ n n))])
+    (raise 'not-handled-by-inner-handler)))
+
+]
+
+Notice that when a value is raised, the enclosing context is discard.
+In the third example, the surrounding @racket[(+ [] 30)] part is
+ignored and instead the raised value @racket[10] is given the
+exception handler predicates, selecting the appropriate handler.
+
+Thinking about the implementation, what this means is that a portion
+of the stack needs to be discarded, namely the area between the
+current top of the stack and the stack that was in place when the
+@racket[with-handlers] expression was evaluated.
+
+This suggestions that a @racket[with-handlers] expression should stash
+away the current value of @racket['rsp].  When a @racket[raise]
+happens, it grabs the stashed away value and installs it as the
+current value of @racket['rsp], effectively rolling back the stack to
+its state at the point the exception handler was installed.  It should
+then jump to code that will carry out the applying of the predicates
+and right-hand-side functions.
+
+Since @racket[with-handler]s can be nested, you will need to maintain
+an arbitrarily large collection of exception handlers, each of which
+has a pointer into the stack and a label for the code to handle the
+exception.  This collection should operate like a stack: each
+@racket[with-handlers] expression adds a new handler to the handler
+stack.  If the body expression returns normally, the top-most handler
+should be removed.  When a raise happens, the top-most handler is
+popped and used.
+
+@subsection{Additional requirements}
+
+To receive full credit, you will to add the above features to Perp and
+do the following.
+
+After you have a working implementation of @racket[raise] and
+@racket[with-handlers], add a structure definition to your standard
+library: @racket[(struct exn:fail (msg cm))].  Rework the compiler so
+that all run-time errors raise an instance of @racket[struct:fail].
+This enables user-programs to handle run-time errors like this:
+
+@ex[
+
+(with-handlers ([exn:fail? (λ (e) 'OK)])
+  (add1 #f))
+
+]
+
+(The @racket[cm] field can be ignored; you can always populate it with
+@racket[#f] if you'd like.  It's there just for consistency with
+Racket's @racket[exn:fail].)
+
+
+
+
+
 There will be a final course project to be completed over the last
 several weeks of the course.  The project will involve extending the
 design and implementation of the programming language and its compiler
@@ -48,13 +177,13 @@ semester:
 
   @item{Typing Loot. We have discussed typing for @tt{Hustle} and its
   implications in the compiler (deleting a whole lot of assertions), as
-  well as typing for a simple lambda calculus. This project would aim
+  well as typing for a simple λ calculus. This project would aim
   to combine the two threads, implementing a type system on top of Loot.
   There are interesting design decisions here, so feel free to reach out
   to talk about them!}
 
   @item{Loot Optimizations. Sky's the limit here. You can try
-  high-level optimizations (e.g. inlining, lambda lifting, dead-code
+  high-level optimizations (e.g. inlining, λ lifting, dead-code
   elimination, partial evaluation, etc.) or low-level ones (register
   allocation, register-based calling conventions etc.). Optimizations
   can be tricky to get right, so make sure you reuse all the unit