Index: doc/theses/jiada_liang_MMath/relatedwork.tex =================================================================== --- doc/theses/jiada_liang_MMath/relatedwork.tex (revision a8f44c83c718e40d2e0e570f7ed20e3d0093f30b) +++ doc/theses/jiada_liang_MMath/relatedwork.tex (revision 5b4c8df9dc208f341ec7d3f9e57a247012317062) @@ -33,5 +33,5 @@ The type of each constant name (enumerator) is inferred from the constant-expression type. -Pascal introduced the enumeration type characterized by a set of ordered, unscoped identifiers (enumerators), which are not overloadable.\footnote{% +Some dialects of Pascal introduced the enumeration type characterized by a set of ordered, unscoped identifiers (enumerators), which are not overloadable.\footnote{% Pascal is \emph{case-insensitive} so identifiers may appear in multiple forms and still be the same, \eg \lstinline{Mon}, \lstinline{moN}, and \lstinline{MON} (a questionable design decision).} \begin{pascal} @@ -1246,12 +1246,12 @@ & \begin{ocaml} + + + + + 3 3.5 3 5 - - - - - \end{ocaml} \end{tabular} @@ -1532,7 +1532,6 @@ \section{Comparison} -\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. +\VRef[Table]{t:FeatureLanguageComparison} shows a comparison of enumeration features and programming languages with the explaination of categories below. +The features are high level and may not capture nuances within a particular language. \begin{table} @@ -1543,50 +1542,49 @@ \newcommand{\CM}{\checkmark} \begin{tabular}{r|c|c|c|c|c|c|c|c|c|c|c|c|c} - &Pascal & Ada &\Csharp & OCaml & Java &Golang& Rust & Swift & Python& C & \CC & \CFA \\ + &Pascal & Ada &\Csharp & OCaml & Java &Golang & Rust & Swift & Python& C & \CC & \CFA \\ \hline -enum &Dialect& \CM & \CM & ADT & \CM & @const@&ADT/\CM &ADT/\CM & \CM &\CM &\CM &\CM\\ +enum &Dialect& \CM & \CM & ADT & \CM & @const@ &ADT/\CM &ADT/\CM & \CM &\CM &\CM &\CM\\ \hline \hline -opaque & & & & \CM & \CM & & & \CM & & & & \CM \\ +opaque & \CM & & & \CM & \CM & & \CM & \CM & & & & \CM \\ \hline -typed &Int & Int & Integral & H & U & H & U/H & U/H & H & Int & Integral& U \\ +typed & Int & Int & Integral & H & U & H & U/H & U/H & H & Int & Integral& U \\ \hline -safety & \CM & \CM & & \CM & \CM & & \CM & \CM & & & \CM & \CM \\ +safety & \CM & \CM & & \CM & \CM & & \CM & \CM & & & \CM & \CM \\ \hline -posn ordered & \CM & \CM & \CM & \CM & \CM & & & \CM & & & & \CM \\ +posn ordered & Implied & Implied & & \CM & & & & & & & & \CM \\ \hline -unique values & \CM & & \CM & & \CM & \CM & & \CM & alias & \CM & \CM & \CM \\ +unique values & \CM & \CM & & & & & & \CM & & & & \\ \hline -% setable repr. & \CM & \CM & \CM & & \CM & \CM & \CM & \CM & \CM & \CM & \CM & \CM \\ -% \hline -auto-init & \CM & @all or none@ & \CM & & & \CM & \CM & \CM & \CM & \CM & \CM & \CM \\ -% This one is tricky: C/C++/CC has auto-init value. Some have auto-init underlying representation +auto-init & \CM & @all or none@ & \CM & & & \CM & \CM & \CM & \CM & \CM & \CM & \CM \\ \hline -(Un)Scoped & U & U & S & S & S & U & S & S & S & U & U/S & U/S \\ +(un)Scoped & U & U & S & S & S & U & S & S & S & U & U/S & U/S \\ \hline -overload & & \CM & n/a & n/a &n/a & & n/a & n/a &n/a & & & \CM \\ +overload & & \CM & & & & & & & & & & \CM \\ \hline -loop & \CM & \CM & & & & & & & \CM & & & \CM \\ +loop & \CM & \CM & & & & & & & \CM & & & \CM \\ \hline -% array/subscript & & & & & & & & & & \CM & & \CM \\ -% \hline -subset & \CM & \CM & & \CM & & & & & & & & \CM \\ +arr. dim. & \CM & \CM & & & & & & & & & & \CM \\ \hline -superset & & & & & & & & & & & & \CM \\ +subset & \CM & \CM & & \CM & & & & & & & & \CM \\ +\hline +superset & & & & & & & & & & & & \CM \\ \end{tabular} \end{table} \begin{enumerate} -\item Opaque: Language has opaque enum if its enumerator cannot be used as its underlying representation or its enum is implemented as ADT. -\item Typed: The type of value. H: heterogeneous type; enumerators from the same enum need not be has the same type. -U: uni-type; enumerators must have the same type. +\item Opaque: Opaque enums' enumerator cannot be used as its underlying representation or being implemented in terms of ADT. +\item Typed: The type of value. H: heterogeneous type; values from the same enum need not be the same type. +U: uni-type; value must have the same type. \item Safe: A enumeration variable can only hold a value from its defined enumerators. \item Posn ordered: enumerators have defined ordering based on enuemrator declaration order. +It is implied position ordered if its enumerator value must be strictly increasingly ordered. \item Unique value: enumerators must have unique value. -\item Auto-init: Value are auto initializable. -\item (Un)Scoped: U: unscoped enuemrators and does not need qualification; S: Scoped enumerators and requires qualification -\item Overload: An enumerator label can be used without type qualification in a context where the label has defined by multiple enumerations -\item Loop: Enumerate enum members without explicitly convert it to other data structures -\item Subset: Name a subset of enumerator as a new type. -\item Superset: Create a new enumeration that contain all enumerators from pre-defined enuemration. +\item Auto-init: Value are auto initializable by language specification, often being the "+1" of the predecessor. +\item (Un)Scoped: U: unscoped enuemrators and does not need qualification; S: Scoped enumerators and requires qualification. +\item Overload: An enumerator label can be used without type qualification in a context where the label has defined by multiple enumerations. +\item Loop: Enumerate enum members without the need to convert an enumeration to another data structure +\item Arr. dim: An enumeration can be used directly as array dimension and enumerators can be mapped to an array element (not a conversion to integer type). +\item Subset: Name a subset of enumerators as a new type. +\item Superset: Create a new enumeration that contains all enumerators from pre-defined enuemrations. \end{enumerate}