Index: doc/theses/jiada_liang_MMath/CFAenum.tex
===================================================================
--- doc/theses/jiada_liang_MMath/CFAenum.tex	(revision dc1c43080c7e19efbb0190198c9459ca44c5774f)
+++ doc/theses/jiada_liang_MMath/CFAenum.tex	(revision 1f922f495d15fa3ae45ffe287f9aa77cf191f409)
@@ -130,5 +130,5 @@
 \end{cfa}
 
-\CFA does not define attributes functions for C style enumeration. But it is possilbe for users to explicitly implement
+\CFA does not define attribute functions for C style enumeration. But it is possilbe for users to explicitly implement
 enumeration traits for C enum and any other types.
 
@@ -147,5 +147,5 @@
 \end{cfa}
 
-A type that implement trait @CfaEnum@, \ie, a type has no @value@, is called an opaque enum.
+A type that implements trait @CfaEnum@, \ie, a type has no @value@, is called an opaque enum.
 
 % \section{Enumerator Opaque Type}
@@ -164,5 +164,5 @@
 };
 \end{cfa}
-The function @first()@ and @last()@ of enumertated type E return the first and the last enumerator declared in E, respectively. \eg:
+The function @first()@ and @last()@ of enumerated type E return the first and the last enumerator declared in E, respectively. \eg:
 \begin{cfa}
 Workday day = first();					$\C{// Mon}$
@@ -292,5 +292,5 @@
 
 Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Names@ by containment, and a @Names@ enumeration is a subtype of enumeration @Name2@.
-Note, enumerators must be unique in inheritance but enumerator values may be repeated.
+Note, that enumerators must be unique in inheritance but enumerator values may be repeated.
 
 % The enumeration type for the inheriting type must be the same as the inherited type;
@@ -301,5 +301,5 @@
 Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\C{// enum type of Names}$
 \end{cfa}
-A subtype can be casted to its super type, assigned to a super type variable, or be used as a function argument that expects the super type.
+A subtype can be cast to its supertype, assigned to a supertype variable, or be used as a function argument that expects the supertype.
 \begin{cfa}
 Names fred = Name.Fred;
@@ -332,7 +332,7 @@
 In most programming languages, an enumerator is implicitly converted to its value (like a typed macro substitution).
 However, enumerator synonyms and typed enumerations make this implicit conversion to value incorrect in some contexts.
-In these contexts, a programmer's initition assumes an implicit conversion to postion.
-
-For example, an intuitive use of enumerations is with the \CFA @switch@/@choose@ statement, where @choose@ performs an implict @break@ rather than a fall-through at the end of a @case@ clause.
+In these contexts, a programmer's initition assumes an implicit conversion to position.
+
+For example, an intuitive use of enumerations is with the \CFA @switch@/@choose@ statement, where @choose@ performs an implicit @break@ rather than a fall-through at the end of a @case@ clause.
 \begin{cquote}
 \begin{cfa}
@@ -367,7 +367,7 @@
 enum Count { First, Second, Third @= First@, Fourth };
 \end{cfa}
-which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicase @case@ clauses.
+which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicate @case@ clauses.
 To better match with programmer intuition, \CFA toggles between value and position semantics depending on the language context.
-For conditional clauses and switch statments, \CFA uses the robust position implementation.
+For conditional clauses and switch statements, \CFA uses the robust position implementation.
 \begin{cfa}
 choose( @position@( e ) ) {
@@ -392,10 +392,10 @@
 for (c: -~=Alphabet ) { sout | c; }
 \end{cfa}
-The @range loop@ for enumeration is a syntax sugar that looping over all enumeerators and assign each enumeration to a variable in every iteration.
-The loop control of range loop consists of two parts: a variable declaration and a @range expression@, with type of the variable
+The @range loop@ for enumeration is a syntax sugar that loops over all enumerators and assigns each enumeration to a variable in every iteration.
+The loop control of the range loop consists of two parts: a variable declaration and a @range expression@, with the type of the variable
 can be inferred from the range expression.
 
 The range expression is an enumeration type, optionally prefixed by @+~=@ or @-~=@. Without a prefix, or prefixed with @+~=@, the control
-loop over all enumerator from the first to the last. With a @-~=@ prefix, the control loops backwards.
+loop over all enumerators from the first to the last. With a @-~=@ prefix, the control loops backward.
 
 On a side note, the loop syntax
@@ -405,5 +405,5 @@
 does not work. When d == last(), the loop control will still attempt to assign succ(d) to d, which causes an @enumBound@ exception.
 
-\CFA reduces conditionals to its "if case" if the predicate not equal to ( @!=@ ) zero, and the "else case" otherwises.
+\CFA reduces conditionals to its "if case" if the predicate is not equal to ( @!=@ ) zero, and the "else case" otherwise.
 Overloading the @!=@ operator with an enumeration type against the zero defines a conceptual conversion from
 enum to boolean, which can be used as predicates.
@@ -416,8 +416,8 @@
 \end{cfa}
 
-Indicentally, \CFA does not define boolean conversion for enumeration. If no 
+Incidentally, \CFA does not define boolean conversion for enumeration. If no 
 @?!=?(ErrorCode, zero_t)@ 
 overloading defined,
-\CFA looks for the boolean conversion in terms of its value, and gives an compiler error if no such conversion is available.
+\CFA looks for the boolean conversion in terms of its value and gives a compiler error if no such conversion is available.
 
 \begin{cfa}
@@ -431,5 +431,5 @@
 \end{cfa}
 
-As an alternatively, users can define the boolean conversion for CfaEnum:
+As an alternative, users can define the boolean conversion for CfaEnum:
 
 \begin{cfa}
@@ -442,5 +442,5 @@
 
 \section{Enumerated Arrays}
-Enumerated array use an \CFA array as their index.
+Enumerated arrays use an \CFA array as their index.
 \begin{cfa}
 enum() Colour {
@@ -457,10 +457,10 @@
 \VRef[Figure]{f:PlanetExample} shows an archetypal enumeration example illustrating most of the \CFA enumeration features.
 @Planet@ is an enumeration of type @MR@.
-Each of the planet enumerators is initialized to a specific mass/radius, @MR@, value.
+Each planet enumerator is initialized to a specific mass/radius, @MR@, value.
 The unnamed enumeration provides the gravitational-constant enumerator @G@.
 Function @surfaceGravity@ uses the @with@ clause to remove @p@ qualification from fields @mass@ and @radius@.
 The program main uses the pseudo function @countof@ to obtain the number of enumerators in @Planet@, and safely converts the random value into a @Planet@ enumerator using @fromInt@.
 The resulting random orbital-body is used in a @choose@ statement.
-The enumerators in the @case@ clause use enumerator position for testing.
+The enumerators in the @case@ clause use the enumerator position for testing.
 The prints use @label@ to print an enumerator's name.
 Finally, a loop enumerates through the planets computing the weight on each planet for a given earth mass.