Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision cfc3e0facc59b4b72c5c4ade00f35a2478f94cf2)
+++ doc/papers/general/Paper.tex	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -59,4 +59,7 @@
 %\DeclareTextCommandDefault{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}
 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+
+\renewcommand*{\thefootnote}{\alph{footnote}} % hack because fnsymbol does not work
+%\renewcommand*{\thefootnote}{\fnsymbol{footnote}}
 
 \makeatletter
@@ -197,5 +200,5 @@
 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects.
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
-Nevertheless, C, first standardized almost fourty years ago, lacks many features that make programming in more modern languages safer and more productive.
+Nevertheless, C, first standardized almost forty years ago, lacks many features that make programming in more modern languages safer and more productive.
 
 The goal of the \CFA project (pronounced ``C-for-all'') is to create an extension of C that provides modern safety and productivity features while still ensuring strong backwards compatibility with C and its programmers.
@@ -233,5 +236,5 @@
 Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
 In many cases, \CC is often used solely as a better C.
-Nevertheless, C, first standardized almost fourty years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
+Nevertheless, C, first standardized almost forty years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
 
 \CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
@@ -299,5 +302,5 @@
 The \CFA tests are 290+ files and 27,000+ lines of code.
 The tests illustrate syntactic and semantic features in \CFA, plus a growing number of runtime benchmarks.
-The tests check for correctness and are used for daily regression testing of commits (3800+).
+The tests check for correctness and are used for daily regression testing of 3800+ commits.
 
 Finally, it is impossible to describe a programming language without usages before definitions.
@@ -348,5 +351,5 @@
 \eg, it cannot implement the example above, because the variables @max@ are ambiguous 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 dispatch functions, which must all have distinct names.
-For backwards compatibility, \CFA supports @_Generic@ expressions, but it is an unnecessary mechanism. \TODO{actually implement that}
+\CFA supports @_Generic@ expressions for backwards compatibility, but it is an unnecessary mechanism. \TODO{actually implement that}
 
 % http://fanf.livejournal.com/144696.html
@@ -543,5 +546,5 @@
 \begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
 \begin{cfa}
-forall( otype R, otype S ) struct pair {
+`forall( otype R, otype S )` struct pair {
 	R first;	S second;
 };
@@ -1180,13 +1183,13 @@
   case Mon~Thu:  // program
 
-  case Fri:  // program
+  case Fri:    // program
 	wallet += pay;
 	`fallthrough;`
-  case Sat:  // party
+  case Sat:   // party
 	wallet -= party;
 
   case Sun:  // rest
 
-  default:  // error
+  default:    // print error
 }
 \end{cfa}
@@ -1196,13 +1199,13 @@
   case Mon: case Tue: case Wed: case Thu:  // program
 	`break;`
-  case Fri:  // program
+  case Fri:    // program
 	wallet += pay;
 
-  case Sat:  // party
+  case Sat:   // party
 	wallet -= party;
 	`break;`
   case Sun:  // rest
 	`break;`
-  default:  // error
+  default:    // print error
 }
 \end{cfa}
@@ -1477,5 +1480,5 @@
 If an exception is raised and caught, the handler is run before the finally clause.
 Like a destructor (see Section~\ref{s:ConstructorsDestructors}), a finally clause can raise an exception but not if there is an exception being propagated.
-Mimicking the @finally@ clause with mechanisms like RAII is non-trivially when there are multiple types and local accesses.
+Mimicking the @finally@ clause with mechanisms like RAII is non-trivial when there are multiple types and local accesses.
 
 
@@ -1530,10 +1533,10 @@
 with ( s, t ) {
 	j + k;									$\C{// unambiguous, s.j + t.k}$
-	m = 5.0;								$\C{// unambiguous, t.m = 5.0}$
-	m = 1;									$\C{// unambiguous, s.m = 1}$
-	int a = m;								$\C{// unambiguous, a = s.i }$
-	double b = m;							$\C{// unambiguous, b = t.m}$
+	m = 5.0;								$\C{// unambiguous, s.m = 5.0}$
+	m = 1;									$\C{// unambiguous, t.m = 1}$
+	int a = m;								$\C{// unambiguous, a = t.m }$
+	double b = m;							$\C{// unambiguous, b = s.m}$
 	int c = s.i + t.i;						$\C{// unambiguous, qualification}$
-	(double)m;								$\C{// unambiguous, cast}$
+	(double)m;								$\C{// unambiguous, cast s.m}$
 }
 \end{cfa}
@@ -1559,7 +1562,7 @@
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
-void ?{}( S & s, int `i` ) with ( s ) `with( $\emph{\color{red}params}$ )` {
+void ?{}( S & s, int `i` ) with ( s ) `{` `with( $\emph{\color{red}params}$ )` {
 	s.i = `i`; j = 3; m = 5.5;
-}
+} `}`
 \end{cfa}
 Finally, a cast may be used to disambiguate among overload variables in a @with@ expression:
@@ -1660,9 +1663,9 @@
 \begin{cfa}
 `*` int x, y;
-int y;
-\end{cfa}
-&
-\begin{cfa}
-int `*`x, `*`y;
+int z;
+\end{cfa}
+&
+\begin{cfa}
+int `*`x, `*`y, z;
 
 \end{cfa}
@@ -1670,5 +1673,6 @@
 \lstMakeShortInline@%
 \end{cquote}
-The downside of the \CFA semantics is the need to separate regular and pointer declarations.
+% The downside of the \CFA semantics is the need to separate regular and pointer declarations.
+The separation of regular and pointer declarations by \CFA declarations enforces greater clarity with only slightly more syntax.
 
 \begin{comment}
@@ -1792,8 +1796,5 @@
 * [ * int, int ] ( int ) jp;	$\C{// pointer to function returning pointer to int and int with int parameter}$
 \end{cfa}
-Note, a function name cannot be specified:
-\begin{cfa}
-* [ int x ] f () fp;			$\C{// function name "f" is disallowed}\CRT$
-\end{cfa}
+Note, the name of the function pointer is specified last, as for other variable declarations.
 
 Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
@@ -2637,5 +2638,5 @@
 
 
-\section{Polymorphism Evaluation}
+\section{Polymorphic Evaluation}
 \label{sec:eval}