Changeset 41624f92

Timestamp:

Mar 22, 2018, 4:22:06 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:

dc7db63

Parents:

f810e09

Message:

tuple functions missing tuple-return syntax

File:

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

doc/papers/general/Paper.tex

@@ -671 +671 @@
 \begin{cfa}
 int f( int, int );
-int g( [int, int] );
-int h( int, [int, int] );
+[int] g( [int, int] );
+[int] h( int, [int, int] );
 [int, int] x;
 int y;
@@ -706 +706 @@
 This example shows mass, multiple, and cascading assignment used in one expression:
 \begin{cfa}
-void f( [int, int] );
+[void] f( [int, int] );
 f( [x, y] = z = 1.5 );                                          $\C{// assignments in parameter list}$
 \end{cfa}
@@ -814 +814 @@
 Flattening and restructuring conversions are also applied to tuple types in polymorphic type assertions.
 \begin{cfa}
-int f( [int, double], double );
+[int] f( [int, double], double );
 forall( otype T, otype U | { T f( T, U, U ); } ) void g( T, U );
 g( 5, 10.21 );
@@ -1152 +1152 @@
   case 4:
         ... `fallthrough common;`
-  common: // below fallthrough at same level as case clauses
+  `common`: // below fallthrough at same level as case clauses
         ...      // common code for cases 3 and 4
         // implicit break
@@ -1857 +1857 @@
 \begin{cfa}
 struct S { double x, y; };
-int i, j;
+int x, y;
 void f( int & i, int & j, S & s, int v[] );
-f( 3, i + j, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } );   $\C{// pass rvalue to lvalue \(\Rightarrow\) implicit temporary}$
+f( 3, x + y, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } ); $\C{// pass rvalue to lvalue \(\Rightarrow\) implicit temporary}$
 \end{cfa}
 This allows complex values to be succinctly and efficiently passed to functions, without the syntactic overhead of explicit definition of a temporary variable or the runtime cost of pass-by-value.
@@ -1998 +1998 @@
 {
         VLA  x,            y = { 20, 0x01 },     z = y; $\C{// z points to y}$
-        //      ?{}( x );  ?{}( y, 20, 0x01 );  ?{}( z, y ); 
+        //    ?{}( x );   ?{}( y, 20, 0x01 );    ?{}( z, y ); 
         ^x{};                                                                   $\C{// deallocate x}$
         x{};                                                                    $\C{// reallocate x}$