Changeset bc17be98 for doc/theses

Timestamp:

Jun 12, 2024, 9:21:05 AM (3 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

d280784

Parents:

c033405

Message:

small proofreading changes to Cforall numeration chapter

File:

• doc/theses/jiada_liang_MMath/CFAenum.tex (modified) (6 diffs)

doc/theses/jiada_liang_MMath/CFAenum.tex

@@ -25 +25 @@
 
 In C, unscoped enumerators present a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
-There is no mechanism in C to resolve these naming conflicts other than renaming one of the duplicates, which may be impossible.
+There is no mechanism in C to resolve these naming conflicts other than renaming one of the duplicates, which may be impossible if the conflict comes from system include files.
 
 The \CFA type-system allows extensive overloading, including enumerators.
@@ -33 +33 @@
 enum E1 { First, Second, Third, Fourth };
 enum E2 { @Fourth@, @Third@, @Second@, @First@ }; $\C{// same enumerator names}$
-E1 p() { return Third; }                                $\C{// return}$
-E2 p() { return Fourth; }
+E1 f() { return Third; }                                $\C{// overloaded functions, different return types}$
+E2 f() { return Fourth; }
 void foo() {
         E1 e1 = First;   E2 e2 = First;         $\C{// initialization}$
         e1 = Second;   e2 = Second;                     $\C{// assignment}$
-        e1 = p();   e2 = p();                           $\C{// function call}$
+        e1 = f();   e2 = f();                           $\C{// function call}$
         int i = @E1.@First + @E2.@First;        $\C{// disambiguate with qualification}$
         int j = @(E1)@First + @(E2)@First;      $\C{// disambiguate with cast}$
 }
 \end{cfa}
-\CFA overloading allows programmers to use the most meaningful names without fear of name clashes from include files.
-In most cases, the type system implicitly disambiguates, otherwise the programmer explicitly disambiguates using qualification or casting.
+\CFA overloading allows programmers to use the most meaningful names without fear of name clashes within a program or from external sources, like include files.
+Experience from \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.
+Any ambiguity can be resolved using qualification or casting.
 
 
@@ -63 +64 @@
 It is possible to toggle back to unscoping using the \CFA @with@ clause/statement (see also \CC \lstinline[language=c++]{using enum} in Section~\ref{s:C++RelatedWork}).
 \begin{cfa}
-with ( @Week@, @RGB@ ) {                        $\C{// type names}$
-         week = @Sun@;                                  $\C{// no qualification}$
+with ( @Week@, @RGB@ ) {                                $\C{// type names}$
+         week = @Sun@;                                          $\C{// no qualification}$
          rgb = @Green@;
 }
 \end{cfa}
-As in Section~\ref{s:EnumeratorVisibility}, opening multiple scoped enumerations in a @with@ can result in duplicate enumeration names, but \CFA implicit type resolution and explicit qualification/casting handle ambiguities.
+As in Section~\ref{s:EnumeratorVisibility}, opening multiple scoped enumerations in a @with@ can result in duplicate enumeration names, but \CFA implicit type resolution and explicit qualification/casting handle this localized scenario.
+
 
 \section{Enumeration Trait}
@@ -184 +186 @@
 % \end{cfa}
 % Note the ability to print all of an enumerator's properties.
-
 
 
@@ -371 +372 @@
 
 
-
 \section{Enumerated Arrays}
 Enumerated array use an \CFA array as their index.
@@ -382 +382 @@
 sout | "Colour Code of Orange is " | colourCode[Orange];
 \end{cfa}
+
 
 \section{Planet Example}