Index: doc/theses/colby_parsons_MMAth/text/CFA_intro.tex =================================================================== --- doc/theses/colby_parsons_MMAth/text/CFA_intro.tex (revision 9363b1b75d922f4913c32d04c265d16fe3642b62) +++ doc/theses/colby_parsons_MMAth/text/CFA_intro.tex (revision 59c05958993d069b1a24a717e5f66d679cb650b4) @@ -7,53 +7,53 @@ \section{Overview} The following serves as an introduction to \CFA. -\CFA is a layer over C, is transpiled to C and is largely considered to be an extension of C. -Beyond C, it adds productivity features, libraries, a type system, and many other language constructions. -However, \CFA stays true to C as a language, with most code revolving around @struct@'s and routines, and respects the same rules as C. -\CFA is not object oriented as it has no notion of @this@ and no classes or methods, but supports some object oriented adjacent ideas including costructors, destructors, and limited inheritance. -\CFA is rich with interesting features, but a subset that is pertinent to this work will be discussed. +\CFA is a layer over C, is transpiled\footnote{Source to source translator.} to C, and is largely considered to be an extension of C. +Beyond C, it adds productivity features, extended libraries, an advanced type system, and many control-flow/concurrency constructions. +However, \CFA stays true to the C programming style, with most code revolving around @struct@'s and routines, and respects the same rules as C. +\CFA is not object oriented as it has no notion of @this@ (receiver) and no structures with methods, but supports some object oriented ideas including constructors, destructors, and limited containment inheritance. +While \CFA is rich with interesting features, only the subset pertinent to this work is discussed. \section{References} -References in \CFA are similar to references in \CC, however in \CFA references are rebindable, and support multi-level referencing. +References in \CFA are similar to references in \CC; however \CFA references are rebindable, and support multi-level referencing. References in \CFA are a layer of syntactic sugar over pointers to reduce the number of ref/deref operations needed with pointer usage. -Some examples of references in \CFA are shown in Listing~\ref{l:cfa_ref}. -Another related item to note is that the \CFA equivalent of \CC's @nullptr@ is @0p@. +Another difference is the use of @0p@ instead of C's @NULL@ or \CC's @nullptr@. +Examples of references are shown in \VRef[Listing]{l:cfa_ref}. \begin{cfa}[caption={Example of \CFA references},label={l:cfa_ref}] int i = 2; -int & ref_i = i; $\C[1.5in]{// declare ref to i}$ -int * ptr_i = &i; $\C{// ptr to i}$ +int & ref_i = i; $\C{// declare ref to i}$ +int * ptr_i = &i; $\C{// ptr to i}$ // address of ref_i is the same as address of i assert( &ref_i == ptr_i ); -int && ref_ref_i = ref_i; $\C{// can have a ref to a ref}$ -ref_i = 3; $\C{// set i to 3}$ +int && ref_ref_i = ref_i; $\C{// can have a ref to a ref}$ +ref_i = 3; $\C{// set i to 3}$ int new_i = 4; // syntax to rebind ref_i (must cancel implicit deref) -&ref_i = &new_i; $\C{// (\&*)ref\_i = \&new\_i; (sets underlying ptr)}\CRT$ -\end{cfa} - - -\section{Overloading} -In \CFA routines can be overloaded on parameter type, number of parameters, and return type. +&ref_i = &new_i; $\C{// (\&*)ref\_i = \&new\_i; (sets underlying ptr)}$ +\end{cfa} + + +\section{Overloading}\label{s:Overloading} +\CFA routines can be overloaded on parameter type, number of parameters, and \emph{return type}. Variables can also be overloaded on type, meaning that two variables can have the same name so long as they have different types. -The variables will be disambiguated via type, sometimes requiring a cast. -The code snippet in Listing~\ref{l:cfa_overload} contains examples of overloading. - - -\begin{cfa}[caption={Example of \CFA function overloading},label={l:cfa_overload}] -int foo() { printf("A\n"); return 0;} -int foo( int bar ) { printf("B\n"); return 1; } -int foo( double bar ) { printf("C\n"); return 2; } -double foo( double bar ) { printf("D\n"); return 3;} -void foo( double bar ) { printf("%.0f\n", bar); } - -int main() { - foo(); // prints A - foo( 0 ); // prints B - int a = foo( 0.0 ); // prints C - double a = foo( 0.0 ); // prints D - foo( a ); // prints 3 +A routine or variable is disambiguated at each usage site via its type and surrounding expression context. +A cast is used to disambiguate any conflicting usage. +Examples of overloading are shown in \VRef[Listing]{l:cfa_overload}. + +\begin{cfa}[caption={Example of \CFA overloading},label={l:cfa_overload}] +int foo() { sout | "A"; return 0;} +int foo( int bar ) { sout | "B"; return 1; } +int foo( double bar ) { sout | "C"; return 2; } +double foo( double bar ) { sout | "D"; return 3; } +void foo( double bar ) { sout | bar; } + +int main() { + foo(); $\C{// prints A}$ + foo( 0 ); $\C{// prints B}$ + int foo = foo( 0.0 ); $\C{// prints C}$ + double foo = foo( 0.0 ); $\C{// prints D}$ + foo( foo ); $\C{// prints 3., where left-hand side of expression is void}$ } \end{cfa} @@ -61,42 +61,21 @@ \section{With Statement} -The with statement is a tool for exposing members of aggregate types within a scope in \CFA. -It allows users to use fields of aggregate types without using their fully qualified name. -This feature is also implemented in Pascal. -It can exist as a stand-alone statement or it can be used on routines to expose fields in the body of the routine. -An example is shown in Listing~\ref{l:cfa_with}. - - -\begin{cfa}[tabsize=3,caption={Usage of \CFA with statement},label={l:cfa_with}] -struct obj { - int a, b, c; -}; -struct pair { - double x, y; -}; - -// Stand-alone with stmt: +The \CFA @with@ statement is for exposing fields of an aggregate type within a scope, allowing field names without qualification. +This feature is also implemented in Pascal~\cite{Pascal}. +It can exist as a stand-alone statement or wrap a routine body to expose aggregate fields. +Examples of the @with@ statement are shown in \VRef[Listing]{l:cfa_with}. + +\begin{cfa}[caption={Example of \CFA \lstinline{with} statement},label={l:cfa_with}] +struct pair { double x, y; }; +struct triple { int a, b, c; }; pair p; -with( p ) { - x = 6.28; - y = 1.73; -} - -// Can be used on routines: -void foo( obj o, pair p ) with( o, p ) { - a = 1; - b = 2; - c = 3; - x = 3.14; - y = 2.71; -} - -// routine foo is equivalent to routine bar: -void bar( obj o, pair p ) { - o.a = 1; - o.b = 2; - o.c = 3; - p.x = 3.14; - p.y = 2.71; + +@with( p )@ { $\C{// stand-alone with}$ + p.x = 6.28; p.y = 1.73; $\C{// long form}$ + x = 6.28; y = 1.73; $\C{// short form}$ +} +void foo( triple t, pair p ) @with( t, p )@ { $\C{// routine with}$ + t.a = 1; t.b = 2; t.c = 3; p.x = 3.14; p.y = 2.71; $\C{// long form}$ + a = 1; b = 2; c = 3; x = 3.14; y = 2.71; $\C{// short form}$ } \end{cfa} @@ -105,23 +84,17 @@ \section{Operators} Operators can be overloaded in \CFA with operator routines. -Operators in \CFA are named using the operator symbol and '?' to respresent operands. -An example is shown in Listing~\ref{l:cfa_operate}. - - -\begin{cfa}[tabsize=3,caption={Example of \CFA operators},label={l:cfa_operate}] +Operators in \CFA are named using an operator symbol and '@?@' to represent operands. +Examples of \CFA operators are shown in \VRef[Listing]{l:cfa_operate}. + +\begin{cfa}[caption={Example of \CFA operators},label={l:cfa_operate}] struct coord { - double x; - double y; - double z; -}; -coord ++?( coord & c ) with(c) { - x++; - y++; - z++; - return c; -} -coord ?<=?( coord op1, coord op2 ) with( op1 ) { - return (x*x + y*y + z*z) <= - (op2.x*op2.x + op2.y*op2.y + op2.z*op2.z); + double x, y, z; +}; +coord ++@?@( coord & c ) with( c ) { $\C{// post increment}$ + x++; y++; z++; + return c; +} +coord @?@<=@?@( coord op1, coord op2 ) with( op1 ) { $\C{// ambiguous with both parameters}$ + return (x * x + y * y + z * z) <= (op2.x * op2.x + op2.y * op2.y + op2.z * op2.z); } \end{cfa} @@ -129,38 +102,31 @@ \section{Constructors and Destructors} -Constructors and destructors in \CFA are two special operator routines that are used for creation and destruction of objects. -The default constructor and destructor for a type are called implicitly upon creation and deletion respectively if they are defined. -An example is shown in Listing~\ref{l:cfa_ctor}. - - -\begin{cfa}[tabsize=3,caption={Example of \CFA constructors and destructors},label={l:cfa_ctor}] +Constructors and destructors in \CFA are special operator routines used for creation and destruction of objects. +The default constructor and destructor for a type are called implicitly upon creation and deletion, respectively. +Examples of \CFA constructors and destructors are shown in \VRef[Listing]{l:cfa_ctor}. + +\begin{cfa}[caption={Example of \CFA constructors and destructors},label={l:cfa_ctor}] struct discrete_point { - int x; - int y; -}; -void ?{}( discrete_point & this ) with(this) { // ctor - x = 0; - y = 0; -} -void ?{}( discrete_point & this, int x, int y ) { // ctor - this.x = x; - this.y = y; -} -void ^?{}( discrete_point & this ) with(this) { // dtor - x = 0; - y = 0; -} - -int main() { - discrete_point d; // implicit call to ?{} - discrete_point p{}; // same call as line above - discrete_point dp{ 2, -4 }; // specialized ctor -} // ^d{}, ^p{}, ^dp{} all called as they go out of scope + int x, y; +}; +void ?{}( discrete_point & this ) with(this) { $\C{// default constructor}$ + [x, y] = 0; +} +void ?{}( discrete_point & this, int x, int y ) { $\C{// explicit constructor}$ + this.[x, y] = [x, y]; +} +void ^?{}( discrete_point & this ) with(this) { $\C{// destructor}$ + ?{}( this ); $\C{// reset by calling default constructor}$ +} +int main() { + discrete_point x, y{}; $\C{// implicit call to default ctor, ?\{\}}$ + discrete_point s = { 2, -4 }, t{ 4, 2 }; $\C{// explicit call to specialized ctor}$ +} // ^t{}, ^s{}, ^y{}, ^x{} implicit calls in reverse allocation order \end{cfa} \section{Polymorphism}\label{s:poly} -C does not natively support polymorphism, and requires users to implement polymorphism themselves if they want to use it. -\CFA extends C with two styles of polymorphism that it supports, parametric polymorphism and nominal inheritance. +C supports limited polymorphism, often requiring users to implement polymorphism using a @void *@ (type erasure) approach. +\CFA extends C with generalized overloading polymorphism (see \VRef{s:Overloading}), as well as, parametric polymorphism and nominal inheritance. \subsection{Parametric Polymorphism} @@ -168,27 +134,25 @@ A @forall@ takes in a set of types and a list of constraints. The declarations that follow the @forall@ are parameterized over the types listed that satisfy the constraints. -Sometimes the list of constraints can be long, which is where a @trait@ can be used. -A @trait@ is a collection of constraints that is given a name and can be reused in foralls. -An example of the usage of parametric polymorphism in \CFA is shown in Listing~\ref{l:cfa_poly}. - -\begin{cfa}[tabsize=3,caption={Example of \CFA polymorphism},label={l:cfa_poly}] +A list of @forall@ constraints can be refactored into a named @trait@ and reused in @forall@s. +Examples of \CFA parametric polymorphism are shown in \VRef[Listing]{l:cfa_poly}. + +\begin{cfa}[caption={Example of \CFA parametric polymorphism},label={l:cfa_poly}] // sized() is a trait that means the type has a size -forall( V & | sized(V) ) // type params for trait +forall( V & | sized(V) ) $\C{// type params for trait}$ trait vector_space { - V add( V, V ); // vector addition - V scalar_mult( int, V ); // scalar multiplication - - // dtor and copy ctor needed in constraints to pass by copy - void ?{}( V &, V & ); // copy ctor for return - void ^?{}( V & ); // dtor -}; - -forall( V & | vector_space( V )) { - V get_inverse( V v1 ) { - return scalar_mult( -1, v1 ); // can use ?*? routine defined in trait - } - V add_and_invert( V v1, V v2 ) { - return get_inverse( add( v1, v2 ) ); // can use ?*? routine defined in trait - } + // dtor and copy ctor needed in constraints to pass by copy + void ?{}( V &, V & ); $\C{// copy ctor for return}$ + void ^?{}( V & ); $\C{// dtor}$ + V ?+?( V, V ); $\C{// vector addition}$ + V ?*?( int, V ); $\C{// scalar multiplication}$ +}; + +forall( V & | vector_space( V ) ) { + V get_inverse( V v1 ) { + return -1 * v1; $\C{// can use ?*? routine defined in trait}$ + } + V add_and_invert( V v1, V v2 ) { + return get_inverse( v1 + v2 ); $\C{// can use ?+? routine defined in trait}$ + } } struct Vec1 { int x; }; @@ -196,6 +160,6 @@ void ?{}( Vec1 & this, int x ) { this.x = x; } void ^?{}( Vec1 & this ) {} -Vec1 add( Vec1 v1, Vec1 v2 ) { v1.x += v2.x; return v1; } -Vec1 scalar_mult( int c, Vec1 v1 ) { v1.x = v1.x * c; return v1; } +Vec1 ?+?( Vec1 v1, Vec1 v2 ) { v1.x += v2.x; return v1; } +Vec1 ?*?( int c, Vec1 v1 ) { v1.x = v1.x * c; return v1; } struct Vec2 { int x; int y; }; @@ -203,32 +167,30 @@ void ?{}( Vec2 & this, int x ) { this.x = x; this.y = x; } void ^?{}( Vec2 & this ) {} -Vec2 add( Vec2 v1, Vec2 v2 ) { v1.x += v2.x; v1.y += v2.y; return v1; } -Vec2 scalar_mult( int c, Vec2 v1 ) { v1.x = v1.x * c; v1.y = v1.y * c; return v1; } - -int main() { - Vec1 v1{ 1 }; // create Vec1 and call ctor - Vec2 v2{ 2 }; // create Vec2 and call ctor - - // can use forall defined routines since types satisfy trait - add_and_invert( get_inverse( v1 ), v1 ); - add_and_invert( get_inverse( v2 ), v2 ); -} - +Vec2 ?+?( Vec2 v1, Vec2 v2 ) { v1.x += v2.x; v1.y += v2.y; return v1; } +Vec2 ?*?( int c, Vec2 v1 ) { v1.x = v1.x * c; v1.y = v1.y * c; return v1; } + +int main() { + Vec1 v1{ 1 }; $\C{// create Vec1 and call ctor}$ + Vec2 v2{ 2 }; $\C{// create Vec2 and call ctor}$ + // can use forall defined routines since types satisfy trait + add_and_invert( get_inverse( v1 ), v1 ); + add_and_invert( get_inverse( v2 ), v2 ); +} \end{cfa} \subsection{Inheritance} -Inheritance in \CFA copies its style from Plan-9 C nominal inheritance. -In \CFA structs can @inline@ another struct type to gain its fields and to be able to be passed to routines that require a parameter of the inlined type. -An example of \CFA inheritance is shown in Listing~\ref{l:cfa_inherit}. - -\begin{cfa}[tabsize=3,caption={Example of \CFA inheritance},label={l:cfa_inherit}] +Inheritance in \CFA is taken from Plan-9 C's containment inheritance. +In \CFA, @struct@s can @inline@ another struct type to gain its fields and masquerade as that type. +Examples of \CFA containment inheritance are shown in \VRef[Listing]{l:cfa_inherit}. + +\begin{cfa}[caption={Example of \CFA containment inheritance},label={l:cfa_inherit}] struct one_d { double x; }; struct two_d { - inline one_d; - double y; + @inline@ one_d; + double y; }; struct three_d { - inline two_d; - double z; + @inline@ two_d; + double z; }; double get_x( one_d & d ){ return d.x; } @@ -236,29 +198,34 @@ struct dog {}; struct dog_food { - int count; + int count; }; struct pet { - inline dog; - inline dog_food; -}; -void pet_dog( dog & d ){printf("woof\n");} -void print_food( dog_food & f ){printf("%d\n", f.count);} - -int main() { - one_d x; - two_d y; - three_d z; - x.x = 1; - y.x = 2; - z.x = 3; - get_x( x ); // returns 1; - get_x( y ); // returns 2; - get_x( z ); // returns 3; - pet p; - p.count = 5; - pet_dog( p ); // prints woof - print_food( p ); // prints 5 -} -\end{cfa} - - + @inline@ dog; + @inline@ dog_food; +}; +void pet_dog( dog & d ) { sout | "woof"; } +void print_food( dog_food & f ) { sout | f.count; } + +int main() { + one_d x; + two_d y; + three_d z; + x.x = 1; + y.x = 2; + z.x = 3; + get_x( x ); $\C{// returns 1;}$ + get_x( y ); $\C{// returns 2;}$ + get_x( z ); $\C{// returns 3;}$ + pet p; + p.count = 5; + pet_dog( p ); $\C{// prints woof}$ + print_food( p ); $\C{// prints 5}$ +} +\end{cfa} + +% Local Variables: % +% tab-width: 4 % +% fill-column: 100 % +% End: % + +