Changes in doc/proposals/concurrency/text/cforall.tex [cae28da:6090518]

File:

• doc/proposals/concurrency/text/cforall.tex (modified) (6 diffs)

doc/proposals/concurrency/text/cforall.tex

@@ -52 +52 @@
 % ======================================================================
 \section{Operators}
-Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation appear, e.g.:
+Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation occur, e.g.:
 \begin{cfacode}
 int ++? (int op);                       //unary prefix increment
@@ -72 +72 @@
 % ======================================================================
 \section{Constructors/Destructors}
-Object lifetime is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object lifetime as a means of synchronization and/or mutual exclusion. Since \CFA relies heavily on the lifetime of objects, constructors and destructors is a core feature required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors:
+Object lifetime is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object lifetime as a means of synchronization and/or mutual exclusion. Since \CFA relies heavily on the lifetime of objects, constructors and destructors is a core feature required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors :
 \begin{cfacode}
 struct S {
@@ -107 +107 @@
 % ======================================================================
 \section{Parametric Polymorphism}
-\label{s:ParametricPolymorphism}
-Routines in \CFA can also be reused for multiple types. This capability is done using the \code{forall} clauses, which allow separately compiled routines to support generic usage over multiple types. For example, the following sum function works for any type that supports construction from 0 and addition:
+Routines in \CFA can also be reused for multiple types. This capability is done using the \code{forall} clause, which gives \CFA its name. \code{forall} clauses allow separately compiled routines to support generic usage over multiple types. For example, the following sum function works for any type that supports construction from 0 and addition :
 \begin{cfacode}
 //constraint type, 0 and +
@@ -125 +124 @@
 Since writing constraints on types can become cumbersome for more constrained functions, \CFA also has the concept of traits. Traits are named collection of constraints that can be used both instead and in addition to regular constraints:
 \begin{cfacode}
-trait summable( otype T ) {
+trait sumable( otype T ) {
         void ?{}(T *, zero_t);          //constructor from 0 literal
         T ?+?(T, T);                            //assortment of additions
@@ -132 +131 @@
         T ?++(T *);
 };
-forall( otype T | summable(T) ) //use trait
+forall( otype T | sumable(T) )  //use trait
 T sum(T a[], size_t size);
 \end{cfacode}
@@ -140 +139 @@
 % ======================================================================
 \section{with Clause/Statement}
-Since \CFA lacks the concept of a receiver, certain functions end up needing to repeat variable names often. To remove this inconvenience, \CFA provides the \code{with} statement, which opens an aggregate scope making its fields directly accessible (like Pascal).
+Since \CFA lacks the concept of a receiver, certain functions end-up needing to repeat variable names often. To remove this inconvenience, \CFA provides the \code{with} statement, which opens an aggregate scope making its fields directly accessible (like Pascal).
 \begin{cfacode}
 struct S { int i, j; };