Changeset 387c9a1

Timestamp:

May 7, 2018, 6:23:40 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

5fec3f6, 83034ec

Parents:

c5e5109

Message:

corrections for referee responses

File:

• doc/papers/general/Paper.tex (modified) (15 diffs)

doc/papers/general/Paper.tex

@@ -59 +59 @@
 %\DeclareTextCommandDefault{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}
 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+
+\renewcommand*{\thefootnote}{\alph{footnote}} % hack because fnsymbol does not work
+%\renewcommand*{\thefootnote}{\fnsymbol{footnote}}
 
 \makeatletter
@@ -197 +200 @@
 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects.
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
-Nevertheless, C, first standardized almost fourty years ago, lacks many features that make programming in more modern languages safer and more productive.
+Nevertheless, C, first standardized almost forty years ago, lacks many features that make programming in more modern languages safer and more productive.
 
 The goal of the \CFA project (pronounced ``C-for-all'') is to create an extension of C that provides modern safety and productivity features while still ensuring strong backwards compatibility with C and its programmers.
@@ -233 +236 @@
 Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
 In many cases, \CC is often used solely as a better C.
-Nevertheless, C, first standardized almost fourty years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
+Nevertheless, C, first standardized almost forty years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
 
 \CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
@@ -299 +302 @@
 The \CFA tests are 290+ files and 27,000+ lines of code.
 The tests illustrate syntactic and semantic features in \CFA, plus a growing number of runtime benchmarks.
-The tests check for correctness and are used for daily regression testing of commits (3800+).
+The tests check for correctness and are used for daily regression testing of 3800+ commits.
 
 Finally, it is impossible to describe a programming language without usages before definitions.
@@ -348 +351 @@
 \eg, it cannot implement the example above, because the variables @max@ are ambiguous with the functions @max@. 
 Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the dispatch functions, which must all have distinct names.
-For backwards compatibility, \CFA supports @_Generic@ expressions, but it is an unnecessary mechanism. \TODO{actually implement that}
+\CFA supports @_Generic@ expressions for backwards compatibility, but it is an unnecessary mechanism. \TODO{actually implement that}
 
 % http://fanf.livejournal.com/144696.html
@@ -543 +546 @@
 \begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
 \begin{cfa}
-forall( otype R, otype S ) struct pair {
+`forall( otype R, otype S )` struct pair {
         R first;        S second;
 };
@@ -1180 +1183 @@
   case Mon~Thu:  // program
 
-  case Fri:  // program
+  case Fri:    // program
         wallet += pay;
         `fallthrough;`
-  case Sat:  // party
+  case Sat:   // party
         wallet -= party;
 
   case Sun:  // rest
 
-  default:  // error
+  default:    // print error
 }
 \end{cfa}
@@ -1196 +1199 @@
   case Mon: case Tue: case Wed: case Thu:  // program
         `break;`
-  case Fri:  // program
+  case Fri:    // program
         wallet += pay;
 
-  case Sat:  // party
+  case Sat:   // party
         wallet -= party;
         `break;`
   case Sun:  // rest
         `break;`
-  default:  // error
+  default:    // print error
 }
 \end{cfa}
@@ -1477 +1480 @@
 If an exception is raised and caught, the handler is run before the finally clause.
 Like a destructor (see Section~\ref{s:ConstructorsDestructors}), a finally clause can raise an exception but not if there is an exception being propagated.
-Mimicking the @finally@ clause with mechanisms like RAII is non-trivially when there are multiple types and local accesses.
+Mimicking the @finally@ clause with mechanisms like RAII is non-trivial when there are multiple types and local accesses.
 
 
@@ -1530 +1533 @@
 with ( s, t ) {
         j + k;                                                                  $\C{// unambiguous, s.j + t.k}$
-        m = 5.0;                                                                $\C{// unambiguous, t.m = 5.0}$
-        m = 1;                                                                  $\C{// unambiguous, s.m = 1}$
-        int a = m;                                                              $\C{// unambiguous, a = s.i }$
-        double b = m;                                                   $\C{// unambiguous, b = t.m}$
+        m = 5.0;                                                                $\C{// unambiguous, s.m = 5.0}$
+        m = 1;                                                                  $\C{// unambiguous, t.m = 1}$
+        int a = m;                                                              $\C{// unambiguous, a = t.m }$
+        double b = m;                                                   $\C{// unambiguous, b = s.m}$
         int c = s.i + t.i;                                              $\C{// unambiguous, qualification}$
-        (double)m;                                                              $\C{// unambiguous, cast}$
+        (double)m;                                                              $\C{// unambiguous, cast s.m}$
 }
 \end{cfa}
@@ -1559 +1562 @@
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
-void ?{}( S & s, int `i` ) with ( s ) `with( $\emph{\color{red}params}$ )` {
+void ?{}( S & s, int `i` ) with ( s ) `{` `with( $\emph{\color{red}params}$ )` {
         s.i = `i`; j = 3; m = 5.5;
-}
+} `}`
 \end{cfa}
 Finally, a cast may be used to disambiguate among overload variables in a @with@ expression:
@@ -1660 +1663 @@
 \begin{cfa}
 `*` int x, y;
-int y;
-\end{cfa}
-&
-\begin{cfa}
-int `*`x, `*`y;
+int z;
+\end{cfa}
+&
+\begin{cfa}
+int `*`x, `*`y, z;
 
 \end{cfa}
@@ -1670 +1673 @@
 \lstMakeShortInline@%
 \end{cquote}
-The downside of the \CFA semantics is the need to separate regular and pointer declarations.
+% The downside of the \CFA semantics is the need to separate regular and pointer declarations.
+The separation of regular and pointer declarations by \CFA declarations enforces greater clarity with only slightly more syntax.
 
 \begin{comment}
@@ -1792 +1796 @@
 * [ * int, int ] ( int ) jp;    $\C{// pointer to function returning pointer to int and int with int parameter}$
 \end{cfa}
-Note, a function name cannot be specified:
-\begin{cfa}
-* [ int x ] f () fp;                    $\C{// function name "f" is disallowed}\CRT$
-\end{cfa}
+Note, the name of the function pointer is specified last, as for other variable declarations.
 
 Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
@@ -2637 +2638 @@
 
 
-\section{Polymorphism Evaluation}
+\section{Polymorphic Evaluation}
 \label{sec:eval}