fix conflicts

zokrates_book/src/toolbox/zokrates_js.md

@@ -24,7 +24,7 @@ const { initialize } = require('zokrates-js/node');
 ## Example
 ```js
 initialize().then((zokratesProvider) => {
-    const source = "def main(private field a) -> (field): return a * a";
+    const source = "def main(private field a) -> field: return a * a";
 
     // compilation
     const artifacts = zokratesProvider.compile(source);

zokrates_cli/examples/add.zok

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

zokrates_cli/examples/argument_reassign.zok

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

zokrates_cli/examples/arrays/array_argument.zok

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

zokrates_cli/examples/arrays/array_loop.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field[3] a = [1, 2, 3]
 	field c = 0
 	for field i in 0..3 do

zokrates_cli/examples/arrays/constant_array.zok

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

zokrates_cli/examples/arrays/cube.zok

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

zokrates_cli/examples/arrays/if_eq.zok

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

zokrates_cli/examples/arrays/lookup.zok

@@ -1,2 +1,2 @@
-def main(field index, field[5] array) -> (field):
+def main(field index, field[5] array) -> field:
 	return array[index]

zokrates_cli/examples/arrays/return_array.zok

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

zokrates_cli/examples/arrays/return_variable_array.zok

@@ -1,2 +1,2 @@
-def main(field[2] a, field[2] b) -> (field[2]):
+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,4 +1,4 @@
-def foo(field[3] a) -> (field):
+def foo(field[3] a) -> field:
 	a[1] = 2
 	return a[1]
 

zokrates_cli/examples/arrays/update_with_call.zok

@@ -1,4 +1,4 @@
-def foo(field a) -> (field):
+def foo(field a) -> field:
 	return 2
 
 def main(field a) -> (field, field):

zokrates_cli/examples/arrays/value.zok

@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
 	field[3] a = [1, 2, 3]
 	bool[3] b = [true, true, false]
 	field[3][2] c = [[1, 2], [3, 4], [5, 6]]

zokrates_cli/examples/arrays/wrap_select.zok

@@ -1,7 +1,7 @@
-def get(field[32] array, field index) -> (field):
+def get(field[32] array, field index) -> field:
 	return array[index]
 
-def main() -> (field):
+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/book/abi.zok

@@ -7,5 +7,5 @@ struct Foo {
     Bar b
 }
 
-def main(Foo foo, bool[2] bar, field num) -> (field):
+def main(Foo foo, bool[2] bar, field num) -> field:
 	return 42

zokrates_cli/examples/book/array.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+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

zokrates_cli/examples/book/comments.zok

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

zokrates_cli/examples/book/declaration.zok

@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
 	// declare and define `my_variable`
 	field my_variable = 2
 	// redefine `my_variable`

zokrates_cli/examples/book/factorize.zok

@@ -1,2 +1,2 @@
-def main(private field a, field b) -> (bool):
+def main(private field a, field b) -> bool:
   return a * a == b

zokrates_cli/examples/book/field_overflow.zok

@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
     field pMinusOne = 21888242871839275222246405745257275088548364400416034343698204186575808495616
     assert(0 - 1 == pMinusOne)
     return

zokrates_cli/examples/book/for.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
     field res = 0
     for field i in 0..4 do
     	for field j in i..5 do

zokrates_cli/examples/book/for_scope.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a = 0
 	for field i in 0..5 do
 		a = a + i

zokrates_cli/examples/book/function_declaration.zok

@@ -1,5 +1,5 @@
-def foo() -> (field):
+def foo() -> field:
     return 1
 
-def main() -> (field):
+def main() -> field:
     return foo()

zokrates_cli/examples/book/function_scope.zok

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

zokrates_cli/examples/book/hashexample.zok

@@ -1,5 +1,5 @@
 import "hashes/sha256/512bitPacked" as sha256packed
 
-def main(private field a, private field b, private field c, private field d) -> (field[2]):
+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/hashexample_updated.zok

@@ -1,6 +1,6 @@
 import "hashes/sha256/512bitPacked" as sha256packed
 
-def main(private field a, private field b, private field c, private field d) -> ():
+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)

zokrates_cli/examples/book/if_else.zok

@@ -1,3 +1,3 @@
-def main(field x) -> (field):
+def main(field x) -> field:
   field y = if x + 2 == 3 then 1 else 5 fi
   return y

zokrates_cli/examples/book/multi_def.zok

@@ -1,7 +1,7 @@
 def foo() -> (field, field):
     return 21, 42
 
-def main() -> (field):
+def main() -> field:
 	// a is declared here
 	field a = 1
 	// b is declared here

zokrates_cli/examples/book/multidim_array.zok

@@ -1,4 +1,4 @@
-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]]

zokrates_cli/examples/book/multiline_comments.zok

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

zokrates_cli/examples/book/no_shadowing.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a = 2
 	// field a = 3 <- not allowed
 	for field i in 0..5 do

zokrates_cli/examples/book/side_effects.zok

@@ -1,8 +1,8 @@
-def incr(field a) -> (field):
+def incr(field a) -> field:
     a = a + 1
     return a
 
-def main() -> ():
+def main():
     field x = 1
     field res = incr(x)
     assert(x == 1) // x has not changed

zokrates_cli/examples/book/type_annotations.zok

@@ -4,6 +4,6 @@ def foo() -> (field, field[3]):
 def foo() -> (field, field):
     return 1, 2
 
-def main() -> ():
+def main():
     field a, field[3] b = foo()
     return

zokrates_cli/examples/bool_and.zok

@@ -1,6 +1,6 @@
 // example using if-then-else-fi with &&
 
-def main(field a, field b) -> (field):
+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)

zokrates_cli/examples/bool_not.zok

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

zokrates_cli/examples/bool_or.zok

@@ -1,5 +1,5 @@
 // example using if-then-else-fi with ||
-def main(field a, field b) -> (field):
+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)

zokrates_cli/examples/boolean_literal.zok

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

zokrates_cli/examples/brackets.zok

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

zokrates_cli/examples/comments.zok

@@ -1,5 +1,5 @@
 // only using add, no need to flatten
-def main(field a) -> (field): // a needs to be 1
+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

zokrates_cli/examples/comparison_operators.zok

@@ -1,5 +1,5 @@
 // comparison operator example
-def main(field x) -> (field):
+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

zokrates_cli/examples/conditions.zok

@@ -6,10 +6,10 @@ struct Bar {
 	Foo[1] foo
 }
 
-def isEqual(field a, field b) -> (bool):
+def isEqual(field a, field b) -> bool:
 	return a == b
 
-def main(field a) -> (field):
+def main(field a) -> field:
   field b = (a + 5) * 6
   assert(2 * b == a * 12 + 60)
   field c = 7 * (b + a)

zokrates_cli/examples/error/assert.zok

@@ -1,5 +1,5 @@
-def assert() -> ():
+def assert():
 	return
 
-def main() -> ():
+def main():
 	return

zokrates_cli/examples/error/forbidden_power_base.zok

@@ -1,2 +1,2 @@
-def main(field a) -> (field):
+def main(field a) -> field:
 	return a*2**3

zokrates_cli/examples/error/out_of_for_scope.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	for field i in 0..5 do
 	endfor
 	return i

zokrates_cli/examples/error/shadowing.zok

@@ -1,7 +1,7 @@
-def foo() -> (field):
+def foo() -> field:
 	return 1
 
-def main() -> (field):
+def main() -> field:
 	field a = 2
 	field a = foo()
 	return 1

zokrates_cli/examples/error/unassigned.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a
 	field b = a + 1
 	return b

zokrates_cli/examples/factorization.zok

@@ -1,5 +1,5 @@
 // a and b are factorization of c
-def main(field c, private field a, private field b) -> ():
+def main(field c, private field a, private field b):
   field d = a * b
   assert(c == d)
   return

zokrates_cli/examples/flatten.zok

@@ -1,5 +1,5 @@
 // this code needs flattening
-def main(field a) -> (field):
+def main(field a) -> field:
   field b = a + 5 + a * a
   field c = b + a + a * b * b
   field d = a * b + c * c

zokrates_cli/examples/for.zok

@@ -1,4 +1,4 @@
-def main(field a) -> (field):
+def main(field a) -> field:
   field x = 7
   for field i in 0..10 do
     // x = x + a

zokrates_cli/examples/functions/expressions.zok

@@ -1,9 +1,9 @@
-def add(field a,field b) -> (field):
+def add(field a,field b) -> field:
   field v = a + b
   return v
 
 // Expected for inputs 1,1: c=4, d=7, e=10
-def main(field a,field b) -> (field):
+def main(field a,field b) -> field:
    field c = add(a*2+3*b-a,b-1)
    field d = add(a*b+2, a*b*c)
    field e = add(add(a,d),add(a,b))

zokrates_cli/examples/functions/functions.zok

@@ -1,6 +1,6 @@
-def add(field f,field g) -> (field):
+def add(field f,field g) -> field:
   return f+g
 
-def main(field a, field b) -> (field):
+def main(field a, field b) -> field:
   field c = add(a,b)
   return c

zokrates_cli/examples/functions/lt_comparison.zok

@@ -1,17 +1,17 @@
-def lt(field a,field b) -> (bool):
+def lt(field a,field b) -> bool:
     return a < b
 
-def cutoff() -> (field):
+def cutoff() -> field:
     return 31337
 
-def getThing(field index) -> (field):
+def getThing(field index) -> field:
 	field[6] a = [13, 23, 43, 53, 73, 83]
 	return a[index]
 
-def cubeThing(field thing) -> (field):
+def cubeThing(field thing) -> field:
     return thing**3
 
-def main(field index) -> (bool):
+def main(field index) -> bool:
     field thing = getThing(index)
     thing = cubeThing(thing)
     return lt(cutoff(), thing)

zokrates_cli/examples/functions/multi_functions.zok

@@ -1,8 +1,8 @@
-def add(field a, field b) -> (field):
+def add(field a, field b) -> field:
   field v = a + b
   return v + a
 
-def main(field a, field b,field c, field d) -> (field):
+def main(field a, field b,field c, field d) -> field:
   field g = a + b
   field x = add(a,b)
   field y = add(c,d)

zokrates_cli/examples/functions/multi_shadowing.zok

@@ -1,11 +1,11 @@
-def add(field a,field b) -> (field):
+def add(field a,field b) -> field:
   field v = a + b
   return v
 
-def sub(field a, field b) -> (field):
+def sub(field a, field b) -> field:
   return a-b
 
-def main(field a, field b) -> (field):
+def main(field a, field b) -> field:
   field c = add(a,b)
   field d = sub(a,b)
   return 0

zokrates_cli/examples/functions/no_args_multiple.zok

@@ -1,10 +1,10 @@
-def const() -> (field):
+def const() -> field:
   return 123123
 
-def add(field a,field b) -> (field):
+def add(field a,field b) -> field:
   a=const()
   return a+b
 
-def main(field a,field b) -> (field):
+def main(field a,field b) -> field:
   field c = add(a, b+const())
   return const()

zokrates_cli/examples/functions/shadowing.zok

@@ -1,6 +1,6 @@
-def add(field a,field b) -> (field):
+def add(field a,field b) -> field:
   return a+b
 
-def main(field a,field b) -> (field):
+def main(field a,field b) -> field:
   field c = add(a,b)
   return c

zokrates_cli/examples/functions_equivalent.zok

@@ -1,3 +1,3 @@
-def main(field a,field b) -> (field):
+def main(field a,field b) -> field:
   field c = a + b
   return c

zokrates_cli/examples/if_eq.zok

@@ -1,7 +1,7 @@
 // example using if-then-else-fi with ==
 // x = 1 -> 1 + 1 + 1 = 3
 // x = 2 -> 2 + 5 + 125 = 132
-def main(field x) -> (field):
+def main(field x) -> field:
   field y = if x + 2 == 3 then 1 else 5 fi
   field z = if y == x then x**3 else y**3 fi
   return x + y + z

zokrates_cli/examples/imports/bar.zok

@@ -1,5 +1,5 @@
 struct Bar {
 }
 
-def main() -> (field):
+def main() -> field:
 	return 21

zokrates_cli/examples/imports/baz.zok

@@ -1,5 +1,5 @@
 struct Baz {
 }
 
-def main() -> (field):
+def main() -> field:
 	return 123

zokrates_cli/examples/imports/foo.zok

@@ -3,7 +3,7 @@ from "./baz" import Baz
 import "./baz"
 from "./baz" import main as my_function
 
-def main() -> (field):
+def main() -> field:
 	field a = my_function()
 	Baz b = Baz {}
 	return baz()

zokrates_cli/examples/imports/import.zok

@@ -4,7 +4,7 @@ from "./bar" import Bar
 import "./foo"
 import "./bar"
 
-def main() -> (field):
+def main() -> field:
 	MyBar my_bar = MyBar {}
 	Bar bar = Bar {}
 	assert(my_bar == bar)

zokrates_cli/examples/imports/import_with_alias.zok

@@ -1,4 +1,4 @@
 import "./foo" as d
 
-def main() -> (field):
+def main() -> field:
 	return d()

zokrates_cli/examples/left_side_call.zok

@@ -1,6 +1,6 @@
-def foo() -> (field):
+def foo() -> field:
 	return 1
 
-def main() -> ():
+def main():
 	assert(foo() + (1 + 44*3) == 1)
 	return

zokrates_cli/examples/merkleTree/pedersenPathProof3.zok

@@ -10,7 +10,7 @@ def multiplex(bool selector, u32[8] left, u32[8] right) -> (u32[8]):
 // Merke-Tree inclusion proof for tree depth 3 using SNARK efficient pedersen hashes
 // directionSelector=> true if current digest is on the rhs of the hash
 
-def main(u32[8] rootDigest, private u32[8] leafDigest, private bool[3] directionSelector, u32[8] PathDigest0, private u32[8] PathDigest1, private u32[8] PathDigest2) -> ():
+def main(u32[8] rootDigest, private u32[8] leafDigest, private bool[3] directionSelector, u32[8] PathDigest0, private u32[8] PathDigest1, private u32[8] PathDigest2):
 	BabyJubJubParams context = context()
 
 	//Setup

zokrates_cli/examples/merkleTree/sha256PathProof3.zok

@@ -5,7 +5,7 @@ def multiplex(bool selector, u32[8] left, u32[8] right) -> (u32[8]):
 
 // Merkle-Tree inclusion proof for tree depth 3
 
-def main(field treeDepth, u32[8] rootDigest, private u32[8] leafDigest, private bool[2] directionSelector, u32[8] PathDigest0, private u32[8] PathDigest1) -> ():
+def main(field treeDepth, u32[8] rootDigest, private u32[8] leafDigest, private bool[2] directionSelector, u32[8] PathDigest0, private u32[8] PathDigest1):
 
 	//Setup
 	u32[8] currentDigest = leafDigest

zokrates_cli/examples/multi_return.zok

@@ -2,6 +2,6 @@ def foo(field a) -> (field, field, field, field):
 	field b = 12*a
 	return a, 2*a, 5*b, a*b
 
-def main(field i) -> ():
+def main(field i):
 	field x, field y, field z, field t = foo(i)
     return

zokrates_cli/examples/multiple_witnesses.zok

@@ -1,4 +1,4 @@
 // this code does not need to be flattened
-def main(field x, field a, field b) -> (field):
+def main(field x, field a, field b) -> field:
   assert(a == b * 7)
   return x + a + b

zokrates_cli/examples/n_choose_k.zok

@@ -1,5 +1,5 @@
 // Binomial Coeffizient, n!/(k!*(n-k)!).
-def fac(field x) -> (field):
+def fac(field x) -> field:
     field f = 1
     field counter = 0
     for field i in 1..100 do
@@ -8,5 +8,5 @@ def fac(field x) -> (field):
     endfor
     return f
 
-def main(field n, field k) -> (field):
+def main(field n, field k) -> field:
     return fac(n)/(fac(k)*fac(n-k))

zokrates_cli/examples/no_flatten.zok

@@ -1,5 +1,5 @@
 // this code does not need to be flattened
-def main(field x, field y, field z) -> (field):
+def main(field x, field y, field z) -> field:
   field a = x + 3*y - z *2 - x * 12
   assert(3*y - z *2 - x * 12 == a - x)
   assert((x + y) - ((z + 3*x) - y) == (x - y) + ((2*x - 4*y) + (4*y - 2*z)))

zokrates_cli/examples/pow.zok

@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
   field x = 2**4
   assert(x == 16)
   x = x**2

zokrates_cli/examples/pragma.zok

@@ -1,4 +1,4 @@
 #pragma curve bn128
 
-def main() -> ():
+def main():
 	return

zokrates_cli/examples/propagate.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a = 1 + 2 + 3
 	field b = if 1 < a then 3 else a + 3 fi
 	field c = if b + a == 2 then 1 else b fi

zokrates_cli/examples/propagate_call.zok

@@ -2,6 +2,6 @@ def foo(field a, field b) -> (field, field):
 	assert(a == b + 2)
 	return a, b
 
-def main() -> (field):
+def main() -> field:
 	field a, field b = foo(1, 1)
 	return a + b

zokrates_cli/examples/reassignment.zok

@@ -1,4 +1,4 @@
-def main(field x) -> (field):
+def main(field x) -> field:
   field a = x + 5
   field b = a + x
   a = 7

zokrates_cli/examples/reduceable_exponent.zok

@@ -1,3 +1,3 @@
-def main() -> (field):
+def main() -> field:
 	field a = 2
 	return 2**(a**2 + 2)

zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok

@@ -4,7 +4,7 @@
 // It should not work for the maxvalue = 2^(pbits - 2) - 1 augmented by one
 // /!\ should be called with a = 0
 
-def main(field a) -> (bool):
+def main(field a) -> bool:
   field pbits = 254
   // maxvalue = 2**252 - 1
   field maxvalue = a + 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1

zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok

@@ -1,7 +1,7 @@
 // as p - 1 is greater than p/2, comparing to it should fail
 // /!\ should be called with a = 0
 
-def main(field a) -> (bool):
+def main(field a) -> bool:
   field p = 21888242871839275222246405745257275088548364400416034343698204186575808495617 + a
   // we added a = 0 to prevent the condition to be evaluated at compile time
   return 0 < p - 1

zokrates_cli/examples/simple_add.zok

@@ -1,3 +1,3 @@
 // only using add, no need to flatten
-def main(field a, field b) -> (field):
+def main(field a, field b) -> field:
   return a + b

zokrates_cli/examples/simple_ifelse.zok

@@ -1,7 +1,7 @@
 // simple ifelse example
 // x = 2 -> 2 + 1 + 2**3 = 11
 // x = 5 -> 5 + 5 + 5**3 = 135
-def main(field x) -> (field):
+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
   return x + y + z

zokrates_cli/examples/simple_mul.zok

@@ -1,3 +1,3 @@
 
-def main(field a, field b, field c) -> (field):
+def main(field a, field b, field c) -> field:
   return a * b * c

zokrates_cli/examples/spaces_tabs_comments.zok

@@ -2,7 +2,7 @@
 
 // comment
 
-def main(field x) -> (field):
+def main(field x) -> field:
   // comment
   field y = x**3
   field b = x**5

zokrates_cli/examples/structs/add.zok

@@ -3,7 +3,7 @@ struct Point {
 	field y
 }
 
-def main(Point p, Point q) -> (Point):
+def main(Point p, Point q) -> Point:
 
     field a = 42
     field d = 21

zokrates_cli/examples/structs/set_member.zok

@@ -8,7 +8,7 @@ struct Foo {
 	bool b
 }
 
-def main() -> (Foo):
+def main() -> Foo:
 	Foo[2] f = [
 		Foo {
 			a: Bar {

zokrates_cli/examples/sub.zok

@@ -1,5 +1,5 @@
 // only using sub, no need to flatten
-def main(field a) -> (field):
+def main(field a) -> field:
   field b = a + 100
   field c = b + a + b
   field d = b - a - 3 - a

zokrates_cli/examples/sudoku/prime_sudoku_checker.zok

@@ -16,16 +16,16 @@
 
 // returns true if there are no duplicates
 // assumption: `a, b, c, d` are all in `{ 2, 3, 5, 7 }`
-def checkNoDuplicates(field a, field b, field c, field d) -> (bool):
+def checkNoDuplicates(field a, field b, field c, field d) -> bool:
   // as `{ 2, 3, 5, 7 }` are primes, the set `{ a, b, c, d }` is equal to the set `{ 2, 3, 5, 7}` if and only if the products match
   return a * b * c * d == 2 * 3 * 5 * 7
 
 // returns `0` if and only if `x` in `{ 2, 3, 5, 7 }`
-def validateInput(field x) -> (bool):
+def validateInput(field x) -> bool:
   return (x-2) * (x-3) * (x-5) * (x-7) == 0
 
 // variables naming: box'row''column'
-def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> (bool):
+def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> bool:
 
   field[4][4] a = [[a11, a12, b11, b12], [a21, a22, b21, b22], [c11, c12, d11, d12], [c21, c22, d21, d22]]
 

zokrates_cli/examples/sudoku/sudoku_checker.zok

@@ -10,7 +10,7 @@
 
 // We use a naive encoding of the values as `[1, 2, 3, 4]` and rely on if-else statements to detect duplicates
 
-def countDuplicates(field e11,field e12,field e21,field e22) -> (field):
+def countDuplicates(field e11,field e12,field e21,field e22) -> field:
   field duplicates = if e11 == e12 then 1 else 0 fi
   duplicates = duplicates + if e11 == e21 then 1 else 0 fi
   duplicates = duplicates + if e11 == e22 then 1 else 0 fi
@@ -20,11 +20,11 @@ def countDuplicates(field e11,field e12,field e21,field e22) -> (field):
   return duplicates
 
 // returns 0 for x in (1..4)
-def validateInput(field x) -> (bool):
+def validateInput(field x) -> bool:
   return (x-1)*(x-2)*(x-3)*(x-4) == 0
 
 // variables naming: box'row''column'
-def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> (bool):
+def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> bool:
 
   // validate inputs
   assert(validateInput(a11))

zokrates_cli/examples/synonyms.zok

@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a = 1
 	field b = a
 	field c = b

zokrates_cli/examples/taxation.zok

@@ -1,7 +1,7 @@
-def wtax(field debt, field wealth) -> (field):
+def wtax(field debt, field wealth) -> field:
   field x = if wealth < debt then 0 else (wealth-debt) fi
   return x
 
-def main(private field debt, private field wealth) -> (field):
+def main(private field debt, private field wealth) -> field:
   field tax = wtax(debt,wealth)
   return tax

zokrates_cli/examples/test1.zok

@@ -1,5 +1,5 @@
 // only using sub, no need to flatten
-def main(field x) -> (field):
+def main(field x) -> field:
   field a = 5
   field b = 7
   field c = if a == b then 4 else 3 fi

zokrates_cli/examples/test_lt_max_value.zok

@@ -3,7 +3,7 @@
 // we can compare numbers up to 2^(pbits - 2) - 1, ie any number which fits in (pbits - 2) bits
 // lt should work for the maxvalue = 2^(pbits - 2) - 1
 
-def main(field a) -> (bool):
+def main(field a) -> bool:
   field pbits = 254
   // maxvalue = 2**252 - 1
   field maxvalue = 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1

zokrates_cli/examples/waldo.zok

@@ -0,0 +1,15 @@
+// Where's Waldo is a puzzle where the goal is to find Waldo in the picture of a crowd
+// In this example, the crowd is a series of numbers, ideally* all prime but one, and Waldo is a non-prime number
+// * we don't enforce only one number being non-prime, so there could be multiple Waldos
+
+def isWaldo(field a, field p, field q) -> bool:
+  // make sure that p and q are both not one
+  assert(p != 1 && q != 1)
+
+  // we know how to factor a
+  return a == p * q
+
+// define all
+def main(field[3] a, private field index, private field p, private field q) -> bool:
+  // prover provides the index of Waldo
+  return isWaldo(a[index], p, q)

zokrates_cli/examples/wavelets.zok

@@ -0,0 +1,19 @@
+
+def main(field in1, field in2, field in3, field in4, field in5, field in6, field in7, field in8) -> field:
+  // first iteration
+  field a = (in1 + in2) / 2
+  field b = (in3 + in4) / 2
+  field c = (in5 + in6) / 2
+  field d = (in7 + in8) / 2
+  field e = (in1 - in2) / 2
+  field f = (in3 - in4) / 2
+  field g = (in5 - in6) / 2
+  field h = (in7 - in8) / 2
+  // second iteration
+  field i = (a + b) / 2
+  field j = (c + d) / 2
+  field k = (e - f) / 2
+  field l = (g - h) / 2
+  // third iteration
+  field out1 = (i + j) / 2
+  return (k - l) / 2

zokrates_cli/tests/code/arithmetics.zok

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

zokrates_cli/tests/code/if_else_false.zok

@@ -1,2 +1,2 @@
-def main(field a) -> (field):
+def main(field a) -> field:
 	return if a == 1 then 1 else 0 fi

zokrates_cli/tests/code/if_else_true.zok

@@ -1,2 +1,2 @@
-def main(field a) -> (field):
+def main(field a) -> field:
 	return if a == 1 then 1 else 0 fi

zokrates_cli/tests/code/multidim_update.zok

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

zokrates_cli/tests/code/n_choose_k.zok

@@ -1,5 +1,5 @@
 // Binomial Coeffizient, n!/(k!*(n-k)!).
-def fac(field x) -> (field):
+def fac(field x) -> field:
     field f = 1
     field counter = 0
     for field i in 1..100 do
@@ -8,5 +8,5 @@ def fac(field x) -> (field):
     endfor
     return f
 
-def main(field n, field k) -> (field):
+def main(field n, field k) -> field:
     return fac(n)/(fac(k)*fac(n-k))

zokrates_cli/tests/code/no_return.zok

@@ -1,3 +1,3 @@
-def main(field a, field b) -> ():
+def main(field a, field b):
 	assert(a == b)
 	return