Index: doc/proposals/enum.tex
===================================================================
--- doc/proposals/enum.tex	(revision dd1ebb19c6c8f45df1b0b974cfc7f695804381b9)
+++ doc/proposals/enum.tex	(revision a55ebcca1b712f00e2fd94a9d348511dd62c8f8a)
@@ -7,4 +7,5 @@
 \usepackage{graphics}
 \usepackage{xspace}
+\usepackage{relsize}									% must be after change to small or selects old size
 \usepackage{calc}										% latex arithmetic
 
@@ -64,4 +65,5 @@
 \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
 \newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}		% C++ symbolic name
+\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 \newcommand{\PAB}[1]{{\color{red}PAB: #1}}
 
@@ -110,5 +112,5 @@
 \begin{abstract}
 An enumeration is a type defining an ordered set of named constant values, where a name abstracts a value, e.g., @PI@ versus @3.145159@.
-C and \CC restrict an enumeration type to the integral type @signed int@, meaning enumeration names bind to integer constants.
+C restrict an enumeration type to the integral type @signed int@, which \CC support , meaning enumeration names bind to integer constants.
 \CFA extends C enumerations to allow all basic and custom types for the enumeration type, like other modern programming languages.
 Furthermore, \CFA adds other useful features for enumerations to support better software-engineering practices and simplify program development.
@@ -132,7 +134,7 @@
 The C-Style enumeration has the following syntax and semantics.
 \begin{lstlisting}[label=lst:weekday]
-enum Weekday { Monday, Tuesday, Wednesday, Thursday@=10@, Friday, Saturday, Sunday };
-                $\(\uparrow\)$                                                                      $\(\uparrow\)$
-    ${\rm \newterm{enumeration name}}$                                        ${\rm \newterm{enumerator names}}
+enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday };
+                $\(\uparrow\)$                                                                        $\(\uparrow\)$
+    ${\rm \newterm{enumeration name}}$                                          ${\rm \newterm{enumerator names}}
 \end{lstlisting}
 Here, the enumeration type @Weekday@ defines the ordered \newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
@@ -190,5 +192,6 @@
 A \CFA-enum can be scoped, meaning the enumerator constants are not projected into the enclosing scope.
 \begin{lstlisting}
-enum Colour( char * ) @!@ { ... };
+enum Weekday @!@ { /* as above */ };
+enum Colour( char * ) @!@ { /* as above */ };
 \end{lstlisting}
 where the @'!'@ implies the enumerators are \emph{not} projected.
@@ -197,10 +200,13 @@
 % $$<qualified\_expression> := <enum\_type>.<enumerator>$$
 \begin{lstlisting}
-Colour colour = @Colour.@Red;			$\C{// qualification}$
+Weekday weekday = @Weekday.Monday@;		$\C{// qualification}$
+Colour colour = @Colour.@Red;
 colour = @Colour.@Blue;
 \end{lstlisting}
 
 \subsection{Enumeration Pseudo-functions}
-Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@. Instead, the call to functions will be substituted into other expressions in compilation time.
+
+Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@.
+Often a call to a pseudo-function is substituted with information extracted from the symbol table at compilation time, like storage size or alignment associated with the underlying architecture..
 
 \subsubsection{Enumerator Attributes}
@@ -212,5 +218,6 @@
 \end{lstlisting}
 
-Enumeration Greek may have more or less enumerators than Letter, but the enumerator values must be from Letter. Therefore, Greek enumerators are a subset of type Letter and are type compatible with enumeration Letter, but Letter enumerators are not type compatible with enumeration Greek. 
+Enumeration Greek may have more or less enumerators than Letter, but the enumerator values must be from Letter.
+Therefore, Greek enumerators are a subset of type Letter and are type compatible with enumeration Letter, but Letter enumerators are not type compatible with enumeration Greek. 
 
 \subsubsection{\lstinline{enumerate()}}
@@ -920,4 +927,42 @@
 \section{Related Work}
 
+Enumerations exist in many popular programming languages, e.g., Pascal, Ada, \Csharp, \CC, Go, Java, Modula-3, Rust, Swift, Python, and Algebraic data type in functional programming.
+There are a large set of overlapping features for all the languages, but each language has its own unique restrictions and extensions.
+
+\subsection{Pascal}
+
+\subsection{Ada}
+
+\subsection{\Csharp}
+
+\subsection{\CC}
+
+Because \CC is backwards compatible with C, it inherited C's enumerations, except there is no implicit conversion from an integral value to an enumeration;
+hence, the values in a \CC enumeration can only be its enumerators.
+
+\CC{11} extended enumeration with a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are local to the enumeration and are accessed using type qualification, e.g., @Weekday::Monday@.
+\CC{20} supports unscoped access with a \lstinline[language=c++]{using enum} declaration.
+
+For both unscoped and scoped enumerations, the underlying type is an implementation-defined integral type that is large enough to hold all enumerated values; it does not have to be the smallest possible type.
+The underlying integral type can be explicitly specified:
+\begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
+enum class RGB : @long@ { Red, Green, Blue };
+enum class rgb : @char@ { Red = 'r', Green = 'g', Blue = 'b' };
+enum class srgb : @signed char@ { Red = -1, Green = 0, Blue = 1 };
+\end{lstlisting}
+
+\subsection{Go}
+
+\subsection{Java}
+
+\subsection{Modula-3}
+
+\subsection{Rust}
+
+\subsection{Swift}
+
+\subsection{Python}
+
+\subsection{Algebraic Data Type}
 
 \end{document}