change syntax in cli/examples

zokrates_cli/examples/add.zok

@@ -1,6 +1,8 @@
 // only using add, no need to flatten
-def main(field a) -> field:
-  field b = a + 5
-  field c = a + b + a + 4
-  field d = a + c + a + b
-  return b + c + d
+def main(field a) -> field {
+    field b = a + 5;
+    field c = a + b + a + 4;
+    field d = a + c + a + b;
+    return b + c + d;
+}
+

zokrates_cli/examples/alias/basic_aliasing.zok

@@ -1,13 +1,15 @@
-type byte = u8
-type uint32 = u32
-type UInt32Array<N> = uint32[N]
+type byte = u8;
+type uint32 = u32;
+type UInt32Array<N> = uint32[N];
 
-type matrix<R, C> = field[R][C]
+type matrix<R, C> = field[R][C];
 
-def fill<R, C>(field v) -> matrix<R, C>:
-    return [[v; C]; R]
+def fill<R, C>(field v) -> matrix<R, C> {
+    return [[v; C]; R];
+}
 
-def main(uint32 a, uint32 b) -> (UInt32Array<2>, matrix<2, 4>):
-    UInt32Array<2> res = [a, b]
-    matrix<2, 4> m = fill(1)
-    return res, m
+def main(uint32 a, uint32 b) -> (UInt32Array<2>, matrix<2, 4>) {
+    UInt32Array<2> res = [a, b];
+    matrix<2, 4> m = fill(1);
+    return res, m;
+}

zokrates_cli/examples/alias/import_alias.zok

@@ -1,14 +1,16 @@
-from "./basic_aliasing.zok" import matrix
-from "./struct_aliasing.zok" import Buzz
+from "./basic_aliasing.zok" import matrix;
+from "./struct_aliasing.zok" import Buzz;
 
-const u32 R = 2
-const u32 C = 4
+const u32 R = 2;
+const u32 C = 4;
 
-type matrix_2x4 = matrix<R, C>
+type matrix_2x4 = matrix<R, C>;
 
-def buzz<N>() -> Buzz<N>:
-    return Buzz { a: [0; N], b: [0; N] }
+def buzz<N>() -> Buzz<N> {
+    return Buzz { a: [0; N], b: [0; N] };
+}
 
-def main(matrix_2x4 m) -> (Buzz<2>, matrix_2x4):
-    Buzz<2> b = buzz::<2>()
-    return b, m
+def main(matrix_2x4 m) -> (Buzz<2>, matrix_2x4) {
+    Buzz<2> b = buzz::<2>();
+    return b, m;
+}

zokrates_cli/examples/alias/struct_aliasing.zok

@@ -1,15 +1,16 @@
-type FieldArray<N> = field[N]
+type FieldArray<N> = field[N];
 
 struct Foo<A, B> {
-    FieldArray<A> a
-    FieldArray<B> b
+    FieldArray<A> a;
+    FieldArray<B> b;
 }
 
-type Bar = Foo<2, 2>
-type Buzz<A> = Foo<A, A>
+type Bar = Foo<2, 2>;
+type Buzz<A> = Foo<A, A>;
 
-def main(Bar a) -> Buzz<2>:
-    Bar bar = Bar { a: [1, 2], b: [1, 2] }
-    Buzz<2> buzz = Buzz { a: [1, 2], b: [1, 2] }
-    assert(bar == buzz)
-    return buzz
+def main(Bar a) -> Buzz<2> {
+    Bar bar = Bar { a: [1, 2], b: [1, 2] };
+    Buzz<2> buzz = Buzz { a: [1, 2], b: [1, 2] };
+    assert(bar == buzz);
+    return buzz;
+}

zokrates_cli/examples/argument_reassign.zok

@@ -1,6 +1,8 @@
-def sub(field a) -> field:
-  a = a + 3
-  return a
+def sub(field a) -> field {
+    a = a + 3;
+    return a;
+}
 
-def main() -> field:
-   return sub(4)
+def main() -> field {
+    return sub(4);
+}

zokrates_cli/examples/array_generic_inference.zok

@@ -1,11 +1,12 @@
-def myFct<N, N2>(u64[N] ignored) -> u64[N2]:
-	assert(2*N == N2)
-	return [0; N2]
+def myFct<N, N2>(u64[N] ignored) -> u64[N2] {
+	assert(2*N == N2);
+	return [0; N2];
+}
 
-const u32 N = 3
+const u32 N = 3;
+const u32 N2 = 2 * N;
 
-const u32 N2 = 2*N
-
-def main(u64[N] arg) -> bool:
-    u64[N2] someVariable = myFct(arg)
-    return true
+def main(u64[N] arg) -> bool {
+    u64[N2] someVariable = myFct(arg);
+    return true;
+}

zokrates_cli/examples/array_overload.zok

@@ -1,8 +1,11 @@
-def foo(field[2] a) -> bool:
-    return true
+def foo(field[2] a) -> bool {
+    return true;
+}
 
-def foo(field[1] a) -> bool:
-    return true
+def foo(field[1] a) -> bool {
+    return true;
+}
 
-def main() -> bool:
-    return foo([1])
+def main() -> bool {
+    return foo([1]);
+}

zokrates_cli/examples/arrays/array_argument.zok

@@ -1,2 +1,3 @@
-def main(field[3] a) -> field:
-	return a[0] + a[1] + a[2]
+def main(field[3] a) -> field {
+    return a[0] + a[1] + a[2];
+}

zokrates_cli/examples/arrays/array_loop.zok

@@ -1,7 +1,8 @@
-def main() -> u32:
-	u32[3] a = [1, 2, 3]
-	u32 c = 0
-	for u32 i in 0..3 do
-		c = c + a[i]
-	endfor
-	return c
+def main() -> u32 {
+    u32[3] a = [1, 2, 3];
+	u32 c = 0;
+	for u32 i in 0..3 {
+	    c = c + a[i];
+	}
+	return c;
+}

zokrates_cli/examples/arrays/array_loop_update.zok

@@ -1,7 +1,8 @@
-def main() -> (u32[3]):
-	u32[3] a = [1, 2, 3]
-	u32[3] c = [4, 5, 6]
-	for u32 i in 0..3 do
-		c[i] = c[i] + a[i]
-	endfor
-	return c
+def main() -> (u32[3]) {
+    u32[3] a = [1, 2, 3];
+	u32[3] c = [4, 5, 6];
+	for u32 i in 0..3 {
+	    c[i] = c[i] + a[i];
+	}
+	return c;
+}

zokrates_cli/examples/arrays/boolean_array.zok

@@ -1,9 +1,11 @@
-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 u32 i in 0..3 do
-		result[i] = if a[i] then 33 else 0 fi
-	endfor
-	return result
+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 u32 i in 0..3 {
+		result[i] = a[i] ? 33 : 0;
+	}
+	return result;
+}
+

zokrates_cli/examples/arrays/constant_array.zok

@@ -1,3 +1,4 @@
-def main() -> field:
-	field[4] a = [1, 2, 42, 55]
-	return a[2]
+def main() -> field {
+    field[4] a = [1, 2, 42, 55];
+	return a[2];
+}

zokrates_cli/examples/arrays/cube.zok

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

zokrates_cli/examples/arrays/if_eq.zok

@@ -1,2 +1,3 @@
-def main(field[2] a, field[2] b, field condition) -> field[2]:
-	return if condition == 1 then a else b fi
+def main(field[2] a, field[2] b, field condition) -> field[2] {
+	return condition == 1 ? a : b;
+}

zokrates_cli/examples/arrays/init_with_value.zok

@@ -1,2 +1,3 @@
-def main(field value) -> (field[3]):
-  return [value, value, value]
+def main(field value) -> (field[3]) {
+    return [value, value, value];
+}

zokrates_cli/examples/arrays/large_equality.zok

@@ -1,4 +1,6 @@
-const u32 SIZE = 100
-def main(private field[SIZE][SIZE] a):
-    assert(a == [[0; SIZE]; SIZE])
-    return
+const u32 SIZE = 100;
+
+def main(private field[SIZE][SIZE] a) {
+    assert(a == [[0; SIZE]; SIZE]);
+    return;
+}

zokrates_cli/examples/arrays/lookup.zok

@@ -1,2 +1,3 @@
-def main(u32 index, field[5] array) -> field:
-	return array[index]
+def main(u32 index, field[5] array) -> field {
+    return array[index];
+}

zokrates_cli/examples/arrays/multi_init.zok

@@ -1,5 +1,7 @@
-def identity<N>(field[N][N] t) -> field[N][N]:
-    return t
+def identity<N>(field[N][N] t) -> field[N][N] {
+    return t;
+}
 
-def main() -> field[1][1]:
-    return identity([[0]; 1])
+def main() -> field[1][1] {
+    return identity([[0]; 1]);
+}

zokrates_cli/examples/arrays/multidim_update.zok

@@ -1,4 +1,5 @@
-def main(field[10][10][10] a, u32 i, u32 j, u32 k) -> (field[3]):
-	a[i][j][k] = 42
-	field[3][3] b = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
-	return b[0]
+def main(field[10][10][10] a, u32 i, u32 j, u32 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/repeat.zok

@@ -1,4 +1,5 @@
-def main(field a) -> field[4]:
-	u32 SIZE = 4
-	field[SIZE] res = [a; SIZE]
-	return res
+def main(field a) -> field[4] {
+    u32 SIZE = 4;
+	field[SIZE] res = [a; SIZE];
+	return res;
+}

zokrates_cli/examples/arrays/return_array.zok

@@ -1,5 +1,7 @@
-def foo() -> field[2]:
-	return [1, 2]
+def foo() -> field[2] {
+    return [1, 2];
+}
 
-def main() -> field[2]:
-	return foo()
+def main() -> field[2] {
+    return foo();
+}

zokrates_cli/examples/arrays/return_variable_array.zok

@@ -1,2 +1,3 @@
-def main(field[2] a, field[2] b) -> field[2]:
-	return [a[0] + b[0], a[1] + b[1]]
+def main(field[2] a, field[2] b) -> field[2] {
+    return [a[0] + b[0], a[1] + b[1]];
+}

zokrates_cli/examples/arrays/update.zok

@@ -1,9 +1,12 @@
-def foo(field[3] a) -> field:
-	a[1] = 2
-	return a[1]
+def foo(field[3] a) -> field {
+    a[1] = 2;
+    return a[1];
+}
+
+def main() -> (field, field) {
+    field[3] a = [0, 0, 0];
+	field res = foo(a);
+	assert(a[1] == 0);
+	return res, a[1];
+}
 
-def main() -> (field, field):
-	field[3] a = [0, 0, 0]
-	field res = foo(a)
-	assert(a[1] == 0)
-	return res, a[1]

zokrates_cli/examples/arrays/update_with_call.zok

@@ -1,9 +1,11 @@
-def foo(field a) -> field:
-	return 2
+def foo(field a) -> field {
+    return 2;
+}
 
-def main(field a) -> (field, field):
-	field[2] result = [0, 0]
-	field r = foo(a)
-	result[1] = r
-	assert(result[1] == r)
-	return result[1], r
+def main(field a) -> (field, field) {
+    field[2] result = [0, 0];
+    field r = foo(a);
+    result[1] = r;
+    assert(result[1] == r);
+    return result[1], r;
+}

zokrates_cli/examples/arrays/value.zok

@@ -1,10 +1,11 @@
-def main():
-	field[3] a = [1, 2, 3]
-	bool[3] b = [true, true, false]
-	field[3][2] c = [[1, 2], [3, 4], [5, 6]]
+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]
+    field[3] aa = [...a];
+    bool[3] bb = [...b];
+    field[3][2] cc = [...c];
 
-	return
+    return;
+}

zokrates_cli/examples/arrays/wrap_select.zok

@@ -1,7 +1,9 @@
-def get(field[32] array, u32 index) -> field:
-	return array[index]
+def get(field[32] array, u32 index) -> field {
+	return array[index];
+}
 
-def main() -> field:
-	field[32] array = [0, 0, 0, 0, 0, 0, 7, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-	field r = get(array, 7)
-	return r
+def main() -> field {
+    field[32] array = [0, 0, 0, 0, 0, 0, 7, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    field r = get(array, 7);
+    return r;
+}

zokrates_cli/examples/assign_to_element.zok

@@ -1,11 +1,13 @@
-def foo() -> u32:
-    return 0
+def foo() -> u32 {
+    return 0;
+}
 
-def bar() -> (u32, u32):
-    return 0, 0
+def bar() -> (u32, u32) {
+    return 0, 0;
+}
 
-
-def main(u32[1] a, u32 b):
-    a[0] = foo()
-    a[0], b = bar()
-    return
+def main(u32[1] a, u32 b) {
+    a[0] = foo();
+    a[0], b = bar();
+    return;
+}

zokrates_cli/examples/book/abi.zok

@@ -1,11 +1,12 @@
 struct Bar {
-    field a
+    field a;
 }
 
 struct Foo {
-    u8 a
-    Bar b
+    u8 a;
+    Bar b;
 }
 
-def main(Foo foo, bool[2] bar, field num) -> field:
-	return 42
+def main(Foo foo, bool[2] bar, field num) -> field {
+    return 42;
+}

zokrates_cli/examples/book/array.zok

@@ -1,10 +1,11 @@
-def main() -> field:
-    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
-    u32 SIZE = 3
-    field[SIZE] f = [1, 2, 3] // initialize a field array with a size that's a compile-time constant
-    return a[0] + b[1] + c[2]
+def main() -> field {
+    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
+    u32 SIZE = 3;
+    field[SIZE] f = [1, 2, 3]; // initialize a field array with a size that's a compile-time constant
+    return a[0] + b[1] + c[2];
+}

zokrates_cli/examples/book/assert.zok

@@ -1,3 +1,4 @@
-def main() -> ():
-	assert(1f + 1f == 2f)
-	return
+def main() -> () {
+    assert(1f + 1f == 2f);
+	return;
+}

zokrates_cli/examples/book/bubblesort.zok

@@ -1,16 +1,20 @@
-def swap(u32 a, u32 b, bool c) -> (u32, u32):
-	u32 a_prime = if c then b else a fi
-	b = if c then a else b fi
-	return a_prime, b
+def swap(u32 a, u32 b, bool c) -> (u32, u32) {
+    u32 a_prime = c ? b : a;
+	b = c ? a : b;
+	return a_prime, b;
+}
 
-def bubblesort<N>(u32[N] a) -> u32[N]:
-	for u32 i in 0..(N-1) do
-		for u32 j in 0..(N-1-i) do
-			bool need_swap = a[j + 1] < a[j]
-			a[j], a[j + 1] = swap(a[j], a[j + 1], need_swap)
-		endfor
-	endfor
-	return a
+def bubblesort<N>(u32[N] a) -> u32[N] {
+    for u32 i in 0..(N-1) {
+        for u32 j in 0..(N-1-i) {
+            bool need_swap = a[j + 1] < a[j];
+            a[j], a[j + 1] = swap(a[j], a[j + 1], need_swap);
+        }
+    }
+	return a;
+}
+
+def main(u32[10] a) -> u32[10] {
+    return bubblesort(a);
+}
 
-def main(u32[10] a) -> u32[10]:
-        return bubblesort(a)

zokrates_cli/examples/book/comments.zok

@@ -1,4 +1,5 @@
-def main() -> field:
-    field a = 42 // this is an end of line comment
+def main() -> field {
+    field a = 42; // this is an end of line comment
     // this is a full line comment
-    return a
+    return a;
+}

zokrates_cli/examples/book/constant_definition.zok

@@ -1,4 +1,5 @@
-const field PRIME = 31
+const field PRIME = 31;
 
-def main() -> field:
-    return PRIME
+def main() -> field {
+    return PRIME;
+}

zokrates_cli/examples/book/constant_reference.zok

@@ -1,5 +1,6 @@
-const field ONE = 1
-const field TWO = ONE + ONE
+const field ONE = 1;
+const field TWO = ONE + ONE;
 
-def main() -> field:
-    return TWO
+def main() -> field {
+    return TWO;
+}

zokrates_cli/examples/book/declaration.zok

@@ -1,6 +1,7 @@
-def main():
-	// declare and define `my_variable`
-	field my_variable = 2
+def main() {
+    // declare and define `my_variable`
+	field my_variable = 2;
 	// redefine `my_variable`
-	my_variable = 3
-	return
+	my_variable = 3;
+	return;
+}

zokrates_cli/examples/book/explicit_generic_parameters.zok

@@ -1,11 +1,13 @@
 // a function to sum the N first powers of a field element
-def sum_powers<N>(field a) -> field:
-    field res = 0
-    for u32 i in 0..N do
-        res = res + a ** i
-    endfor
-    return res
+def sum_powers<N>(field a) -> field {
+    field res = 0;
+    for u32 i in 0..N {
+        res = res + a ** i;
+    }
+    return res;
+}
 
-def main(field a) -> field:
+def main(field a) -> field {
     // call `sum_powers` providing the explicit generic parameter `N := 5`
-    return sum_powers::<5>(a)
+    return sum_powers::<5>(a);
+}

zokrates_cli/examples/book/factorize.zok

@@ -1,3 +1,4 @@
-def main(private field a, field b):
-  assert(a * a == b)
-  return
+def main(private field a, field b) {
+    assert(a * a == b);
+    return;
+}

zokrates_cli/examples/book/field_overflow.zok

@@ -1,4 +1,5 @@
-def main():
-    field pMinusOne = 21888242871839275222246405745257275088548364400416034343698204186575808495616
-    assert(0 - 1 == pMinusOne)
-    return
+def main() {
+    field pMinusOne = 21888242871839275222246405745257275088548364400416034343698204186575808495616;
+    assert(0 - 1 == pMinusOne);
+    return;
+}

zokrates_cli/examples/book/for.zok

@@ -1,8 +1,9 @@
-def main() -> u32:
-    u32 res = 0
-    for u32 i in 0..4 do
-    	for u32 j in i..5 do
-        	res = res + i
-        endfor
-    endfor
-    return res
+def main() -> u32 {
+    u32 res = 0;
+    for u32 i in 0..4 {
+    	for u32 j in i..5 {
+        	res = res + i;
+        }
+    }
+    return res;
+}

zokrates_cli/examples/book/for_scope.zok

@@ -1,7 +1,8 @@
-def main() -> u32:
-	u32 a = 0
-	for u32 i in 0..5 do
-		a = a + i
-	endfor
+def main() -> u32 {
+	u32 a = 0;
+	for u32 i in 0..5 {
+		a = a + i;
+	}
 	// return i <- not allowed
-	return a
+	return a;
+}

zokrates_cli/examples/book/function_declaration.zok

@@ -1,5 +1,7 @@
-def foo(field a, field b) -> field:
-    return a + b
+def foo(field a, field b) -> field {
+    return a + b;
+}
 
-def main() -> field:
-    return foo(1, 2)
+def main() -> field {
+    return foo(1, 2);
+}

zokrates_cli/examples/book/function_scope.zok

@@ -1,7 +1,9 @@
-def foo() -> field:
-	// return myGlobal <- not allowed
-	return 42
+def foo() -> field {
+    // return myGlobal <- not allowed
+    return 42;
+}
 
-def main() -> field:
-	field myGlobal = 42
-	return foo()
+def main() -> field {
+    field myGlobal = 42;
+    return foo();
+}

zokrates_cli/examples/book/generic_call.zok

@@ -1,7 +1,9 @@
-def foo<N, P>() -> field[P]:
-    return [42; P]
+def foo<N, P>() -> field[P] {
+    return [42; P];
+}
 
-def main() -> field[2]:
+def main() -> field[2] {
     // `P` is inferred from the declaration of `res`, while `N` is provided explicitly
-    field[2] res = foo::<3, _>()
-    return res
+    field[2] res = foo::<3, _>();
+    return res;
+}

zokrates_cli/examples/book/generic_function_declaration.zok

@@ -1,6 +1,8 @@
-def foo<N>() -> field[N]:
-    return [42; N]
+def foo<N>() -> field[N] {
+    return [42; N];
+}
 
-def main() -> field[2]:
-    field[2] res = foo()
-    return res
+def main() -> field[2] {
+    field[2] res = foo();
+    return res;
+}

zokrates_cli/examples/book/generics.zok

@@ -1,9 +1,11 @@
-def sum<N>(field[N] a) -> field:
-	field res = 0
-	for u32 i in 0..N do
-		res = res + a[i]
-	endfor
-	return res
+def sum<N>(field[N] a) -> field {
+	field res = 0;
+	for u32 i in 0..N {
+	    res = res + a[i];
+	}
+	return res;
+}
 
-def main(field[3] a) -> field:
-	return sum(a)
+def main(field[3] a) -> field {
+    return sum(a);
+}

zokrates_cli/examples/book/mpc_tutorial/circuit.zok

@@ -1,2 +1,3 @@
-def main(private field a, private field b) -> field:
-    return a * b
+def main(private field a, private field b) -> field {
+    return a * b;
+}

zokrates_cli/examples/book/multi_def.zok

@@ -1,9 +1,11 @@
-def foo() -> (field, field):
-    return 21, 42
+def foo() -> (field, field) {
+    return 21, 42;
+}
 
-def main():
-	// a is declared here
-	field a = 1
-	// b is declared here
-	a, field b = foo()
-	return
+def main() {
+    // a is declared here
+    field a = 1;
+    // b is declared here
+    a, field b = foo();
+    return;
+}

zokrates_cli/examples/book/multi_return.zok

@@ -1,2 +1,3 @@
-def main() -> (field, field[3]):
-    return 1, [2, 3, 4]
+def main() -> (field, field[3]) {
+    return 1, [2, 3, 4];
+}

zokrates_cli/examples/book/multidim_array.zok

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

zokrates_cli/examples/book/multiline_comments.zok

@@ -2,5 +2,6 @@
     This is a multi-line comment
     written in more than just one line.
 */
-def main() -> field:
-    return 42
+def main() -> field {
+    return 42;
+}

zokrates_cli/examples/book/no_shadowing.zok

@@ -1,7 +1,8 @@
-def main() -> field:
-	field a = 2
+def main() -> field {
+	field a = 2;
 	// field a = 3 <- not allowed
-	for u32 i in 0..5 do
+	for u32 i in 0..5 {
 		// field a = 7 <- not allowed
-	endfor
-	return a
+	}
+	return a;
+}

zokrates_cli/examples/book/not_equal.zok

@@ -1,2 +1,3 @@
-def main(field a, field b) -> (bool):
-  return !(a == b)
+def main(field a, field b) -> (bool) {
+    return !(a == b);
+}

zokrates_cli/examples/book/numeric_inference.zok

@@ -1,9 +1,10 @@
-def main():
+def main() {
 	// `255` is infered to `255f`, and the addition happens between field elements
-	assert(255 + 1f == 256)
+	assert(255 + 1f == 256);
 
 	// `255` is infered to `255u8`, and the addition happens between u8
-	// This causes an overflow 
-	assert(255 + 1u8 == 0)
-	
-	return
+	// This causes an overflow
+	assert(255 + 1u8 == 0);
+
+	return;
+}

zokrates_cli/examples/book/rng_tutorial/get_hash.zok

@@ -1,5 +1,6 @@
-import "hashes/sha256/512bit" as sha256
+import "hashes/sha256/512bit" as sha256;
 
-def main(u32[16] hashMe) -> u32[8]:
-  u32[8] h = sha256(hashMe[0..8], hashMe[8..16])
-  return h
+def main(u32[16] hashMe) -> u32[8] {
+    u32[8] h = sha256(hashMe[0..8], hashMe[8..16]);
+    return h;
+}

zokrates_cli/examples/book/rng_tutorial/reveal_bit.zok

@@ -1,20 +1,19 @@
-import "hashes/sha256/512bit" as sha256
-import "utils/casts/u32_to_bits" as u32_to_bits
+import "hashes/sha256/512bit" as sha256;
+import "utils/casts/u32_to_bits" as u32_to_bits;
 
 // Reveal a bit from a 512 bit value, and return it with the corresponding hash
 // for that value.
 //
 // WARNING, once enough bits have been revealed it is possible to brute force
 // the remaining preimage bits.
-
-def main(private u32[16] preimage, u32 bitNum) -> (u32[8], bool):
-  // Convert the preimage to bits
-  bool[512] preimageBits = [false; 512]
-  for u32 i in 0..16 do
-    bool[32] val = u32_to_bits(preimage[i])
-    for u32 bit in 0..32 do
-      preimageBits[i*32+bit] = val[bit]
-    endfor
-  endfor
-  
-  return sha256(preimage[0..8], preimage[8..16]), preimageBits[bitNum]
+def main(private u32[16] preimage, u32 bitNum) -> (u32[8], bool) {
+    // Convert the preimage to bits
+    bool[512] preimageBits = [false; 512];
+    for u32 i in 0..16 {
+        bool[32] val = u32_to_bits(preimage[i]);
+        for u32 bit in 0..32 {
+            preimageBits[i*32 + bit] = val[bit];
+        }
+    }
+    return sha256(preimage[0..8], preimage[8..16]), preimageBits[bitNum];
+}

zokrates_cli/examples/book/sha256_tutorial/hashexample.zok

@@ -1,5 +1,6 @@
-import "hashes/sha256/512bitPacked" as sha256packed
+import "hashes/sha256/512bitPacked" as sha256packed;
 
-def main(private field a, private field b, private field c, private field d) -> field[2]:
-	field[2] h = sha256packed([a, b, c, d])
-	return h
+def main(private field a, private field b, private field c, private field d) -> field[2] {
+    field[2] h = sha256packed([a, b, c, d]);
+    return h;
+}

zokrates_cli/examples/book/sha256_tutorial/hashexample_updated.zok

@@ -1,7 +1,8 @@
-import "hashes/sha256/512bitPacked" as sha256packed
+import "hashes/sha256/512bitPacked" as sha256packed;
 
-def main(private field a, private field b, private field c, private field d):
-	field[2] h = sha256packed([a, b, c, d])
-	assert(h[0] == 263561599766550617289250058199814760685)
-	assert(h[1] == 65303172752238645975888084098459749904)
-	return
+def main(private field a, private field b, private field c, private field d) {
+    field[2] h = sha256packed([a, b, c, d]);
+    assert(h[0] == 263561599766550617289250058199814760685);
+    assert(h[1] == 65303172752238645975888084098459749904);
+    return;
+}

zokrates_cli/examples/book/side_effects.zok

@@ -1,9 +1,11 @@
-def incr(field a) -> field:
-    a = a + 1
-    return a
+def incr(field a) -> field {
+    a = a + 1;
+    return a;
+}
 
-def main():
-    field x = 1
-    field res = incr(x)
-    assert(x == 1) // x has not changed
-    return
+def main() {
+    field x = 1;
+    field res = incr(x);
+    assert(x == 1); // x has not changed
+    return;
+}

zokrates_cli/examples/book/struct_assign.zok

@@ -1,10 +1,11 @@
 struct Point {
-	field x
-	field y
+	field x;
+	field y;
 }
 
-def main(field a) -> (Point):
-	Point p = Point {x: 1, y: 0}
-	p.x = a
-	p.y = p.x
-	return p
+def main(field a) -> (Point) {
+    Point p = Point { x: 1, y: 0 };
+    p.x = a;
+    p.y = p.x;
+    return p;
+}

zokrates_cli/examples/book/struct_init.zok

@@ -1,8 +1,10 @@
 struct Point {
-	field x
-	field y
+	field x;
+	field y;
+}
+
+def main() -> (Point) {
+	Point p = Point { x: 1, y: 0 };
+	return p;
 }
 
-def main() -> (Point):
-	Point p = Point {x: 1, y: 0}
-	return p

zokrates_cli/examples/book/structs.zok

@@ -1,14 +1,16 @@
 struct Bar<N> {
-	field[N] c
-	bool d
+	field[N] c;
+	bool d;
 }
 
 struct Foo<P> {
-	Bar<P> a
-	bool b
+	Bar<P> a;
+	bool b;
+}
+
+def main() -> (Foo<2>) {
+	Foo<2>[2] f = [Foo { a: Bar { c: [0, 0], d: false }, b: true}, Foo { a: Bar {c: [0, 0], d: false}, b: true }];
+	f[0].a.c = [42, 43];
+	return f[0];
 }
 
-def main() -> (Foo<2>):
-	Foo<2>[2] f = [Foo { a: Bar { c: [0, 0], d: false }, b: true}, Foo { a: Bar {c: [0, 0], d: false}, b: true}]
-	f[0].a.c = [42, 43]
-	return f[0]

zokrates_cli/examples/book/tuples.zok

@@ -1,4 +1,6 @@
-def main() -> bool:
-	(field[2], bool) v = ([1, 2], true)
-	v.0 = [42, 43]
-	return v.1
+def main() -> bool {
+	(field[2], bool) v = ([1, 2], true);
+	v.0 = [42, 43];
+	return v.1;
+}
+

zokrates_cli/examples/book/type_aliases.zok

@@ -1,11 +1,12 @@
-type MyField = field
+type MyField = field;
 
-type Rectangle<L, W> = bool[L][W]
+type Rectangle<L, W> = bool[L][W];
 
-type Square<S> = Rectangle<S, S>
+type Square<S> = Rectangle<S, S>;
 
-def main():
-    MyField f = 42
-    Rectangle<2, 2> r = [[true; 2]; 2]
-    Square<2> s = r
-    return
+def main() {
+    MyField f = 42;
+    Rectangle<2, 2> r = [[true; 2]; 2];
+    Square<2> s = r;
+    return;
+}

zokrates_cli/examples/book/type_annotations.zok

@@ -1,9 +1,12 @@
-def foo() -> (field, field[3]):
-    return 1, [2, 3, 4]
+def foo() -> (field, field[3]) {
+    return 1, [2, 3, 4];
+}
 
-def foo() -> (field, field):
-    return 1, 2
+def foo() -> (field, field) {
+    return 1, 2;
+}
 
-def main():
-    field a, field[3] b = foo()
-    return
+def main() {
+    field a, field[3] b = foo();
+    return;
+}

zokrates_cli/examples/bool_and.zok

@@ -1,7 +1,8 @@
-// example using if-then-else-fi with &&
+// example using ternary with &&
 
-def main(field a, field b) -> field:
-    field y = if a + 2 == 3 && a * 2 == 2 then 1 else 0 fi
-    field z = if y == 1 && 1-y == 0 then y else 1 fi
-    assert(b == 1)
-    return a
+def main(field a, field b) -> field {
+    field y = a + 2 == 3 && a * 2 == 2 ? 1 : 0;
+    field z = y == 1 && 1 - y == 0 ? y : 1;
+    assert(b == 1);
+    return a;
+}

zokrates_cli/examples/bool_not.zok

@@ -1,3 +1,4 @@
-def main(field a) -> field:
-	field x = if !(!(a < 5) && !(a > 1) || a < 4) then 3 else 4 fi
-	return x
+def main(field a) -> field {
+	field x = !(!(a < 5) && !(a > 1) || a < 4) ? 3 : 4;
+	return x;
+}

zokrates_cli/examples/bool_or.zok

@@ -1,7 +1,7 @@
 // example using if-then-else-fi with ||
-def main(field a, field b) -> field:
-    field y = if a + 2 == 4 || b * 2 == 2 then 1 else 0 fi
-    field z = if y == 1 || y == 0 then y else 1 fi
-    assert(z == 1)
-    return z
-
+def main(field a, field b) -> field {
+    field y = a + 2 == 4 || b * 2 == 2 ? 1 : 0;
+    field z = y == 1 || y == 0 ? y : 1;
+    assert(z == 1);
+    return z;
+}

zokrates_cli/examples/boolean_literal.zok

@@ -1,2 +1,3 @@
-def main(bool a) -> bool:
-	return (false || true) && false
+def main(bool a) -> bool {
+	return (false || true) && false;
+}

zokrates_cli/examples/brackets.zok

@@ -1,4 +1,5 @@
-def main(field a) -> field:
-  field b = (a + 5) * 6
-  field c = 7 * (b + a)
-  return b + c
+def main(field a) -> field {
+    field b = (a + 5) * 6;
+    field c = 7 * (b + a);
+    return b + c;
+}

zokrates_cli/examples/call_in_const.zok

@@ -1,10 +1,12 @@
-from "./call_in_const_aux.zok" import A, foo, F
+from "./call_in_const_aux.zok" import A, foo, F;
 
-def bar(field[A] x) -> field[A]:
-    return x
-    
-const field[A] Y = [...bar(foo::<A>(F))[..A - 1], 1]
+def bar(field[A] x) -> field[A] {
+    return x;
+}
 
-def main(field[A] X):
-    assert(X == Y)
-    return
+const field[A] Y = [...bar(foo::<A>(F))[..A - 1], 1];
+
+def main(field[A] X) {
+    assert(X == Y);
+    return;
+}

zokrates_cli/examples/call_in_const_aux.zok

@@ -1,9 +1,11 @@
-const field F = 10
-const u32 A = 10
-const u32 B = A
+const field F = 10;
+const u32 A = 10;
+const u32 B = A;
 
-def foo<N>(field X) -> field[N]:
-    return [X; N]
+def foo<N>(field X) -> field[N] {
+    return [X; N];
+}
 
-def main():
-    return
+def main() {
+    return;
+}

zokrates_cli/examples/call_in_constant.zok

@@ -1,7 +1,9 @@
-def yes() -> bool:
-    return true
+def yes() -> bool {
+    return true;
+}
 
-const bool TRUE = yes()
+const bool TRUE = yes();
 
-def main():
-    return
+def main() {
+    return;
+}

zokrates_cli/examples/comments.zok

@@ -1,7 +1,8 @@
 // only using add, no need to flatten
-def main(field a) -> field: // a needs to be 1
-  field b = a + 5 // inline comment
-  field c = a + b + a + 4
-  assert(a == 1) // another inline comment
-  field d = a + c + a + b
-  return b + c + d
+def main(field a) -> field { // a needs to be 1
+    field b = a + 5; // inline comment
+    field c = a + b + a + 4;
+    assert(a == 1); // another inline comment
+    field d = a + c + a + b;
+    return b + c + d;
+}

zokrates_cli/examples/comparison_operators.zok

@@ -1,8 +1,9 @@
 // comparison operator example
-def main(field x) -> field:
-  field y = if x >= 3 then 1 else 5 fi
-  field z = if y <= x then x**3 else y**3 fi
-  y = if x < 3 then 2 else 6 fi
-  z = if y > z then 1 else 2 fi
-  x = if x == x then x else y fi
-  return x + y + z
+def main(field x) -> field {
+    field y = x >= 3 ? 1 : 5;
+    field z = y <= x ? x**3 : y**3;
+    y = x < 3 ? 2 : 6;
+    z = y > z ? 1 : 2;
+    x = x == x ? x : y;
+    return x + y + z;
+}

zokrates_cli/examples/compile_errors/ambiguous_generic_call.zok

@@ -1,14 +1,17 @@
 // this should not compile, as A == B
 
-const u32 A = 1
-const u32 B = 1
+const u32 A = 1;
+const u32 B = 1;
 
-def foo(field[A] a) -> bool:
-    return true
+def foo(field[A] a) -> bool {
+    return true;
+}
 
-def foo(field[B] a) -> bool:
-    return true
+def foo(field[B] a) -> bool {
+    return true;
+}
 
-def main():
-    assert(foo([1]))
-    return
+def main() {
+    assert(foo([1]));
+    return;
+}

zokrates_cli/examples/compile_errors/ambiguous_generic_call_too_strict.zok

@@ -1,14 +1,17 @@
 // this should actually compile, as A != B
 
-const u32 A = 2
-const u32 B = 1
+const u32 A = 2;
+const u32 B = 1;
 
-def foo(field[A] a) -> bool:
-    return true
+def foo(field[A] a) -> bool {
+    return true;
+}
 
-def foo(field[B] a) -> bool:
-    return true
+def foo(field[B] a) -> bool {
+    return true;
+}
 
-def main():
-    assert(foo([1]))
-    return
+def main() {
+    assert(foo([1]));
+    return;
+}

zokrates_cli/examples/compile_errors/assertion.zok

@@ -1,3 +1,4 @@
-def main():
-    assert(1f == 2f)
-    return
+def main() {
+    assert(1f == 2f);
+    return;
+}

zokrates_cli/examples/compile_errors/assertion_unequal_arrays.zok

@@ -1,3 +1,4 @@
-def main():
-    assert([1f] == [2f])
-    return
+def main() {
+    assert([1f] == [2f]);
+    return;
+}

zokrates_cli/examples/compile_errors/const_complex_type_mismatch.zok

@@ -1,7 +1,8 @@
-const u32 ONE = 1
-const u32 TWO = 2
-const field[ONE] ONE_FIELD = [1; TWO] // actually set the value to an array of 2 elements
+const u32 ONE = 1;
+const u32 TWO = 2;
+const field[ONE] ONE_FIELD = [1; TWO]; // actually set the value to an array of 2 elements
 
-def main(field[TWO] TWO_FIELDS):
-    assert(TWO_FIELDS == ONE_FIELD) // use the value as is
-    return
+def main(field[TWO] TWO_FIELDS) {
+    assert(TWO_FIELDS == ONE_FIELD); // use the value as is
+    return;
+}

zokrates_cli/examples/compile_errors/constant_array_size_type_mismatch_field.zok

@@ -1,4 +1,5 @@
-const field SIZE = 2
+const field SIZE = 2;
 
-def main(field[SIZE] n):
-    return
+def main(field[SIZE] n) {
+    return;
+}

zokrates_cli/examples/compile_errors/constant_array_size_type_mismatch_u8.zok

@@ -1,4 +1,5 @@
-const u8 SIZE = 0x02
+const u8 SIZE = 0x02;
 
-def main(field[SIZE] n):
-    return
+def main(field[SIZE] n) {
+    return;
+}

zokrates_cli/examples/compile_errors/constant_assignment.zok

@@ -1,5 +1,6 @@
-const field a = 1
+const field a = 1;
 
-def main() -> field:
-    a = 2 // not allowed
-    return a
+def main() -> field {
+    a = 2; // not allowed
+    return a;
+}

zokrates_cli/examples/compile_errors/constant_reduction_fail.zok

@@ -1,6 +1,7 @@
-from "EMBED" import bit_array_le
+from "EMBED" import bit_array_le;
 
-const bool CONST = bit_array_le([true], [true])
+const bool CONST = bit_array_le([true], [true]);
 
-def main() -> bool:
-    return CONST
+def main() -> bool {
+    return CONST;
+}

zokrates_cli/examples/compile_errors/constant_type_error.zok

@@ -1,4 +1,5 @@
-const u32[2] A = [1]
+const u32[2] A = [1];
 
-def main() -> u32[2]:
-    return A
+def main() -> u32[2] {
+    return A;
+}

zokrates_cli/examples/compile_errors/declare_non_identifier.zok

@@ -1,3 +1,4 @@
-def main():
-    field[2] a[2] = [1, 2] // only variables can be declared in such a statement, declaring `a[2]` is invalid
-    return
+def main() {
+    field[2] a[2] = [1, 2]; // only variables can be declared in such a statement, declaring `a[2]` is invalid
+    return;
+}

zokrates_cli/examples/compile_errors/div_by_zero.zok

@@ -1,3 +1,4 @@
-def main(field input) -> field:
-    field divisor = if [input, 0] != [input, 1] then 0 else 1 fi
-    return input / divisor
+def main(field input) -> field {
+    field divisor = [input, 0] != [input, 1] ? 0 : 1;
+    return input / divisor;
+}

zokrates_cli/examples/compile_errors/double_negation.zok

@@ -1,3 +1,4 @@
-def main():
-    field a = - - 1
-    return
+def main() {
+    field a = - - 1;
+    return;
+}

zokrates_cli/examples/compile_errors/double_power.zok

@@ -1,3 +1,4 @@
-def main():
-    field a = 1**2**3 // parentheses are required here
-    return
+def main() {
+    field a = 1**2**3; // parentheses are required here
+    return;
+}

zokrates_cli/examples/compile_errors/embed_type_mismatch.zok

@@ -1,5 +1,6 @@
-import "EMBED/u8_to_bits" as u8_to_bits
+import "EMBED/u8_to_bits" as u8_to_bits;
 
-def main(u8 x):
-   bool[32] b = u8_to_bits(x) // note the incorrect array length on the left
-   return
+def main(u8 x) {
+   bool[32] b = u8_to_bits(x); // note the incorrect array length on the left
+   return;
+}

zokrates_cli/examples/compile_errors/generics/assertion.zok

@@ -1,7 +1,10 @@
-def foo<N>(field[N] inputs) -> bool:
-    assert(N <= 5)
-    return true
+def foo<N>(field[N] inputs) -> bool {
+    assert(N <= 5);
+    return true;
+}
+
+def main() {
+    bool b = foo([1, 2, 3, 4, 5, 6]);
+    return;
+}
 
-def main():
-    bool b = foo([1, 2, 3, 4, 5, 6])
-    return

zokrates_cli/examples/compile_errors/generics/assign_size_mismatch.zok

@@ -1,8 +1,9 @@
-def foo<N>(field[N] a) -> bool:
-	field[3] b = a
-	return true
+def foo<N>(field[N] a) -> bool {
+    field[3] b = a;
+	return true;
+}
 
-
-def main(field[1] a):
-	assert(foo(a))
-	return
+def main(field[1] a) {
+    assert(foo(a));
+	return;
+}

zokrates_cli/examples/compile_errors/generics/concrete_length_mismatch.zok

@@ -1,3 +1,4 @@
-def main():
-	assert([1] == [1, 2])
-	return
+def main() {
+	assert([1] == [1, 2]);
+	return;
+}

zokrates_cli/examples/compile_errors/generics/conflicting_call.zok

@@ -1,11 +1,15 @@
-def foo<N, P>(field[N] a) -> field[P]:
-    return a
+def foo<N, P>(field[N] a) -> field[P] {
+    return a;
+}
 
-def foo<P, N>(field[P] a) -> field[N]:
-    return a
+def foo<P, N>(field[P] a) -> field[N] {
+    return a;
+}
 
-def bar<Q>(field[Q] a) -> field[Q]:
-    return foo(a)
+def bar<Q>(field[Q] a) -> field[Q] {
+    return foo(a);
+}
 
-def main() -> field[1]:
-    return bar([1])
+def main() -> field[1] {
+    return bar([1]);
+}

zokrates_cli/examples/compile_errors/generics/conflicting_constant.zok

@@ -1,7 +1,9 @@
-const u32 N = 42
+const u32 N = 42;
 
-def foo<N>(field[N] a) -> bool:
-    return true
+def foo<N>(field[N] a) -> bool {
+    return true;
+}
 
-def main():
-    return
+def main() {
+    return;
+}

zokrates_cli/examples/compile_errors/generics/conflicting_functions.zok

@@ -1,8 +1,11 @@
-def foo<N>(field[N] a) -> bool:
-    return true
+def foo<N>(field[N] a) -> bool {
+    return true;
+}
 
-def foo<P>(field[P] a) -> bool:
-    return true
+def foo<P>(field[P] a) -> bool {
+    return true;
+}
 
-def main():
-    return
+def main() {
+    return;
+}

zokrates_cli/examples/compile_errors/generics/duplicate_struct_generic.zok

@@ -1,6 +1,7 @@
 struct A<N, N> {
-    field[N] a
+    field[N] a;
 }
 
-def main():
-    return
+def main() {
+    return;
+}

zokrates_cli/examples/compile_errors/generics/generic_in_main.zok

@@ -1,2 +1,3 @@
-def main<P>():
-	return
+def main<P>() {
+	return;
+}

zokrates_cli/examples/compile_errors/generics/generic_inference.zok

@@ -1,7 +1,8 @@
 struct A<N> {
-    field[N] a
+    field[N] a;
 }
 
-def main():
-    A<_> a = A { a: [1] }
-    return
+def main() {
+    A<_> a = A { a: [1] };
+    return;
+}

zokrates_cli/examples/compile_errors/generics/generics_in_main.zok

@@ -1,2 +1,3 @@
-def main<P>(field[P] a):
-	return
+def main<P>(field[P] a) {
+	return;
+}