Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision 4136ae43771ba66133fba9f6684bbefe1d0f9250)
+++ doc/papers/general/Paper.tex	(revision b002261f85fbbab79c7747b91cd5c2880094e5f1)
@@ -117,5 +117,5 @@
 		_Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute,
 		__attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
-		__const, __const__, disable, dtype, enable, __extension__, fallthrough, fallthru,
+		__const, __const__, disable, dtype, enable, exception, __extension__, fallthrough, fallthru,
 		finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
 		otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
@@ -260,5 +260,5 @@
 \Celeven did add @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. 
 The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@. 
-Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names. 
+Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names.
 Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that}
 
@@ -1357,10 +1357,11 @@
 \subsection{Exception Handling}
 
-\CFA provides two forms of exception handling: \newterm{resumption} (fix-up) and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
+The following framework for \CFA exception handling is in place, excluding a run-time type information and dynamic casts.
+\CFA provides two forms of exception handling: \newterm{fix-up} and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
 Both mechanisms provide dynamic call to a handler using dynamic name-lookup, where fix-up has dynamic return and recovery has static return from the handler.
-\CFA restricts exception types to those defined by aggregate type @_Exception@.
+\CFA restricts exception types to those defined by aggregate type @exception@.
 The form of the raise dictates the set of handlers examined during propagation: \newterm{resumption propagation} (@resume@) only examines resumption handlers (@catchResume@); \newterm{terminating propagation} (@throw@) only examines termination handlers (@catch@).
 If @resume@ or @throw@ have no exception type, it is a reresume/rethrow, meaning the currently exception continues propagation.
-If there is no current exception, the reresume/rethrow results in an error.
+If there is no current exception, the reresume/rethrow results in a runtime error.
 
 \begin{figure}
@@ -1370,9 +1371,10 @@
 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Resumption}}	& \multicolumn{1}{c}{\textbf{Recovery}}	\\
 \begin{cfa}
-`_Exception R { int fix; };`
+`exception R { int fix; };`
 void f() {
 	R r;
 	... `resume( r );` ...
 	... r.fix // control does return here after handler
+}
 `try` {
 	... f(); ...
@@ -1383,9 +1385,10 @@
 &
 \begin{cfa}
-`_Exception T {};`
+`exception T {};`
 void f() {
 
 	... `throw( T{} );` ...
 	// control does NOT return here after handler
+}
 `try` {
 	... f(); ...
@@ -1420,6 +1423,6 @@
 	... write( `datafile`, ... ); ...		$\C{// may throw IOError}$
 	... write( `logfile`, ... ); ...
-} catch ( IOError err; `err == datafile` ) { ... } $\C{// handle datafile error}$
-   catch ( IOError err; `err == logfile` ) { ... } $\C{// handle logfile error}$
+} catch ( IOError err; `err.file == datafile` ) { ... } $\C{// handle datafile error}$
+   catch ( IOError err; `err.file == logfile` ) { ... } $\C{// handle logfile error}$
    catch ( IOError err ) { ... }			$\C{// handler error from other files}$
 \end{cfa}
@@ -1429,7 +1432,8 @@
 The resumption raise can specify an alternate stack on which to raise an exception, called a \newterm{nonlocal raise}:
 \begin{cfa}
-resume [ $\emph{exception-type}$ ] [ _At $\emph{alternate-stack}$ ] ;
-\end{cfa}
-The @_At@ clause raises the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
+resume( $\emph{exception-type}$, $\emph{alternate-stack}$ )
+resume( $\emph{alternate-stack}$ )
+\end{cfa}
+These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
 Nonlocal raise is restricted to resumption to provide the exception handler the greatest flexibility because processing the exception does not unwind its stack, allowing it to continue after the handle returns.
 
@@ -1622,5 +1626,5 @@
 \lstMakeShortInline@%
 \end{cquote}
-Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}.
+Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}
 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}}.
 
@@ -1677,5 +1681,5 @@
 * [ * int, int ] ( int ) jp;				$\C{// pointer to routine returning pointer to int and int, with int parameter}$
 \end{cfa}
-Note, \emph{a routine name cannot be specified}:
+Note, a routine name cannot be specified:
 \begin{cfa}
 * [ int x ] f () fp;						$\C{// routine name "f" is disallowed}$
@@ -1994,4 +1998,5 @@
 The addition of @one_t@ allows generic algorithms to handle the unit value uniformly for types where that is meaningful. 
 \TODO{Make this sentence true} In particular, polymorphic functions in the \CFA prelude define @++x@ and @x++@ in terms of @x += 1@, allowing users to idiomatically define all forms of increment for a type @T@ by defining the single function @T & ?+=(T &, one_t)@; analogous overloads for the decrement operators are present as well.
+
 
 \subsection{Integral Suffixes}
@@ -2614,5 +2619,5 @@
 \section{Acknowledgments}
 
-The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen and the three anonymous reviewers for valuable feedback.
+The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen for feedback in the writing.
 %This work is supported in part by a corporate partnership with \grantsponsor{Huawei}{Huawei Ltd.}{http://www.huawei.com}, and Aaron Moss and Peter Buhr are funded by the \grantsponsor{Natural Sciences and Engineering Research Council} of Canada.
 % the first author's \grantsponsor{NSERC-PGS}{NSERC PGS D}{http://www.nserc-crsng.gc.ca/Students-Etudiants/PG-CS/BellandPostgrad-BelletSuperieures_eng.asp} scholarship.
