Changeset c459f99

Timestamp:

May 2, 2023, 11:11:34 AM (19 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

21d1c9c

Parents:

d1c51b1

Message:

formatting, small updates

File:

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

doc/theses/colby_parsons_MMAth/text/CFA_intro.tex

@@ -6 +6 @@
 
 \section{Overview}
-The following serves as an introduction to \CFA. 
-\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. 
+The following serves as an introduction to \CFA.
+\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 \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. 
+References in \CFA are similar to references in \CC; however \CFA references are \emph{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.
 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}. 
+Examples of references are shown in \VRef[Listing]{l:cfa_ref}.
 
 \begin{cfa}[caption={Example of \CFA references},label={l:cfa_ref}]
@@ -37 +37 @@
 
 \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. 
+\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.
 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}. 
+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}]
@@ -60 +60 @@
 
 
-\section{With Statement}
+\section{\lstinline{with} Statement}
 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}. 
+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}]
@@ -83 +83 @@
 
 \section{Operators}
-Operators can be overloaded in \CFA with operator routines. 
+Operators can be overloaded in \CFA with operator routines.
 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}. 
+Examples of \CFA operators are shown in \VRef[Listing]{l:cfa_operate}.
 
 \begin{cfa}[caption={Example of \CFA operators},label={l:cfa_operate}]
@@ -102 +102 @@
 
 \section{Constructors and Destructors}
-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}. 
+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}]
@@ -128 +128 @@
 \section{Polymorphism}\label{s:poly}
 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.
+\CFA extends C with generalized overloading polymorphism (see \VRef{s:Overloading}), as well as, parametric polymorphism and limited containment inheritance.
 
 \subsection{Parametric Polymorphism}
-\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. 
-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}. 
+\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.
+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}]
@@ -180 +180 @@
 
 \subsection{Inheritance}
-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}. 
+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 { 
+struct two_d {
         @inline@ one_d;
         double y;
 };
-struct three_d { 
+struct three_d {
         @inline@ two_d;
         double z;