Index: doc/theses/andrew_beach_MMath/future.tex
===================================================================
--- doc/theses/andrew_beach_MMath/future.tex	(revision a0329928b5ebad02f9600ac279465f0d483c8c13)
+++ doc/theses/andrew_beach_MMath/future.tex	(revision 02b73ea0deb52150e03b52873253e63aa0be7d38)
@@ -8,9 +8,14 @@
 parts of the exception system that use the current version.
 
-For instance a full virtual system would probably allow for several
-improvements to the exception traits. Although they do currently work they
-could be made easier to use by making the virtual table type implitate in the
-trait (which would remove the need for those wrapper marcos) or allowing
-for assertions that give the layout of a virtual table for safety.
+There are several improvements to the virtual system that would improve
+the exception traits. The biggest one is an assertion that checks that one
+virtual type is a child of another virtual type. This would capture many of
+the requirements much more precisely.
+
+The full virtual system might also include other improvement like associated
+types. This is a proposed feature that would allow traits to refer to types
+not listed in their header. This would allow the exception traits to not
+refer to the virtual table type explicatly which would remove the need for
+the interface macros.
 
 \section{Additional Throws}
@@ -65,17 +70,44 @@
 
 Also new techniques to skip previously searched parts of the stack will have
-to be developed.
+to be developed. The recursive resume problem still remains and ideally the
+same pattern of ignoring sections of the stack.
 
-\section{Support for More Platforms}
-Termination is not portable because it is implemented with inline assembly.
-Those sections will have to be rewritten to support different architectures
+\section{Signal Exceptions}
+Exception Handling: Issues and a Proposed Notation suggests there are three
+types of exceptions: escape, notify and signal.
+Escape exceptions are our termination exceptions, notify exceptions are
+resumption exceptions and that leaves signal exception unimplemented.
 
-\section{Quality-of-Life Improvements}
-Finally come various improvements to the usability of \CFA. Most of these
-would just require time. Time that would not lead to interesting research so
-it has been left aside for now. A few examples are included here but there
-are more:
+Signal exceptions allow either behaviour, that is after the exception is
+handled control can either return to the throw or from where the handler is
+defined.
+
+The design should be rexamined and be updated for \CFA. A very direct
+translation would perhaps have a new throw and catch pair and a statement
+(or statements) could be used to decide if the handler returns to the throw
+or continues where it is, but there are other options.
+
+For instance resumption could be extended to cover this use by allowing
+local control flow out of it. This would require an unwind as part of the
+transition as there are stack frames that have to be removed.
+This would mean there is no notify like throw but because \CFA does not have
+exception signatures a termination can be thrown from any resumption handler
+already so there are already ways one could try to do this in existing \CFA.
+
+% Maybe talk about the escape; and escape CONTROL_STMT; statements or how
+% if we could choose if _Unwind_Resume proceeded to the clean-up stage this
+% would be much easier to implement.
+
+\section{Language Improvements}
+There is also a lot of work that are not follow ups to this work in terms of
+research, some have no interesting research to be done at all, but would
+improve \CFA as a programming language. The full list of these would
+naturally be quite extensive but here are a few examples that involve
+exceptions:
 
 \begin{itemize}
+\item The implementation of termination is not portable because it includes
+some assembly statements. These sections will have to be re-written to so
+\CFA has full support on more machines.
 \item Allowing exception handler to bind the exception to a reference instead
 of a pointer. This should actually result in no change in behaviour so there
@@ -88,13 +120,3 @@
 much easier. (To do the same for try blocks would probably wait for zero-cost
 exceptions, which would allow the try block to be inlined as well.)
-\item Enabling local control flow out of a resumption handler. This would be
-a weighty operation, causing a stack unwind like a termination, so there might
-be a different statement or a statement modifier to make sure the user does
-this purposefully.
-
-However this would require the more complex system as they cannot be inlined
-into the original function as they can be run at a different place on the
-stack. So instead the unwinding will have to carry with it information on
-which one of these points to continue at and possibly also the return value
-for the function if a \codeCFA{return} statement was used.
 \end{itemize}
