Context Navigation

-                      r0139351
+                      r7d9a805b
 \label{s:RelatedWork}
+\begin{comment}
 An algebraic data type (ADT) can be viewed as a recursive sum of product types.
 A sum type lists values as members.
 …
 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.
 Values of algebraic types are access by subscripting, field qualification, or type (pattern) matching.
+\end{comment}
 Enumeration types 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}, Java~\cite{Java}, Modula-3~\cite{Modula-3}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
 …
 \section{Pascal}
+\label{s:Pascal}
 \lstnewenvironment{pascal}[1][]{\lstset{language=pascal,escapechar=\$,moredelim=**[is][\color{red}]{@}{@},}\lstset{#1}}{}
 …
                  PI = 3.14159;   Plus = '+';   Fred = 'Fred';
 \end{pascal}
 Here, there is no enumeration because there is no specific type (pseudo enumeration).
+This mechanism is not an enumeration because there is no specific type (pseudo enumeration).
 Hence, there is no notion of a (possibly ordered) set, modulo the \lstinline[language=pascal]{set of} type.
 The type of each constant name (enumerator) is inferred from the constant-expression type.
 …
 with Ada.Text_IO; use Ada.Text_IO;
 procedure test is
    type RGB is ( @Red@, Green, Blue );
    type Traffic_Light is ( @Red@, Yellow, Green );         -- overload
    procedure @Red@( Colour : RGB ) is begin            -- overload
        Put_Line( "Colour is " & RGB'Image( Colour ) );
    end Red;
    procedure @Red@( TL : Traffic_Light ) is begin       -- overload
        Put_Line( "Light is " & Traffic_Light'Image( TL ) );
    end Red;
+        type RGB is ( @Red@, Green, Blue );
+        type Traffic_Light is ( @Red@, Yellow, Green );         -- overload
+        procedure @Red@( Colour : RGB ) is begin            -- overload
+                Put_Line( "Colour is " & RGB'Image( Colour ) );
+        end Red;
+        procedure @Red@( TL : Traffic_Light ) is begin       -- overload
+                Put_Line( "Light is " & Traffic_Light'Image( TL ) );
+        end Red;
 begin
     @Red@( Blue );                               -- RGB
     @Red@( Yellow );                            -- Traffic_Light
     @Red@( @RGB'(Red)@ );               -- ambiguous without cast
+        @Red@( Blue );                           -- RGB
+        @Red@( Yellow );                                -- Traffic_Light
+        @Red@( @RGB'(Red)@ );           -- ambiguous without cast
 end test;
 \end{ada}
 …
 \lstnewenvironment{c++}[1][]{\lstset{language=[GNU]C++,escapechar=\$,moredelim=**[is][\color{red}]{@}{@},}\lstset{#1}}{}
+\CC is largely backwards compatible with C, so it inherited C's enumerations.
+However, the following non-backwards compatible changes have been made.
+\CC has the equivalent of Pascal typed @const@ declarations \see{\VRef{s:Pascal}}, with static and dynamic initialization.
+\begin{c++}
+const auto one = 0 + 1;                                 $\C{// static intialization}$
+const auto NULL = nullptr;
+const auto PI = 3.14159;
+const auto Plus = '+';
+const auto Fred = "Fred";
+const auto Mon = 0, Tue = Mon + 1, Wed = Tue + 1, Thu = Wed + 1, Fri = Thu + 1,
+                                Sat = Fri + 1, Sun = Sat + 1;
+int sa[Sun];
+const auto r = random();                                $\C{// dynamic intialization}$
+int da[r];                                                              $\C{// VLA}$
+\end{c++}
+Statically initialized identifiers may appear in any constant-expression context, \eg @case@.
+Dynamically intialized identifiers may appear as array dimensions in @g++@, which allows variable-sized arrays.
+Interestingly, global \CC @const@ declarations are implicitly marked @static@ (@r@ rather than @R@).
+\begin{c++}
+$\$$ nm test.o
+0000000000000018 @r@ Mon
+\end{c++}
+\CC enumeration is largely backwards compatible with C, so it inherited C's enumerations.
+However, the following non-backwards compatible changes are made.
 \begin{cquote}
 …
 \begin{Go}
 const ( Mon = iota; Tue; Wed; // 0, 1, 2
          @Thu = 10@; Fri; Sat; Sun ) // 10, 10, 10, 10
+        @Thu = 10@; Fri; Sat; Sun ) // 10, 10, 10, 10
 \end{Go}
 Auto-incrementing can be restarted with an expression containing \emph{one} \lstinline[language=Go]{iota}.
 …
 const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@; V5 ) // 0 1 7 3 4
 const ( Mon = iota; Tue; Wed; // 0, 1, 2
          @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
+        @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
 \end{Go}
 Note, \lstinline[language=Go]{iota} is advanced for an explicitly initialized enumerator, like the underscore @_@ identifier.
 …
 \lstnewenvironment{python}[1][]{\lstset{language=Python,escapechar=\$,moredelim=**[is][\color{red}]{@}{@},}\lstset{#1}}{}
+An @Enum@ is a set of symbolic names bound to unique values.
+They are similar to global variables, but they offer a more useful @repr()@, grouping, type-safety, and a few other features.
+They are most useful when you have a variable that can take one of a limited selection of values. For example, the days of the week:
+\begin{python}
+>>> from enum import Enum
+>>> class Weekday(Enum):
+...    MONDAY = 1
+...    TUESDAY = 2
+...    WEDNESDAY = 3
+...    THURSDAY = 4
+...    FRIDAY = 5
+...    SATURDAY = 6
+...    SUNDAY = 7
+\end{python}
+Or perhaps the RGB primary colors:
+\begin{python}
+>>> from enum import Enum
+>>> class Color(Enum):
+...    RED = 1
+...    GREEN = 2
+...    BLUE = 3
+\end{python}
+As you can see, creating an @Enum@ is as simple as writing a class that inherits from @Enum@ itself.
+Note: Case of Enum Members
+Because Enums are used to represent constants, and to help avoid issues with name clashes between mixin-class methods/attributes and enum names, we strongly recommend using @UPPER_CASE@ names for members, and will be using that style in our examples.
+A Python enumeration is a set of symbolic names bound to \emph{unique} values.
+They are similar to global variables, but offer a more useful @repr()@, grouping, type-safety, and additional features.
+Enumerations inherits from the @Enum@ class, \eg:
+\begin{python}
+class Weekday(@Enum@): Mon = 1; Tue = 2; Wed = 3; Thu = 4; Fri = 5; Sat = 6; Sun = 7
+class RGB(@Enum@): Red = 1; Green = 2; Blue = 3
+\end{python}
 Depending on the nature of the enum a member's value may or may not be important, but either way that value can be used to get the corresponding member:
 \begin{python}
 >>> Weekday(3)
 <Weekday.WEDNESDAY: 3>
+print( repr( Weekday( 3 ) ) )
+<Weekday.Wed: 3>
 \end{python}
 As you can see, the @repr()@ of a member shows the enum name, the member name, and the value.
 The @str()@ of a member shows only the enum name and member name:
 \begin{python}
 print(Weekday.THURSDAY)
 Weekday.THURSDAY
+print( str( Weekday.Thu ), Weekday.Thu )
+Weekday.Thu Weekday.Thu
 \end{python}
 The type of an enumeration member is the enum it belongs to:
 \begin{python}
 >>> type(Weekday.MONDAY)
+print( type( Weekday.Thu ) )
 <enum 'Weekday'>
 isinstance(Weekday.FRIDAY, Weekday)
+print( isinstance(Weekday.Fri, Weekday) )
 True
 \end{python}
 Enum members have an attribute that contains just their name:
 \begin{python}
 >>> print(Weekday.TUESDAY.name)
+print(Weekday.TUESDAY.name)
 TUESDAY
 \end{python}
 Likewise, they have an attribute for their value:
 \begin{python}
 >>> Weekday.WEDNESDAY.value
+Weekday.WEDNESDAY.value
 \end{python}
 Unlike many languages that treat enumerations solely as name/value pairs, Python @Enum@s can have behavior added.
 For example, @datetime.date@ has two methods for returning the weekday: @weekday()@ and @isoweekday()@.
 …
 Rather than keep track of that ourselves we can add a method to the @Weekday@ enum to extract the day from the date instance and return the matching enum member:
 \begin{python}
+class Weekday(Enum): Mon = 1; Tue = 2; Wed = 3; Thu = 10; Fri = 15; Sat = 16; Sun = 17
 $@$classmethod
 def from_date(cls, date):
+    return cls(date.isoweekday())
+\end{python}
+The complete Weekday enum now looks like this:
+\begin{python}
+>>> class Weekday(Enum):
+...    MONDAY = 1
+...    TUESDAY = 2
+...    WEDNESDAY = 3
+...    THURSDAY = 4
+...    FRIDAY = 5
+...    SATURDAY = 6
+...    SUNDAY = 7
+...    #
+...    $@$classmethod
+...    def from_date(cls, date):
+...        return cls(date.isoweekday())
+        return cls(date.isoweekday())
 \end{python}
 Now we can find out what today is! Observe:
 …
 This Weekday enum is great if our variable only needs one day, but what if we need several? Maybe we're writing a function to plot chores during a week, and don't want to use a @list@ -- we could use a different type of @Enum@:
 \begin{python}
+>>> from enum import Flag
+>>> class Weekday(Flag):
+...    MONDAY = 1
+...    TUESDAY = 2
+...    WEDNESDAY = 4
+...    THURSDAY = 8
+...    FRIDAY = 16
+...    SATURDAY = 32
+...    SUNDAY = 64
+from enum import Flag
+class WeekdayF(@Flag@): Mon = @1@; Tue = @2@; Wed = @4@; Thu = @8@; Fri = @16@; Sat = @32@; Sun = @64@
 \end{python}
 We've changed two things: we're inherited from @Flag@, and the values are all powers of 2.
+Just like the original @Weekday@ enum above, we can have a single selection:
+\begin{python}
+>>> first_week_day = Weekday.MONDAY
+>>> first_week_day
+<Weekday.MONDAY: 1>
+\end{python}
+But @Flag@ also allows us to combine several members into a single variable:
+\begin{python}
+>>> weekend = Weekday.SATURDAY | Weekday.SUNDAY
+>>> weekend
+<Weekday.SATURDAY|SUNDAY: 96>
+@Flag@ allows combining several members into a single variable:
+\begin{python}
+print( repr(WeekdayF.Sat | WeekdayF.Sun) )
+<WeekdayF.Sun|Sat: 96>
 \end{python}
 You can even iterate over a @Flag@ variable:
 \begin{python}
 >>> for day in weekend:
 ...    print(day)
+for day in weekend:
+        print(day)
 Weekday.SATURDAY
 Weekday.SUNDAY
 …
 \subsection{Duplicating enum members and values}
+Having two enum members with the same name is invalid:
+\begin{python}
+>>> class Shape(Enum):
+...    SQUARE = 2
+...    SQUARE = 3
+...
+Traceback (most recent call last):
+...
+TypeError: 'SQUARE' already defined as 2
+\end{python}
+However, an enum member can have other names associated with it.
+An enum member can have other names associated with it.
 Given two entries @A@ and @B@ with the same value (and @A@ defined first), @B@ is an alias for the member @A@.
 By-value lookup of the value of @A@ will return the member @A@.
 …
 By-name lookup of @B@ will also return the member @A@:
 \begin{python}
+>>> class Shape(Enum):
+...    SQUARE = 2
+...    DIAMOND = 1
+...    CIRCLE = 3
+...    ALIAS_FOR_SQUARE = 2
+...
+class Shape(Enum): SQUARE = 2; DIAMOND = 1; CIRCLE = 3; ALIAS_FOR_SQUARE = 2
 >>> Shape.SQUARE
 <Shape.SQUARE: 2>
 …
 When this behavior isn't desired, you can use the @unique()@ decorator:
 \begin{python}
+>>> from enum import Enum, unique
+>>> $@$unique
+... class Mistake(Enum):
+...     ONE = 1
+...     TWO = 2
+...     THREE = 3
+...     FOUR = 3
+...
+Traceback (most recent call last):
+...
+from enum import Enum, unique
+$@$unique
+class DupVal(Enum): ONE = 1; TWO = 2; THREE = 3; FOUR = 3
 ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE
 \end{python}
 …
 If the exact value is unimportant you can use @auto@:
 \begin{python}
+>>> from enum import Enum, auto
+>>> class Color(Enum):
+...     RED = auto()
+...     BLUE = auto()
+...     GREEN = auto()
+...
+>>> [member.value for member in Color]
+[1, 2, 3]
+\end{python}
+The values are chosen by \_generate\_next\_value\_(), which can be overridden:
+from enum import Enum, auto
+class RGBa(Enum): RED = auto(); BLUE = auto(); GREEN = auto()
+\end{python}
+(Like Golang @iota@.)
+The values are chosen by @_generate_next_value_()@, which can be overridden:
 \begin{python}
 >>> class AutoName(Enum):
 …
 \begin{python}
 class EnumName([mix-in, ...,] [data-type,] base-enum):
     pass
+        pass
 \end{python}
 Also, subclassing an enumeration is allowed only if the enumeration does not define any members.
 …
 \begin{python}
 Enum(
     value='NewEnumName',
     names=<...>,
     *,
     module='...',
     qualname='...',
     type=<mixed-in class>,
     start=1,
+    )
+        value='NewEnumName',
+        names=<...>,
+        *,
+        module='...',
+        qualname='...',
+        type=<mixed-in class>,
+        start=1,
+        )
 \end{python}
 \begin{itemize}
 …
 \begin{python}
 class IntEnum(int, Enum):
     pass
+        pass
 \end{python}
 This demonstrates how similar derived enumerations can be defined;
 …
 \begin{python}
 def __bool__(self):
     return bool(self.value)
+        return bool(self.value)
 \end{python}
 Plain @Enum@ classes always evaluate as @True@.
 …
 If @__new__()@ or @__init__()@ is defined, the value of the enum member will be passed to those methods:
+\begin{python}
+>>> class Planet(Enum):
+...     MERCURY = (3.303e+23, 2.4397e6)
+...     VENUS   = (4.869e+24, 6.0518e6)
+...     EARTH   = (5.976e+24, 6.37814e6)
+...     MARS    = (6.421e+23, 3.3972e6)
+...     JUPITER = (1.9e+27,   7.1492e7)
+...     SATURN  = (5.688e+26, 6.0268e7)
+...     URANUS  = (8.686e+25, 2.5559e7)
+...     NEPTUNE = (1.024e+26, 2.4746e7)
+...     def __init__(self, mass, radius):
+...         self.mass = mass       # in kilograms
+...         self.radius = radius   # in meters
+...     $\@$property
+...     def surface_gravity(self):
+...         # universal gravitational constant  (m3 kg-1 s-2)
+...         G = 6.67300E-11
+...         return G * self.mass / (self.radius * self.radius)
+...
+>>> Planet.EARTH.value
+(5.976e+24, 6378140.0)
+>>> Planet.EARTH.surface_gravity
+.802652743337129
+\end{python}
+\begin{figure}
+\begin{python}
+from enum import Enum
+class Planet(Enum):
+        MERCURY = ( 3.303E23, 2.4397E6 )
+        VENUS       = ( 4.869E24, 6.0518E6 )
+        EARTH       = (5.976E24, 6.37814E6)
+        MARS         = (6.421E23, 3.3972E6)
+        JUPITER    = (1.9E27,   7.1492E7)
+        SATURN     = (5.688E26, 6.0268E7)
+        URANUS    = (8.686E25, 2.5559E7)
+        NEPTUNE  = (1.024E26, 2.4746E7)
+        def __init__( self, mass, radius ):
+                self.mass = mass                # in kilograms
+                self.radius = radius    # in meters
+        def surface_gravity( self ):
+                # universal gravitational constant  (m3 kg-1 s-2)
+                G = 6.67300E-11
+                return G * self.mass / (self.radius * self.radius)
+for p in Planet:
+        print( f"{p.name}: {p.value}" )
+MERCURY: (3.303e+23, 2439700.0)
+VENUS: (4.869e+24, 6051800.0)
+EARTH: (5.976e+24, 6378140.0)
+MARS: (6.421e+23, 3397200.0)
+JUPITER: (1.9e+27, 71492000.0)
+SATURN: (5.688e+26, 60268000.0)
+URANUS: (8.686e+25, 25559000.0)
+NEPTUNE: (1.024e+26, 24746000.0)
+\end{python}
+\caption{Python Planet Example}
+\label{f:PythonPlanetExample}
+\end{figure}
 \subsection{TimePeriod}
 …
 \section{OCaml}
 \lstnewenvironment{ocaml}[1][]{\lstset{language=OCaml,escapechar=\$,moredelim=**[is][\color{red}]{@}{@},}\lstset{#1}}{}
+% https://ocaml.org/docs/basic-data-types#enumerated-data-types
 OCaml provides a variant (union) type, where multiple heterogeneously-typed objects share the same storage.
 …
 With valediction,
   - Gregor Richards
+Date: Thu, 14 Mar 2024 21:45:52 -0400
+Subject: Re: OCaml "enums" do come with ordering
+To: "Peter A. Buhr" <pabuhr@uwaterloo.ca>
+From: Gregor Richards <gregor.richards@uwaterloo.ca>
+On 3/14/24 21:30, Peter A. Buhr wrote:
+> I've marked 3 places with your name to shows places with enum ordering.
+>
+> type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
+> let day : weekday = Mon
+> let take_class( d : weekday ) =
+>       if d <= Fri then                                (* Gregor *)
+>               Printf.printf "weekday\n"
+>       else if d >= Sat then                   (* Gregor *)
+>               Printf.printf "weekend\n";
+>       match d with
+>               Mon | Wed -> Printf.printf "CS442\n" |
+>               Tue | Thu -> Printf.printf "CS343\n" |
+>               Fri -> Printf.printf "Tutorial\n" |
+>               _ -> Printf.printf "Take a break\n"
+>
+> let _ = take_class( Mon ); take_class( Sat );
+>
+> type colour = Red | Green of string | Blue of int * float
+> let c = Red
+> let _ = match c with Red -> Printf.printf "Red, "
+> let c = Green( "abc" )
+> let _ = match c with Green g -> Printf.printf "%s, " g
+> let c = Blue( 1, 1.5 )
+> let _ = match c with Blue( i, f ) -> Printf.printf "%d %g\n" i f
+>
+> let check_colour(c: colour): string =
+>       if c < Green( "xyz" ) then              (* Gregor *)
+>               Printf.printf "green\n";
+>       match c with
+>               Red -> "Red" |
+>               Green g -> g |
+>               Blue(i, f) -> string_of_int i ^ string_of_float f
+> let _ = check_colour( Red ); check_colour( Green( "xyz" ) );
+>
+> type stringList = Empty | Pair of string * stringList
+> let rec len_of_string_list(l: stringList): int =
+>       match l with
+>               Empty -> 0 |
+>               Pair(_ , r) -> 1 + len_of_string_list r
+>
+> let _ = for i = 1 to 10 do
+>       Printf.printf "%d, " i
+> done
+>
+> (* Local Variables: *)
+> (* tab-width: 4 *)
+> (* compile-command: "ocaml test.ml" *)
+> (* End: *)
+My functional-language familiarity is far more with Haskell than OCaml.  I
+mostly view OCaml through a lens of "it's Haskell but with cheating".  Haskell
+"enums" (ADTs) aren't ordered unless you specifically and manually put them in
+the Ord typeclass by defining the comparators.  Apparently, OCaml has some
+other rule, which I would guess is something like "sort by tag then by order of
+parameter". Having a default behavior for comparators is *bizarre*; my guess
+would be that it gained this behavior in its flirtation with object
+orientation, but that's just a guess (and irrelevant).
+This gives a total order, but not enumerability (which would still be
+effectively impossible or even meaningless since enums are just a special case
+of ADTs).
+With valediction,
+  - Gregor Richards
 \end{comment}
 …
 \section{Comparison}
+\begin{tabular}{r|ccccccccc}
+feat. / lang. & Pascal  & Ada   & \Csharp       & OCaml & Java  & Modula-3      & Rust  & Swift & Python        \\
+\VRef[Table]{t:FeatureLanguageComparison} shows a comparison of enumeration features and programming languages.
+The features are high level and may not capture nuances within a particular language
+The @const@ feature is simple macros substitution and not a typed enumeration.
+\begin{table}
+\caption{Enumeration Feature / Language Comparison}
+\label{t:FeatureLanguageComparison}
+\small
+\setlength{\tabcolsep}{3pt}
+\newcommand{\CM}{\checkmark}
+\begin{tabular}{r|c|c|c|c|c|c|c|c|c|c|c|c|c}
+                                &Pascal & Ada   &\Csharp& OCaml & Java  &Modula-3&Golang& Rust  & Swift & Python& C             & \CC   & \CFA  \\
 \hline
+pure            &                       &               &                       &               &               &                       &               &               &                       \\
+ordered         &                       &               &                       &               &               &                       &               &               &                       \\
+setable         &                       &               &                       &               &               &                       &               &               &                       \\
+auto-init       &                       &               &                       &               &               &                       &               &               &                       \\
+scoped          &                       &               &                       &               &               &                       &               &               &                       \\
+typed           &                       &               &                       &               &               &                       &               &               &                       \\
+switch          &                       &               &                       &               &               &                       &               &               &                       \\
+loop            &                       &               &                       &               &               &                       &               &               &                       \\
+array           &                       &               &                       &               &               &                       &               &               &                       \\
+@const@                 & \CM   &               &               &               &               &               & \CM   &               &               &               &               & \CM   &               \\
+\hline
+\hline
+pure                    &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
+\hline
+typed                   &               &               &               &               &               &               &               &               &               &               & @int@ & integral      & @T@   \\
+\hline
+safe                    &               &               &               &               &               &               &               &               &               &               &               & \CM   & \CM   \\
+\hline
+ordered                 &               &               &               &               &               &               &               &               &               &               & \CM   & \CM   & \CM   \\
+\hline
+dup. values             &               &               &               &               &               &               &               &               &               & alias & \CM   & \CM   & \CM   \\
+\hline
+setable                 &               &               &               &               &               &               &               &               &               &               & \CM   & \CM   & \CM   \\
+\hline
+auto-init               &               &               &               &               &               &               &               &               &               &               & \CM   & \CM   & \CM   \\
+\hline
+(un)scoped              &               &               &               &               &               &               &               &               &               &               & U             & U/S   & U/S   \\
+\hline
+overload                &               & \CM   &               &               &               &               &               &               &               &               &               & \CM   & \CM   \\
+\hline
+switch                  &               &               &               &               &               &               &               &               &               &               & \CM   & \CM   & \CM   \\
+\hline
+loop                    &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
+\hline
+array                   &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
+\hline
+subtype                 &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
+\hline
+inheritance             &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
 \end{tabular}
+\end{table}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 7d9a805b for doc/theses/jiada_liang_MMath/relatedwork.tex

Legend:

doc/theses/jiada_liang_MMath/relatedwork.tex

Download in other formats: