Index: doc/theses/fangren_yu_MMath/intro.tex
===================================================================
--- doc/theses/fangren_yu_MMath/intro.tex	(revision a950021625a9c0dd9fa2837bbed60637235f36eb)
+++ doc/theses/fangren_yu_MMath/intro.tex	(revision 7846f910c8fe9db6807539191b713224180ffc21)
@@ -43,5 +43,6 @@
 
 Virtually all programming languages overload the arithmetic operators across the basic computational types using the number and type of parameters and returns.
-Like \CC, \CFA maps operators to named functions and allows these operators to be overloaded with user-defined types.
+However, in many programming languages, arithmetic operators are not first class, and hence, they cannot be overloaded by programmers.
+Like \CC, \CFA maps operators to named functions allowing them to be overloaded with user-defined types.
 The syntax for operator names uses the @'?'@ character to denote a parameter, \eg left and right unary operators: @?++@ and @++?@, and binary operators @?+?@ and @?<=?@.
 Here, a user-defined type is extended with an addition operation with the same syntax as a builtin type.
@@ -171,4 +172,34 @@
 
 
+\section{Overload Resolution Strategies}
+
+For languages with user-defined overloading,
+Given an overloaded constant, variable, or (generic) function, there must exist strategies for differentiating among them and selecting the most appropriate one in a given context.
+The criteria commonly used to match operator/function/method names with definitions are: number of parameters, parameter types, parameter order or name, return type, implicit argument type conversions (safe/unsafe), generic, where some features are missing in certain programming languages.
+\VRef[Table]{t:OverloadingFeatures} shows a subset of popular programming languages with overloading and the discriminating features used to disambiguate among overloadings.
+Language C, Go and Rust have no overloading beyond basic types and operators.
+
+\begin{table}
+\caption{Overload Discriminating Features in Programming Languages}
+\label{t:OverloadingFeatures}
+\centering
+
+
+\begin{minipage}{0.75\textwidth}
+\begin{tabular}{@{}r|ccccccc@{}}
+Feat.\,{\textbackslash}\,Lang.	& Ada	& \CC	& \CFA	& Java	& Scala	& Swift & Haskell	\\
+\hline
+Oper./Func./Meth. name	& O\footnote{except assignment}/F	& O/F/M	& O/F	& M	& O/M	& O/F/M	\\
+\# of parameters		& yes	& yes	& yes	& yes	& yes	& yes	\\
+parameter types			& yes	& yes	& yes	& yes	& yes	& yes	\\
+parameter Order/Name	& O/N	& O		& O		& O		& 		& O/N	\\
+return type				& yes	& no	& yes	& no	& 		& yes	\\
+Safe/Unsafe arg. conv.	& 		& 		& S/U	& 		& 		& no\footnote{literals only, Int -> Double (Safe)}	\\
+generic					& 		& 		& yes	& 		& 		& yes
+\end{tabular}
+\end{minipage}
+\end{table}
+
+
 \section{Type Inferencing}
 \label{s:IntoTypeInferencing}