Changes in / [379b6ea:446dde5]

File:

• doc/theses/fangren_yu_MMath/intro.tex (modified) (3 diffs)

doc/theses/fangren_yu_MMath/intro.tex

@@ -888 +888 @@
 \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 Features in Programming Languages}
+\caption{Overload Discriminating Features in Programming Languages}
 \label{t:OverloadingFeatures}
 \centering
@@ -899 +915 @@
 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{parameter \# $\Rightarrow$ number, T $\Rightarrow$ type, N $\Rightarrow$ name; R $\Rightarrow$ return type}
+general constraints\footnote{\# $\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 \\
-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 \\
+%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
 \end{tabular}
 \end{minipage}
@@ -912 +932 @@
 % 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}