Changeset 0e398ad for doc/theses/colby_parsons_MMAth/text

Timestamp:

Apr 3, 2023, 5:51:56 PM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

525a46a

Parents:

9432499

Message:

convert to CFAStyle in CFA_intro chapter

File:

• doc/theses/colby_parsons_MMAth/text/CFA_intro.tex (modified) (13 diffs)

doc/theses/colby_parsons_MMAth/text/CFA_intro.tex ¶

@@ -9 +9 @@
 \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 +17 @@
 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 +43 @@
 
 
-\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 +57 @@
     foo( a );               // prints 3
 }
-\end{cfacode}
+\end{cfa}
 
 
@@ -68 +68 @@
 
 
-\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 +100 @@
     p.y = 2.71;
 }
-\end{cfacode}
+\end{cfa}
 
 
@@ -109 +109 @@
 
 
-\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 +125 @@
         (op2.x*op2.x + op2.y*op2.y + op2.z*op2.z);
 }
-\end{cfacode}
+\end{cfa}
 
 
@@ -134 +134 @@
 
 
-\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 +157 @@
     discrete_point dp{ 2, -4 }; // specialized ctor
 } // ^d{}, ^p{}, ^dp{} all called as they go out of scope
-\end{cfacode}
+\end{cfa}
 
 
@@ -165 +165 @@
 
 \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 +215 @@
 }
 
-\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 +260 @@
     print_food( p ); // prints 5
 }
-\end{cfacode}
-
-
+\end{cfa}
+
+