Arrays of anything

zokrates_book/src/concepts/types.md

@@ -1,8 +1,10 @@
 ## Types
 
-ZoKrates currently exposes three types:
+ZoKrates currently exposes two primitive types and a complex array type:
 
-### `field`
+### Primitive Types
+
+#### `field`
 
 This is the most basic type in ZoKrates, and it represents a positive integer in `[0,  p - 1]` where `p` is a (large) prime number.
 
@@ -14,18 +16,72 @@ While `field` values mostly behave like unsigned integers, one should keep in mi
 {{#include ../../../zokrates_cli/examples/book/field_overflow.code}}
 ```
 
-### `bool`
+#### `bool`
 
 ZoKrates has limited support for booleans, to the extent that they can only be used as the condition in `if ... else ... endif` expressions.
 
 You can use them for equality checks, inequality checks and inequality checks between `field` values.
 
 Note that while equality checks are cheap, inequality checks should be use wisely as they are orders of magnitude more expensive.
 
-### `field[n]`
+### Complex Types
+
+#### Arrays
+
+ZoKrates supports static arrays, i.e., their length needs to be known at compile time.
+Arrays can contain elements of any type and have arbitrary dimensions.
 
-Static arrays of `field` can be instantiated with a constant size, and their elements can be accessed and updated:
+The following examples code shows examples of how to use arrays:
 
 ```zokrates
 {{#include ../../../zokrates_cli/examples/book/array.code}}
 ```
+
+##### Declaration and Initialization
+An array is defined by appending `[]` to a type literal representing the type of the array's elements. 
+
+Initialization always needs to happen in the same statement than declaration, unless the array is declared within a function's signature.
+
+For initialization, a list of comma-separated values is provided within brackets `[]`. 
+
+ZoKrates offers a special shorthand syntax to initialize an array with a constant value:
+`[value;repetitions]`
+
+
+The following code provides examples for declaration and initialization:
+```zokrates
+    field[3] a = [1, 2, 3] // initialize a field array with field values
+    bool[13] b = [false; 13] // initialize a bool array with value false
+```
+
+##### Multidimensional Arrays
+
+As an array can contain any type of elements, it can contain arrays again.
+There is a special syntax to declare such multi-dimensional arrays, i.e., arrays of arrays.
+To declare an array of an inner array, i.e., and array of elements of a type, prepend brackets `[size]` to the declaration of the inner array. 
+In summary, this leads to the following scheme for array declarations:
+`data_type[size of 1st dimension][size of 2nd dimension]`.
+Consider the following example:
+
+```zokrates
+{{#include ../../../zokrates_cli/examples/book/multidim_array.code}}
+```
+
+##### Spreads and Slices
+ZoKrates provides some syntactic sugar to retrieve subsets of arrays.
+
+###### Spreads
+The spread operator `...` applied to an copies the elements of an existing array.
+This can be used to conveniently compose new arrays, as shown in the following example:
+```
+field[3] = [1, 2, 3]
+field[4] c = [...a, 4] // initialize an array copying values from `a`, followed by 4
+```
+
+###### Slices
+An array can also be assigned to by creating a copy of a subset of an existing array.
+This operation is called slicing, and the following example shows how to slice in ZoKrates:
+```
+field[3] a = [1, 2, 3]
+field[2] b = a[1..3]   // initialize an array copying a slice from `a`
+```

zokrates_cli/examples/arrays/boolean_array.code

@@ -0,0 +1,9 @@
+def main(bool[3] a) -> (field[3]):
+	bool[3] c = [true, true || false, true]
+	a[1] = true || a[2]
+	a[2] = a[0]
+	field[3] result = [0; 3]
+	for field i in 0..3 do
+		result[i] = if a[i] then 33 else 0 fi
+	endfor
+	return result

zokrates_cli/examples/arrays/cube.code

@@ -0,0 +1,12 @@
+def main(field[2][2][2] cube) -> (field):
+	field res = 0
+
+	for field i in 0..2 do
+		for field j in 0..2 do
+			for field k in 0..2 do
+				res = res + cube[i][j][k]
+			endfor
+		endfor
+	endfor
+
+	return res

zokrates_cli/examples/arrays/multidim_update.code

@@ -0,0 +1,4 @@
+def main(field[10][10][10] a, field i, field j, field k) -> (field[3]):
+	a[i][j][k] = 42
+	field[3][3] b = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
+	return b[0]

zokrates_cli/examples/arrays/value.code

@@ -0,0 +1,10 @@
+def main() -> ():
+	field[3] a = [1, 2, 3]
+	bool[3] b = [true, true, false]
+	field[3][2] c = [[1, 2], [3, 4], [5, 6]]
+
+	field[3] aa = [...a]
+	bool[3] bb = [...b]
+	field[3][2] cc = [...c]
+
+	return

zokrates_cli/examples/book/array.code

@@ -1,7 +1,8 @@
 def main() -> (field):
-    field[3] a = [1, 2, 3] // initialize an array with values
+    field[3] a = [1, 2, 3] // initialize a field array with field values
     a[2] = 4               // set a member to a value
     field[4] b = [42; 4]   // initialize an array of 4 values all equal to 42
     field[4] c = [...a, 4] // initialize an array copying values from `a`, followed by 4
     field[2] d = a[1..3]   // initialize an array copying a slice from `a`
+    bool[3] e = [true, true || false, true] // initialize a boolean array
     return a[0] + b[1] + c[2]

zokrates_cli/examples/book/multidim_array.code

@@ -0,0 +1,9 @@
+def main() -> (field):
+
+    // Array of two elements of array of 3 elements
+    field[2][3] a = [[1, 2, 3],[4, 5, 6]]
+
+    field[3] b = a[0] // should be [1, 2, 3]
+
+    // allowed access [0..2][0..3]
+    return a[1][2]

zokrates_cli/tests/code/multidim_update.arguments.json

@@ -0,0 +1,6 @@
+[
+	0,
+	0,
+	0,
+	0
+]

zokrates_cli/tests/code/multidim_update.code

@@ -0,0 +1,3 @@
+def main(field[2][2] a) -> (field[2][2]):
+	a[1][1] = 42
+	return a

zokrates_cli/tests/code/multidim_update.expected.witness

@@ -0,0 +1,4 @@
+~out_0 0
+~out_1 0
+~out_2 0
+~out_3 42