Changeset 503c350 for doc

Timestamp:

Aug 4, 2024, 12:22:17 PM (3 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

a57ad8a

Parents:

1e12f07

Message:

move overload material into background chapter

File:

• doc/theses/jiada_liang_MMath/background.tex (modified) (5 diffs)

doc/theses/jiada_liang_MMath/background.tex

@@ -235 +235 @@
 \section{\CFA}
 
-\CFA in \emph{not} an object-oriented programming-language, \ie functions cannot be nested in aggregate types, and hence, there is no receive notation for calling functions, \eg @obj.method(...)@, where the first argument proceeds the call.
-The following section provide short descriptions of \CFA features mentioned further in the thesis.
+\CFA in \emph{not} an object-oriented programming-language, \ie functions cannot be nested in aggregate types, and hence, there is no \newterm{receiver} notation for calling functions, \eg @obj.method(...)@, where the first argument proceeds the call and becomes an  implicit first (\lstinline[language=C++]{this}) parameter.
+The following sections provide short descriptions of \CFA features needed further in the thesis.
+Other \CFA features are presented in-situ with short explanations, or no explanation because the feature is obvious to C programmers.
+
+
+\subsection{Overloading}
+
+Overloading allows programmers to use the most meaningful names without fear of name clashes within a program or from external sources, like include files.
+\begin{quote}
+There are only two hard things in Computer Science: cache invalidation and naming things. --- Phil Karlton
+\end{quote}
+Experience from \CC and \CFA developers is that the type system implicitly and correctly disambiguates the majority of overloaded names, \ie it is rare to get an incorrect selection or ambiguity, even among hundreds of overloaded (variables and) functions.
+In many cases, a programmer has no idea there are name clashes, as they are silently resolved, simplifying the development process.
+Depending on the language, ambiguous cases are resolved using some form of qualification or casting.
 
 
@@ -268 +280 @@
 Here, there is a perfect match for the call, @f( 'A' )@ with the number and parameter type of function (2).
 
-Ada, Scala, and \CFA type-systems also use the return type in resolving a call.
+Ada, Scala, and \CFA type-systems also use the return type in resolving a call, to pinpoint the best overloaded name.
 \begin{cfa}
 int f( void );                  $\C[1.75in]{// (4); overloaded on return type}$
@@ -291 +303 @@
 \end{cfa}
 The \CFA type system simply treats overloaded variables as an overloaded function returning a value with no parameters.
+Hence, no significant effort is required to support this feature.
 
 
@@ -303 +316 @@
 
 The prototype for the constructor/destructor are @void ?{}( T &, ... )@ and @void ^?{}( T &, ... )@, respectively.
-The first parameter is logically, the \lstinline[language=C++]{this} or \lstinline[language=java]{self} in other object-oriented languages, and implicitly passed.
+The first parameter is logically, the \lstinline[language=C++]{this} or \lstinline[language=Python]{self} in other object-oriented languages, and implicitly passed.
+\VRef[Figure]{f:CFAConstructorDestructor} shows an example of creating and using a constructor and destructor.
+Both constructor and destructor can be explicitly called to reuse a variable.
+
+\begin{figure}
 \begin{cfa}
 struct Employee {
@@ -309 +326 @@
         double salary;
 };
-void @?{}@( Employee & this, char * name, double salary ) {
-        this.name = aalloc( sizeof(name) );
-        strcpy( this.name, name );
-        this.salary = salary;
-}
-void @^?{}@( Employee & this ) {
-        free( this.name );
+void @?{}@( Employee & emp, char * nname, double nsalary ) with( emp ) { // auto qualification
+        name = aalloc( sizeof(nname) );
+        strcpy( name, nname );
+        salary = nsalary;
+}
+void @^?{}@( Employee & emp ) {
+        free( emp.name );
 }
 {
-        Employee name = { "Sara Schmidt", 20.5 };
-} // implicit destructor call
-\end{cfa}
-Both constructor and destructor can be explicitly called.
-\begin{cfa}
-        Employee name = { "Sara Schmidt", 20.5 };
-        ... // use name
-        ^?{}( name ); // de-initialize
-        ?{}( name, "Jack Smith", 10.5 }; // re-initialize
-        ... // use name
-\end{cfa}
+        Employee emp = { "Sara Schmidt", 20.5 }; $\C{// initialize with implicit constructor call}$
+        ... // use emp
+        ^?{}( emp ); $\C{// explicit de-initialize}$
+        ?{}( emp, "Jack Smith", 10.5 ); $\C{// explicit re-initialize}$
+        ... // use emp
+} $\C{// de-initialize with implicit destructor call}$
+\end{cfa}
+\caption{\CFA Constructor and Destructor}
+\label{f:CFAConstructorDestructor}
+\end{figure}