Index: doc/theses/fangren_yu_MMath/intro.tex
===================================================================
--- doc/theses/fangren_yu_MMath/intro.tex	(revision 399074a5d8e05559710bede105d5b113eee30e65)
+++ doc/theses/fangren_yu_MMath/intro.tex	(revision 8ef0bf7fc6b88ef4c5b4af9f25e5a5380815a9a2)
@@ -888,22 +888,6 @@
 \section{Language Comparison}
 
-Because \CFA's type system is focused on overloading and overload resolution, \VRef[Table]{t:OverloadingFeatures} compares \CFA with a representive set of popular programming languages and their take on overloading.
-The first row classifies whether there is general overloading, and what enities may be overloaded.
-\begin{cfa}
-int foo( int );					int foo;
-double foo( int, int );			double foo;
-\end{cfa}
-The second row classifies the specialzation mechanisms used distinished among the general overloads.
-The third row classifies if generic functions can be overloaded based on the number and differing type variables.
-\begin{cfa}
-forall( T ) T foo( T t );
-forall( T ) T foo( T t, T s );
-forall( T, U ) T foo( T t, U s );
-\end{cfa}
-The fourth row classifies the mechnaism used to specialize  provide  if generic functions can be overloaded based on the number and differing type variables.
-The fifth row classifies if conversions are attempted beyond exact match.
-
 \begin{table}
-\caption{Overload Discriminating Features in Programming Languages}
+\caption{Overload Features in Programming Languages}
 \label{t:OverloadingFeatures}
 \centering
@@ -915,16 +899,12 @@
 general\footnote{overloadable entities: V $\Rightarrow$ variable, O $\Rightarrow$ operator, F $\Rightarrow$ function, M $\Rightarrow$ member}
 						& O\footnote{except assignment}/F	& O/F/M	& V/O/F	& M\footnote{not universal}	& O/M	& O/F/M	& no	& no	\\
-general constraints\footnote{\# $\Rightarrow$ number, T $\Rightarrow$ type, N $\Rightarrow$ name, R $\Rightarrow$ return type}
+general constraints\footnote{parameter \# $\Rightarrow$ number, T $\Rightarrow$ type, N $\Rightarrow$ name; R $\Rightarrow$ return type}
 						& \#/T/R	& \#/T	& \#/T/R	& \#/T	& \#/T/N/R	& \#/T/N/R	& \#/T/N	& T/R \\
-type parameters			& no		& yes	& yes		& yes	& yes	& yes	& yes	& yes \\
+type parameters			& no		& yes	& yes		& yes	& yes		& yes		& yes	& yes \\
 type constraint\footnote{T $\Rightarrow$ trait/concept, B $\Rightarrow$ type bounds, TC $\Rightarrow$ type class}
-						& no		& T		& T			& T		& B		& T	& T	& TC \\
-%parameter number		& yes	& yes		& yes	& yes	& yes	& yes	& maybe	& no	\\
-%parameter types		& yes	& yes		& yes	& yes	& yes	& yes	& yes	& yes	\\
-%parameter name			& no	& no		& no	& no	& yes	& yes	& no	& no	\\
-%return type			& yes	& no		& yes	& no	& no	& yes	& no	& yes	\\
-Safe/Unsafe arg. conv.	& no	& S/U\footnote{no conversions allowed during template parameter deduction}	& S/U
-	& S\footnote{unsafe (narrowing) conversion only allowed in assignment or initialization to a primitive (builtin) type}	& S
-	& no\footnote{literals only, Int $\rightarrow$ Double (Safe)}	& no	& no
+						& no		& T		& T			& T		& B			& T			& T	& TC \\
+Safe/Unsafe arg. conv.	& no		& S/U\footnote{no conversions allowed during template parameter deduction}	& S/U
+						& S\footnote{unsafe (narrowing) conversion only allowed in assignment or initialization to a primitive (builtin) type}	& S
+						& no\footnote{literals only, Int $\rightarrow$ Double (Safe)}	& no	& no
 \end{tabular}
 \end{minipage}
@@ -932,4 +912,90 @@
 % https://dl.acm.org/doi/10.1145/75277.75283
 \end{table}
+
+Because \CFA's type system is focused on overloading and overload resolution, \VRef[Table]{t:OverloadingFeatures} compares \CFA with a representative set of popular programming languages and their take on overloading.
+The first row classifies whether there is general overloading, and what entities may be overloaded.
+\begin{cquote}
+\setlength{\tabcolsep}{10pt}
+\begin{tabular}{@{}llll@{}}
+\multicolumn{1}{c}{\textbf{variable}} & \multicolumn{1}{c}{\textbf{operator}} & \multicolumn{1}{c}{\textbf{function}} & \multicolumn{1}{c}{\textbf{member}} \\
+\begin{cfa}
+int foo;
+double foo;
+
+
+\end{cfa}
+&
+\begin{cfa}
+int ?+?( int );
+double ?+?( double );
+
+
+\end{cfa}
+&
+\begin{cfa}
+int foo( int );
+double foo( int, int );
+
+
+\end{cfa}
+&
+\begin{c++}
+class C {
+	int foo( int );
+	double foo( int, int );
+};
+\end{c++}
+\end{tabular}
+\end{cquote}
+The second row classifies the specialization mechanisms used to distinguish among the general overload capabilities.
+\begin{cquote}
+\begin{tabular}{@{}llll@{}}
+\multicolumn{1}{c}{\textbf{number}} & \multicolumn{1}{c}{\textbf{type}} & \multicolumn{1}{c}{\textbf{name}} & \multicolumn{1}{c}{\textbf{return}} \\
+\begin{lstlisting}[language=swift]
+func foo( _ x : Int )
+func foo( _ x : Int, _ y : Int )
+foo( 3 )
+foo( 3, 3 )
+\end{lstlisting}
+&
+\begin{lstlisting}[language=swift]
+func foo( _ x : Int )
+func foo( _ x : Double )
+foo( 3 )
+foo( 3.5 )
+\end{lstlisting}
+&
+\begin{lstlisting}[language=swift]
+func foo( x : Int )
+func foo( y : Int )
+foo( x : 3 )
+foo( y : 3 );
+\end{lstlisting}
+&
+\begin{lstlisting}[language=swift]
+func foo() -> Int
+func foo() -> String
+var i : Int = foo()
+var s : String = foo();
+\end{lstlisting}
+\end{tabular}
+\end{cquote}
+The third row classifies if generic functions can be overloaded based on the number and differing type variables.
+\begin{cfa}
+forall( T ) T foo( T t );
+forall( T ) T foo( T t, T s );
+forall( T, U ) T foo( T t, U s );
+\end{cfa}
+The fourth row classifies the mechanism used to specialize the type variables to make them practical.
+\begin{cfa}
+forall( T | T ?+?( T, T ) ) T foo( T t );
+\end{cfa}
+The fifth row classifies if conversions are attempted beyond exact match.
+\begin{cfa}
+int foo( double ); // 1
+double foo( int ); // 2
+int i = foo( 3 ); // 1 : 3 => 3.0
+double d = foo( 3.5 ); // 1 : int result => double
+\end{cfa}