Context Navigation

-                      r9363b1b
+                      r59c05958
 \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}
 …
 \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}
 …
 \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}
 …
 \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}
 …
 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; };
 …
 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; };
 …
 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; }
 …
 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: %

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 59c05958

Legend:

doc/theses/colby_parsons_MMAth/text/CFA_intro.tex

Download in other formats: