Context Navigation

-                      r5b4c8df
+                      rab11ab1
 \chapter{Introduction}
 All basic types in a programming language have a set of constants (symbols), and these constants represent computable values, \eg integer types have constants @-1@, @17@, @0xff@ representing whole numbers, floating-point types have constants @5.3@, @2.3E-5@, @0xff.ffp0@ representing  real numbers, character types have constants @'a'@, @"abc\n"@, \mbox{\lstinline{u8"}\texttt{\guillemotleft{na\"{i}ve}\guillemotright}\lstinline{"}} representing (human readable) text, \etc.
+All basic types in a programming language have a set of constants (symbols), and these constants represent computable values, \eg integer types have constants @-1@, @17@, @0xff@ representing whole numbers, floating-point types have constants @5.3@, @2.3E-5@, @0xff.ffp0@ representing real numbers, character types have constants @'a'@, @"abc\n"@, \mbox{\lstinline{u8"}\texttt{\guillemotleft{na\"{i}ve}\guillemotright}\lstinline{"}} representing (human readable) text, \etc.
 Constants can be overloaded among types, \eg @0@ is a null pointer for all pointer types, and the value zero for integer and floating-point types.
 (In \CFA, the constants @0@ and @1@ can be overloaded for any type.)
 …
 A constant's symbolic name is dictated by language syntax related to types, \eg @5.@ (double), @5.0f@ (float), @5l@ (long double).
 In general, the representation of a constant's value is \newterm{opaque}, so the internal representation can be chosen arbitrarily, \eg two's complement, IEEE floating-point.
 In theory, there are an infinite set of constant names per type representing an infinite set of values.
+In theory, there is an infinite set of constant names per type representing an infinite set of values.
 It is common in mathematics, engineering, and computer science to alias new constants to existing constants so they have the same value, \eg $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), K(k), M, G, T for powers of 2\footnote{Overloaded with SI powers of 10.} often prefixing bits (b) or bytes (B), \eg Gb, MB, and in general situations, \eg specific times (noon, New Years), cities (Big Apple), flowers (Lily), \etc.
 …
 Because an aliased name is a constant, it cannot appear in a mutable context, \eg \mbox{$\pi$ \lstinline{= 42}} is meaningless, and a constant has no address, \ie it is an \newterm{rvalue}\footnote{
 The term rvalue defines an expression that can only appear on the right-hand side of an assignment expression.}.
 In theory, there are an infinite set of possible aliasing, in practice, the number of aliasing per program is finite and small.
+In theory, there is an infinite set of possible aliasing; in practice, the number of aliasing per program is finite and small.
 Aliased constants can form an (ordered) set, \eg days of a week, months of a year, floors of a building (basement, ground, 1st), colours in a rainbow, \etc.
 …
 \end{sloppypar}
 \item
 The alias names are constants, which follows transitively from their binding to other constants.
+The alias names are constants, which follow transitively from their binding to other constants.
 \item
 Defines a type for generating instants (variables).
 …
 Hence, the term \emph{enumeration} can be confusing and misunderstood.
 Furthermore, some languages conjoin the enumeration with other type features, making it difficult to tease apart which feature is being used.
 This section discusses some language features that are sometimes called an enumeration but do not provide all enumeration aspects.
+This section discusses some language features that are sometimes called enumeration but do not provide all enumeration aspects.
 …
 \end{cfa}
 For these reasons, aliasing is sometimes called an enumeration.
 However, there is no type to create a type-checked instance or iterator cursor, so there is no ability for enumerating.
+However, there is no type to create a type-checked instance or iterator cursor, so there is no ability to enumerate.
 Hence, there are multiple enumeration aspects not provided by aliasing, justifying a separate enumeration type in a programming language.
 …
 the ADT has three variants (constructors), @A@, @B@, @C@, with associated types @Int@, @Double@, and @S@.
 The constructors create an initialized value of the specific type that is bound to the immutable variables @foo@, @bar@, and @baz@.
 Hence, the ADT @Foo@ is like a union containing values of the associated types, and a constructor name is used to intialize and access the value using dynamic pattern-matching.
+Hence, the ADT @Foo@ is like a union containing values of the associated types, and a constructor name is used to initialize and access the value using dynamic pattern-matching.
 \begin{cquote}
 \setlength{\tabcolsep}{20pt}
 …
 baz = Z 5;
 \end{haskell}
 Here, the constructor name gives different meaning to the values in the common \lstinline[language=Haskell]{Int} type, \eg the value @3@ has different interpretations depending on the constructor name in the pattern matching.
+Here, the constructor name gives different meanings to the values in the common \lstinline[language=Haskell]{Int} type, \eg the value @3@ has different interpretations depending on the constructor name in the pattern matching.
 Note, the term \newterm{variant} is often associated with ADTs.
 However, there are multiple languages with a @variant@ type that is not an ADT \see{Algol68~\cite{Algol68} or \CC \lstinline{variant}}.
 Here, the type (and possibly the position for equivalent types) is used to discriminant the specific \emph{variant} within the variant instance.
+Here, the type (and possibly the position for equivalent types) is used to discriminate the specific \emph{variant} within the variant instance.
 For example, \VRef[Figure]{f:C++variant} shows the \CC equivalent of the two Haskell ADT types using variant types.
 In these languages, the variant cannot be used to simulate an enumeration.
 …
 data Week = Mon | Tue | Wed | Thu | Fri | Sat | Sun deriving(Enum, Eq, Show)
 \end{haskell}
 the default type for each constructor is the unit type, and deriving from @Enum@ enforces no other associated types, @Eq@ allows equality comparison, and @Show@ is for printing.
 The nullary constructors for the unit types are numbered left-to-right from $0$ to @maxBound@$- 1$, and provides enumerating operations @succ@, @pred@, @enumFrom@, @enumFromTo@.
+the default type for each constructor is the unit type, and deriving from @Enum@ enforces no other associated types. The @Eq@ allows equality comparison, and @Show@ is for printing.
+The nullary constructors for the unit types are numbered left-to-right from $0$ to @maxBound@$- 1$, and provide enumerating operations @succ@, @pred@, @enumFrom@, @enumFromTo@.
 \VRef[Figure]{f:HaskellEnumeration} shows enumeration comparison and iterating (enumerating).
 …
 However, when extended with advanced features, enumerations become complex for both the type system and the runtime implementation.
 The contribution of this work are:
+The contributions of this work are:
 \begin{enumerate}
 \item
 …
 overloading: Provide a pattern to overload functions, literals, and variables for polymorphic enumerations using the \CFA type system.
 \item
 scoping: Add a name space for enumerations and qualified access into the namespace to deal with the naming problem.
+scoping: Add a namespace for enumerations and qualified access into the namespace to deal with the naming problem.
 \item
 generalization: Support all language types for enumerators with associated values providing enumeration constants for any type.

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

Context Navigation

Changeset ab11ab1 for doc/theses/jiada_liang_MMath/intro.tex

Legend:

doc/theses/jiada_liang_MMath/intro.tex

Download in other formats: