Ignore:
Timestamp:
Sep 9, 2024, 6:29:59 AM (3 months ago)
Author:
JiadaL <j82liang@…>
Branches:
master
Children:
478dade
Parents:
9bb6c5f
Message:

update thesis

Location:
doc/theses/jiada_liang_MMath
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • doc/theses/jiada_liang_MMath/CFAenum.tex

    r9bb6c5f r29c8675  
    5353enum E { A, B, C, D, @N@ };  // N == 4
    5454\end{cfa}
    55 
    56 The underlying representation of \CFA enumeration object is its position, saved as an integral type.
    57 Therefore, the size of a \CFA enumeration is consistent with a C enumeration.
    58 Attribute function @posn@ performs type substitution on an expression from \CFA type to an integral type.
    59 The label and value of an enumerator are stored in a global data structure for each enumeration, where attribute functions @label@/@value@ map an \CFA enumeration object to the corresponding data.
    60 These operations do not apply to C Enums because backward compatibility means the necessary backing data structures cannot be supplied.
    61 
    6255
    6356\section{Opaque Enumeration}
    … …  
    138131calling constructors happens at runtime (dynamic).
    139132
     133\section{Implementation}
     134\CFA-cc is is a transpiler that translates \CFA code into C, which can later be compiled by a C compiler.
     135
     136During the transpilation, \CFA-cc breaks a \CFA enumeration definition into a definition of a C enumeration with the same name and auxiliary arrays: a label array and a value array for a typed enumeration.
     137For example:
     138\begin{cfa}
     139// CFA (source):
     140enum(T) E { E1=t1, E2=t2, E3=t3 };
     141\end{cfa}
     142is compiled into:
     143\begin{cfa}
     144// C (transpiled by cfa-cc):
     145enum E { E1, E2, E3 };
     146const char * E_labels[3] = { "E1", "E2", "E3" };
     147const T E_values [3] = { t1, t2, t3 };
     148\end{cfa}
     149The generated C enumeration will have enumerator values equals to their positions thanks to C's auto-initialization scheme. Notice that value and label arrays are dynamically allocated data structures that take up
     150memory. If an enumeration is globally defined, the arrays are allocated in the @.data@ section and will be initialized before the program execution.
     151Otherwise, if an enumeration has its definition in a local scope, these arrays will be allocated on the stack and be initialized when the program counter
     152reaches the code location of the enumeration definition.
     153
     154% This bring a considerable overhead to the program, in terms of both execution time and storage.
     155% An opaque enumeration has no overhead
     156% for values, and it has been suggested as a future work to leave as an option to not generate the label array.
     157
     158Alongs with the enumeration defintion, \CFA-cc adds defintions of attribute functions: @posn@, @label@ and @value@:
     159\begin{cfa}
     160inline int posn( E e ) { return (int) e; }
     161inline const * label( E e ) { return E_labels[ (int) e ]; }
     162inline const * E_value( E e ) { return E_values[ (int) e ]; }
     163\end{cfa}
     164These functions are not implemented in \CFA code: they are Abstract Syntax Tree (AST) nodes appends to the Abstract Syntax Tree (AST).
     165Notably, the AST subnode for the "cast to @int@" expression inside the functions is annotated as reinterpreted casts.
     166In order words, the effect of a case is only to change the type of an expression, and it stops further reduction on the expression \see{\VRef{s:ValueConversion}}.
     167
     168Consequently, \CFA enumeration comes with space and runtime overhead, both for enumeration definition and function call to attribute functions. \CFA made efforts to reduce the runtime
     169overhead on function calls by aggressively reducing @label()@ and @value()@ function calls on an enumeration constant to a constant expression. The interpreted casts are extraneous
     170after type checking and removed in later steps. A @label()@ and @value()@ call on an enumeration variable is a lookup of an element of an array of constant values, and it is up to the
     171C compiler to optimize its runtime. While OpaqueEnum is effectively an "opt-out" of the value overhead, it has been suggested that an option to "opt-out" from labels be added as well.
     172A @label()@ function definition is still necessary to accomplish enumeration traits. But it will return an empty string for an enumeration label when "opt-out" or the enumerator name
     173when it is called on an enumeration constant. It will allow a user not to pay the overhead for labels when the enumerator names of a particular enumerated type are not helpful.
    140174
    141175\section{Value Conversion}
    142 
     176\label{s:ValueConversion}
    143177C has an implicit type conversion from an enumerator to its base type @int@.
    144178Correspondingly, \CFA has an implicit conversion from a typed enumerator to its base type, allowing typed enumeration to be seamlessly used as the value of its base type
    … …  
    191225enum(S) E { A, B, C, D };
    192226\end{cfa}
     227
     228The restriction on C's enumeration initializers being constant expression is relaxed on \CFA enumeration.
     229Therefore, an enumerator initializer allows function calls like @?+?( S & s, one_t )@ and @?{}( S & s, zero_t )@.
     230It is because the values of \CFA enumerators are not stored in the compiled enumeration body but in the @value@ array, which
     231allows dynamic initialization.
    193232
    194233\section{Subset}
    … …  
    520559The enumerators in the @case@ clause use the enumerator position for testing.
    521560The prints use @label@ to print an enumerator's name.
    522 Finally, a loop enumerates through the planets computing the weight on each planet for a given earth mass.
     561Finally, a loop enumerates through the planets computing the weight on each planet for a given Earth mass.
    523562The print statement does an equality comparison with an enumeration variable and enumerator (@p == MOON@).
    524563

  • doc/theses/jiada_liang_MMath/Cenum.tex

    r9bb6c5f r29c8675  
    1717There 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.
    1818
    19 The \CFA type-system allows extensive overloading, including enumerators.
     19The \CFA type-system allows extensive overloading, including enumerators. For example, enumerator First from E1 can exist at the scope as First from E2.
    2020Hence, most ambiguities among C enumerators are implicitly resolved by the \CFA type system, possibly without any programmer knowledge of the conflict.
    2121In addition, C Enum qualification is added, exactly like aggregate field-qualification, to disambiguate.
    2222\VRef[Figure]{f:EnumeratorVisibility} shows how resolution, qualification, and casting are used to disambiguate situations for enumerations @E1@ and @E2@.
     23
     24Aside, name shadowing in \CFA only happens when a name has been redefined with the exact same type. Because an enumeration define its type and enumerators in one definition,
     25and enumeration cannot be changed afterward, shadowing an enumerator is not possible (it is impossible to have another @First@ with same type @E1@.).
    2326
    2427\begin{figure}
    … …  
    5760\end{cfa}
    5861% with feature unimplemented
    59 It is possible to toggle back to unscoped using the \CFA @with@ auto-qualification clause/statement (see also \CC \lstinline[language=c++]{using enum} in Section~\ref{s:C++RelatedWork}).
     62It is possible to introduce enumerators from a scoped enumeration to a block scope using the \CFA @with@ auto-qualification clause/statement (see also \CC \lstinline[language=c++]{using enum} in Section~\ref{s:C++RelatedWork}).
    6063\begin{cfa}
    6164with ( @Week@, @RGB@ ) {                                $\C{// type names}$
    … …  
    6568\end{cfa}
    6669As in Section~\ref{s:CVisibility}, 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.
    67 
    6870
    6971\section{Type Safety}

  • doc/theses/jiada_liang_MMath/background.tex

    r9bb6c5f r29c8675  
    66\section{C}
    77
    8 As mentioned in \VRef{s:Aliasing}, it is common for C programmers to ``believe'' there are three equivalent forms of named constants.
     8As mentioned in \VRef{s:Aliasing}, it is common for C programmers to believe there are three equivalent forms of named constants.
    99\begin{clang}
    1010#define Mon 0
    … …  
    1515\item
    1616For @#define@, the programmer must explicitly manage the constant name and value.
    17 Furthermore, these C preprocessor macro names are outside the C type system and can incorrectly change random text in a program.
     17Furthermore, these C preprocessor macro names are outside the C type system and can unintentionally change semantics of a program.
    1818\item
    1919The same explicit management is true for the @const@ declaration, and the @const@ variable cannot appear in constant-expression locations, like @case@ labels, array dimensions,\footnote{
    … …  
    2424\end{clang}
    2525\item
    26 Only the @enum@ form is managed by the compiler, is part of the language type-system, works in all C constant-expression locations, and normally does not occupy storage.
     26Only the @enum@ form is managed by the compiler, is part of the language type-system, works in all C constant-expression locations, and does not occupy storage.
    2727\end{enumerate}
    2828
    … …  
    5555\end{cquote}
    5656However, statically initialized identifiers cannot appear in constant-expression contexts, \eg @case@.
    57 Dynamically initialized identifiers may appear in initialization and array dimensions in @g++@, which allows variable-sized arrays on the stack.
     57Dynamically initialized identifiers may appear in initialization and array dimensions, which allows variable-sized arrays on the stack.
    5858Again, this form of aliasing is not an enumeration.
    5959
    … …  
    132132Theoretically, a C enumeration \emph{variable} is an implementation-defined integral type large enough to hold all enumerator values.
    133133In practice, C defines @int@~\cite[\S~6.4.4.3]{C11} as the underlying type for enumeration variables, restricting initialization to integral constants, which have type @int@ (unless qualified with a size suffix).
    134 However, type @int@ is defined as:
     134According to the C standard, type @int@ is defined as the following:
    135135\begin{quote}
    136136A ``plain'' @int@ object has the natural size suggested by the architecture of the execution environment (large enough to contain any value in the range @INT_MIN@ to @INT_MAX@ as defined in the header @<limits.h>@).~\cite[\S~6.2.5(5)]{C11}
    137137\end{quote}
    138138However, @int@ means 4 bytes on both 32/64-bit architectures, which does not seem like the ``natural'' size for a 64-bit architecture.
    139 Whereas @long int@ means 4 bytes on a 32-bit and 8 bytes on 64-bit architectures, and @long long int@ means 8 bytes on both 32/64-bit architectures, where 64-bit operations are simulated on 32-bit architectures.
     139% Whereas @long int@ means 4 bytes on a 32-bit and 8 bytes on 64-bit architectures, and @long long int@ means 8 bytes on both 32/64-bit architectures, where 64-bit operations are simulated on 32-bit architectures.
    140140\VRef[Figure]{f:gccEnumerationStorageSize} shows both @gcc@ and @clang@ partially ignore this specification and type the integral size of an enumerator based on its initialization.
    141141Hence, initialization in the range @INT_MIN@..@INT_MAX@ results in a 4-byte enumerator, and outside this range, the enumerator is 8 bytes.
    142 Note that @sizeof( typeof( IMin ) ) != sizeof( E )@, making the size of an enumerator different than is containing enumeration type, which seems inconsistent, \eg @sizeof( typeof( 3 ) ) == sizeof( int )@.
     142Note that @sizeof( typeof( IMin ) ) != sizeof( E )@, making the size of an enumerator different than its containing enumeration type, which seems inconsistent.
    143143
    144144\begin{figure}
    … …  
    156156}
    1571578 4
     1584 8
    1581594 -2147483648 2147483647
    1591608 -9223372036854775808 9223372036854775807
    … …  
    168169\label{s:Usage}
    169170
    170 C proves an implicit \emph{bidirectional} conversion between an enumeration and its integral type and between two different enumerations.
     171C proves an implicit \emph{bidirectional} conversion between an enumeration and its integral type and between different enumerations.
    171172\begin{clang}
    172173enum Week week = Mon;                           $\C{// week == 0}$
    … …  
    255256Virtually all programming languages overload the arithmetic operators across the basic types using the number and type of parameters and returns.
    256257Like \CC, \CFA also allows these operators to be overloaded with user-defined types.
    257 The syntax for operator names uses the @'?'@ character to denote a parameter, \eg prefix and infix increment operators: @?++@, @++?@, and @?+?@.
     258The syntax for operator names uses the @'?'@ character to denote a parameter, \eg unary operators: @?++@, @++?@, binary operator @?+?@.
    258259\begin{cfa}
    259260struct S { int i, j };

  • doc/theses/jiada_liang_MMath/conclusion.tex

    r9bb6c5f r29c8675  
    22\label{c:conclusion}
    33
    4 The goal of this work is to extend the simple and unsafe enumeration type in the C programming language into a complex and safe enumeration type in the \CFA programming language while maintaining backward compatibility with C.
     4This work aims to extend the simple and unsafe enumeration type in the C programming language into a complex and safe enumeration type in the \CFA programming language while maintaining backward compatibility with C.
    55Within this goal, the new \CFA enumeration should align with the analogous enumeration features in other languages to match modern programming expectations.
    66Hence, the \CFA enumeration features are borrowed from a number of programming languages, but engineered to work and play with \CFA's type system and feature set.
    … …  
    88Strong type-checking of enumeration initialization and assignment provides additional safety, ensuring an enumeration only contains its enumerators.
    99Overloading and scoping of enumerators significantly reduces the naming problem, providing a better software-engineering environment, with fewer name clashes and the ability to disambiguate those that cannot be implicitly resolved.
    10 Typed enumerations solve the data-harmonization problem increasing safety through better software engineering.
     10Typed enumerations solve the data-harmonization problem, increasing safety through better software engineering.
    1111Moreover, integrating enumerations with existing control structures provides a consistent upgrade for programmers and a succinct and secure mechanism to enumerate with the new loop-range feature.
    1212Generalization and reuse are supported by incorporating the new enumeration type using the \CFA trait system.
    13 Enumeration traits define the meaning of an enumeration, allowing functions to be written that work on any enumeration, such as the reading and printing an enumeration.
    14 Using advanced duck typing, existing C enumerations can be extended so they work with all of the enumeration features, providing for legacy C code to be moved forward into the modern \CFA programming domain.
    15 Finally, I expanded the \CFA project's test-suite with multiple enumeration features tests with respect to implicit conversions, control structures, inheritance, interaction with the polymorphic types, and the features built on top of enumeration traits.
     13Enumeration traits define the meaning of an enumeration, allowing functions to be written that work on any enumeration, such as the reading and printing of an enumeration.
     14With advanced structural typing, C enumerations can be extended so they work with all of the enumeration features, providing for legacy C code to be moved forward into the modern \CFA programming domain.
     15Finally, the \CFA project's test suite has been expanded with multiple enumeration features tests with respect to implicit conversions, control structures, inheritance, interaction with the polymorphic types, and the features built on top of enumeration traits.
    1616These tests ensure future \CFA work does not accidentally break the new enumeration system.
    1717
    18 The conclusion is that the new \CFA enumeration mechanisms achieve the initial goals, providing C programmers with an intuitive enumeration mechanism for handling modern programming requirements.
     18In summary, the new \CFA enumeration mechanisms achieve the initial goals, providing C programmers with an intuitive enumeration mechanism for handling modern programming requirements.
    1919
    2020
    … …  
    5151\end{cfa}
    5252\item
    53 Currently enumeration scoping is all or nothing. In some cases, it might be useful to
     53Currently, enumeration scoping is all or nothing. In some cases, it might be useful to
    5454increase the scoping granularity to individual enumerators.
    5555\begin{cfa}
    … …  
    6868typedef RGB.Red OtherRed; // alias
    6969\end{cfa}
     70\item
     71Label arrays are auxiliary data structures that are always generated for \CFA enumeration, which is a considerable program overhead.
     72It is helpful to provide a new syntax or annotation for a \CFA enumeration definition that tells the compiler the labels will not be used
     73throughout the execution. Therefore, \CFA optimizes the label array away. The @value()@ function can still be used on an enumeration constant,
     74and the function called is reduced to a @char *@ constant expression that holds the name of the enumerator. But if @value()@ is called on
     75a variable with an enumerated type, it returns an empty string since the label information is lost for the runtime.
    7076\end{enumerate}

  • doc/theses/jiada_liang_MMath/intro.tex

    r9bb6c5f r29c8675  
    6161The alias names are constants, which follow transitively from their binding to other constants.
    6262\item
    63 Defines a type for generating instants (variables).
     63Defines a type for generating instances (variables).
    6464\item
    6565For safety, an enumeration instance should be restricted to hold only its constant names.
    … …  
    232232% https://hackage.haskell.org/package/base-4.19.1.0/docs/GHC-Enum.html
    233233
    234 The association between ADT and enumeration occurs if all the constructors have a unit (empty) type, \eg @struct unit {}@.
    235 Note, the unit type is not the same as \lstinline{void}.
    236 \begin{cfa}
    237 void foo( void );
    238 struct unit {} u;       $\C[1.5in]{// empty type}$
    239 unit bar( unit );
    240 foo( @foo()@ );         $\C{// void argument does not match with void parameter}$
    241 bar( bar( u ) );        $\C{// unit argument does match with unit parameter}\CRT$
    242 \end{cfa}
     234% The association between ADT and enumeration occurs if all the constructors have a unit (empty) type, \eg @struct unit {}@.
     235% Note, the unit type is not the same as \lstinline{void}.
     236In terms of functional programming linguistics, enumerations often refers to a @unit type@ ADT, where @unit type@ is a type
     237that carry no information.
     238% \begin{cfa}
     239% void foo( void );
     240% struct unit {} u;     $\C[1.5in]{// empty type}$
     241% unit bar( unit );
     242% foo( @foo()@ );               $\C{// void argument does not match with void parameter}$
     243% bar( bar( u ) );      $\C{// unit argument does match with unit parameter}\CRT$
     244% \end{cfa}
    243245
    244246For example, in the Haskell ADT:

  • doc/theses/jiada_liang_MMath/relatedwork.tex

    r9bb6c5f r29c8675  
    11\chapter{Related Work}
    22\label{s:RelatedWork}
    3 
    4 \begin{comment}
    5 An algebraic data type (ADT) can be viewed as a recursive sum of product types.
    6 A sum type lists values as members.
    7 A member in a sum type definition is known as a data constructor.
    8 For example, C supports sum types union and enumeration (enum).
    9 An enumeration in C can be viewed as the creation of a list of zero-arity data constructors.
    10 A union instance holds a value of one of its member types.
    11 Defining a union does not generate new constructors.
    12 The definition of member types and their constructors are from the outer lexical scope.
    13 
    14 In general, an \newterm{algebraic data type} (ADT) is a composite type, \ie, a type formed by combining other types.
    15 Three common classes of algebraic types are \newterm{array type}, \ie homogeneous types, \newterm{product type}, \ie heterogeneous tuples and records (structures), and \newterm{sum type}, \ie tagged product-types (unions).
    16 Enumerated types are a special case of product/sum types with non-mutable fields, \ie initialized (constructed) once at the type's declaration, possible restricted to compile-time initialization.
    17 Values of algebraic types are access by subscripting, field qualification, or type (pattern) matching.
    18 \end{comment}
    193
    204Enumeration-like features exist in many popular programming languages, both past and present, \eg Pascal~\cite{Pascal}, Ada~\cite{Ada}, \Csharp~\cite{Csharp}, OCaml~\cite{OCaml} \CC, Go~\cite{Go}, Haskell~\cite{Haskell} \see{discussion in \VRef{s:AlgebraicDataType}}, Java~\cite{Java}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
    … …  
    4529type Boolean = ( false, true );
    4630\end{pascal}
    47 The enumeration ordering supports the relational operators @=@, @<>@, @<@, @<=@, @>=@, and @>@, provided both operands are the same (sub)type.
     31The enumeration supports the relational operators @=@, @<>@, @<@, @<=@, @>=@, and @>@, interpreted as as comparison in terms of declaration order.
    4832
    4933The following auto-generated pseudo-functions exist for all enumeration types:
    … …  
    6549         wend : Weekend;
    6650\end{pascal}
    67 Hence, the ordering of the enumerators is crucial to provide the necessary ranges.
     51Hence, declaration order of enumerators is crucial to provide the necessary ranges.
    6852There is a bidirectional assignment between the enumeration and its subranges.
    6953\begin{pascal}
    … …  
    151135
    152136The underlying type is an implementation-defined integral type large enough to hold all enumerated values; it does not have to be the smallest possible type.
    153 The integral size can be explicitly specified using compiler directive @$PACKENUM@~$N$, where $N$ is the number of bytes, \eg:
     137The integral size can be explicitly specified using compiler directive \$@PACKENUM@~$N$, where $N$ is the number of bytes, \eg:
    154138\begin{pascal}
    155139Type @{$\color{red}\$$PACKENUM 1}@ SmallEnum = ( one, two, three );
    … …  
    199183\end{figure}
    200184
    201 Enumerators without initialization are auto-initialized from left to right, starting at zero, incrementing by 1.
     185Enumerators without initialization are auto-initialized from left to right, starting at zero and incrementing by 1.
    202186Enumerators with initialization must set \emph{all} enumerators in \emph{ascending} order, \ie there is no auto-initialization.
    203187\begin{ada}
    … …  
    382366\end{c++}
    383367\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct})\footnote{
    384 The use of keyword \lstinline[language=c++]{class} is resonable because default visibility is \lstinline[language=c++]{private} (scoped).
     368The use of keyword \lstinline[language=c++]{class} is reasonable because default visibility is \lstinline[language=c++]{private} (scoped).
    385369However, default visibility for \lstinline[language=c++]{struct} is \lstinline[language=c++]{public} (unscoped) making it an odd choice.},
    386370where the enumerators are accessed using type qualification.
    … …  
    396380E e = A;    e = B;                                              $\C{// direct access}$
    397381\end{c++}
    398 \CC{11} added the ability to explicitly declare only an underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
     382\CC{11} added the ability to explicitly declare an underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
    399383\begin{c++}
    400384enum class RGB @: long@ { Red, Green, Blue };
    … …  
    430414\end{tabular}
    431415\end{cquote}
    432 However, there is no mechanism to iterate through an enumeration without an unsafe cast and it does not understand the enumerator values.
     416However, there is no mechanism to iterate through an enumeration.
     417A common workaround is to iterate over enumerator as integral values, but it only works if
     418enumerators resemble a sequence of natural, i.e., enumerators are auto-initialized.
     419Otherwises, the iteration would have integers that are not enumeration values.
    433420\begin{c++}
    434421enum Week { Mon, Tue, Wed, Thu = 10, Fri, Sat, Sun };
    … …  
    449436% https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/enums
    450437
    451 \Csharp is a dynamically-typed programming language with a scoped, integral enumeration similar to \CC \lstinline[language=C++]{enum class}.
     438\Csharp is a programming language with a scoped, integral enumeration similar to \CC \lstinline[language=C++]{enum class}.
    452439\begin{csharp}
    453440enum Week : @long@ { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun }
    … …  
    508495\end{cquote}
    509496
    510 To indirectly enumerate, \Csharp's Enum library has @Enum.GetValues@, a pseudo-method that retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     497To indirectly enumerate, \Csharp's Enum library provides @Enum.GetValues@,
     498% a pseudo-method that retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     499a static memeber of abstract Enum type that return a reference to an array of all enumeration constants.
     500Internally, a Enum type has a static member called @fieldInfoHash@, a @Hashtable@ that stores enumerators information. The field is populated on-demand:
     501it only contains information if a @reflection@ like @GetValues@ is called. But the information will be cached, so the cost of reflection is paid only
     502once throughout the lifetime of a program. @GetValues@ then converts a @Hashtable@ to an @Array@, which supports enumerating.
    511503\begin{csharp}
    512504foreach ( Week d in @Enum.GetValues@( typeof(Week) ) ) {
    … …  
    535527\label{s:Go}
    536528
    537 Go has a no enumeration.
    538 It has @const@ aliasing declarations, similar to \CC \see{\VRef{s:C++RelatedWork}}, for basic types with type inferencing and static initialization (constant expression).
     529Go has @const@ aliasing declarations, similar to \CC \see{\VRef{s:C++RelatedWork}}, for basic types with type inferencing and static initialization (constant expression).
     530The most basic form of constant definition is a @const@ keyword, followed by the name of constant, an optional type declaration of the constant, and a mandatory initialize.
     531For exmaple:
    539532\begin{Go}
    540533const R @int@ = 0;  const G @uint@ = 1;  const B = 2; $\C{// explicit typing and type inferencing}$
    … …  
    544537const V = 3.1;  const W = 3.1;
    545538\end{Go}
    546 Since these declarations are immutable variables, they are unscoped and Go has no overloading.
    547 
    548 Go provides an enumeration-like feature to group together @const@ declaration into a block and introduces a form of auto-initialization.
     539Since these declarations are immutable variables, they are unscoped and Go has no overloading. If no type declaration provided, Go infers
     540type from the initializer expression.
     541
     542% Go provides an enumeration-like feature to group together @const@ declaration into a block and introduces a form of auto-initialization.
     543These named constants can be grouped together in one @const@ declaration block and introduces a form of auto-initialization.
    549544\begin{Go}
    550545const ( R = 0; G; B )                                   $\C{// implicit initialization: 0 0 0}$
    551546const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit initialization: Fred Mary Jane}$
    552 const ( S = 0; T; USA = "USA"; U; V = 3.1; W ) $\C{// type change, implicit/explicit: 0 0 USA USA 3.1 3.1}$
     547const ( S = 0; T; USA = "USA"; U; V = 3.1; W ) $\C{// implicit/explicit: 0 0 USA USA 3.1 3.1}$
    553548\end{Go}
    554549The first identifier \emph{must} be explicitly initialized;
    555550subsequent identifiers can be implicitly or explicitly initialized.
    556 Implicit initialization is the \emph{previous} (predecessor) identifier value.
    557 
    558 Each @const@ declaration provides an implicit integer counter starting at zero, called \lstinline[language=Go]{iota}.
     551Implicit initialization always uses the \emph{previous} (predecessor) constant expression initializer.
     552
     553% Each @const@ declaration provides an implicit integer counter starting at zero, called \lstinline[language=Go]{iota}.
     554Each const declaration is often paired with a const expression \lstinline[language=Go]{iota} to re-define its
     555implicit initialization. \lstinline[language=Go]{iota} represents an sequence of natural number starting from zero.
     556Every implicit or explicit \lstinline[language=Go]{iota} increments the value of the expression by one.
    559557Using \lstinline[language=Go]{iota} outside of a @const@ block always sets the identifier to zero.
    560558\begin{Go}
    561559const R = iota;                                                 $\C{// 0}$
    562560\end{Go}
    563 Inside a @const@ block, \lstinline[language=Go]{iota} is implicitly incremented for each \lstinline[language=golang]{const} identifier and used to initialize the next uninitialized identifier.
     561% Inside a @const@ block, \lstinline[language=Go]{iota} is implicitly incremented for each \lstinline[language=golang]{const} identifier and used to initialize the next uninitialized identifier.
     562Inside a @const@ block, if a constant has \lstinline[language=Go]{iota} initializer, its successor will also use \lstinline[language=Go]{iota} initializer.
     563\lstinline[language=Go]{iota} is no different than other constant expression when it is used in implicit initialization, but
     564thanks to the increment natural of \lstinline[language=Go]{iota}, the successor will have a value equal to its predecessor plus 1.
    564565\begin{Go}
    565566const ( R = @iota@; G; B )                              $\C{// implicit: 0 1 2}$
     567% const ( C = @iota + B + 1@; G; Y )            $\C{// implicit: 3 4 5}$
     568\end{Go}
     569The constant blocks from the previous example is equivalanet to:
     570\begin{Go}
     571const ( R = @iota@; G=@iota@; B=@iota@ )                                $\C{// implicit: 0 1 2}$
     572\end{Go}
     573R, G, B have values 0, 1, 2, respectively, because \lstinline[language=Go]{iota} is an increasing.
     574
     575Similarly,
     576\begin{Go}
    566577const ( C = @iota + B + 1@; G; Y )              $\C{// implicit: 3 4 5}$
    567578\end{Go}
    568 An underscore \lstinline[language=golang]{const} identifier advances \lstinline[language=Go]{iota}.
     579can be rewritten as:
    569580\begin{Go}
    570 const ( O1 = iota + 1; @_@; O3; @_@; O5 ) // 1, 3, 5
     581const ( C = @iota + B + 1@; G = @iota + B + 1@; Y = @iota + B + 1@ )            $\C{// implicit: 3 4 5}$
    571582\end{Go}
    572 Auto-initialization reverts from \lstinline[language=Go]{iota} to the previous value after an explicit initialization, but auto-incrementing of \lstinline[language=Go]{iota} continues.
     583Go's grouped constants do not define a new type, and constants in the same block can have heterogeneous types.
     584These two characteristics differs a grouped constant from an enumeration, but also gives a direction on approximating enumeration in Go:
     585first to define a new type externally, and make sure all constants in the same group will have the new type.
    573586\begin{Go}
    574 const ( Mon = iota; Tue; Wed; // 0, 1, 2
    575                 @Thu = 10@; Fri; Sat; @Sun = itoa@ ) $\C{// 10, 10, 10, {\color{red}6}}$
     587type Language int64
     588const (
     589        C Language = iota
     590        CPP
     591        CSharp
     592        CFA
     593        Go
     594)
    576595\end{Go}
    577 Auto-initialization from \lstinline[language=Go]{iota} is restarted and \lstinline[language=Go]{iota} reinitialized with an expression containing at most \emph{one} \lstinline[language=Go]{iota}.
    578 \begin{Go}
    579 const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@ + 1; V5 ) // 0 1 7 4 5
    580 const ( Mon = iota; Tue; Wed; // 0, 1, 2
    581                 @Thu = 10;@ Fri = @iota@ - Wed + Thu - 1; Sat; Sun ) // 10, 11, 12, 13
    582 \end{Go}
    583 Here, @V4@ and @Fri@ restart auto-incrementing from \lstinline[language=Go]{iota} and reset \lstinline[language=Go]{iota} to 4 and 11, respectively, because of the initialization expressions containing \lstinline[language=Go]{iota}.
    584 Note, because \lstinline[language=Go]{iota} is incremented for an explicitly initialized identifier or @_@,
    585 at @Fri@ \lstinline[language=Go]{iota} is 4 requiring the minus one to compute the value for @Fri@.
     596By typing the first constant as @Language@ and assigning initializer with \lstinline[language=Go]{iota}, all other constants will have the same type
     597and the same initialzer. It is a close approximation, but it is not a real enumeration. The definition of the "enumerated type" is separate from
     598the "enumerator definition", and nothing stop outside constants to have the type @Language@.
     599
     600% An underscore \lstinline[language=golang]{const} identifier advances \lstinline[language=Go]{iota}.
     601% \begin{Go}
     602% const ( O1 = iota + 1; @_@; O3; @_@; O5 ) // 1, 3, 5
     603% \end{Go}
     604% Auto-initialization reverts from \lstinline[language=Go]{iota} to the previous value after an explicit initialization, but auto-incrementing of \lstinline[language=Go]{iota} continues.
     605% \begin{Go}
     606% const ( Mon = iota; Tue; Wed; // 0, 1, 2
     607%               @Thu = 10@; Fri; Sat; @Sun = itoa@ ) $\C{// 10, 10, 10, {\color{red}6}}$
     608% \end{Go}
     609% Auto-initialization from \lstinline[language=Go]{iota} is restarted and \lstinline[language=Go]{iota} reinitialized with an expression containing at most \emph{one} \lstinline[language=Go]{iota}.
     610% \begin{Go}
     611% const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@ + 1; V5 ) // 0 1 7 4 5
     612% const ( Mon = iota; Tue; Wed; // 0, 1, 2
     613%               @Thu = 10;@ Fri = @iota@ - Wed + Thu - 1; Sat; Sun ) // 10, 11, 12, 13
     614% \end{Go}
     615% Here, @V4@ and @Fri@ restart auto-incrementing from \lstinline[language=Go]{iota} and reset \lstinline[language=Go]{iota} to 4 and 11, respectively, because of the initialization expressions containing \lstinline[language=Go]{iota}.
     616% Note, because \lstinline[language=Go]{iota} is incremented for an explicitly initialized identifier or @_@,
     617% at @Fri@ \lstinline[language=Go]{iota} is 4 requiring the minus one to compute the value for @Fri@.
     618
    586619
    587620Basic switch and looping are possible.
    … …  
    610643\end{tabular}
    611644\end{cquote}
    612 However, the loop prints the values from 0 to 13 because there is no actual enumeration.
     645However, the loop in this example prints the values from 0 to 13 because there is no actual enumeration.
    613646
    614647A constant variable can be used as an array dimension or a subscript.
    … …  
    627660Week day = Week.Sat;
    628661\end{Java}
    629 The enumerator's members are scoped and cannot be made \lstinline[language=java]{public}, hence requiring qualification.
     662The enumerator's members are scoped and requires qualification.
    630663The value of an enumeration instance is restricted to its enumerators.
    631664
    … …  
    663696If the implementation member is \lstinline[language=Java]{public}, the enumeration is unsafe, as any value of the underlying type can be assigned to it, \eg @day = 42@.
    664697The implementation constructor must be private since it is only used internally to initialize the enumerators.
    665 Initialization occurs at the enumeration-type declaration for each enumerator in the first line.
     698Initialization occurs at the enumeration-type declaration.
    666699
    667700Enumerations can be used in the @if@ and @switch@ statements but only for equality tests.
    … …  
    691724
    692725There are no arithmetic operations on enumerations, so there is no arithmetic way to iterate through an enumeration without making the implementation type \lstinline[language=Java]{public}.
    693 Like \Csharp, looping over an enumeration is done using method @values@, which returns an array of enumerator values (expensive operation).
     726Like \Csharp, looping over an enumeration is done using static method @values@, which returns an array of enumerator values.
     727Unfortunately, @values@ is an expensive @O(n)@ operation because it creates a new array every time it is called.
    694728\begin{Java}
    695729for ( Week d : Week.values() ) {
    … …  
    700734Like \Csharp, enumerating is supplied indirectly through another enumerable type, not via the enumeration.
    701735
     736% Java provides an @EnumSet@ where the underlying type is an efficient set of bits, one per enumeration \see{\Csharp \lstinline{Flags}, \VRef{s:Csharp}}, providing (logical) operations on groups of enumerators.
     737% There is also a specialized version of @HashMap@ with enumerator keys, which has performance benefits.
     738Java provides @EnumSet@, an auxiliary data structure that takes an enum @class@ as parameter (Week.class) for its construction, and it contains members only with the supplied
     739enum type. @EnumSet@ is enumerable because it extends @AbstractSet@ interfaces and thus supports direct enumerating via @forEach@. It also has subset operation
     740@range@ and it is possible to add to and remove from members of the set.
     741@EnumSet@ supports more enumeration features, but it is not an enumeration type: it is a set of enumerators from a pre-define enum.
     742
     743
    702744An enumeration type cannot declare an array dimension nor can an enumerator be used as a subscript.
    703745Enumeration inheritence is disallowed because an enumeration is \lstinline[language=Java]{final}.
    704 
    705 Java provides an @EnumSet@ where the underlying type is an efficient set of bits, one per enumeration \see{\Csharp \lstinline{Flags}, \VRef{s:Csharp}}, providing (logical) operations on groups of enumerators.
    706 There is also a specialized version of @HashMap@ with enumerator keys, which has performance benefits.
    707 
    708746
    709747\section{Rust}
    … …  
    733771adt = ADT::S(s);  println!( "{:?}", adt );
    734772@match@ adt {
    735         ADT::I( i ) => println!( "{:}", i ),
    736         ADT::F( f ) => println!( "{:}", f ),
    737         ADT::S( s ) => println!( "{:} {:}", s.i, s.j ),
     773        ADT::I( i ) $=>$ println!( "{:}", i ),
     774        ADT::F( f ) $=>$ println!( "{:}", f ),
     775        ADT::S( s ) $=>$ println!( "{:} {:}", s.i, s.j ),
    738776}
    739777\end{rust}
    … …  
    757795let mut week : Week = Week::Mon;
    758796match week {
    759         Week::Mon => println!( "Mon" ),
     797        Week::Mon $=>$ println!( "Mon" ),
    760798        ...
    761         Week::Sun => println!( "Sun" ),
     799        Week::Sun $=>$ println!( "Sun" ),
    762800}
    763801\end{rust}
    … …  
    813851        Week::Mon | Week:: Tue | Week::Wed | Week::Thu
    814852                | Week::Fri => println!( "weekday" ),
    815         Week::Sat | Week:: Sun => println!( "weekend" ),
     853        Week::Sat | Week:: Sun $=>$ println!( "weekend" ),
    816854}
    817855\end{c++}
    818856\end{tabular}
    819857\end{cquote}
    820 However, there is no mechanism to iterate through an enumeration without casting to integral and positions versus values is not handled.
     858% However, there is no mechanism to iterate through an enumeration without casting to integral and positions versus values is not handled.
     859Like C/\CC, there is no mechanism to iterate through an enumeration. It can only be approximated
     860by a loop over a range of enumerator and will not work if enumerator values is a sequence of natural numbers.
    821861\begin{c++}
    822862for d in Week::Mon as isize ..= Week::Sun as isize {
    … …  
    8258650 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
    826866\end{c++}
    827 An enumeration type cannot declare an array dimension nor as a subscript.
    828 There is no mechanism to subset or inherit from an enumeration.
     867% An enumeration type cannot declare an array dimension nor as a subscript.
     868There is no direct way to harmonize an enumeration and another data structure. For example,
     869there is no mapping from an enumerated type to an array type.
     870In terms of extensibility, there is no mechanism to subset or inherit from an enumeration.
    829871
    830872
    831873\section{Swift}
    832 
     874\label{s:Swift}
    833875% https://www.programiz.com/swift/online-compiler
    834 
    835 Like Rust, Swift @enum@ provides two largely independent mechanisms from a single language feature: an ADT and an enumeration.
     876Despite being named as enumeration, A Swift @enum@ is in fact a ADT: cases (enumerators) of an @enum@ can have heterogeneous types and be recursive.
     877% Like Rust, Swift @enum@ provides two largely independent mechanisms from a single language feature: an ADT and an enumeration.
    836878When @enum@ is an ADT, pattern matching is used to discriminate among the variant types.
    837879\begin{cquote}
    … …  
    875917\end{tabular}
    876918\end{cquote}
    877 Note, after an @adt@'s type is know, the enumerator is inferred without qualification, \eg @.I(3)@.
    878 
    879 An enumeration is created when \emph{all} the enumerators are unit-type, which is like a scoped, opaque enumeration.
     919% Note, after an @adt@'s type is know, the enumerator is inferred without qualification, \eg @.I(3)@.
     920Normally an enumeration case needs a type qualification. But in the example when pattern matching @adt@, which
     921has a type @ADT@, the context provides that the cases refer to @ADT@'s cases and no explicit type qualification is required.
     922
     923% An enumeration is created when \emph{all} the enumerators are unit-type, which is like a scoped, opaque enumeration.
     924Without type declaration for enumeration cases, a Swift enum syntax defined a unit-type enumeration, which is like a scoped, opaque enumeration.
    880925\begin{swift}
    881926enum Week { case Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // unit-type
    882927var week : Week = @Week.Mon@;
    883928\end{swift}
    884 As well, it is possible to type \emph{all} the enumerators with a common type, and set different values for each enumerator;
    885 for integral types, there is auto-incrementing.
     929% As well, it is possible to type \emph{all} the enumerators with a common type, and set different values for each enumerator;
     930% for integral types, there is auto-incrementing.
     931As well, it is possible to type associated values of enumeration cases with a common types.
     932When enumeration cases are typed with a common integral type, Swift auto-initialize enumeration cases following the same initialization scheme as C language.
     933If enumeration is typed with @string@, its cases are auto-initialized to case names (labels).
    886934\begin{cquote}
    887935\setlength{\tabcolsep}{15pt}
    … …  
    933981\end{tabular}
    934982\end{cquote}
    935 Enumerating is accomplished by inheriting from @CaseIterable@ without any associated values.
     983Enumerating is accomplished by inheriting from @CaseIterable@ protocol, which has a static
     984@enum.allCases@ property that returns a collection of all the cases for looping over an enumeration type or variable.
     985Like \CFA, Swift's default enumerator output is the case name (label). An enumerator of a typed enumeration has attribute
     986@rawValue@ that return its case value.
    936987\begin{swift}
    937988enum Week: Comparable, @CaseIterable@ {
    … …  
    943994Mon Tue Wed Thu Fri Sat Sun
    944995\end{swift}
    945 The @enum.allCases@ property returns a collection of all the cases for looping over an enumeration type or variable (expensive operation).
    946 
    947 A typed enumeration is accomplished by inheriting from any Swift type, and accessing the underlying enumerator value is done with the attribute @rawValue@.
    948 Type @Int@ has auto-incrementing from the previous enumerator;
    949 type @String@ has auto-incrementing of the enumerator label.
     996
     997
    950998\begin{cquote}
    951999\setlength{\tabcolsep}{15pt}
    … …  
    9751023\end{cquote}
    9761024
    977 There is a bidirectional conversion from typed enumerator to @rawValue@ and vice versa.
     1025There is a safe bidirectional conversion from typed enumerator to @rawValue@ and vice versa.
    9781026\begin{swift}
    979 var weekInt : WeekInt = WeekInt.Mon;
    9801027if let opt = WeekInt( rawValue: 0 ) {  // test optional return value
    981         print( weekInt.rawValue, opt )  // 0 Mon
     1028        print( opt.rawValue, opt )  // 0 Mon
    9821029} else {
    9831030        print( "invalid weekday lookup" )
    9841031}
    9851032\end{swift}
    986 Conversion from @rawValue@ to enumerator may fail (bad lookup), so the result is an optional value.
    987 
     1033% Conversion from @rawValue@ to enumerator may fail (bad lookup), so the result is an optional value.
     1034In the previous exmaple, the initialization of @opt@ fails when there is no enumeration cases has value equals 0, resulting in a
     1035@nil@ value. Initialization from a raw value is considered a expensive operation because it requires a value lookup.
    9881036
    9891037\section{Python 3.13}
    … …  
    10041052class Week(!Enum!): Mon = 1; Tue = 2; Wed = 3; Thu = 4; Fri = 5; Sat = 6; Sun = 7
    10051053\end{python}
    1006 and/or explicitly auto-initialized, \eg:
     1054and/or explicitly auto-initialized with @auto@ method, \eg:
    10071055\begin{python}
    10081056class Week(Enum): Mon = 1; Tue = 2; Wed = 3; Thu = 10; Fri = !auto()!; Sat = 4; Sun = !auto()!
    10091057Mon : 1 Tue : 2 Wed : 3 Thu : 10 Fri : !11! Sat : 4 Sun : !12!
    10101058\end{python}
    1011 where @auto@ increments by 1 from the previous @auto@ value \see{Go \lstinline[language=Go]{iota}, \VRef{s:Go}}.
    1012 @auto@ is controlled by member @_generate_next_value_()@, which can be overridden:
     1059@auto@ is controlled by member @_generate_next_value_()@, which by default return one plus the highest value among enumerators, and can be overridden:
    10131060\begin{python}
    10141061@staticmethod
    … …  
    11971244% https://dev.realworldocaml.org/runtime-memory-layout.html
    11981245
    1199 Like Haskell, OCaml @enum@ provides two largely independent mechanisms from a single language feature: an ADT and an enumeration.
     1246Like Swift (\VRef{s:Swift}) and Haskell (\VRef{s:AlgebraicDataType}), OCaml @enum@ provides two largely independent mechanisms from a single language feature: an ADT and an enumeration.
    12001247When @enum@ is an ADT, pattern matching is used to discriminate among the variant types.
    12011248\begin{cquote}
    … …  
    12361283\end{tabular}
    12371284\end{cquote}
    1238 (Note, after an @adtv@'s type is know, the enumerator is inferred without qualification, \eg @I(3)@.)
     1285% (Note, after an @adtv@'s type is know, the enumerator is inferred without qualification, \eg @I(3)@.)
     1286
    12391287The type names are independent of the type value and mapped to an opaque, ascending, integral tag, starting from 0, supporting relational operators @<@, @<=@, @>@, and @>=@.
    12401288\begin{cquote}
    … …  
    12781326
    12791327While OCaml enumerators have an ordering following the definition order, they are not enumerable.
    1280 To iterate over all enumerators, an OCaml type needs to derive from the @enumerate@ preprocessor, which appends a list of all enumerators to the program abstract syntax tree (AST).
    1281 However, the list of values may not persist in the defined ordering.
    1282 As a consequence, there is no meaningful enumerating mechanism.
    1283 
    1284 Enumeration subsetting is allowed but inheritance is restricted to classes not types.
    1285 \begin{ocaml}
    1286 type weekday = Mon | Tue | Wed | Thu | Fri
    1287 type weekend = Sat | Sun
    1288 type week = Weekday of weekday | Weekend of weekend
    1289 let day : week = Weekend Sun
    1290 \end{ocaml}
     1328To iterate over all enumerators, an OCaml type needs to derive from the @enumerate@ PPX (Pre-Preocessor eXtension), which appends a list of all enumerators to the program abstract syntax tree (AST).
     1329However, as stated in the documentation, @enumerate@ PPX does not guarantee the order of the list.
     1330PPX is beyond the scope of OCaml native language and it is a preprocessor directly modifying a parsed AST. In conclusion, there is no enumerating mechanism within the scope of OCaml language.
    12911331
    12921332%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    … …  
    15271567opaque                  & \CM    &                              &                  & \CM    & \CM   &             & \CM         & \CM                   &               &               &               & \CM   \\
    15281568\hline
    1529 typed                   & Int    & Int                  & Integral  & H     & U     & H       & U/H         & U/H           & H     & Int       & Integral& U   \\
     1569typed                   & Int    & Int                  & Int     & H     & U     & H       & U/H         & U/H           & H       & Int       & Int   & U     \\
    15301570\hline
    15311571safety          & \CM   & \CM                   &          & \CM        & \CM   &                 & \CM                 & \CM                   &               &               & \CM   & \CM   \\
    … …  
    15331573posn ordered    & Implied & Implied     &          & \CM    &       &             &                         &                   &       &           &       & \CM       \\
    15341574\hline
    1535 unique values   & \CM   & \CM           &           &           &       &      &                            & \CM               &       &           &       &     \\
     1575unique values   & \CM   & \CM           &           &\CM        &       &      &                            & \CM               &       &           &       &     \\
    15361576\hline
    1537 auto-init               & \CM   & all or none   & \CM      &     &       & \CM     & \CM           & \CM               & \CM   & \CM   & \CM   & \CM   \\
     1577auto-init               & \CM   & all or none   & \CM      & N/A &       & \CM     & \CM            & \CM               & \CM   & \CM   & \CM   & \CM   \\
    15381578\hline
    15391579(Un)Scoped              & U     & U                     & S        & S      & S         & U       & S               & S                         & S     & U             & U/S   & U/S   \\
    … …  
    15451585arr. dim.               & \CM   & \CM           &                  &              &                 &           &                 &                         &            &      &               & \CM \\
    15461586\hline
    1547 subset                  & \CM   & \CM                   &         & \CM     &           &                 &                         &                   &               &               &               & \CM   \\
     1587subset                  & \CM   & \CM                   &         &      &              &                 &                         &                   &               &               &               & \CM   \\
    15481588\hline
    15491589superset                &               &                               &                 &                 &           &                 &                         &               &           &               &               & \CM   \\
    … …  
    15591599Position ordered is implied if the enumerator values must be strictly increasingly.
    15601600\item unique value: enumerators must have a unique value.
    1561 \item auto-init: Values are auto-initializable by language specification, often being "+1" of the predecessor.
     1601\item auto-init: Values are auto-initializable by language specification. \\
     1602It is not appliable to OCaml because OCaml enumeration has unit type.
    15621603\item (Un)Scoped: U $\Rightarrow$ enumerators are projected into the containing scope.
    15631604S $\Rightarrow$ enumerators are contained in the enumeration scope and require qualification.
Note: See TracChangeset for help on using the changeset viewer.