Context Navigation

-                      rbfa7bf0
+                      rdc1c430
 The following sections detail all of my new contributions to enumerations in \CFA.
+\section{Aliasing}
+C already provides @const@-style aliasing using the unnamed enumerator \see{\VRef{s:TypeName}}, even if the name @enum@ is misleading (@const@ would be better).
+Given the existence of this form, it is straightforward to extend it with types other than @int@.
+\begin{cfa}
+enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
+\end{cfa}
+which matches with @const@ aliasing in other programming languages.
+Here, the type of the enumerator is the type of the initialization constant, \eg @typeof(20u)@ for @Size@ implies @unsigned int@.
+Auto-initialization is restricted to the case where all constants are @int@, matching with C.
+As seen in \VRef{s:EnumeratorTyping}, this feature is just a shorthand for multiple typed-enumeration declarations.
+\begin{comment}
+        Not support.
+\end{comment}
+% \section{Aliasing}
+% C already provides @const@-style aliasing using the unnamed enumerator \see{\VRef{s:TypeName}}, even if the name @enum@ is misleading (@const@ would be better).
+% Given the existence of this form, it is straightforward to extend it with types other than @int@.
+% \begin{cfa}
+% enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
+% \end{cfa}
+% which matches with @const@ aliasing in other programming languages.
+% Here, the type of the enumerator is the type of the initialization constant, \eg @typeof(20u)@ for @Size@ implies @unsigned int@.
+% Auto-initialization is restricted to the case where all constants are @int@, matching with C.
+% As seen in \VRef{s:EnumeratorTyping}, this feature is just a shorthand for multiple typed-enumeration declarations.
 …
 The \CFA type-system allows extensive overloading, including enumerators.
+Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name.
+Furthermore, \CFA uses the environment, such as the left-had of assignment and function parameter, to pinpoint the best overloaded name.
+% Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name.
 Finally, qualification and casting are provided to disambiguate any ambiguous situations.
 \begin{cfa}
 …
 E1 f() { return Third; }                                $\C{// overloaded functions, different return types}$
 E2 f() { return Fourth; }
+void g(E1 e);
+void h(E2 e);
 void foo() {
         E1 e1 = First;   E2 e2 = First;         $\C{// initialization}$
         e1 = Second;   e2 = Second;                     $\C{// assignment}$
+        e1 = f();   e2 = f();                           $\C{// function call}$
+        e1 = f();   e2 = f();                           $\C{// function return}$
+        g(First); h(First);                                     $\C{// function parameter}$
         int i = @E1.@First + @E2.@First;        $\C{// disambiguate with qualification}$
         int j = @(E1)@First + @(E2)@First;      $\C{// disambiguate with cast}$
 …
 \section{Enumeration Trait}
 The header file \lstinline[deletekeywords=enum]{<enum.hfa>} defines the set of traits containing operators and helper functions for @enum@.
+\section{Enumeration Traits}
+\CFA defines the set of traits containing operators and helper functions for @enum@.
 A \CFA enumeration satisfies all of these traits allowing it to interact with runtime features in \CFA.
 Each trait is discussed in detail.
+The trait @Bounded@:
+The trait @CfaEnum@:
+\begin{cfa}
+forall( E ) trait CfaEnum {
+        char * label( E e );
+        unsigned int posn( E e );
+};
+\end{cfa}
+describes an enumeration as a named constant with position. And @TypeEnum@
+\begin{cfa}
+forall( E, V ) trait TypeEnum {
+        V value( E e );
+};
+\end{cfa}
+asserts two types @E@ and @T@, with @T@ being the base type for the enumeration @E@.
+The declarative syntax
+\begin{cfa}
+enum(T) E { A = ..., B = ..., C = ... };
+\end{cfa}
+creates an enumerated type E with @label@, @posn@ and @value@ implemented automatically.
+\begin{cfa}
+void foo( T t ) { ... }
+void bar(E e) {
+        choose (e) {
+                case A: printf("\%d", posn(e));
+                case B: printf("\%s", label(e));
+                case C: foo(value(e));
+        }
+}
+\end{cfa}
+Implementing general functions across all enumeration types is possible by asserting @CfaEnum( E, T )@, \eg:
+\begin{cfa}
+#include <string.hfa>
+forall( E, T | CfaEnum( E, T ) | {unsigned int toUnsigned(T)} )
+string formatEnum( E e ) {
+        unsigned int v = toUnsigned(value(e));
+        string out = label(e) + '(' + v +')';
+        return out;
+}
+printEunm( Week.Mon );
+printEnum( RGB.Green );
+\end{cfa}
+\CFA does not define attributes functions for C style enumeration. But it is possilbe for users to explicitly implement
+enumeration traits for C enum and any other types.
+\begin{cfa}
+enum Fruit { Apple, Bear, Cherry };                     $\C{// C enum}$
+char * label(Fruit f) {
+        switch(f) {
+                case Apple: "A"; break;
+                case Bear: "B"; break;
+                case Cherry: "C"; break;
+        }
+}
+unsigned posn(Fruit f) { return f; }
+char* value(Fruit f) { return ""; }             $\C{// value can return any non void type}$
+formatEnum( Apple );                                                    $\C{// Fruit is now a Cfa enum}$
+\end{cfa}
+A type that implement trait @CfaEnum@, \ie, a type has no @value@, is called an opaque enum.
+% \section{Enumerator Opaque Type}
+% \CFA provides a special opaque enumeration type, where the internal representation is chosen by the compiler and only equality operations are available.
+\begin{cfa}
+enum@()@ Planets { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE };
+\end{cfa}
+In addition, \CFA implements @Bound@ and @Serial@ for \CFA Enums.
 \begin{cfa}
 forall( E ) trait Bounded {
 …
 };
 \end{cfa}
 defines the bounds of the enumeration, where @first()@ returns the first enumerator and @last()@ returns the last, \eg:
+The function @first()@ and @last()@ of enumertated type E return the first and the last enumerator declared in E, respectively. \eg:
 \begin{cfa}
 Workday day = first();                                  $\C{// Mon}$
 …
 Calling either functions without a context results in a type ambiguity, except in the rare case where the type environment has only one enumeration.
 \begin{cfa}
 @first();@                                                              $\C{// ambiguous Workday and Planet implement Bounded}$
+@first();@                                                              $\C{// ambiguous because both Workday and Planet implement Bounded}$
 sout | @last()@;
 Workday day = first();                                  $\C{// day provides type Workday}$
 …
 Specifically, for enumerator @E@ declaring $N$ enumerators, @fromInt( i )@ returns the $i-1_{th}$ enumerator, if $0 \leq i < N$, or raises the exception @enumBound@.
 The @Serial@ trait also requires interface functions @succ( E e )@ and @pred( E e )@ be implemented for a serial type, which imply the enumeration positions are consecutive and ordinal.
+The @succ( E e )@ and @pred( E e )@ imply the enumeration positions are consecutive and ordinal.
 Specifically, if @e@ is the $i_{th}$ enumerator, @succ( e )@ returns the $i+1_{th}$ enumerator when $e \ne last()$, and @pred( e )@ returns the $i-1_{th}$ enumerator when $e \ne first()$.
 The exception @enumRange@ is raised if the result of either operation is outside the range of type @E@.
-The trait @TypedEnum@:
-\begin{cfa}
-forall( E, T ) trait TypedEnum {
-        T valueE( E e );
-        char * labelE( E e );
-        unsigned int posE( E e );
-};
-\end{cfa}
-captures three basic attributes of an enumeration type: value, label, and position.
-@TypedEnum@ asserts two types @E@ and @T@, with @T@ being the base type of the enumeration @E@, \eg @enum( T ) E { ... };@.
-Implementing general functions across all enumeration types is possible by asserting @TypeEnum( E, T )@, \eg:
-\begin{cfa}
-forall( E, T | TypeEnum( E, T ) )
-void printEnum( E e ) {
-        sout | "Enum "| labelE( e );
+}
-printEunm( MARS );
-\end{cfa}
 Finally, there is an associated trait defining comparison operators among enumerators.
 \begin{cfa}
 forall( E, T | TypedEnum( E, T ) ) {
+forall( E, T | CfaEnum( E, T ) ) {
         // comparison
         int ?==?( E l, E r );           $\C{// true if l and r are same enumerators}$
 …
+}
 \end{cfa}
+Note, the overloaded operators are defined only when the header @<enum.hfa>@ is included.
+If not, the compiler converts an enumerator to its value, and applies the operators defined for the value type @E@, \eg:
+\begin{cfa}
+// if not include <enum.hfa>
+enum( int ) Fruits { APPLE = 2, BANANA = 10, CHERRY = 2 };
+APPLE == CHERRY; // true because valueE( APPLE ) == valueE( CHERRY )
+#include <enum.hfa>
+APPLE == CHERRY; // false because posE( APPLE ) != posE( CHERRY )
+\end{cfa}
+An enumerator returns its @position@ by default.
+In particular, @printf( ... )@ from @<stdio.h>@ functions provides no context to its parameter type, so it prints @position@.
+On the other hand, the pipeline operator @?|?( ostream os, E enumType )@ provides type context for type @E@, and \CFA has overwritten this operator to print the enumeration @value@ over @position@.
+\begin{cfa}
+printf( "Position of BANANA is \%d", BANANA ); // Position of BANANA is 1
+sout | "Value of BANANA is " | BANANA; // Value of BANANA is 10
+\end{cfa}
+Programmers can overwrite this behaviour by overloading the pipeline operator themselves.
+\PAB{This needs discussing because including \lstinline{<enum.hfa>} can change the entire meaning of a program.}
+% \section{Enumeration Pseudo-functions}
+% Pseudo-functions are function-like operators that do not result in any run-time computations, \ie like @sizeof@, @alignof@, @typeof@.
+% A pseudo-function call is often substituted with information extracted from the compilation symbol-table, like storage size or alignment associated with the underlying architecture.
+% The attributes of an enumerator are accessed by pseudo-functions @posE@, @valueE@, and @labelE@.
+% \begin{cfa}
+% int jane_pos = @posE@( Names.Jane );   $\C{// 2}$
+% char * jane_value = @valueE@( Names.Jane ); $\C{// "JANE"}$
+% char * jane_label = @labelE@( Names.Jane ); $\C{// "Jane"}$
+% sout | posE( Names.Jane) | labelE( Names.Jane ) | valueE( Names.Jane );
+% \end{cfa}
+% Note the ability to print all of an enumerator's properties.
+\section{Enumerator Typing}
+\section{Typed Enum}
 \label{s:EnumeratorTyping}
 …
 calling constructors happens at runtime (dynamic).
-\section{Enumerator Opaque Type}
-\CFA provides a special opaque enumeration type, where the internal representation is chosen by the compiler and only equality operations are available.
-\begin{cfa}
-enum@()@ Planets { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE };
-\end{cfa}
 \section{Enumeration Inheritance}
 \CFA Plan-9 inheritance may be used with enumerations, where Plan-9 inheritance is containment inheritance with implicit unscoping (like a nested unnamed @struct@/@union@ in C).
 \begin{cfa}
 enum( char * ) Names { /* as above */ };
 enum( char * ) Names2 { @inline Names@, Jack = "JACK", Jill = "JILL" };
+@***@enum /* inferred */ Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" };
+\end{cfa}
+enum( char * ) Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" };
+\end{cfa}
 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.
 The enumeration type for the inheriting type must be the same as the inherited type;
 hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
+% The enumeration type for the inheriting type must be the same as the inherited type;
+% hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
 % When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
 Specifically, the inheritance relationship for @Names@ is:
 \begin{cfa}
+Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\(\subset\)$ const char * $\C{// enum type of Names}$
+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.
+\begin{cfa}
+Names fred = Name.Fred;
+(Names2) fred; (Names3) fred; (Name3) Names.Jack;  $\C{// cast to super type}$
+Names2 fred2 = fred; Names3 fred3 = fred2; $\C{// assign to super type}$
 \end{cfa}
 For the given function prototypes, the following calls are valid.
 …
 g( Fred );   g( Jill );
 h( Fred );   h( Jill );   h( Sue );
  j( Fred );    j( Jill );    j( Sue );    j( "WILL" );
+j( Fred );    j( Jill );    j( Sue );    j( "WILL" );
 \end{cfa}
 \end{tabular}
 \end{cquote}
 Note, the validity of calls is the same for call-by-reference as for call-by-value, and @const@ restrictions are the same as for other types.
 \section{Enumerator Control Structures}
 …
 \end{cfa}
+@if@ statement
+@switch@ statement
+looping statements
+\begin{cfa}
+for (d; Workday) { sout | d; }
+for (p; +~=Planet) { sout | p; }
+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
+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.
+On a side note, the loop syntax
+\begin{cfa}
+for ( typeof(Workday) d; d <= last(); d = succ(d) );
+\end{cfa}
+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.
+Overloading the @!=@ operator with an enumeration type against the zero defines a conceptual conversion from
+enum to boolean, which can be used as predicates.
+\begin{cfa}
+enum(int) ErrorCode { Normal = 0, Slow = 1, Overheat = 1000, OutOfResource = 1001 };
+bool ?!=?(ErrorCode lhs, zero_t) { return value(lhs) >= 1000; }
+ErrorCode code = /.../
+if (code) { scream(); }
+\end{cfa}
+Indicentally, \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.
+\begin{cfa}
+enum(int) Weekday { Mon, Tues, Wed, Thurs, Fri, Sat, Sun, };
+enum() Colour { Red, Green, Blue };
+enum(S) Fruit { Apple, Banana, Cherry }
+Weekday w = ...; Colour c = ...; Fruit f = ...;
+if (w) { ... } // w is true if and only if w != Mon, because value(Mon) == 0 (auto initialized)
+if (c) { ... } // error
+if (s) { ... } // depends on ?!=?(S lhs, zero_t ), and error if no such overloading available
+\end{cfa}
+As an alternatively, users can define the boolean conversion for CfaEnum:
+\begin{cfa}
+forall(E | CfaEnum(E))
+bool ?!=?(E lhs, zero_t) {
+        return posn(lhs) != 0;
+}
+\end{cfa}
+which effectively turns the first enumeration as a logical zero and non-zero for others.
 \section{Enumerated Arrays}

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

Context Navigation

Changeset dc1c430 for doc/theses/jiada_liang_MMath

Legend:

doc/theses/jiada_liang_MMath/CFAenum.tex

Download in other formats: