Index: doc/generic_types/generic_types.tex
===================================================================
--- doc/generic_types/generic_types.tex	(revision ea73caf618e36e68d559d772dc6888ac79d824e9)
+++ doc/generic_types/generic_types.tex	(revision 36e05a2da4315d4bdb924d9f8a099da1bd00cd9f)
@@ -133,5 +133,5 @@
 \item Extensions introduced by \CFA must be translated in the most efficient way possible.
 \end{enumerate}
-The purpose of these goals is to ensure that existing C code-bases can be converted to \CFA incrementally and with minimal effort, and that programmers who know C can productively generate \CFA code without training beyond the features they wish to employ. In its current implementation, \CFA is compiled by translating it to the GCC-dialect of C~\citep{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by GCC, meeting goals (1)-(3).
+These goals ensure existing C code-bases can be converted to \CFA incrementally and with minimal effort, and C programmers can productively generate \CFA code without training beyond the features they wish to employ. In its current implementation, \CFA is compiled by translating it to the GCC-dialect of C~\citep{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by GCC, meeting goals (1)-(3). Ultimately, a compiler is necessary for advanced features and optimal performance.
 
 \CFA has been previously extended with polymorphic functions and name overloading (including operator overloading) by \citet{Bilson03}, and deterministically-executed constructors and destructors by \citet{Schluntz17}. This paper describes how generic and tuple types are designed and implemented in \CFA in accordance with both the backward compatibility goals and existing features described above.
@@ -167,7 +167,7 @@
 \begin{lstlisting}
 forall( otype T `| { int ?<?( T, T ); }` )	$\C{// type assertion}$
-  void qsort( const T * arr, size_t dim );
+  void qsort( const T * arr, size_t size );
 forall( otype T `| { int ?<?( T, T ); }` )	$\C{// type assertion}$
-  T * bsearch( T key, const T * arr, size_t dim );
+  T * bsearch( T key, const T * arr, size_t size );
 double vals[10] = { /* 10 floating-point values */ };
 qsort( vals, 10 );							$\C{// sort array}$
@@ -190,11 +190,11 @@
 but providing a type-safe \CFA overloaded wrapper.
 \begin{lstlisting}
-forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t dim ) {
+forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
 	int comp( const void * t1, const void * t2 ) { /* as above with double changed to T */ }
-	return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
-}
-forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t dim ) {
-	T *result = bsearch( key, arr, dim );	$\C{// call first version}$
-	return result ? result - arr : dim;		$\C{// pointer subtraction includes sizeof(T)}$
+	return (T *)bsearch( &key, arr, size, sizeof(T), comp );
+}
+forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
+	T *result = bsearch( key, arr, size );	$\C{// call first version}$
+	return result ? result - arr : size;		$\C{// pointer subtraction includes sizeof(T)}$
 }
 double * val = bsearch( 5.0, vals, 10 );	$\C{// selection based on return type}$
@@ -262,7 +262,7 @@
 };
 forall( otype T | summable( T ) )
-  T sum( T a[$\,$], size_t dim ) {
-	T total = { 0 };							$\C{// instantiate T from 0}$
-	for ( unsigned int i = 0; i < dim; i += 1 )
+  T sum( T a[$\,$], size_t size ) {
+	T total = { 0 };						$\C{// instantiate T from 0}$
+	for ( unsigned int i = 0; i < size; i += 1 )
 		total += a[i];						$\C{// select appropriate +}$
 	return total;