Index: doc/theses/colby_parsons_MMAth/text/CFA_intro.tex =================================================================== --- doc/theses/colby_parsons_MMAth/text/CFA_intro.tex (revision 9432499cdffe4cba7cc9a5b7eaf055321da1f23a) +++ doc/theses/colby_parsons_MMAth/text/CFA_intro.tex (revision 0e398ade9c5f271c0f54a551281cd28129f39e40) @@ -9,6 +9,6 @@ \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 \code{struct}'s and routines, and respects the same rules as C. -\CFA is not object oriented as it has no notion of \code{this} and no classes or methods, but supports some object oriented adjacent ideas including costructors, destructors, and limited inheritance. +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. @@ -17,21 +17,21 @@ 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 \code{nullptr} is \code{0p}. - -\begin{cfacode}[caption={Example of \CFA references},label={l:cfa_ref}] +Another related item to note is that the \CFA equivalent of \CC's @nullptr@ is @0p@. + +\begin{cfa}[caption={Example of \CFA references},label={l:cfa_ref}] int i = 2; -int & ref_i = i; // declare ref to i -int * ptr_i = &i; // ptr to i +int & ref_i = i; $\C[1.5in]{// 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; // can have a ref to a ref -ref_i = 3; // 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; // (&*)ref_i = &new_i; (sets underlying ptr) -\end{cfacode} +&ref_i = &new_i; $\C{// (\&*)ref\_i = \&new\_i; (sets underlying ptr)}\CRT$ +\end{cfa} @@ -43,5 +43,5 @@ -\begin{cfacode}[caption={Example of \CFA function overloading},label={l:cfa_overload}] +\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; } @@ -57,5 +57,5 @@ foo( a ); // prints 3 } -\end{cfacode} +\end{cfa} @@ -68,5 +68,5 @@ -\begin{cfacode}[tabsize=3,caption={Usage of \CFA with statement},label={l:cfa_with}] +\begin{cfa}[tabsize=3,caption={Usage of \CFA with statement},label={l:cfa_with}] struct obj { int a, b, c; @@ -100,5 +100,5 @@ p.y = 2.71; } -\end{cfacode} +\end{cfa} @@ -109,5 +109,5 @@ -\begin{cfacode}[tabsize=3,caption={Example of \CFA operators},label={l:cfa_operate}] +\begin{cfa}[tabsize=3,caption={Example of \CFA operators},label={l:cfa_operate}] struct coord { double x; @@ -125,5 +125,5 @@ (op2.x*op2.x + op2.y*op2.y + op2.z*op2.z); } -\end{cfacode} +\end{cfa} @@ -134,5 +134,5 @@ -\begin{cfacode}[tabsize=3,caption={Example of \CFA constructors and destructors},label={l:cfa_ctor}] +\begin{cfa}[tabsize=3,caption={Example of \CFA constructors and destructors},label={l:cfa_ctor}] struct discrete_point { int x; @@ -157,5 +157,5 @@ discrete_point dp{ 2, -4 }; // specialized ctor } // ^d{}, ^p{}, ^dp{} all called as they go out of scope -\end{cfacode} +\end{cfa} @@ -165,12 +165,12 @@ \subsection{Parametric Polymorphism} -\CFA provides parametric polymorphism in the form of \code{forall}, and \code{trait}s. -A \code{forall} takes in a set of types and a list of constraints. -The declarations that follow the \code{forall} are parameterized over the types listed that satisfy the constraints. -Sometimes the list of constraints can be long, which is where a \code{trait} can be used. -A \code{trait} is a collection of constraints that is given a name and can be reused in foralls. +\CFA provides parametric polymorphism in the form of @forall@, and @trait@s. +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{cfacode}[tabsize=3,caption={Example of \CFA polymorphism},label={l:cfa_poly}] +\begin{cfa}[tabsize=3,caption={Example of \CFA polymorphism},label={l:cfa_poly}] // sized() is a trait that means the type has a size forall( V & | sized(V) ) // type params for trait @@ -215,12 +215,12 @@ } -\end{cfacode} +\end{cfa} \subsection{Inheritance} Inheritance in \CFA copies its style from Plan-9 C nominal inheritance. -In \CFA structs can \code{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. +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{cfacode}[tabsize=3,caption={Example of \CFA inheritance},label={l:cfa_inherit}] +\begin{cfa}[tabsize=3,caption={Example of \CFA inheritance},label={l:cfa_inherit}] struct one_d { double x; }; struct two_d { @@ -260,5 +260,5 @@ print_food( p ); // prints 5 } -\end{cfacode} - - +\end{cfa} + +