Changeset 8ef0bf7 for doc/theses

Timestamp:

Mar 26, 2025, 9:41:52 AM (2 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

379b6ea

Parents:

d73e667

Message:

update Table 1.1

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 Discriminating Features in Programming Languages}
+\caption{Overload Features in Programming Languages}
 \label{t:OverloadingFeatures}
 \centering
@@ -915 +899 @@
 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 +912 @@
 % 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}