Changeset c141c09 for doc/theses/jiada_liang_MMath/CEnum.tex

Timestamp:

Aug 2, 2024, 12:32:18 AM (5 weeks ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

a9ae5ca, b12e4ad

Parents:

3a7cd15

Message:

Update

File:

• doc/theses/jiada_liang_MMath/CEnum.tex (modified) (4 diffs)

doc/theses/jiada_liang_MMath/CEnum.tex

@@ -1 @@
-\chapter{C Enum in CFA}
+\chapter{C Enumeration in CFA}
 
-\CFA supports C enumeration using the same syntax for backwards compatibility, and the semantics is mostly consistent with C with small difference in terms of typing.
-C style enums in \CFA language are called "C enum".
-\CFA also extends C-Style enumeration by adding a number of new features that bring enumerations inline with other modern programming languages.
+\CFA supports legacy C enumeration using the same syntax for backwards compatibility. 
+C-style Enumeration in \CFA language are called \newterm{C Enumeration} or \newterm{C Enum}.
+The semantics of C Enumeration is mostly consistent with C with more restrictive typing.
+\CFA also extends C Enumeration by adding a number of new features that bring enumerations aligns with other modern programming languages.
 Any enumeration extensions must be intuitive to C programmers both in syntax and semantics.
 The following sections detail all of my new contributions to enumerations in \CFA.
@@ -24 +25 @@
 enum E1 { First, Second, Third, Fourth };
 enum E2 { @Fourth@, @Third@, @Second@, @First@ }; $\C{// same enumerator names}$
-E1 f() { return Third; }                                $\C{// overloaded functions, different return types}$
+E1 f() { return Third; }                                $\C{// overload functions with different return types}$
 E2 f() { return Fourth; }
 void g( E1 e );
@@ -71 +72 @@
 \section{Type Safety}
 
-As in Section~\ref{s:Usage}, C's implicit conversion between enumeration and integral type raises a safety concern.
-\CFA disallows an implicit conversion from integral type to enueration, and conversion between different C enumeration type.
-It loses some degree of its backward compatibility to C, in exchange for type safety.
+As in Section~\ref{s:Usage}, C's implicit bidirectional conversion between enumeration and integral type raises a safety concern.
+In \CFA, the conversion is unidirectional: 
+% disallows an implicit conversion from integral type to enumeration, and conversion between different C enumeration type.
+% It loses some degree of its backward compatibility to C, in exchange for type safety.
+an enumeration can be implicitly converted into an integral type, with an associated @safe@ conversion cost.
+But an integral type cannot be implicitly converted into a C enumeration. (Conversion Cost is Infinity.)
 \begin{cfa}
 enum Bird { Pengin, Robin, Eagle };
@@ -81 +85 @@
 @enum Bird bird = Shark;@ $\C{// Disallow }$ 
 @enum Bird bird = 1;@  $\C{// Disallow }$ 
-
+\end{cfa}
+As a workaround, \CFA allows an explicit cast to an enumeration, turning an integral type to an enumeration that can be used in assignment or function argument, 
+in which case \CFA treats C enuemration as its underlying integral type. In such cases, it is up to user to ensure program correctness.
+\begin{cfa}
 @enum Bird bird = (Bird) Shark@ 
 @enum Bird bird = (Bird) 1;@ 
 \end{cfa}
-As a workaround, \CFA allows explicit cast to an enumeration, turning an integral type to an enumeration that can be used in assignment or function argument, 
-in which case \CFA treats C enuemration as its underlying integral type. In such cases, it is up to user to ensure program correctness.