Index: doc/theses/andrew_beach_MMath/features.tex
===================================================================
--- doc/theses/andrew_beach_MMath/features.tex	(revision 93d0ed361f29a474f7f865ef1d42b3bde741dda9)
+++ doc/theses/andrew_beach_MMath/features.tex	(revision f42a6b855873c132f4969475fb95578812619238)
@@ -16,43 +16,35 @@
 throw/catch as a particular kind of raise/handle.
 These are the two parts that the user writes and may
-be the only two pieces of the EHM that have any syntax in a language.
+be the only two pieces of the EHM that have any syntax in the language.
 
 \paragraph{Raise}
-The raise is the starting point for exception handling
-by raising an exception, which passes it to
+The raise is the starting point for exception handling. It marks the beginning
+of exception handling by raising an exception, which passes it to
 the EHM.
 
 Some well known examples include the @throw@ statements of \Cpp and Java and
-the \code{Python}{raise} statement of Python. In real systems, a raise may
-perform some other work (such as memory management) but for the
+the \code{Python}{raise} statement from Python. In real systems a raise may
+preform some other work (such as memory management) but for the
 purposes of this overview that can be ignored.
 
 \paragraph{Handle}
-The primary purpose of an EHM is to run some user code to handle a raised
-exception. This code is given, with some other information, in a handler.
+The purpose of most exception operations is to run some user code to handle
+that exception. This code is given, with some other information, in a handler.
 
 A handler has three common features: the previously mentioned user code, a
-region of code it guards, and an exception label/condition that matches
-the raised exception.
+region of code they guard and an exception label/condition that matches
+certain exceptions.
 Only raises inside the guarded region and raising exceptions that match the
 label can be handled by a given handler.
 If multiple handlers could can handle an exception,
-EHMs define a rule to pick one, such as ``best match" or ``first found".
+EHMs will define a rule to pick one, such as ``best match" or ``first found".
 
 The @try@ statements of \Cpp, Java and Python are common examples. All three
-show the common features of guarded region, raise, matching and handler.
-\begin{cfa}
-try {				// guarded region
-	...	 
-	throw exception;	// raise
-	...	 
-} catch( exception ) {	// matching condition, with exception label
-	...				// handler code
-}
-\end{cfa}
+also show another common feature of handlers, they are grouped by the guarded
+region.
 
 \subsection{Propagation}
 After an exception is raised comes what is usually the biggest step for the
-EHM: finding and setting up the handler for execution. The propagation from raise to
+EHM: finding and setting up the handler. The propagation from raise to
 handler can be broken up into three different tasks: searching for a handler,
 matching against the handler and installing the handler.
@@ -60,6 +52,6 @@
 \paragraph{Searching}
 The EHM begins by searching for handlers that might be used to handle
-the exception. The search is restricted to
-handlers that have the raise site in their guarded
+the exception. Searching is usually independent of the exception that was
+thrown as it looks for handlers that have the raise site in their guarded
 region.
 The search includes handlers in the current function, as well as any in
@@ -67,13 +59,14 @@
 
 \paragraph{Matching}
-Each handler found is matched with the raised exception. The exception
-label defines a condition that is used with the exception and decides if
+Each handler found has to be matched with the raised exception. The exception
+label defines a condition that is used with exception and decides if
 there is a match or not.
+
 In languages where the first match is used, this step is intertwined with
-searching; a match check is performed immediately after the search finds
-a handler.
+searching; a match check is preformed immediately after the search finds
+a possible handler.
 
 \paragraph{Installing}
-After a handler is chosen, it must be made ready to run.
+After a handler is chosen it must be made ready to run.
 The implementation can vary widely to fit with the rest of the
 design of the EHM. The installation step might be trivial or it could be
@@ -82,8 +75,8 @@
 
 If a matching handler is not guaranteed to be found, the EHM needs a
-different course of action for this case.
+different course of action for the case where no handler matches.
 This situation only occurs with unchecked exceptions as checked exceptions
-(such as in Java) are guaranteed to find a matching handler.
-The unhandled action is usually very general, such as aborting the program.
+(such as in Java) can make the guarantee.
+This unhandled action is usually very general, such as aborting the program.
 
 \paragraph{Hierarchy}
@@ -92,16 +85,17 @@
 exception hierarchy is a natural extension of the object hierarchy.
 
-Consider the following exception hierarchy:
+Consider the following hierarchy of exceptions:
 \begin{center}
 \input{exception-hierarchy}
 \end{center}
+
 A handler labeled with any given exception can handle exceptions of that
 type or any child type of that exception. The root of the exception hierarchy
-(here \code{C}{exception}) acts as a catch-all, leaf types catch single types,
+(here \code{C}{exception}) acts as a catch-all, leaf types catch single types
 and the exceptions in the middle can be used to catch different groups of
 related exceptions.
 
 This system has some notable advantages, such as multiple levels of grouping,
-the ability for libraries to add new exception types, and the isolation
+the ability for libraries to add new exception types and the isolation
 between different sub-hierarchies.
 This design is used in \CFA even though it is not a object-orientated
@@ -116,5 +110,5 @@
 is usually set up to do most of the work.
 
-The EHM can return control to many different places, where
+The EHM can return control to many different places,
 the most common are after the handler definition (termination)
 and after the raise (resumption).
@@ -123,24 +117,24 @@
 For effective exception handling, additional information is often passed
 from the raise to the handler and back again.
-So far, only communication of the exception's identity is covered.
-A common communication method for passing more information is putting fields into the exception instance
+So far only communication of the exceptions' identity has been covered.
+A common communication method is putting fields into the exception instance
 and giving the handler access to them.
-Using reference fields pointing to data at the raise location allows data to be
+Passing the exception by reference instead of by value can allow data to be
 passed in both directions.
 
 \section{Virtuals}
-\label{s:Virtuals}
 Virtual types and casts are not part of \CFA's EHM nor are they required for
-an EHM.
-However, one of the best ways to support an exception hierarchy
+any EHM.
+However, it is one of the best ways to support an exception hierarchy
 is via a virtual hierarchy and dispatch system.
-Ideally, the virtual system should have been part of \CFA before the work
+
+Ideally, the virtual system would have been part of \CFA before the work
 on exception handling began, but unfortunately it was not.
 Hence, only the features and framework needed for the EHM were
-designed and implemented for this thesis. Other features were considered to ensure that
+designed and implemented. Other features were considered to ensure that
 the structure could accommodate other desirable features in the future
-but are not implemented.
-The rest of this section only discusses the implemented subset of the
-virtual-system design.
+but they were not implemented.
+The rest of this section will only discuss the implemented subset of the
+virtual system design.
 
 The virtual system supports multiple ``trees" of types. Each tree is
@@ -149,37 +143,13 @@
 number of children.
 Any type that belongs to any of these trees is called a virtual type.
-For example, the following hypothetical syntax creates two virtual-type trees.
-\begin{flushleft}
-\lstDeleteShortInline@
-\begin{tabular}{@{\hspace{20pt}}l@{\hspace{20pt}}l}
-\begin{cfa}
-vtype V0, V1(V0), V2(V0);
-vtype W0, W1(W0), W2(W1);
-\end{cfa}
-&
-\raisebox{-0.6\totalheight}{\input{vtable}}
-\end{tabular}
-\lstMakeShortInline@
-\end{flushleft}
+
 % A type's ancestors are its parent and its parent's ancestors.
 % The root type has no ancestors.
 % A type's descendants are its children and its children's descendants.
-Every virtual type (tree node) has a pointer to a virtual table with a unique
-@Id@ and a list of virtual members (see \autoref{s:VirtualSystem} for
-details). Children inherit their parent's list of virtual members but may add
-and/or replace members.  For example,
-\begin{cfa}
-vtable W0 | { int ?<?( int, int ); int ?+?( int, int ); }
-vtable W1 | { int ?+?( int, int ); int w, int ?-?( int, int ); }
-\end{cfa}
-creates a virtual table for @W0@ initialized with the matching @<@ and @+@
-operations visible at this declaration context.  Similarly, @W1@ is initialized
-with @<@ from inheritance with @W0@, @+@ is replaced, and @-@ is added, where
-both operations are matched at this declaration context. It is important to
-note that these are virtual members, not virtual methods of object-orientated
-programming, and can be of any type. Finally, trait names can be used to
-specify the list of virtual members.
-
-\PAB{Need to look at these when done.
+
+Every virtual type also has a list of virtual members. Children inherit
+their parent's list of virtual members but may add new members to it.
+It is important to note that these are virtual members, not virtual methods
+of object-orientated programming, and can be of any type.
 
 \CFA still supports virtual methods as a special case of virtual members.
@@ -189,25 +159,29 @@
 as if it were a method.
 \todo{Clarify (with an example) virtual methods.}
-}%
+
+Each virtual type has a unique id.
+This id and all the virtual members are combined
+into a virtual table type. Each virtual type has a pointer to a virtual table
+as a hidden field.
+\todo{Might need a diagram for virtual structure.}
 
 Up until this point the virtual system is similar to ones found in
-object-orientated languages but this is where \CFA diverges. Objects encapsulate a
-single set of methods in each type, universally across the entire program,
-and indeed all programs that use that type definition. Even if a type inherits and adds methods, it still encapsulate a
-single set of methods. In this sense,
-object-oriented types are ``closed" and cannot be altered.
-
-In \CFA, types do not encapsulate any code. Traits are local for each function and
-types can satisfy a local trait, stop satisfying it or, satisfy the same
-trait in a different way at any lexical location in the program where a function is call.
-In this sense, the set of functions/variables that satisfy a trait for a type is ``open" as the set can change at every call site.
+object-orientated languages but this where \CFA diverges. Objects encapsulate a
+single set of behaviours in each type, universally across the entire program,
+and indeed all programs that use that type definition. In this sense, the
+types are ``closed" and cannot be altered.
+
+In \CFA, types do not encapsulate any behaviour. Traits are local and
+types can begin to satisfy a trait, stop satisfying a trait or satisfy the same
+trait in a different way at any lexical location in the program.
+In this sense, they are ``open" as they can change at any time.
 This capability means it is impossible to pick a single set of functions
-that represent a type's implementation across a program.
+that represent the type's implementation across the program.
 
 \CFA side-steps this issue by not having a single virtual table for each
 type. A user can define virtual tables that are filled in at their
 declaration and given a name. Anywhere that name is visible, even if it is
-defined locally inside a function \PAB{What does this mean? (although that means it does not have a
-static lifetime)}, it can be used.
+defined locally inside a function (although that means it does not have a
+static lifetime), it can be used.
 Specifically, a virtual type is ``bound" to a virtual table that
 sets the virtual members for that object. The virtual members can be accessed
@@ -247,5 +221,5 @@
 completing the virtual system). The imaginary assertions would probably come
 from a trait defined by the virtual system, and state that the exception type
-is a virtual type, is a descendant of @exception_t@ (the base exception type),
+is a virtual type, is a descendant of @exception_t@ (the base exception type)
 and note its virtual table type.
 
@@ -267,5 +241,5 @@
 \end{cfa}
 Both traits ensure a pair of types are an exception type, its virtual table
-type,
+type
 and defines one of the two default handlers. The default handlers are used
 as fallbacks and are discussed in detail in \vref{s:ExceptionHandling}.
@@ -276,5 +250,5 @@
 facing way. So these three macros are provided to wrap these traits to
 simplify referring to the names:
-@IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@, and @IS_RESUMPTION_EXCEPTION@.
+@IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@.
 
 All three take one or two arguments. The first argument is the name of the
@@ -298,22 +272,22 @@
 \CFA provides two kinds of exception handling: termination and resumption.
 These twin operations are the core of \CFA's exception handling mechanism.
-This section covers the general patterns shared by the two operations and
-then goes on to cover the details of each individual operation.
+This section will cover the general patterns shared by the two operations and
+then go on to cover the details each individual operation.
 
 Both operations follow the same set of steps.
-First, a user raises an exception.
-Second, the exception propagates up the stack.
-Third, if a handler is found, the exception is caught and the handler is run.
+Both start with the user preforming a raise on an exception.
+Then the exception propagates up the stack.
+If a handler is found the exception is caught and the handler is run.
 After that control continues at a raise-dependent location.
-Fourth, if a handler is not found, a default handler is run and, if it returns, then control
+If the search fails a default handler is run and, if it returns, then control
 continues after the raise.
 
-%This general description covers what the two kinds have in common.
-The differences in the two operations include how propagation is performed, where execution continues
-after an exception is caught and handled, and which default handler is run.
+This general description covers what the two kinds have in common.
+Differences include how propagation is preformed, where exception continues
+after an exception is caught and handled and which default handler is run.
 
 \subsection{Termination}
 \label{s:Termination}
-Termination handling is the familiar EHM and used in most programming
+Termination handling is the familiar kind and used in most programming
 languages with exception handling.
 It is a dynamic, non-local goto. If the raised exception is matched and
@@ -334,7 +308,7 @@
 @is_termination_exception@ at the call site.
 Through \CFA's trait system, the trait functions are implicitly passed into the
-throw code for use by the EHM.
+throw code and the EHM.
 A new @defaultTerminationHandler@ can be defined in any scope to
-change the throw's behaviour when a handler is not found (see below).
+change the throw's behaviour (see below).
 
 The throw copies the provided exception into managed memory to ensure
@@ -346,8 +320,8 @@
 % How to say propagation starts, its first sub-step is the search.
 Then propagation starts with the search. \CFA uses a ``first match" rule so
-matching is performed with the copied exception as the search key.
-It starts from the raise in the throwing function and proceeds towards the base of the stack,
+matching is preformed with the copied exception as the search continues.
+It starts from the throwing function and proceeds towards base of the stack,
 from callee to caller.
-At each stack frame, a check is made for termination handlers defined by the
+At each stack frame, a check is made for resumption handlers defined by the
 @catch@ clauses of a @try@ statement.
 \begin{cfa}
@@ -361,5 +335,5 @@
 \end{cfa}
 When viewed on its own, a try statement simply executes the statements
-in the \snake{GUARDED_BLOCK}, and when those are finished,
+in \snake{GUARDED_BLOCK} and when those are finished,
 the try statement finishes.
 
@@ -367,10 +341,10 @@
 invoked functions, all the handlers in these statements are included in the
 search path.
-Hence, if a termination exception is raised, these handlers may be matched
+Hence, if a termination exception is raised these handlers may be matched
 against the exception and may handle it.
 
 Exception matching checks the handler in each catch clause in the order
 they appear, top to bottom. If the representation of the raised exception type
-is the same or a descendant of @EXCEPTION_TYPE@$_i$, then @NAME@$_i$
+is the same or a descendant of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$
 (if provided) is
 bound to a pointer to the exception and the statements in @HANDLER_BLOCK@$_i$
@@ -378,24 +352,25 @@
 freed and control continues after the try statement.
 
-If no termination handler is found during the search, then the default handler
-(\defaultTerminationHandler) visible at the raise statement is called.
-Through \CFA's trait system the best match at the raise statement is used.
+If no termination handler is found during the search then the default handler
+(\defaultTerminationHandler) visible at the raise statement is run.
+Through \CFA's trait system the best match at the raise statement will be used.
 This function is run and is passed the copied exception.
-If the default handler finishes, control continues after the raise statement.
+If the default handler is run control continues after the raise statement.
 
 There is a global @defaultTerminationHandler@ that is polymorphic over all
 termination exception types.
+Since it is so general a more specific handler can be
+defined and is used for those types, effectively overriding the handler
+for a particular exception type.
 The global default termination handler performs a cancellation
-(see \vref{s:Cancellation} for the justification) on the current stack with the copied exception.
-Since it is so general, a more specific handler is usually
-defined, possibly with a detailed message, and used for specific exception type, effectively overriding the default handler.
+(see \vref{s:Cancellation}) on the current stack with the copied exception.
 
 \subsection{Resumption}
 \label{s:Resumption}
 
-Resumption exception handling is the less familar EHM, but is
+Resumption exception handling is less common than termination but is
 just as old~\cite{Goodenough75} and is simpler in many ways.
 It is a dynamic, non-local function call. If the raised exception is
-matched, a closure is taken from up the stack and executed,
+matched a closure is taken from up the stack and executed,
 after which the raising function continues executing.
 The common uses for resumption exceptions include
@@ -403,5 +378,5 @@
 function once the error is corrected, and
 ignorable events, such as logging where nothing needs to happen and control
-should always continue from the raise point.
+should always continue from the same place.
 
 A resumption raise is started with the @throwResume@ statement:
@@ -417,9 +392,9 @@
 the exception system while handling the exception.
 
-At run-time, no exception copy is made, since
-resumption does not unwind the stack nor otherwise remove values from the
-current scope, so there is no need to manage memory to keep the exception in scope.
-
-Then propagation starts with the search. It starts from the raise in the
+At run-time, no exception copy is made.
+Resumption does not unwind the stack nor otherwise remove values from the
+current scope, so there is no need to manage memory to keep things in scope.
+
+The EHM then begins propagation. The search starts from the raise in the
 resuming function and proceeds towards the base of the stack,
 from callee to caller.
@@ -435,72 +410,45 @@
 }
 \end{cfa}
-% PAB, you say this above.
-% When a try statement is executed, it simply executes the statements in the
-% @GUARDED_BLOCK@ and then finishes.
-% 
-% However, while the guarded statements are being executed, including any
-% invoked functions, all the handlers in these statements are included in the
-% search path.
-% Hence, if a resumption exception is raised, these handlers may be matched
-% against the exception and may handle it.
-% 
-% Exception matching checks the handler in each catch clause in the order
-% they appear, top to bottom. If the representation of the raised exception type
-% is the same or a descendant of @EXCEPTION_TYPE@$_i$, then @NAME@$_i$
-% (if provided) is bound to a pointer to the exception and the statements in
-% @HANDLER_BLOCK@$_i$ are executed.
-% If control reaches the end of the handler, execution continues after the
-% the raise statement that raised the handled exception.
-% 
-% Like termination, if no resumption handler is found during the search,
-% then the default handler (\defaultResumptionHandler) visible at the raise
-% statement is called. It will use the best match at the raise sight according
-% to \CFA's overloading rules. The default handler is
-% passed the exception given to the raise. When the default handler finishes
-% execution continues after the raise statement.
-% 
-% There is a global @defaultResumptionHandler{} is polymorphic over all
-% resumption exceptions and performs a termination throw on the exception.
-% The \defaultTerminationHandler{} can be overridden by providing a new
-% function that is a better match.
-
-The @GUARDED_BLOCK@ and its associated nested guarded statements work the same
-for resumption as for termination, as does exception matching at each
-@catchResume@. Similarly, if no resumption handler is found during the search,
-then the currently visible default handler (\defaultResumptionHandler) is
-called and control continues after the raise statement if it returns. Finally,
-there is also a global @defaultResumptionHandler@, which can be overridden,
-that is polymorphic over all resumption exceptions but performs a termination
-throw on the exception rather than a cancellation.
-
-Throwing the exception in @defaultResumptionHandler@ has the positive effect of
-walking the stack a second time for a recovery handler. Hence, a programmer has
-two chances for help with a problem, fixup or recovery, should either kind of
-handler appear on the stack. However, this dual stack walk leads to following
-apparent anomaly:
-\begin{cfa}
-try {
-	throwResume E;
-} catch (E) {
-	// this handler runs
-}
-\end{cfa}
-because the @catch@ appears to handle a @throwResume@, but a @throwResume@ only
-matches with @catchResume@. The anomaly results because the unmatched
-@catchResuem@, calls @defaultResumptionHandler@, which in turn throws @E@.
-
 % I wonder if there would be some good central place for this.
-Note, termination and resumption handlers may be used together
+Note that termination handlers and resumption handlers may be used together
 in a single try statement, intermixing @catch@ and @catchResume@ freely.
 Each type of handler only interacts with exceptions from the matching
 kind of raise.
+When a try statement is executed, it simply executes the statements in the
+@GUARDED_BLOCK@ and then finishes.
+
+However, while the guarded statements are being executed, including any
+invoked functions, all the handlers in these statements are included in the
+search path.
+Hence, if a resumption exception is raised these handlers may be matched
+against the exception and may handle it.
+
+Exception matching checks the handler in each catch clause in the order
+they appear, top to bottom. If the representation of the raised exception type
+is the same or a descendant of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$
+(if provided) is bound to a pointer to the exception and the statements in
+@HANDLER_BLOCK@$_i$ are executed.
+If control reaches the end of the handler, execution continues after the
+the raise statement that raised the handled exception.
+
+Like termination, if no resumption handler is found during the search,
+the default handler (\defaultResumptionHandler) visible at the raise
+statement is called. It will use the best match at the raise sight according
+to \CFA's overloading rules. The default handler is
+passed the exception given to the raise. When the default handler finishes
+execution continues after the raise statement.
+
+There is a global \defaultResumptionHandler{} is polymorphic over all
+resumption exceptions and preforms a termination throw on the exception.
+The \defaultTerminationHandler{} can be overridden by providing a new
+function that is a better match.
 
 \subsubsection{Resumption Marking}
 \label{s:ResumptionMarking}
 A key difference between resumption and termination is that resumption does
-not unwind the stack. A side effect is that, when a handler is matched
-and run, its try block (the guarded statements) and every try statement
+not unwind the stack. A side effect that is that when a handler is matched
+and run it's try block (the guarded statements) and every try statement
 searched before it are still on the stack. There presence can lead to
-the \emph{recursive resumption problem}.
+the recursive resumption problem.
 
 The recursive resumption problem is any situation where a resumption handler
@@ -516,17 +464,14 @@
 When this code is executed, the guarded @throwResume@ starts a
 search and matches the handler in the @catchResume@ clause. This
-call is placed on the stack above the try-block. Now the second raise in the handler
-searches the same try block, matches, and puts another instance of the
+call is placed on the stack above the try-block. The second raise then
+searches the same try block and puts another instance of the
 same handler on the stack leading to infinite recursion.
 
-While this situation is trivial and easy to avoid, much more complex cycles can
-form with multiple handlers and different exception types.  The key point is
-that the programmer's intuition expects every raise in a handler to start
-searching \emph{below} the @try@ statement, making it difficult to understand
-and fix the problem.
-
-To prevent all of these cases, each try statement is ``marked" from the
-time the exception search reaches it to either when a matching handler
-completes or when the search reaches the base
+While this situation is trivial and easy to avoid, much more complex cycles
+can form with multiple handlers and different exception types.
+
+To prevent all of these cases, a each try statement is ``marked" from the
+time the exception search reaches it to either when the exception is being
+handled completes the matching handler or when the search reaches the base
 of the stack.
 While a try statement is marked, its handlers are never matched, effectively
@@ -540,9 +485,8 @@
 for instance, marking just the handlers that caught the exception,
 would also prevent recursive resumption.
-However, the rule selected mirrors what happens with termination,
-and hence, matches programmer intuition that a raise searches below a try.
-
-In detail, the marked try statements are the ones that would be removed from
-the stack for a termination exception, \ie those on the stack
+However, these rules mirror what happens with termination.
+
+The try statements that are marked are the ones that would be removed from
+the stack if this was a termination exception, that is those on the stack
 between the handler and the raise statement.
 This symmetry applies to the default handler as well, as both kinds of
@@ -578,5 +522,5 @@
 	// Only handle IO failure for f3.
 }
-// Handle a failure relating to f2 further down the stack.
+// Can't handle a failure relating to f2 here.
 \end{cfa}
 In this example the file that experienced the IO error is used to decide
@@ -609,95 +553,38 @@
 
 \subsection{Comparison with Reraising}
-Without conditional catch, the only approach to match in more detail is to reraise
-the exception after it has been caught, if it could not be handled.
-\begin{center}
-\begin{tabular}{l|l}
+A more popular way to allow handlers to match in more detail is to reraise
+the exception after it has been caught, if it could not be handled here.
+On the surface these two features seem interchangeable.
+
+If @throw;@ (no argument) starts a termination reraise,
+which is the same as a raise but reuses the last caught exception,
+then these two statements have the same behaviour:
 \begin{cfa}
 try {
-	do_work_may_throw();
-} catch(excep_t * ex; can_handle(ex)) {
-
-	handle(ex);
-
-
-
+    do_work_may_throw();
+} catch(exception_t * exc ; can_handle(exc)) {
+    handle(exc);
 }
 \end{cfa}
-&
+
 \begin{cfa}
 try {
-	do_work_may_throw();
-} catch(excep_t * ex) { 
-	if (can_handle(ex)) {
-		handle(ex);
-	} else {
-		throw;
-	}
+    do_work_may_throw();
+} catch(exception_t * exc) { 
+    if (can_handle(exc)) {
+        handle(exc);
+    } else {
+        throw;
+    }
 }
 \end{cfa}
-\end{tabular}
-\end{center}
-Notice catch-and-reraise increases complexity by adding additional data and
-code to the exception process. Nevertheless, catch-and-reraise can simulate
-conditional catch straightforwardly, when exceptions are disjoint, \ie no
-inheritance.
-
-However, catch-and-reraise simulation becomes unusable for exception inheritance.
-\begin{flushleft}
-\begin{cfa}[xleftmargin=6pt]
-exception E1;
-exception E2(E1); // inheritance
-\end{cfa}
-\begin{tabular}{l|l}
-\begin{cfa}
-try {
-	... foo(); ... // raise E1/E2
-	... bar(); ... // raise E1/E2
-} catch( E2 e; e.rtn == foo ) {
-	...
-} catch( E1 e; e.rtn == foo ) {
-	...
-} catch( E1 e; e.rtn == bar ) {
-	...
-}
-
-\end{cfa}
-&
-\begin{cfa}
-try {
-	... foo(); ...
-	... bar(); ...
-} catch( E2 e ) {
-	if ( e.rtn == foo ) { ...
-	} else throw; // reraise
-} catch( E1 e ) {
-	if (e.rtn == foo) { ...
-	} else if (e.rtn == bar) { ...
-	else throw; // reraise
-}
-\end{cfa}
-\end{tabular}
-\end{flushleft}
-The derived exception @E2@ must be ordered first in the catch list, otherwise
-the base exception @E1@ catches both exceptions. In the catch-and-reraise code
-(right), the @E2@ handler catches exceptions from both @foo@ and
-@bar@. However, the reraise misses the following catch clause. To fix this
-problem, an enclosing @try@ statement is need to catch @E2@ for @bar@ from the
-reraise, and its handler must duplicate the inner handler code for @bar@. To
-generalize, this fix for any amount of inheritance and complexity of try
-statement requires a technique called \emph{try-block
-splitting}~\cite{Krischer02}, which is not discussed in this thesis. It is
-sufficient to state that conditional catch is more expressive than
-catch-and-reraise in terms of complexity.
-
-\begin{comment}
-That is, they have the same behaviour in isolation.
+That is, they will have the same behaviour in isolation.
 Two things can expose differences between these cases.
 
 One is the existence of multiple handlers on a single try statement.
-A reraise skips all later handlers for a try statement but a conditional
+A reraise skips all later handlers on this try statement but a conditional
 catch does not.
-% Hence, if an earlier handler contains a reraise later handlers are
-% implicitly skipped, with a conditional catch they are not.
+Hence, if an earlier handler contains a reraise later handlers are
+implicitly skipped, with a conditional catch they are not.
 Still, they are equivalently powerful,
 both can be used two mimic the behaviour of the other,
@@ -750,5 +637,4 @@
 %   `exception_ptr current_exception() noexcept;`
 % https://www.python.org/dev/peps/pep-0343/
-\end{comment}
 
 \section{Finally Clauses}
@@ -766,5 +652,5 @@
 The @FINALLY_BLOCK@ is executed when the try statement is removed from the
 stack, including when the @GUARDED_BLOCK@ finishes, any termination handler
-finishes, or during an unwind.
+finishes or during an unwind.
 The only time the block is not executed is if the program is exited before
 the stack is unwound.
@@ -782,14 +668,15 @@
 
 Not all languages with unwinding have finally clauses. Notably \Cpp does
-without it as destructors, and the RAII design pattern, serve a similar role.
-Although destructors and finally clauses can be used for the same cases,
+without it as descructors, and the RAII design pattern, serve a similar role.
+Although destructors and finally clauses can be used in the same cases,
 they have their own strengths, similar to top-level function and lambda
 functions with closures.
-Destructors take more work for their creation, but if there is clean-up code
-that needs to be run every time a type is used, they are much easier
+Destructors take more work for their first use, but if there is clean-up code
+that needs to be run every time a type is used they soon become much easier
 to set-up.
 On the other hand finally clauses capture the local context, so is easy to
 use when the clean-up is not dependent on the type of a variable or requires
 information from multiple variables.
+% To Peter: I think these are the main points you were going for.
 
 \section{Cancellation}
@@ -804,5 +691,5 @@
 raise, this exception is not used in matching only to pass information about
 the cause of the cancellation.
-Finaly, since a cancellation only unwinds and forwards, there is no default handler.
+(This also means matching cannot fail so there is no default handler.)
 
 After @cancel_stack@ is called the exception is copied into the EHM's memory
@@ -815,8 +702,8 @@
 After the main stack is unwound there is a program-level abort. 
 
-The reasons for this semantics in a sequential program is that there is no more code to execute.
-This semantics also applies to concurrent programs, too, even if threads are running.
-That is, if any threads starts a cancellation, it implies all threads terminate.
-Keeping the same behaviour in sequential and concurrent programs is simple.
+There are two reasons for these semantics.
+The first is that it had to do this abort.
+in a sequential program as there is nothing else to notify and the simplicity
+of keeping the same behaviour in sequential and concurrent programs is good.
 Also, even in concurrent programs there may not currently be any other stacks
 and even if other stacks do exist, main has no way to know where they are.
@@ -863,5 +750,5 @@
 caller's context and passes it to the internal report.
 
-A coroutine only knows of two other coroutines, its starter and its last resumer.
+A coroutine knows of two other coroutines, its starter and its last resumer.
 The starter has a much more distant connection, while the last resumer just
 (in terms of coroutine state) called resume on this coroutine, so the message
@@ -871,5 +758,2 @@
 cascade an error across any number of coroutines, cleaning up each in turn,
 until the error is handled or a thread stack is reached.
-
-\PAB{Part of this I do not understand. A cancellation cannot be caught. But you
-talk about handling a cancellation in the last sentence. Which is correct?}
