Changeset fcf3493 for doc/theses/jiada_liang_MMath/CFAenum.tex

Timestamp:

Jul 30, 2024, 4:07:54 PM (4 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

2ff76d25

Parents:

dd78dbc

Message:

update on thesis

File:

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

doc/theses/jiada_liang_MMath/CFAenum.tex

@@ -114 +114 @@
 \subsection{Value Conversion}
 C has an implicit type conversion from an enumerator to its base type @int@.
-Correspondingly, \CFA has an implicit conversion from a typed enumerator to its base type. The feature that allows Typed enumeration 
-seemlyless used 
+Correspondingly, \CFA has an implicit conversion from a typed enumerator to its base type, allowing typed enumeration to be seemlyless used as 
+a value of its base type. 
 \begin{cfa}
 char currency = Dollar;
@@ -122 +122 @@
 \end{cfa}
 
-During the resolution of expression e with \CFA enumeration type, \CFA adds @value(e)@ as an additional candidate with an extra \newterm{value} cost.
-For expression @char currency = Dollar@, the is no defined conversion from Dollar (\CFA enumeration) type to basic type and the conversion cost is @infinite@, 
-thus the only valid candidate is @value(Dollar)@.
-
-@Value@ is a new category in \CFA's conversion cost model. It is defined to be a more significant factor than a @unsafe@ but weight less than @poly@.
-The resultin g conversion cost is a 8-tuple:
+% During the resolution of expression e with \CFA enumeration type, \CFA adds @value(e)@ as an additional candidate with an extra \newterm{value} cost.
+% For expression @char currency = Dollar@, the is no defined conversion from Dollar (\CFA enumeration) type to basic type and the conversion cost is @infinite@, 
+% thus the only valid candidate is @value(Dollar)@.
+The implicit conversion induces a \newterm{value cost}, which is a new category in \CFA's conversion cost model to disambiguate function overloading over for both \CFA enumeration and its base type.
+\begin{cfa}
+void baz( char ch );            $\C{// (1)}$
+void baz( Currency cu );        $\C{// (2)}$
+
+baz( Cent );
+\end{cfa}
+While both baz are applicable to \CFA enumeration, using Cent as a char in @candiate (1)@ comes with a @value@ cost, 
+while @candidate (2)@ has @zero@ cost. \CFA always choose a overloaded candidate implemented for a \CFA enumeration itself over a candidate applies on a base type.
+
+Value cost is defined to be a more significant factor than an @unsafe@ but weight less than @poly@.
+With @value@ being an additional category, the current \CFA conversion cost is a 8-tuple:
 @@(unsafe, value, poly, safe, sign, vars, specialization, reference)@@.
 
@@ -137 +146 @@
 };
 
-Month a = Februrary;    // (1), with cost (0, 1, 0, 0, 0, 0, 0, 0)
-double a = 5.5;                 // (2), with cost (1, 0, 0, 0, 0, 0, 0, 0)
+Month a = Februrary;    $\C{// (1), with cost (0, 1, 0, 0, 0, 0, 0, 0)}$
+double a = 5.5;                 $\C{// (2), with cost (1, 0, 0, 0, 0, 0, 0, 0)}$
 
 bar(a);
@@ -148 +157 @@
 forall(T | @CfaEnum(T)@) void bar(T);
 
-bar(a);                                 // (3), with cost (0, 0, 1, 0, 0, 0, 0, 0)
+bar(a);                                 $\C{// (3), with cost (0, 0, 1, 0, 0, 0, 0, 0)}$ 
 \end{cfa}
 % @Value@ is designed to be less significant than @poly@ to allow function being generic over \CFA enumeration (see ~\ref{c:trait}). 
@@ -192 +201 @@
 \section{Enumeration Inheritance}
 
-\CFA Plan-9 inheritance may be used with enumerations, where Plan-9 inheritance is containment inheritance with implicit unscoping (like a nested unnamed @struct@/@union@ in C).
+\CFA Plan-9 inheritance may be used with \CFA enumerations, where Plan-9 inheritance is containment inheritance with implicit unscoping (like a nested unnamed @struct@/@union@ in C).
+Inheritance can be nested, and a \CFA enumeration can inline enumerators from more than one \CFA enumeration, forming a tree-like structure.
+Howver, the uniqueness of enumeration label applies to enumerators from supertypes, meaning an enumeration cannot name enumerator with the same label as its subtype's members, or inherits 
+from multiple enumeration that has overlapping enumerator label. As a consequence, a new type cannot inherits both an enumeration and its supertype, or inherit two enumerations with a 
+common supertype (the diamond problem), since such would unavoidably introduce duplicate enumerator labels. 
 
 \begin{cfa}
@@ -200 +213 @@
 \end{cfa}
 
-Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Names@ by containment, and a @Names@ enumeration is a @subtype@ of enumeration @Name2@.
-Note, that enumerators must be unique in inheritance but enumerator values may be repeated.
+% Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Names@ by containment, and a @Names@ enumeration is a @subtype@ of enumeration @Name2@.
+% Note, that enumerators must be unique in inheritance but enumerator values may be repeated.
+
+@Names2@ is defined with five enumerators, three of which are from @Name@ through containment, and two are self-declared.
+@Names3@ inherits all five members from @Names2@ and declare two additional enumerators.
 
 % The enumeration type for the inheriting type must be the same as the inherited type;
@@ -211 +227 @@
 \end{cfa}
 
-Inlined from \CFA enumeration @O@, new enumeration @N@ copies all enumerators from @O@, including those @O@ obtains through inheritance. Enumerators inherited from @O@
-keeps same @label@ and @value@, but @position@ may shift to the right if other enumerators or inline enumeration declared in prior of @inline A@.
+The enumeration type for the inheriting type must be the same as the inherited type. 
+When an enumeration inherits enumerators from another enumeration, it copies the enumerators' @value@ and @label@, even if the @value@ was auto initialized. However, the @position@ as the underlying 
+representation will be the order of the enumerator in new enumeration.
+% new enumeration @N@ copies all enumerators from @O@, including those @O@ obtains through inheritance. Enumerators inherited from @O@
+% keeps same @label@ and @value@, but @position@ may shift to the right if other enumerators or inline enumeration declared in prior of @inline A@.
+% hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
+% When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
+
 \begin{cfa}
 enum() Phynchocephalia { Tuatara };
@@ -220 +242 @@
 Snake, for example, has the position 0 in Squamata, but 1 in Lepidosauromorpha as Tuatara inherited from Phynchocephalia is position 0 in Lepidosauromorpha.
 
-A subtype enumeration can be casted, or implicitly converted into its supertype, with a safe cost.
+A subtype enumeration can be casted, or implicitly converted into its supertype, with a @safe@ cost.
 \begin{cfa}
 enum Squamata squamata_lizard = Lizard;