Changeset 7846f91 for doc

Timestamp:

Feb 4, 2025, 9:16:19 PM (3 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

985ff5f

Parents:

bbbff10

Message:

start adding table overload discriminating features

File:

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

doc/theses/fangren_yu_MMath/intro.tex ¶

@@ -43 +43 @@
 
 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 +172 @@
 
 
+\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}