Index: doc/theses/andrew_beach_MMath/features.tex
===================================================================
--- doc/theses/andrew_beach_MMath/features.tex	(revision 7eb6eb5cffc3f3144044d790cd69b1279c0f7498)
+++ doc/theses/andrew_beach_MMath/features.tex	(revision 1c1c180bbabe89afcd516b9eec10021a2e52dd6b)
@@ -7,5 +7,5 @@
 Virtual types and casts are not required for a basic exception-system but are
 useful for advanced exception features. However, \CFA is not object-oriented so
-there is no obvious concept of virtuals.  Hence, to create advanced exception
+there is no obvious concept of virtuals. Hence, to create advanced exception
 features for this work, I needed to designed and implemented a virtual-like
 system for \CFA.
@@ -30,5 +30,5 @@
 \end{center}
 The hierarchy provides the ability to handle an exception at different degrees
-of specificity (left to right).  Hence, it is possible to catch a more general
+of specificity (left to right). Hence, it is possible to catch a more general
 exception-type in higher-level code where the implementation details are
 unknown, which reduces tight coupling to the lower-level implementation.
@@ -78,5 +78,5 @@
 
 Exceptions are defined by the trait system; there are a series of traits, and
-if a type satisfies them, then it can be used as an exception.  The following
+if a type satisfies them, then it can be used as an exception. The following
 is the base trait all exceptions need to match.
 \begin{cfa}
@@ -92,10 +92,10 @@
 \PAB{I do not understand this paragraph.}
 One odd thing about @get_exception_vtable@ is that it should always be a
-constant function, returning the same value regardless of its argument.  A
+constant function, returning the same value regardless of its argument. A
 pointer or reference to the virtual table instance could be used instead,
 however using a function has some ease of implementation advantages and allows
 for easier disambiguation because the virtual type name (or the address of an
 instance that is in scope) can be used instead of the mangled virtual table
-name.  Also note the use of the word ``promise'' in the trait
+name. Also note the use of the word ``promise'' in the trait
 description. Currently, \CFA cannot check to see if either @exceptT@ or
 @virtualT@ match the layout requirements. This is considered part of
@@ -126,5 +126,5 @@
 
 Finally there are three convenience macros for referring to the these traits:
-@IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@.  Each
+@IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@. Each
 takes the virtual type's name, and for polymorphic types only, the
 parenthesized list of polymorphic arguments. These macros do the name mangling
@@ -212,5 +212,5 @@
 expression has a type with a @void defaultResumptionHandler(T &)@ (default
 handler) defined, where the handler is found at the call site by the type
-system.  At runtime, a representation of the exception type and an instance of
+system. At runtime, a representation of the exception type and an instance of
 the exception type is \emph{not} copied because the stack is maintained during
 the handler search.
@@ -306,5 +306,5 @@
 exception matches, @CONDITION@ is executed. The condition expression may
 reference all names in scope at the beginning of the try block and @NAME@
-introduced in the handler clause.  If the condition is true, then the handler
+introduced in the handler clause. If the condition is true, then the handler
 matches. Otherwise, the exception search continues at the next appropriate kind
 of handler clause in the try block.
@@ -359,6 +359,6 @@
 the end of the block. This requirement ensures always continues as if the
 finally clause is not present, \ie finally is for cleanup not changing control
-flow.  Because of this requirement, local control flow out of the finally block
-is forbidden.  The compiler precludes any @break@, @continue@, @fallthru@ or
+flow. Because of this requirement, local control flow out of the finally block
+is forbidden. The compiler precludes any @break@, @continue@, @fallthru@ or
 @return@ that causes control to leave the finally block. Other ways to leave
 the finally block, such as a long jump or termination are much harder to check,
@@ -371,5 +371,5 @@
 
 There is no special statement for starting a cancellation; instead the standard
-library function @cancel_stack@ is called passing an exception.  Unlike a
+library function @cancel_stack@ is called passing an exception. Unlike a
 raise, this exception is not used in matching only to pass information about
 the cause of the cancellation.
@@ -379,5 +379,5 @@
 \item[Main Stack:]
 The main stack is the one used by the program main at the start of execution,
-and is the only stack in a sequential program.  Hence, when cancellation is
+and is the only stack in a sequential program. Hence, when cancellation is
 forwarded to the main stack, there is no other forwarding stack, so after the
 stack is unwound, there is a program-level abort.
@@ -385,8 +385,8 @@
 \item[Thread Stack:]
 A thread stack is created for a @thread@ object or object that satisfies the
-@is_thread@ trait.  A thread only has two points of communication that must
+@is_thread@ trait. A thread only has two points of communication that must
 happen: start and join. As the thread must be running to perform a
 cancellation, it must occur after start and before join, so join is a
-cancellation point.  After the stack is unwound, the thread halts and waits for
+cancellation point. After the stack is unwound, the thread halts and waits for
 another thread to join with it. The joining thread, checks for a cancellation,
 and if present, resumes exception @ThreadCancelled@.
@@ -408,7 +408,7 @@
 
 \item[Coroutine Stack:] A coroutine stack is created for a @coroutine@ object
-or object that satisfies the @is_coroutine@ trait.  A coroutine only knows of
-two other coroutines, its starter and its last resumer.  The last resumer has
-the tightest coupling to the coroutine it activated.  Hence, cancellation of
+or object that satisfies the @is_coroutine@ trait. A coroutine only knows of
+two other coroutines, its starter and its last resumer. The last resumer has
+the tightest coupling to the coroutine it activated. Hence, cancellation of
 the active coroutine is forwarded to the last resumer after the stack is
 unwound, as the last resumer has the most precise knowledge about the current
