Index: doc/theses/jiada_liang_MMath/relatedwork.tex
===================================================================
--- doc/theses/jiada_liang_MMath/relatedwork.tex	(revision 4094d05a9d0eecad16b84030881ff0331d22a066)
+++ doc/theses/jiada_liang_MMath/relatedwork.tex	(revision e00b10d924c2924526a67259c2aacb409d1d1039)
@@ -2587,4 +2587,86 @@
 With valediction,
   - Gregor Richards
+
+Date: Wed, 20 Mar 2024 18:16:44 -0400
+Subject: Re:
+To: "Peter A. Buhr" <pabuhr@uwaterloo.ca>
+From: Gregor Richards <gregor.richards@uwaterloo.ca>
+
+
+On 3/20/24 17:26, Peter A. Buhr wrote:
+> Gregor, everyone at this end would like a definition of "enumerability". Can
+> you formulate one?
+
+According to the OED (emphasis added to the meaning I'm after):
+
+enumerate (verb, transitive). To count, ascertain the number of; **more
+usually, to mention (a number of things or persons) separately, as if for the
+purpose of counting**; to specify as in a list or catalogue.
+
+With C enums, if you know the lowest and highest value, you can simply loop
+over them in a for loop (this is, of course, why so many enums come with an
+ENUM_WHATEVER_LAST value). But, I would be hesitant to use the word "loop" to
+describe enumerability, since in functional languages, you would recurse for
+such a purpose.
+
+In Haskell, in order to do something with every member of an "enumeration", you
+would have to explicitly list them all. The type system will help a bit since
+it knows if you haven't listed them all, but you would have to statically have
+every element in the enumeration.  If somebody added new elements to the
+enumeration later, your code to enumerate over them would no longer work
+correctly, because you can't simply say "for each member of this enumeration do
+X". In Haskell that's because there aren't actually enumerations; what they use
+as enumerations are a degenerate form of algebraic datatypes, and ADTs are
+certainly not enumerable. In OCaml, you've demonstrated that they impose
+comparability, but I would still assume that you can't make a loop over every
+member of an enumeration. (But, who knows!)
+
+Since that's literally what "enumerate" means, it seems like a rather important
+property for enumerations to have ;)
+
+With valediction,
+  - Gregor Richards
+
+
+From: Andrew James Beach <ajbeach@uwaterloo.ca>
+To: Gregor Richards <gregor.richards@uwaterloo.ca>, Peter Buhr <pabuhr@uwaterloo.ca>
+CC: Michael Leslie Brooks <mlbrooks@uwaterloo.ca>, Fangren Yu <f37yu@uwaterloo.ca>,
+    Jiada Liang <j82liang@uwaterloo.ca>
+Subject: Re: Re:
+Date: Thu, 21 Mar 2024 14:26:36 +0000
+
+Does this mean that not all enum declarations in C create enumerations? If you
+declare an enumeration like:
+
+enum Example {
+    Label,
+    Name = 10,
+    Tag = 3,
+};
+
+I don't think there is any way to enumerate (iterate, loop, recurse) over these
+values without listing all of them.
+
+
+Date: Thu, 21 Mar 2024 10:31:49 -0400
+Subject: Re:
+To: Andrew James Beach <ajbeach@uwaterloo.ca>, Peter Buhr <pabuhr@uwaterloo.ca>
+CC: Michael Leslie Brooks <mlbrooks@uwaterloo.ca>, Fangren Yu <f37yu@uwaterloo.ca>,
+    Jiada Liang <j82liang@uwaterloo.ca>
+From: Gregor Richards <gregor.richards@uwaterloo.ca>
+
+I consider this conclusion reasonable. C enums can be nothing more than const
+ints, and if used in that way, I personally wouldn't consider them as
+enumerations in any meaningful sense, particularly since the type checker
+essentially does nothing for you there. Then they're a way of writing consts
+repeatedly with some textual indicator that these definitions are related; more
+namespace, less enum.
+
+When somebody writes bitfield members as an enum, is that *really* an
+enumeration, or just a use of the syntax for enums to keep related definitions
+together?
+
+With valediction,
+  - Gregor Richards
 \end{comment}