Changeset ec20ab9 for doc


Ignore:
Timestamp:
May 12, 2024, 8:42:31 PM (7 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
bf4fe05
Parents:
07e9df1
Message:

small updates, and more proofreading of the related-works chapter

Location:
doc/theses/jiada_liang_MMath
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • doc/theses/jiada_liang_MMath/CFAenum.tex

    r07e9df1 rec20ab9  
    1111
    1212C already provides @const@-style aliasing using the unnamed enumerator \see{\VRef{s:TypeName}}, even if the name @enum@ is misleading (@const@ would be better).
    13 Given the existence of this form, it is straightforward to extend it with types other than integers.
     13Given the existence of this form, it is straightforward to extend it with types other than @int@.
    1414\begin{cfa}
    1515enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
    … …  
    2121
    2222
    23 \section{Enumerator Unscoping}
    24 \label{s:EnumeratorUnscoping}
    25 
    26 In C, unscoped enumerators presents a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
     23\section{Enumerator Visibility}
     24\label{s:EnumeratorVisibility}
     25
     26In C, unscoped enumerators present a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
    2727There is no mechanism in C to resolve these naming conflicts other than renaming one of the duplicates, which may be impossible.
    2828
    … …  
    3333enum E1 { First, Second, Third, Fourth };
    3434enum E2 { @Fourth@, @Third@, @Second@, @First@ }; $\C{// same enumerator names}$
    35 E1 p() { return Third; }                                $\C{// correctly resolved duplicate names}$
     35E1 p() { return Third; }                                $\C{// return}$
    3636E2 p() { return Fourth; }
    3737void foo() {
    … …  
    5454enum RGB @!@ { Red, Green, Blue };
    5555\end{cfa}
    56 Now the enumerators \emph{must} be qualified with the associated enumeration.
     56Now the enumerators \emph{must} be qualified with the associated enumeration type.
    5757\begin{cfa}
    5858Week week = @Week.@Mon;
    … …  
    6868}
    6969\end{cfa}
    70 As in Section~\ref{s:EnumeratorUnscoping}, opening multiple scoped enumerations in a @with@ can result in duplicate enumeration names, but \CFA implicit type resolution and explicit qualification/casting handles ambiguities.
     70As 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.
    7171
    7272
    … …  
    243243\end{cfa}
    244244which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicase @case@ clauses.
    245 To better match with programmer intuition, \CFA toggles between value and position semantics depneding on the language context.
     245To better match with programmer intuition, \CFA toggles between value and position semantics depending on the language context.
    246246For conditional clauses and switch statments, \CFA uses the robust position implementation.
    247247\begin{cfa}

  • doc/theses/jiada_liang_MMath/background.tex

    r07e9df1 rec20ab9  
    7474However, it is restricted to integral values.
    7575\begin{clang}
    76 enum { Size = 20, Max = 10, MaxPlus10 = Max + 10, Max10Plus1, Fred = -7 };
     76enum { Size = 20, Max = 10, MaxPlus10 = Max + 10, @Max10Plus1@, Fred = -7 };
    7777\end{clang}
    7878Here, the aliased constants are: 20, 10, 20, 21, and -7.
    7979Direct initialization is by a compile-time expression generating a constant value.
    80 An enumerator without initialization is \newterm{auto-initialized}: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
     80Indirect initialization (without initialization, @Max10Plus1@) is \newterm{auto-initialized}: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
    8181Because multiple independent enumerators can be combined, enumerators with the same values can occur.
    8282The enumerators are rvalues, so assignment is disallowed.
    … …  
    8888\begin{cfa}
    8989typedef struct /* unnamed */  { ... } S;
    90 struct /* unnamed */  { ... } x, y, z;                  $\C{// questionable}$
     90struct /* unnamed */  { ... } x, y, z;  $\C{// questionable}$
    9191struct S {
    92         union /* unnamed */ {                                           $\C{// unscoped fields}$
     92        union /* unnamed */ {                           $\C{// unscoped fields}$
    9393                int i;  double d ;  char ch;
    9494        };
    … …  
    107107enum Week {
    108108        Thu@ = 10@, Fri, Sat, Sun,
    109         Mon@ = 0@, Tue, Wed@,@ }; // terminating comma
     109        Mon@ = 0@, Tue, Wed@,@                  $\C{// terminating comma}$
     110};
    110111\end{clang}
    111112Note, the comma in the enumerator list can be a terminator or a separator, allowing the list to end with a dangling comma.\footnote{

  • doc/theses/jiada_liang_MMath/intro.tex

    r07e9df1 rec20ab9  
    135135
    136136\subsection{Algebraic Data Type}
     137\label{s:AlgebraicDataType}
    137138
    138139An algebraic data type (ADT)\footnote{ADT is overloaded with abstract data type.} is another language feature often linked with enumeration, where an ADT conjoins an arbitrary type, possibly a \lstinline[language=C++]{class} or @union@, and a named constructor.

  • doc/theses/jiada_liang_MMath/relatedwork.tex

    r07e9df1 rec20ab9  
    1818\end{comment}
    1919
    20 Enumeration-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}, Java~\cite{Java}, Modula-3~\cite{Modula-3}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
     20Enumeration-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}, Java~\cite{Java}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
    2121Among theses languages, there are a large set of overlapping features, but each language has its own unique extensions and restrictions.
    2222
    … …  
    2424\label{s:Pascal}
    2525
    26 Classic Pascal has the \lstinline[language=Pascal]{const} aliasing declaration binding a name to a constant literal/expression.
     26Classic Pascal introduced the \lstinline[language=Pascal]{const} aliasing declaration binding a name to a constant literal/expression.
    2727\begin{pascal}
    2828const one = 0 + 1;   Vowels = set of (A,E,I,O,U);   NULL = NIL;
    … …  
    6262type Traffic_Light is ( @Red@, Yellow, @Green@ );
    6363\end{ada}
    64 Like \CFA, Ada uses an advanced type-resolution algorithm, including the left-hand side of assignment, to disambiguate among overloaded identifiers.
     64Like \CFA, Ada uses a type-resolution algorithm including the left-hand side of assignmente to disambiguate among overloaded identifiers.
    6565\VRef[Figure]{f:AdaEnumeration} shows how ambiguity is handled using a cast, \ie \lstinline[language=ada]{RGB'(Red)}.
    6666
    … …  
    9797Ada provides an alias mechanism, \lstinline[language=ada]{renames}, for aliasing types, which is useful to shorten package identifiers.
    9898\begin{ada}
    99 OtherRed : RGB renames Red;
     99@OtherRed@ : RGB renames Red;
    100100\end{ada}
    101101which suggests a possible \CFA extension to @typedef@.
    … …  
    160160Hence, the ordering of the enumerators is crucial to provide the necessary ranges.
    161161
    162 An enumeration type can be used in the Ada \lstinline[language=ada]{case} (all enumerators must appear or a default) or iterating constructs.
     162An enumeration type can be used in the Ada \lstinline[language=ada]{case} (all enumerators must appear or a @default@) or iterating constructs.
    163163\begin{cquote}
    164164\setlength{\tabcolsep}{15pt}
    … …  
    241241whereas C @const@ declarations without @static@ are marked @R@.
    242242
    243 The following \CC non-backwards compatible changes are made \see{\cite[\S~7.2]{ANSI98:C++}}.
     243The following \CC non-backwards compatible changes are made \see{\cite[\S~7.2]{ANSI98:c++}}.
    244244\begin{cquote}
    245245Change: \CC objects of enumeration type can only be assigned values of the same enumeration type.
    … …  
    248248\begin{c++}
    249249enum color { red, blue, green };
    250 color c = 1;                                                    $\C{// valid C, invalid C++}$
     250color c = 1;                                                    $\C{// valid C, invalid c++}$
    251251\end{c++}
    252252\textbf{Rationale}: The type-safe nature of \CC. \\
    … …  
    263263enum e { A };
    264264sizeof(A) == sizeof(int)                                $\C{// in C}$
    265 sizeof(A) == sizeof(e)                                  $\C{// in C++}$
     265sizeof(A) == sizeof(e)                                  $\C{// in c++}$
    266266/* and sizeof(int) is not necessary equal to sizeof(e) */
    267267\end{c++}
    … …  
    279279int i = A;    i = e;                                    $\C{// implicit casts to int}$
    280280\end{c++}
    281 \CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are accessed using type qualification.
     281\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct})\footnote{
     282The use of keyword \lstinline[language=c++]{class} is resonable because default visibility is \lstinline[language=c++]{private} (scoped).
     283However, default visibility for \lstinline[language=c++]{struct} is \lstinline[language=c++]{public} (unscoped) making it an odd choice.},
     284where the enumerators are accessed using type qualification.
    282285\begin{c++}
    283286enum class E { A, B, C };
    … …  
    291294E e = A;    e = B;                                              $\C{// direct access}$
    292295\end{c++}
    293 \CC{11} added the ability to explicitly declare the underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
     296\CC{11} added the ability to explicitly declare only an underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
    294297\begin{c++}
    295298enum class RGB @: long@ { Red, Green, Blue };
    … …  
    302305char ch = rgb::Red;   ch = crgb;                $\C{// error}$
    303306\end{c++}
    304 Finally, enumerations can be used in the @switch@ statement but there is no mechanism to iterate through an enumeration.
    305 An enumeration type cannot declare an array dimension but can be used as a subscript.
    306 There is no mechanism to subtype or inherit from enumerations.
     307An enumeration can be used in the @if@ and @switch@ statements.
     308\begin{cquote}
     309\setlength{\tabcolsep}{15pt}
     310\begin{tabular}{@{}ll@{}}
     311\begin{c++}
     312if ( @day@ <= Fri )
     313        cout << "weekday" << endl;
     314
     315
     316
     317
     318\end{c++}
     319&
     320\begin{c++}
     321switch ( @day@ ) {
     322  case Mon: case Tue: case Wed: case Thu: case Fri:
     323        cout << "weekday" << endl; break;
     324  case Sat: case Sun:
     325        cout << "weekend" << endl; break;
     326}
     327\end{c++}
     328\end{tabular}
     329\end{cquote}
     330However, there is no mechanism to iterate through an enumeration without an unsafe cast and it does not understand the enumerator values.
     331\begin{c++}
     332enum Week { Mon, Tue, Wed, Thu = 10, Fri, Sat, Sun };
     333for ( Week d = Mon; d <= Sun; d = @(Week)(d + 1)@ ) cout << d << ' ';
     3340 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
     335\end{c++}
     336An enumeration type cannot declare an array dimension but an enumerator can be used as a subscript.
     337There is no mechanism to subtype or inherit from an enumeration.
    307338
    308339
    … …  
    311342
    312343% https://www.tutorialsteacher.com/codeeditor?cid=cs-mk8Ojx
    313 
    314 \Csharp is a dynamically-typed programming-language with a scoped, integral enumeration-type similar to the C/\CC enumeration.
     344% https://learn.microsoft.com/en-us/dotnet/api/system.enum?view=net-8.0
     345% https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/enums
     346
     347\Csharp is a dynamically-typed programming-language with a scoped, integral enumeration similar to \CC \lstinline[language=C++]{enum class}.
    315348\begin{csharp}
    316 enum Weekday : byte { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun@,@ };
     349enum Week : @long@ { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun@,@ } // terminating comma
     350enum RGB { Red, Green, Blue }
    317351\end{csharp}
    318 The default underlying type is @int@, with auto-incrementing, implicit/explicit initialization, terminator comma, and optional integral typing (default @int@).
    319 A method cannot be defined in an enumeration type.
    320 As well, there is an explicit bidirectional conversion between an enumeration and its integral type, and an implicit conversion to the enumerator label in display contexts.
     352The default underlying integral type is @int@ (no @char@), with auto-incrementing, implicit/explicit initialization, and terminating comma.
     353A method cannot be defined in an enumeration type (extension methods are possible).
     354There is an explicit bidirectional conversion between an enumeration and its integral type, and an implicit conversion to the enumerator label in display contexts.
    321355\begin{csharp}
    322 int day = (int)Weekday.Fri;             $\C{// day == 10}$
    323 Weekday weekday = (Weekdays)42;         $\C{// weekday == 42, logically invalid}$
    324 Console.WriteLine( Weekday.Fri ); $\C{// print Fri}$
    325 string mon = Weekday.Mon.ToString(); $\C{// mon == "Mon"}$
     356int iday = (int)Week.Fri;                       $\C{// day == 11}$
     357Week day = @(Week)@42;                          $\C{// day == 42, unsafe}$
     358string mon = Week.Mon.ToString();       $\C{// mon == "Mon"}$
     359RGB rgb = RGB.Red;                                      $\C{// rgb == "Red"}$
     360day = @(Week)@rgb;                                      $\C{// day == "Mon", unsafe}$
     361Console.WriteLine( Week.Fri );          $\C{// print label Fri}$
    326362\end{csharp}
    327 
    328 The @Enum.GetValues@ pseudo-method retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     363The majority of the integral operators (relational and arithmetic) work with enumerations, except @*@ and @/@.
    329364\begin{csharp}
    330 foreach ( Weekday constant in @Enum.GetValues@( typeof(Weekday) ) ) {
    331         Console.WriteLine( constant + " " + (int)constant ); // label, position
    332 }
     365day = day++ - 5;                                        $\C{// unsafe}$
     366day = day & day;
    333367\end{csharp}
    334368
    335 The @Flags@ attribute creates a bit-flags enumeration, allowing bitwise operators @&@, @|@, @~@ (complement), @^@ (xor).
     369An enumeration can be used in the @if@ and @switch@ statements.
     370\begin{cquote}
     371\setlength{\tabcolsep}{15pt}
     372\begin{tabular}{@{}ll@{}}
    336373\begin{csharp}
    337 @[Flags]@ public enum Weekday {
    338         None = 0x0, Mon = 0x1, Tue = 0x2, Wed = 0x4,
    339         Thu = 0x8, Fri = 0x10, Sat = 0x20, Sun = 0x40,
    340         Weekend = @Sat | Sun@,
    341         Weekdays = @Mon | Tue | Wed | Thu | Fri@
    342 }
    343 Weekday meetings = @Weekday.Mon | Weekday.Wed@; // 0x5
    344 \end{csharp}
    345 
    346 \VRef[Figure]{CsharpFreeVersusClass} shows an enumeration with free routines for manipulation, and embedding the enumeration and operations into an enumeration class.
    347 The key observation is that an enumeration class is just a structuring mechanism without any additional semantics.
    348 
    349 % https://learn.microsoft.com/en-us/dotnet/api/system.enum?view=net-8.0
    350 
    351 \begin{figure}
    352 \centering
    353 \begin{tabular}{@{}l|l@{}}
    354 \multicolumn{1}{@{}c|}{non-object oriented} & \multicolumn{1}{c@{}}{object oriented} \\
    355 \hline
    356 \begin{csharp}
    357 public class Program {
    358 
    359         enum Weekday {
    360                 Mon, Tue, Wed, Thu, Fri, Sat, Sun };
    361 
    362         static bool isWeekday( Weekday wd ) {
    363                 return wd <= Weekday.Fri;
    364         }
    365         static bool isWeekend( Weekday wd ) {
    366                 return Weekday.Sat <= wd;
    367         }
    368 
    369 
    370         public static void Main() {
    371                 Weekday day = Weekday.Sat;
    372 
    373                 Console.WriteLine( isWeekday( day ) );
    374                 Console.WriteLine( isWeekend( day ) );
    375         }
    376 }
     374if ( @day@ <= Week.Fri )
     375        Console.WriteLine( "weekday" );
     376
     377
     378
     379
     380
    377381\end{csharp}
    378382&
    379383\begin{csharp}
    380 public class Program {
    381         public @class@ WeekDay : Enumeration {
    382                 public enum Day {
    383                                 Mon, Tue, Wed, Thu, Fri, Sat, Sun };
    384                 public enum Day2 : Day {
    385                                 XXX, YYY };
    386                 Day day;
    387                 public bool isWeekday() {
    388                         return day <= Day.Fri;
    389                 }
    390                 public bool isWeekend() {
    391                         return day > Day.Fri;
    392                 }
    393                 public WeekDay( Day d ) { day = d; }
    394         }
    395         public static void Main() {
    396                 WeekDay cday = new
    397                                 WeekDay( WeekDay.Day.Sat );
    398                 Console.WriteLine( cday.isWeekday() );
    399                 Console.WriteLine( cday.isWeekend() );
    400         }
     384switch ( @day@ ) {
     385  case Week.Mon: case Week.Tue: case Week.Wed:
     386  case Week.Thu: case Week.Fri:
     387        Console.WriteLine( "weekday" ); break;
     388  case Week.Sat: case Week.Sun:
     389        Console.WriteLine( "weekend" ); break;
    401390}
    402391\end{csharp}
    403392\end{tabular}
    404 \caption{\Csharp: Free Routine Versus Class Enumeration}
    405 \label{CsharpFreeVersusClass}
    406 \end{figure}
     393\end{cquote}
     394However, there is no mechanism to iterate through an enumeration without an unsafe cast to increment and positions versus values is not handled.
     395\begin{csharp}
     396for ( Week d = Mon; d <= Sun; @d += 1@ ) {
     397        Console.Write( d + " " );
     398}
     399Mon Tue Wed @3 4 5 6 7 8 9@ Thu Fri Sat Sun
     400\end{csharp}
     401The @Enum.GetValues@ pseudo-method retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     402\begin{csharp}
     403foreach ( Week d in @Enum.GetValues@( typeof(Week) ) ) {
     404        Console.WriteLine( d + " " + (int)d + " " ); // label, position
     405}
     406Mon 0, Tue 1, Wed 2, Thu 10, Fri 11, Sat 12, Sun 13,
     407\end{csharp}
     408
     409An enumeration type cannot declare an array dimension but an enumerator can be used as a subscript.
     410There is no mechanism to subtype or inherit from an enumeration.
     411
     412The @Flags@ attribute creates a bit-flags enumeration, making bitwise operators @&@, @|@, @~@ (complement), @^@ (xor) sensible.
     413\begin{csharp}
     414@[Flags]@ public enum Week {
     415        None = 0x0, Mon = 0x1, Tue = 0x2, Wed = 0x4,
     416        Thu = 0x8, Fri = 0x10, Sat = 0x20, Sun = 0x40,
     417        Weekdays = @Mon | Tue | Wed | Thu | Fri@ $\C{// Weekdays == 0x1f}$
     418        Weekend = @Sat | Sun@,                  $\C{// Weekend == 0x60}$
     419}
     420Week meetings = @Week.Mon | Week.Wed@; $\C{// 0x5}$
     421\end{csharp}
    407422
    408423
    409424\section{Golang}
    410425
    411 Golang provides pseudo-enumeration similar to classic Pascal \lstinline[language=pascal]{const}, binding a name to a constant literal/expression.
     426Golang has a no enumeration.
     427It has @const@ aliasing declarations, similar to \CC \see{\VRef{s:C++RelatedWork}}, for basic types with type inferencing and static initialization (constant expression).
    412428\begin{Go}
    413 const ( R = 0; G; B )                                   $\C{// implicit: 0 0 0}$
    414 const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit: Fred Mary Jane}$
     429const R @int@ = 0;  const G @uint@ = 1;  const B = 2; $\C{// explicit typing and type inferencing}$
     430const Fred = "Fred";  const Mary = "Mary";  const Jane = "Jane";
     431const S = 0;  const T = 0;
     432const USA = "USA";  const U = "USA";
     433const V = 3.1;  const W = 3.1;
     434\end{Go}
     435Since these declarations are unmutable variables, they are unscoped and Golang has no overloading.
     436
     437Golang provides an enumeration-like feature to group together @const@ declaration into a block and introduces a form of auto-initialization.
     438\begin{Go}
     439const ( R = 0; G; B )                                   $\C{// implicit initialization: 0 0 0}$
     440const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit initialization: Fred Mary Jane}$
    415441const ( S = 0; T; USA = "USA"; U; V = 3.1; W ) $\C{// type change, implicit/explicit: 0 0 USA USA 3.1 3.1}$
    416442\end{Go}
    417 Constant identifiers are unscoped and must be unique (no overloading).
    418 The first enumerator \emph{must} be explicitly initialized;
    419 subsequent enumerators can be implicitly or explicitly initialized.
    420 Implicit initialization is the previous (predecessor) enumerator value.
    421 
    422 Auto-incrementing is supported by the keyword \lstinline[language=Go]{iota}, available only in the \lstinline[language=Go]{const} declaration.
    423 The \lstinline[language=Go]{iota} is a \emph{per \lstinline[language=golang]{const} declaration} integer counter, starting at zero and implicitly incremented by one for each \lstinline[language=golang]{const} identifier (enumerator).
     443The first identifier \emph{must} be explicitly initialized;
     444subsequent identifiers can be implicitly or explicitly initialized.
     445Implicit initialization is the \emph{previous} (predecessor) identifier value.
     446
     447Each @const@ declaration provides an implicit integer counter starting at zero, called \lstinline[language=Go]{iota}.
     448Using \lstinline[language=Go]{iota} outside of a @const@ block always sets the identifier to zero.
     449\begin{Go}
     450const R = iota;                                                 $\C{// 0}$
     451\end{Go}
     452Inside 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.
    424453\begin{Go}
    425454const ( R = @iota@; G; B )                              $\C{// implicit: 0 1 2}$
    … …  
    430459const ( O1 = iota + 1; @_@; O3; @_@; O5 ) // 1, 3, 5
    431460\end{Go}
    432 Auto-incrementing stops after an explicit initialization.
     461Auto-initialization reverts from \lstinline[language=Go]{iota} to the previous value after an explicit initialization, but auto-incrementing of \lstinline[language=Go]{iota} continues.
    433462\begin{Go}
    434463const ( Mon = iota; Tue; Wed; // 0, 1, 2
    435         @Thu = 10@; Fri; Sat; Sun ) // 10, 10, 10, 10
     464                @Thu = 10@; Fri; Sat; Sun = itoa ) // 10, 10, 10, 6
    436465\end{Go}
    437 Auto-incrementing can be restarted with an expression containing \emph{one} \lstinline[language=Go]{iota}.
     466Auto-initialization from \lstinline[language=Go]{iota} is restarted and \lstinline[language=Go]{iota} reinitialized with an expression containing as most \emph{one} \lstinline[language=Go]{iota}.
    438467\begin{Go}
    439 const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@; V5 ) // 0 1 7 3 4
     468const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@ + 1; V5 ) // 0 1 7 4 5
    440469const ( Mon = iota; Tue; Wed; // 0, 1, 2
    441         @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
     470                @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
    442471\end{Go}
    443 Note, \lstinline[language=Go]{iota} is advanced for an explicitly initialized enumerator, like the underscore @_@ identifier.
     472Here, @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 intialization expressions containing \lstinline[language=Go]{iota}.
     473Note, because \lstinline[language=Go]{iota} is incremented for an explicitly initialized identifier or @_@,
     474at @Fri@ \lstinline[language=Go]{iota} is 4 requiring the minus one to compute the value for @Fri@.
    444475
    445476Basic switch and looping are possible.
    446477\begin{cquote}
    447 \setlength{\tabcolsep}{15pt}
     478\setlength{\tabcolsep}{20pt}
    448479\begin{tabular}{@{}ll@{}}
    449480\begin{Go}
    450 day := Mon;
    451 switch day {
     481day := Mon;     // := $\(\Rightarrow\)$ type inferencing
     482switch @day@ {
    452483  case Mon, Tue, Wed, Thu, Fri:
    453484        fmt.Println( "weekday" );
    … …  
    459490\begin{Go}
    460491
    461 for i := Mon; i <= Sun; i += 1 {
     492for i := @Mon@; i <= @Sun@; i += 1 {
    462493        fmt.Println( i )
    463494}
    … …  
    470501However, the loop prints the values from 0 to 13 because there is no actual enumeration.
    471502
     503A constant variable can be used as an array dimension or a subscript.
     504\begin{Go}
     505var ar[@Sun@] int
     506ar[@Mon@] = 3
     507\end{Go}
     508
    472509
    473510\section{Java}
    474511
    475 Every enumeration in Java is an enumeration class.
    476 For a basic enumeration
     512Java provides an enumeration using a specialized class.
     513A basic Java enumeration is an opaque enumeration, where the enumerators are constants.
    477514\begin{Java}
    478 enum Weekday { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
    479 Weekday day = Weekday.Sat;
     515enum Week {
     516        Mon, Tue, Wed, Thu, Fri, Sat, Sun;
     517}
     518Week day = Week.Sat;
    480519\end{Java}
    481 the scoped enumerators are an ordered list of @final@ methods of type integer, ordered left to right starting at 0, increasing by 1.
    482 The value of an enumeration instance is restricted to the enumeration's enumerators.
    483 There is an implicit @int@ variable in the enumeration used to store the value of an enumeration instance.
    484 The position (ordinal) and label are accessible, where the value is the same as the position.
     520The enumerators members are scoped and cannot be made \lstinline[language=java]{public}, hence require qualification.
     521The value of an enumeration instance is restricted to its enumerators.
     522
     523The position (ordinal) and label are accessible but there is no value.
    485524\begin{Java}
    486 System.out.println( day.!ordinal()! + " " + day.!name()! ); // 5 Sat
     525System.out.println( day.!ordinal()! + " " + !day! + " " + day.!name()! );
     5265 Sat Sat
    487527\end{Java}
    488 There is an inverse function @valueOf@ from string to enumerator.
     528Since @day@ has no value, it prints its label (name).
     529The member @valueOf@ is the inverse of @name@ converting a string to enumerator.
    489530\begin{Java}
    490 day = Weekday.valueOf( "Wed" );
     531day = Week.valueOf( "Wed" );
    491532\end{Java}
    492 There are no implicit conversions to/from an enumerator and its underlying type.
    493 Like \Csharp, \VRef[Figure]{f:JavaFreeVersusClass} shows the same example for an enumeration with free routines for manipulation, and embedding the enumeration and operations into an enumeration class.
    494 
    495 \begin{figure}
    496 \centering
    497 \begin{tabular}{@{}l|l@{}}
    498 \multicolumn{1}{@{}c|}{non-object oriented} & \multicolumn{1}{c@{}}{object oriented} \\
    499 \hline
     533Extra members can be added to provide specialized operations.
    500534\begin{Java}
    501 enum Weekday !{!
    502         Mon, Tue, Wed, Thu, Fri, Sat, Sun !}!;
    503 
    504 static boolean isWeekday( Weekday wd ) {
    505         return wd.ordinal() <= Weekday.Fri.ordinal();
    506 }
    507 static boolean isWeekend( Weekday wd ) {
    508         return Weekday.Fri.ordinal() < wd.ordinal();
    509 }
    510 
    511 public static void main( String[] args ) {
    512         Weekday day = Weekday.Sat;
    513         System.out.println( isWeekday( day ) );
    514         System.out.println( isWeekend( day ) );
    515 }
     535public boolean isWeekday() { return !ordinal()! <= Fri.ordinal(); }
     536public boolean isWeekend() { return Fri.ordinal() < !ordinal()!; }
     537\end{Java}
     538Notice the unqualified calls to @ordinal@ in the members implying a \lstinline[language=Java]{this} to some implicit implementation variable, likely an @int@.
     539
     540Enumerator values require an enumeration type (any Java type may be used) and implementation member.
     541\begin{Java}
     542enum Week {
     543        Mon!(1)!, Tue!(2)!, Wed!(3)!, Thu!(4)!, Fri!(5)!, Sat!(6)!, Sun!(7)!; // must appear first
     544        private !long! day;                                     $\C{// enumeration type and implementation member}$
     545        private Week( !long! d ) { day = d; } $\C{// enumerator initialization}$
     546};
     547Week day = Week.Sat;
     548\end{Java}
     549The position, value, and label are accessible.
     550\begin{Java}
     551System.out.println( !day.ordinal()! + " " + !day.day! + " " + !day.name()! );
     5525 6 Sat
     553\end{Java}
     554If 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@.
     555The implementation constructor must be private since it is only used internally to initialize the enumerators.
     556Initialization occurs at the enumeration-type declaration for each enumerator in the first line.
     557
     558Enumerations can be used in the @if@ and @switch@ statements but only for equality tests.
     559\begin{cquote}
     560\setlength{\tabcolsep}{15pt}
     561\begin{tabular}{@{}ll@{}}
     562\begin{Java}
     563if ( !day! == Week.Fri )
     564        System.out.println( "Fri" );
     565
     566
     567
     568
    516569\end{Java}
    517570&
    518571\begin{Java}
    519 enum Weekday !{!
    520         Mon, Tue, Wed, Thu, Fri, Sat, Sun;
    521 
    522         public boolean isWeekday() {
    523                 return ordinal() <= Weekday.Fri.ordinal();
    524         }
    525         public boolean isWeekend() {
    526                 return Weekday.Fri.ordinal() < ordinal();
    527         }
    528 !}!
    529 public static void main( String[] args ) {
    530         WeekDay day = WeekDay.Sat;
    531         System.out.println( day.isWeekday() );
    532         System.out.println( day.isWeekend() );
     572switch ( !day! ) {
     573  case Mon: case Tue: case Wed: case Thu: case Fri:
     574        System.out.println( "weekday" );  break;
     575  case Sat: case Sun:
     576        System.out.println( "weekend" );  break;
    533577}
    534578\end{Java}
    535579\end{tabular}
    536 \caption{Java: Free Routine Versus Class Enumeration}
    537 \label{f:JavaFreeVersusClass}
    538 \end{figure}
    539 
    540 To explicitly assign enumerator values and/or use a non-@int@ enumeration type (any Java type may be used), the enumeration must specify an explicit type in the enumeration class and a constructor.
     580\end{cquote}
     581Notice enumerators in the @switch@ statement do not require qualification.
     582
     583There are no arithemtic operations on enumerations, so there is no arithmetic way to iterate through an enumeration without making the implementation type \lstinline[language=Java]{public}.
     584Like \Csharp, looping over an enumeration is done using method @values@, which returns an array of enumerator values (expensive operation).
    541585\begin{Java}
    542 enum Weekday {
    543         Mon!(1)!, Tue!(2)!, Wed!(3)!, Thu!(4)!, Fri!(5)!, Sat!(6)!, Sun!(7)!; // must appear first
    544         private !long! day;                                     $\C{// underlying enumeration type}$
    545         private Weekday( !long! d ) { day = d; } $\C{// used to initialize enumerators}$
    546 };
    547 Weekday day = Weekday.Sat;
    548 \end{Java}
    549 If an enumerator initialization is a runtime expression, the expression is executed once at the point the enumeration is declaraed.
    550 
    551 The position, value, and label are accessible.
    552 \begin{Java}
    553 System.out.println( !day.ordinal()! + " " + !day.day! + " " + !day.name()! );  // 5 6 Sat
    554 \end{Java}
    555 The constructor is private so only initialization or assignment can be used to set an enumeration, which ensures only corresponding enumerator values are allowed.
    556 
    557 An enumeration can appear in a @switch@ statement, but no ranges.
    558 \begin{Java}
    559 switch ( day ) {
    560   case Mon: case Tue: case Wed: case Thu: case Fri:
    561         System.out.println( "weekday" );
    562         break;
    563   case Sat: case Sun:
    564         System.out.println( "weekend" );
    565         break;
    566 }
    567 \end{Java}
    568 Like \Csharp, looping over an enumeration is done using method @values@, which returns the array of enumerator values (expensive operation).
    569 \begin{Java}
    570 for ( Weekday iday : Weekday.values() ) {
    571         System.out.print( iday.ordinal() + iday.day + " " +  iday.name() + ",  " );
     586for ( Week d : Week.values() ) {
     587        System.out.print( d.ordinal() + d.day + " " +  d.name() + ",  " );
    572588}
    5735890 1 Mon,  1 2 Tue,  2 3 Wed,  3 4 Thu,  4 5 Fri,  5 6 Sat,  6 7 Sun, 
    574590\end{Java}
    575591
    576 As well, 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.
     592An enumeration type cannot declare an array dimension nor can an enumerator be used as a subscript.
     593Enumeration inheritence is disallowed because an enumeration is \lstinline[language=Java]{final}.
     594
     595Java 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.
    577596There is also a specialized version of @HashMap@ with enumerator keys, which has performance benefits.
    578597
    579 Enumeration inheritence is disallowed because an enumeration is @final@.
    580 
    581 
    582 
    583 \section{Modula-3}
    584 
    585 
    586598
    587599\section{Rust}
     600
    588601% https://doc.rust-lang.org/reference/items/enumerations.html
    589602
    590 Rust provides a scoped enumeration based on variant types.
    591 % An enumeration, also referred to as an enum, is a simultaneous definition of a nominal enumerated type as well as a set of constructors, that can be used to create or pattern-match values of the corresponding enumerated type.
    592 An enumeration without constructors is called field-less.
     603Rust @enum@ provides two largely independent mechanisms: an ADT and an enumeration.
     604When @enum@ is an ADT, pattern matching is used to discriminate among the variant types.
     605\begin{cquote}
     606\sf\setlength{\tabcolsep}{20pt}
     607\begin{tabular}{@{}ll@{}}
    593608\begin{rust}
    594 enum Week { Mon, Tues, Wed, Thu, Fri, Sat, Sun@,@ }
    595 let mut week: Week = Week::Mon;
    596 week = Week::Fri;
     609struct S {
     610        i : isize,  j : isize
     611}
     612enum @ADT@ {
     613        I(isize),   // int
     614        F(f64),   // float
     615        S(S),     // struct
     616}
    597617\end{rust}
    598 A field-less enumeration with only unit variants is called unit-only.
     618&
    599619\begin{rust}
    600 enum Week { Mon = 0, Tues = 1, Wed = 2, Thu = 3, Fri = 4, Sat = 5, Sun = 6 }
     620let mut s = S{ i : 3, j : 4 };
     621let mut adt : ADT;
     622adt = ADT::I(3);  adt = ADT::F(3.5);  adt = ADT::S(s); // init examples
     623@match@ adt {
     624        ADT::I(i) => println!( "{:?}", i ),
     625        ADT::F(f) => println!( "{:?}", f ),
     626        ADT::S(s) => println!( "{:?} {:?}", s.i, s.j ),
     627}
    601628\end{rust}
    602 Enum constructors can have either named or unnamed fields:
    603 \begin{rust}
    604 enum Animal {
    605         Dog( String, f64 ),
    606         Cat{ name: String, weight: f64 },
    607 }
    608 let mut a: Animal = Animal::Dog("Cocoa".to_string(), 37.2);
    609 a = Animal::Cat { name: "Spotty".to_string(), weight: 2.7 };
    610 \end{rust}
    611 Here, @Dog@ is an @enum@ variant, whereas @Cat@ is a struct-like variant.
    612 
    613 Each @enum@ type has an implicit integer tag (discriminant), with a unique value for each variant type.
    614 Like a C enumeration, the tag values for the variant types start at 0 with auto incrementing.
    615 The tag is re-purposed for enumeration by allowing it to be explicitly set, and auto incrmenting continues from that value.
    616 \begin{cquote}
    617 \sf\setlength{\tabcolsep}{3pt}
    618 \begin{tabular}{rcccccccr}
    619 @enum@ Week \{  & Mon,  & Tue,  & Wed = 2,      & Thu = 10,     & Fri,  & Sat = 5,      & Sun   & \};   \\
    620 \rm tags                & 0             & 1             & 2                     & 10            & 11    & 5                     & 6             &               \\
    621629\end{tabular}
    622630\end{cquote}
    623 In general, the tag can only be read as an opaque reference for comparison.
     631When the variant types are the unit type, the ADT is still not an enumeration because there is no enumerating \see{\VRef{s:AlgebraicDataType}}.
    624632\begin{rust}
    625 if mem::discriminant(&week) == mem::discriminant(&Week::Mon) ...
     633enum Week { Mon, Tues, Wed, Thu, Fri, Sat, Sun@,@ } // terminating comma
     634let mut week : Week = Week::Mon;
     635match week {
     636        Week::Mon => println!( "Mon" ),
     637        ...
     638        Week::Sun => println!( "Sun" ),
     639}
    626640\end{rust}
    627 If the enumeration is unit-only, or field-less with no explicit discriminants and where only unit variants are explicit, then the discriminant is accessible with a numeric cast.
     641
     642However, Rust allows direct setting of the ADT constructor, which means it is actually a tag.
     643\begin{cquote}
     644\sf\setlength{\tabcolsep}{15pt}
     645\begin{tabular}{@{}ll@{}}
    628646\begin{rust}
    629 if week as isize == Week::Mon as isize ...
     647enum Week {
     648        Mon, Tues, Wed, // start 0
     649        Thu @= 10@, Fri,
     650        Sat, Sun,
     651}
     652
    630653\end{rust}
     654&
     655\begin{rust}
     656#[repr(u8)]
     657enum ADT {
     658        I(isize) @= 5@,  // ???
     659        F(f64) @= 10@,
     660        S(S) @= 0@,
     661}
     662\end{rust}
     663\end{tabular}
     664\end{cquote}
     665Through this integral tag, it is possible to enumerate, and when all tags represent the unit type, it behaves like \CC \lstinline[language=C++]{enum class}.
     666When tags represent non-unit types, Rust largely precludes accessing the tag because the semantics become meaningless.
     667Hence, the two mechanisms are largely disjoint, and ony the enumeration component is discussed.
     668
     669In detail, the @enum@ type has an implicit integer tag (discriminant), with a unique value for each variant type.
     670Direct initialization is by a compile-time expression generating a constant value.
     671Indirect initialization (without initialization, @Fri@/@Sun@) is auto-initialized: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
     672There is an explicit cast from the tag to integer.
     673\begin{rust}
     674let mut mon : isize = Week::Mon as isize;
     675\end{rust}
     676An enumeration can be used in the @if@ and \lstinline[language=rust]{match} (@switch@) statements.
     677\begin{cquote}
     678\setlength{\tabcolsep}{8pt}
     679\begin{tabular}{@{}ll@{}}
     680\begin{c++}
     681if @week as isize@ == Week::Mon as isize {
     682        println!( "{:?}", week );
     683}
     684
     685
     686\end{c++}
     687&
     688\begin{c++}
     689match @week@ {
     690        Week::Mon | Week:: Tue | Week::Wed | Week::Thu
     691                | Week::Fri => println!( "weekday" ),
     692        Week::Sat | Week:: Sun => println!( "weekend" ),
     693}
     694\end{c++}
     695\end{tabular}
     696\end{cquote}
     697However, there is no mechanism to iterate through an enumeration without an casting to integral and positions versus values is not handled.
     698\begin{c++}
     699for d in Week::Mon as isize ..= Week::Sun as isize {
     700        print!( "{:?} ", d );
     701}
     7020 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
     703\end{c++}
     704An enumeration type cannot declare an array dimension nor as a subscript.
     705There is no mechanism to subtype or inherit from an enumeration.
    631706
    632707
    … …  
    21622237A basic variant is a list of nullary datatype constructors, which is like an unscoped, opaque enumeration.
    21632238\begin{ocaml}
    2164 type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
    2165 let day : weekday @= Mon@                               $\C{(* bind *)}$
    2166 let take_class( d : weekday ) =
     2239type week = Mon | Tue | Wed | Thu | Fri | Sat | Sun
     2240let day : week @= Mon@                          $\C{(* bind *)}$
     2241let take_class( d : week ) =
    21672242        @match@ d with                                          $\C{(* matching *)}$
    21682243                Mon | Wed -> Printf.printf "CS442\n" |
    … …  
    21752250The only operations are binding and pattern matching (equality), where the variant name is logically the implementation tag stored in the union for discriminating the value in the object storage.
    21762251After compilation, variant names are mapped to an opague ascending intergral type discriminants, starting from 0.
    2177 Here, function @take_class@ has a @weekday@ parameter, and returns @"CS442"@, if the weekday value is @Mon@ or @Wed@, @"CS343"@, if the value is @Tue@ or @Thu@, and @"Tutorial"@ for @Fri@.
    2178 The ``@_@'' is a wildcard matching any @weekday@ value, so the function returns @"Take a break"@ for values @Sat@ or @Sun@, which are not matched by the previous cases.
     2252Here, function @take_class@ has a @week@ parameter, and returns @"CS442"@, if the week value is @Mon@ or @Wed@, @"CS343"@, if the value is @Tue@ or @Thu@, and @"Tutorial"@ for @Fri@.
     2253The ``@_@'' is a wildcard matching any @week@ value, so the function returns @"Take a break"@ for values @Sat@ or @Sun@, which are not matched by the previous cases.
    21792254Since the variant has no type, it has a \newterm{0-arity constructor}, \ie no parameters.
    2180 Because @weekday@ is a union of values @Mon@ to @Sun@, it is a \newterm{union type} in turns of the functional-programming paradigm.
     2255Because @week@ is a union of values @Mon@ to @Sun@, it is a \newterm{union type} in turns of the functional-programming paradigm.
    21812256
    21822257Each variant can have an associated heterogeneous type, with an n-ary constructor for creating a corresponding value.
    … …  
    22422317term "tag" further.
    22432318
    2244 <<Because weekday is a summation of values Mon to Sun, it is a sum type in
     2319<<Because week is a summation of values Mon to Sun, it is a sum type in
    22452320turns of the functional-programming paradigm>>
    22462321
    … …  
    22592334> I've marked 3 places with your name to shows places with enum ordering.
    22602335>
    2261 > type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
    2262 > let day : weekday = Mon
    2263 > let take_class( d : weekday ) =
     2336> type week = Mon | Tue | Wed | Thu | Fri | Sat | Sun
     2337> let day : week = Mon
     2338> let take_class( d : week ) =
    22642339>       if d <= Fri then                                (* Gregor *)
    2265 >               Printf.printf "weekday\n"
     2340>               Printf.printf "week\n"
    22662341>       else if d >= Sat then                   (* Gregor *)
    22672342>               Printf.printf "weekend\n";
    … …  
    24742549loop                    &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
    24752550\hline
    2476 array                   &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
     2551array/subscript &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
    24772552\hline
    24782553subtype                 &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
Note: See TracChangeset for help on using the changeset viewer.