Changes between Version 5 and Version 6 of Arrays

Timestamp:

09/15/13 09:37:34 (13 years ago)

Author:

siegel

Comment:

--

Arrays

@@ -1 @@
-== True Arrays ==
+== First-class Arrays ==
 
 C uses an "array-pointer" pun.  This is not a particularly useful feature and leads to a lot of confusion.  In C, code such as
@@ -37 +37 @@
   for (int i=0; i<5; i++)
     x[i] = i;
-  y = double(x);
+  y = double(x,5);
 }
 }}}
 
-is a legal CIVL-C program and at termination y hold the array value {0,2,4,6,8}.  Note no pointers are ever used in this program.
+is a legal CIVL-C program and at termination `y` holds the array value {0,2,4,6,8}.  Note no pointers are ever used in this program.
+
+We call arrays declared in this way **first-class arrays**.
 
 Another example:
@@ -47 +49 @@
   $message[[]] append_message($message[[]] queue, $message m);
 }}}
-takes an array of messages and returns an array one longer which is equivalent to the original array with $m$ added.  There is no "sharing" between these two arrays.
+might be the declaration of a function that takes an array of messages and returns an array one longer which is equivalent to the original array with $m$ added.  There is no "sharing" between these two arrays.
 
-You can still modify double-bracketed arrays and  create references to elements of them, just as with regular arrays:
+You can still modify first-class arrays and create references to elements of them, just as with regular arrays:
 {{{
-void f(int a[[]], int n) {
-  a[0] = 10;
-  
+void f(int a[[]]) {
+  a[0] = 10;  
+}
+void g(int *p) {
+  *p = 10;
+}
+void main() {
+  int a[[1]];
+
+  a[0] = 1;
+  f(a);
+  // a still is {1}
+  g(&a[0]);
+  // now a = {10}
 }
 }}}
 
+It should be pointed out that anything that can be done with ordinary C arrays can also be done with first-class arrays.  One just has to manually insert the conversions (`&a[0]`, or `T*` in place of `T[]` in a formal parameter declaration) that C performs automatically.   The ordinary C arrays are kept in CIVL-C just for backwards compatibility.
+
 == Sequence Operations ==
 
-The following operations are available for true arrays:
+The following operations are available for first-class arrays:
 
+* T[[]] $array_create(T *p, int n)
+ * returns a new first-class array value obtained from the sequence of elements of length `n` starting from `p`
 * `int $length(T a[[]])`
- * returns the number of elements in this array
+ * returns the number of elements in `a`
 * `T[[]] $concat(T a[[]], T b[[]])`
  * returns the concatenation of two arrays
@@ -72 +89 @@
  * returns the sub-array of `a` starting at index `start` and ending at index `end-1`
 * `T[[]] $write(T a[[]], int i, T x)`
- * returns the array obtained by replacing the element of `a` at index `i` with `x`
+ * returns the array value obtained by replacing the element of `a` at index `i` with `x`
 
 == Other related ideas ==