Changeset dc1c430 for doc/theses/jiada_liang_MMath/CFAenum.tex
- Timestamp:
- Jul 15, 2024, 1:33:18 PM (3 months ago)
- Branches:
- master
- Children:
- 09dd830
- Parents:
- bfa7bf0
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/theses/jiada_liang_MMath/CFAenum.tex
rbfa7bf0 rdc1c430 7 7 The following sections detail all of my new contributions to enumerations in \CFA. 8 8 9 10 \section{Aliasing} 11 12 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). 13 Given the existence of this form, it is straightforward to extend it with types other than @int@. 14 \begin{cfa} 15 enum E { Size = 20u, PI = 3.14159L, Jack = L"John" }; 16 \end{cfa} 17 which matches with @const@ aliasing in other programming languages. 18 Here, the type of the enumerator is the type of the initialization constant, \eg @typeof(20u)@ for @Size@ implies @unsigned int@. 19 Auto-initialization is restricted to the case where all constants are @int@, matching with C. 20 As seen in \VRef{s:EnumeratorTyping}, this feature is just a shorthand for multiple typed-enumeration declarations. 9 \begin{comment} 10 Not support. 11 \end{comment} 12 % \section{Aliasing} 13 14 % 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). 15 % Given the existence of this form, it is straightforward to extend it with types other than @int@. 16 % \begin{cfa} 17 % enum E { Size = 20u, PI = 3.14159L, Jack = L"John" }; 18 % \end{cfa} 19 % which matches with @const@ aliasing in other programming languages. 20 % Here, the type of the enumerator is the type of the initialization constant, \eg @typeof(20u)@ for @Size@ implies @unsigned int@. 21 % Auto-initialization is restricted to the case where all constants are @int@, matching with C. 22 % As seen in \VRef{s:EnumeratorTyping}, this feature is just a shorthand for multiple typed-enumeration declarations. 21 23 22 24 … … 28 30 29 31 The \CFA type-system allows extensive overloading, including enumerators. 30 Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name. 32 Furthermore, \CFA uses the environment, such as the left-had of assignment and function parameter, to pinpoint the best overloaded name. 33 % Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name. 31 34 Finally, qualification and casting are provided to disambiguate any ambiguous situations. 32 35 \begin{cfa} … … 35 38 E1 f() { return Third; } $\C{// overloaded functions, different return types}$ 36 39 E2 f() { return Fourth; } 40 void g(E1 e); 41 void h(E2 e); 37 42 void foo() { 38 43 E1 e1 = First; E2 e2 = First; $\C{// initialization}$ 39 44 e1 = Second; e2 = Second; $\C{// assignment}$ 40 e1 = f(); e2 = f(); $\C{// function call}$ 45 e1 = f(); e2 = f(); $\C{// function return}$ 46 g(First); h(First); $\C{// function parameter}$ 41 47 int i = @E1.@First + @E2.@First; $\C{// disambiguate with qualification}$ 42 48 int j = @(E1)@First + @(E2)@First; $\C{// disambiguate with cast}$ … … 72 78 73 79 74 \section{Enumeration Trait }75 76 The header file \lstinline[deletekeywords=enum]{<enum.hfa>}defines the set of traits containing operators and helper functions for @enum@.80 \section{Enumeration Traits} 81 82 \CFA defines the set of traits containing operators and helper functions for @enum@. 77 83 A \CFA enumeration satisfies all of these traits allowing it to interact with runtime features in \CFA. 78 84 Each trait is discussed in detail. 79 85 80 The trait @Bounded@: 86 The trait @CfaEnum@: 87 \begin{cfa} 88 forall( E ) trait CfaEnum { 89 char * label( E e ); 90 unsigned int posn( E e ); 91 }; 92 \end{cfa} 93 94 describes an enumeration as a named constant with position. And @TypeEnum@ 95 \begin{cfa} 96 forall( E, V ) trait TypeEnum { 97 V value( E e ); 98 }; 99 \end{cfa} 100 asserts two types @E@ and @T@, with @T@ being the base type for the enumeration @E@. 101 102 The declarative syntax 103 \begin{cfa} 104 enum(T) E { A = ..., B = ..., C = ... }; 105 \end{cfa} 106 creates an enumerated type E with @label@, @posn@ and @value@ implemented automatically. 107 108 \begin{cfa} 109 void foo( T t ) { ... } 110 void bar(E e) { 111 choose (e) { 112 case A: printf("\%d", posn(e)); 113 case B: printf("\%s", label(e)); 114 case C: foo(value(e)); 115 } 116 } 117 \end{cfa} 118 119 Implementing general functions across all enumeration types is possible by asserting @CfaEnum( E, T )@, \eg: 120 \begin{cfa} 121 #include <string.hfa> 122 forall( E, T | CfaEnum( E, T ) | {unsigned int toUnsigned(T)} ) 123 string formatEnum( E e ) { 124 unsigned int v = toUnsigned(value(e)); 125 string out = label(e) + '(' + v +')'; 126 return out; 127 } 128 printEunm( Week.Mon ); 129 printEnum( RGB.Green ); 130 \end{cfa} 131 132 \CFA does not define attributes functions for C style enumeration. But it is possilbe for users to explicitly implement 133 enumeration traits for C enum and any other types. 134 135 \begin{cfa} 136 enum Fruit { Apple, Bear, Cherry }; $\C{// C enum}$ 137 char * label(Fruit f) { 138 switch(f) { 139 case Apple: "A"; break; 140 case Bear: "B"; break; 141 case Cherry: "C"; break; 142 } 143 } 144 unsigned posn(Fruit f) { return f; } 145 char* value(Fruit f) { return ""; } $\C{// value can return any non void type}$ 146 formatEnum( Apple ); $\C{// Fruit is now a Cfa enum}$ 147 \end{cfa} 148 149 A type that implement trait @CfaEnum@, \ie, a type has no @value@, is called an opaque enum. 150 151 % \section{Enumerator Opaque Type} 152 153 % \CFA provides a special opaque enumeration type, where the internal representation is chosen by the compiler and only equality operations are available. 154 \begin{cfa} 155 enum@()@ Planets { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE }; 156 \end{cfa} 157 158 159 In addition, \CFA implements @Bound@ and @Serial@ for \CFA Enums. 81 160 \begin{cfa} 82 161 forall( E ) trait Bounded { … … 85 164 }; 86 165 \end{cfa} 87 defines the bounds of the enumeration, where @first()@ returns the first enumerator and @last()@ returns the last,\eg:166 The function @first()@ and @last()@ of enumertated type E return the first and the last enumerator declared in E, respectively. \eg: 88 167 \begin{cfa} 89 168 Workday day = first(); $\C{// Mon}$ … … 93 172 Calling either functions without a context results in a type ambiguity, except in the rare case where the type environment has only one enumeration. 94 173 \begin{cfa} 95 @first();@ $\C{// ambiguous Workday and Planet implement Bounded}$174 @first();@ $\C{// ambiguous because both Workday and Planet implement Bounded}$ 96 175 sout | @last()@; 97 176 Workday day = first(); $\C{// day provides type Workday}$ … … 116 195 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@. 117 196 118 The @ Serial@ trait also requires interface functions @succ( E e )@ and @pred( E e )@ be implemented for a serial type, whichimply the enumeration positions are consecutive and ordinal.197 The @succ( E e )@ and @pred( E e )@ imply the enumeration positions are consecutive and ordinal. 119 198 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()$. 120 199 The exception @enumRange@ is raised if the result of either operation is outside the range of type @E@. 121 200 122 The trait @TypedEnum@:123 \begin{cfa}124 forall( E, T ) trait TypedEnum {125 T valueE( E e );126 char * labelE( E e );127 unsigned int posE( E e );128 };129 \end{cfa}130 captures three basic attributes of an enumeration type: value, label, and position.131 @TypedEnum@ asserts two types @E@ and @T@, with @T@ being the base type of the enumeration @E@, \eg @enum( T ) E { ... };@.132 Implementing general functions across all enumeration types is possible by asserting @TypeEnum( E, T )@, \eg:133 \begin{cfa}134 forall( E, T | TypeEnum( E, T ) )135 void printEnum( E e ) {136 sout | "Enum "| labelE( e );137 }138 printEunm( MARS );139 \end{cfa}140 141 201 Finally, there is an associated trait defining comparison operators among enumerators. 142 202 \begin{cfa} 143 forall( E, T | TypedEnum( E, T ) ) {203 forall( E, T | CfaEnum( E, T ) ) { 144 204 // comparison 145 205 int ?==?( E l, E r ); $\C{// true if l and r are same enumerators}$ … … 152 212 } 153 213 \end{cfa} 154 Note, the overloaded operators are defined only when the header @<enum.hfa>@ is included. 155 If not, the compiler converts an enumerator to its value, and applies the operators defined for the value type @E@, \eg: 156 \begin{cfa} 157 // if not include <enum.hfa> 158 enum( int ) Fruits { APPLE = 2, BANANA = 10, CHERRY = 2 }; 159 APPLE == CHERRY; // true because valueE( APPLE ) == valueE( CHERRY ) 160 161 #include <enum.hfa> 162 APPLE == CHERRY; // false because posE( APPLE ) != posE( CHERRY ) 163 \end{cfa} 164 An enumerator returns its @position@ by default. 165 In particular, @printf( ... )@ from @<stdio.h>@ functions provides no context to its parameter type, so it prints @position@. 166 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@. 167 \begin{cfa} 168 printf( "Position of BANANA is \%d", BANANA ); // Position of BANANA is 1 169 sout | "Value of BANANA is " | BANANA; // Value of BANANA is 10 170 \end{cfa} 171 Programmers can overwrite this behaviour by overloading the pipeline operator themselves. 172 \PAB{This needs discussing because including \lstinline{<enum.hfa>} can change the entire meaning of a program.} 173 174 175 % \section{Enumeration Pseudo-functions} 176 177 % Pseudo-functions are function-like operators that do not result in any run-time computations, \ie like @sizeof@, @alignof@, @typeof@. 178 % 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. 179 180 % The attributes of an enumerator are accessed by pseudo-functions @posE@, @valueE@, and @labelE@. 181 % \begin{cfa} 182 % int jane_pos = @posE@( Names.Jane ); $\C{// 2}$ 183 % char * jane_value = @valueE@( Names.Jane ); $\C{// "JANE"}$ 184 % char * jane_label = @labelE@( Names.Jane ); $\C{// "Jane"}$ 185 % sout | posE( Names.Jane) | labelE( Names.Jane ) | valueE( Names.Jane ); 186 % \end{cfa} 187 % Note the ability to print all of an enumerator's properties. 188 189 190 \section{Enumerator Typing} 214 215 \section{Typed Enum} 191 216 \label{s:EnumeratorTyping} 192 217 … … 256 281 calling constructors happens at runtime (dynamic). 257 282 258 259 \section{Enumerator Opaque Type}260 261 \CFA provides a special opaque enumeration type, where the internal representation is chosen by the compiler and only equality operations are available.262 \begin{cfa}263 enum@()@ Planets { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE };264 \end{cfa}265 266 267 283 \section{Enumeration Inheritance} 268 284 269 285 \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). 286 270 287 \begin{cfa} 271 288 enum( char * ) Names { /* as above */ }; 272 289 enum( char * ) Names2 { @inline Names@, Jack = "JACK", Jill = "JILL" }; 273 @***@enum /* inferred */ Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" }; 274 \end{cfa} 290 enum( char * ) Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" }; 291 \end{cfa} 292 275 293 Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Names@ by containment, and a @Names@ enumeration is a subtype of enumeration @Name2@. 276 294 Note, enumerators must be unique in inheritance but enumerator values may be repeated. 277 295 278 The enumeration type for the inheriting type must be the same as the inherited type;279 hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.296 % The enumeration type for the inheriting type must be the same as the inherited type; 297 % hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@. 280 298 % When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important. 281 299 Specifically, the inheritance relationship for @Names@ is: 282 300 \begin{cfa} 283 Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\(\subset\)$ const char * $\C{// enum type of Names}$ 301 Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\C{// enum type of Names}$ 302 \end{cfa} 303 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. 304 \begin{cfa} 305 Names fred = Name.Fred; 306 (Names2) fred; (Names3) fred; (Name3) Names.Jack; $\C{// cast to super type}$ 307 Names2 fred2 = fred; Names3 fred3 = fred2; $\C{// assign to super type}$ 284 308 \end{cfa} 285 309 For the given function prototypes, the following calls are valid. … … 297 321 g( Fred ); g( Jill ); 298 322 h( Fred ); h( Jill ); h( Sue ); 299 323 j( Fred ); j( Jill ); j( Sue ); j( "WILL" ); 300 324 \end{cfa} 301 325 \end{tabular} 302 326 \end{cquote} 303 327 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. 304 305 328 306 329 \section{Enumerator Control Structures} … … 364 387 \end{cfa} 365 388 366 367 @if@ statement 368 369 @switch@ statement 370 371 looping statements 372 389 \begin{cfa} 390 for (d; Workday) { sout | d; } 391 for (p; +~=Planet) { sout | p; } 392 for (c: -~=Alphabet ) { sout | c; } 393 \end{cfa} 394 The @range loop@ for enumeration is a syntax sugar that looping over all enumeerators and assign each enumeration to a variable in every iteration. 395 The loop control of range loop consists of two parts: a variable declaration and a @range expression@, with type of the variable 396 can be inferred from the range expression. 397 398 The range expression is an enumeration type, optionally prefixed by @+~=@ or @-~=@. Without a prefix, or prefixed with @+~=@, the control 399 loop over all enumerator from the first to the last. With a @-~=@ prefix, the control loops backwards. 400 401 On a side note, the loop syntax 402 \begin{cfa} 403 for ( typeof(Workday) d; d <= last(); d = succ(d) ); 404 \end{cfa} 405 does not work. When d == last(), the loop control will still attempt to assign succ(d) to d, which causes an @enumBound@ exception. 406 407 \CFA reduces conditionals to its "if case" if the predicate not equal to ( @!=@ ) zero, and the "else case" otherwises. 408 Overloading the @!=@ operator with an enumeration type against the zero defines a conceptual conversion from 409 enum to boolean, which can be used as predicates. 410 411 \begin{cfa} 412 enum(int) ErrorCode { Normal = 0, Slow = 1, Overheat = 1000, OutOfResource = 1001 }; 413 bool ?!=?(ErrorCode lhs, zero_t) { return value(lhs) >= 1000; } 414 ErrorCode code = /.../ 415 if (code) { scream(); } 416 \end{cfa} 417 418 Indicentally, \CFA does not define boolean conversion for enumeration. If no 419 @?!=?(ErrorCode, zero_t)@ 420 overloading defined, 421 \CFA looks for the boolean conversion in terms of its value, and gives an compiler error if no such conversion is available. 422 423 \begin{cfa} 424 enum(int) Weekday { Mon, Tues, Wed, Thurs, Fri, Sat, Sun, }; 425 enum() Colour { Red, Green, Blue }; 426 enum(S) Fruit { Apple, Banana, Cherry } 427 Weekday w = ...; Colour c = ...; Fruit f = ...; 428 if (w) { ... } // w is true if and only if w != Mon, because value(Mon) == 0 (auto initialized) 429 if (c) { ... } // error 430 if (s) { ... } // depends on ?!=?(S lhs, zero_t ), and error if no such overloading available 431 \end{cfa} 432 433 As an alternatively, users can define the boolean conversion for CfaEnum: 434 435 \begin{cfa} 436 forall(E | CfaEnum(E)) 437 bool ?!=?(E lhs, zero_t) { 438 return posn(lhs) != 0; 439 } 440 \end{cfa} 441 which effectively turns the first enumeration as a logical zero and non-zero for others. 373 442 374 443 \section{Enumerated Arrays}
Note: See TracChangeset
for help on using the changeset viewer.