diff --git a/zokrates_book/src/toolbox/zokrates_js.md b/zokrates_book/src/toolbox/zokrates_js.md
index e26009ab..e065b3d4 100644
--- a/zokrates_book/src/toolbox/zokrates_js.md
+++ b/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);
diff --git a/zokrates_cli/examples/add.zok b/zokrates_cli/examples/add.zok
index 7e18a039..c7d2b4d6 100644
--- a/zokrates_cli/examples/add.zok
+++ b/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
diff --git a/zokrates_cli/examples/argument_reassign.zok b/zokrates_cli/examples/argument_reassign.zok
index 645698fa..209d0daa 100644
--- a/zokrates_cli/examples/argument_reassign.zok
+++ 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)
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/array_argument.zok b/zokrates_cli/examples/arrays/array_argument.zok
index c12de263..539df3f6 100644
--- a/zokrates_cli/examples/arrays/array_argument.zok
+++ b/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]
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/array_loop.zok b/zokrates_cli/examples/arrays/array_loop.zok
index c648f1bf..024d3777 100644
--- a/zokrates_cli/examples/arrays/array_loop.zok
+++ b/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
diff --git a/zokrates_cli/examples/arrays/constant_array.zok b/zokrates_cli/examples/arrays/constant_array.zok
index 41ff5543..96e5848e 100644
--- a/zokrates_cli/examples/arrays/constant_array.zok
+++ b/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]
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/cube.zok b/zokrates_cli/examples/arrays/cube.zok
index 82fe1380..1ea112d0 100644
--- a/zokrates_cli/examples/arrays/cube.zok
+++ b/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
diff --git a/zokrates_cli/examples/arrays/if_eq.zok b/zokrates_cli/examples/arrays/if_eq.zok
index cd1c8a56..2fc1aca5 100644
--- a/zokrates_cli/examples/arrays/if_eq.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/lookup.zok b/zokrates_cli/examples/arrays/lookup.zok
index 75a5821d..95404692 100644
--- a/zokrates_cli/examples/arrays/lookup.zok
+++ b/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]
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/return_array.zok b/zokrates_cli/examples/arrays/return_array.zok
index 8c8ea399..a5a63499 100644
--- a/zokrates_cli/examples/arrays/return_array.zok
+++ b/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()
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/return_variable_array.zok b/zokrates_cli/examples/arrays/return_variable_array.zok
index 9ceb3c68..4532c73f 100644
--- a/zokrates_cli/examples/arrays/return_variable_array.zok
+++ b/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]]
\ No newline at end of file
diff --git a/zokrates_cli/examples/arrays/update.zok b/zokrates_cli/examples/arrays/update.zok
index 149f5075..58ddc836 100644
--- a/zokrates_cli/examples/arrays/update.zok
+++ b/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]
 
diff --git a/zokrates_cli/examples/arrays/update_with_call.zok b/zokrates_cli/examples/arrays/update_with_call.zok
index a50b7daa..d27f3b0d 100644
--- a/zokrates_cli/examples/arrays/update_with_call.zok
+++ b/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):
diff --git a/zokrates_cli/examples/arrays/value.zok b/zokrates_cli/examples/arrays/value.zok
index d09822b9..41d2f3e4 100644
--- a/zokrates_cli/examples/arrays/value.zok
+++ b/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]]
diff --git a/zokrates_cli/examples/arrays/wrap_select.zok b/zokrates_cli/examples/arrays/wrap_select.zok
index 10e493e1..162b6e1f 100644
--- a/zokrates_cli/examples/arrays/wrap_select.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/abi.zok b/zokrates_cli/examples/book/abi.zok
index 84969792..a3982799 100644
--- a/zokrates_cli/examples/book/abi.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/array.zok b/zokrates_cli/examples/book/array.zok
index 5f3293fa..943fb12a 100644
--- a/zokrates_cli/examples/book/array.zok
+++ b/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
diff --git a/zokrates_cli/examples/book/comments.zok b/zokrates_cli/examples/book/comments.zok
index dd51d78a..a8c06de1 100644
--- a/zokrates_cli/examples/book/comments.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/declaration.zok b/zokrates_cli/examples/book/declaration.zok
index 2be6ec5a..4f3fd29f 100644
--- a/zokrates_cli/examples/book/declaration.zok
+++ b/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`
diff --git a/zokrates_cli/examples/book/factorize.zok b/zokrates_cli/examples/book/factorize.zok
index c9f6be09..98d3fbe0 100644
--- a/zokrates_cli/examples/book/factorize.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/field_overflow.zok b/zokrates_cli/examples/book/field_overflow.zok
index 1b208553..0ab907e8 100644
--- a/zokrates_cli/examples/book/field_overflow.zok
+++ b/zokrates_cli/examples/book/field_overflow.zok
@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
     field pMinusOne = 21888242871839275222246405745257275088548364400416034343698204186575808495616
     assert(0 - 1 == pMinusOne)
     return
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/for.zok b/zokrates_cli/examples/book/for.zok
index e774b78f..8c61fc29 100644
--- a/zokrates_cli/examples/book/for.zok
+++ b/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
diff --git a/zokrates_cli/examples/book/for_scope.zok b/zokrates_cli/examples/book/for_scope.zok
index 50655615..340ca6c9 100644
--- a/zokrates_cli/examples/book/for_scope.zok
+++ b/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
diff --git a/zokrates_cli/examples/book/function_declaration.zok b/zokrates_cli/examples/book/function_declaration.zok
index f66bc1c5..89658ac0 100644
--- a/zokrates_cli/examples/book/function_declaration.zok
+++ b/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()
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/function_scope.zok b/zokrates_cli/examples/book/function_scope.zok
index d1f060f7..d28717ee 100644
--- a/zokrates_cli/examples/book/function_scope.zok
+++ b/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()
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/hashexample.zok b/zokrates_cli/examples/book/hashexample.zok
index 24f1e824..a4716a34 100644
--- a/zokrates_cli/examples/book/hashexample.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/hashexample_updated.zok b/zokrates_cli/examples/book/hashexample_updated.zok
index 42ed341c..51254f4e 100644
--- a/zokrates_cli/examples/book/hashexample_updated.zok
+++ b/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)
diff --git a/zokrates_cli/examples/book/if_else.zok b/zokrates_cli/examples/book/if_else.zok
index b411022b..c97f2c22 100644
--- a/zokrates_cli/examples/book/if_else.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/multi_def.zok b/zokrates_cli/examples/book/multi_def.zok
index 7a089d92..ca85cf2d 100644
--- a/zokrates_cli/examples/book/multi_def.zok
+++ b/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
diff --git a/zokrates_cli/examples/book/multidim_array.zok b/zokrates_cli/examples/book/multidim_array.zok
index b39c29ae..c05be0cd 100644
--- a/zokrates_cli/examples/book/multidim_array.zok
+++ b/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]]
diff --git a/zokrates_cli/examples/book/multiline_comments.zok b/zokrates_cli/examples/book/multiline_comments.zok
index 6dbcd3c0..458eb32a 100644
--- a/zokrates_cli/examples/book/multiline_comments.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/book/no_shadowing.zok b/zokrates_cli/examples/book/no_shadowing.zok
index 8d852911..2708ee0b 100644
--- a/zokrates_cli/examples/book/no_shadowing.zok
+++ b/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
diff --git a/zokrates_cli/examples/book/side_effects.zok b/zokrates_cli/examples/book/side_effects.zok
index 0941a2d6..6df428f1 100644
--- a/zokrates_cli/examples/book/side_effects.zok
+++ b/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
diff --git a/zokrates_cli/examples/book/type_annotations.zok b/zokrates_cli/examples/book/type_annotations.zok
index e3e1c80d..74600f58 100644
--- a/zokrates_cli/examples/book/type_annotations.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/bool_and.zok b/zokrates_cli/examples/bool_and.zok
index 7ed3a460..e6fa034d 100644
--- a/zokrates_cli/examples/bool_and.zok
+++ b/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)
diff --git a/zokrates_cli/examples/bool_not.zok b/zokrates_cli/examples/bool_not.zok
index e2f19d00..c43408c1 100644
--- a/zokrates_cli/examples/bool_not.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/bool_or.zok b/zokrates_cli/examples/bool_or.zok
index 77457eac..7f313d08 100644
--- a/zokrates_cli/examples/bool_or.zok
+++ b/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)
diff --git a/zokrates_cli/examples/boolean_literal.zok b/zokrates_cli/examples/boolean_literal.zok
index 58ec1a6d..0f6861ca 100644
--- a/zokrates_cli/examples/boolean_literal.zok
+++ b/zokrates_cli/examples/boolean_literal.zok
@@ -1,2 +1,2 @@
-def main(bool a) -> (bool):
+def main(bool a) -> bool:
 	return (false || true) && false
\ No newline at end of file
diff --git a/zokrates_cli/examples/brackets.zok b/zokrates_cli/examples/brackets.zok
index 57ccfc3a..fab05b4d 100644
--- a/zokrates_cli/examples/brackets.zok
+++ b/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
diff --git a/zokrates_cli/examples/comments.zok b/zokrates_cli/examples/comments.zok
index af9d8070..bad9b6eb 100644
--- a/zokrates_cli/examples/comments.zok
+++ b/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
diff --git a/zokrates_cli/examples/comparison_operators.zok b/zokrates_cli/examples/comparison_operators.zok
index e7f8c73f..afad1bb7 100644
--- a/zokrates_cli/examples/comparison_operators.zok
+++ b/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
diff --git a/zokrates_cli/examples/conditions.zok b/zokrates_cli/examples/conditions.zok
index d6f0051b..fd92d11d 100644
--- a/zokrates_cli/examples/conditions.zok
+++ b/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)
diff --git a/zokrates_cli/examples/error/assert.zok b/zokrates_cli/examples/error/assert.zok
index aa2fb018..d0e463d3 100644
--- a/zokrates_cli/examples/error/assert.zok
+++ b/zokrates_cli/examples/error/assert.zok
@@ -1,5 +1,5 @@
-def assert() -> ():
+def assert():
 	return
 
-def main() -> ():
+def main():
 	return
\ No newline at end of file
diff --git a/zokrates_cli/examples/error/forbidden_power_base.zok b/zokrates_cli/examples/error/forbidden_power_base.zok
index c36618ae..40c8b00c 100644
--- a/zokrates_cli/examples/error/forbidden_power_base.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/error/out_of_for_scope.zok b/zokrates_cli/examples/error/out_of_for_scope.zok
index b005b833..5d701a18 100644
--- a/zokrates_cli/examples/error/out_of_for_scope.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/error/shadowing.zok b/zokrates_cli/examples/error/shadowing.zok
index d3345294..805203a3 100644
--- a/zokrates_cli/examples/error/shadowing.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/error/unassigned.zok b/zokrates_cli/examples/error/unassigned.zok
index 01d73bfa..b10c994d 100644
--- a/zokrates_cli/examples/error/unassigned.zok
+++ b/zokrates_cli/examples/error/unassigned.zok
@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a
 	field b = a + 1
 	return b
\ No newline at end of file
diff --git a/zokrates_cli/examples/factorization.zok b/zokrates_cli/examples/factorization.zok
index 31824a9b..55105c49 100644
--- a/zokrates_cli/examples/factorization.zok
+++ 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
diff --git a/zokrates_cli/examples/flatten.zok b/zokrates_cli/examples/flatten.zok
index 9ea0c528..f9245037 100644
--- a/zokrates_cli/examples/flatten.zok
+++ b/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
diff --git a/zokrates_cli/examples/for.zok b/zokrates_cli/examples/for.zok
index 2d4aeb03..6cce5135 100644
--- a/zokrates_cli/examples/for.zok
+++ b/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
diff --git a/zokrates_cli/examples/functions/expressions.zok b/zokrates_cli/examples/functions/expressions.zok
index 9d650213..f2096d52 100644
--- a/zokrates_cli/examples/functions/expressions.zok
+++ b/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))
diff --git a/zokrates_cli/examples/functions/functions.zok b/zokrates_cli/examples/functions/functions.zok
index 7a0b4cc9..e5993764 100644
--- a/zokrates_cli/examples/functions/functions.zok
+++ 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
diff --git a/zokrates_cli/examples/functions/lt_comparison.zok b/zokrates_cli/examples/functions/lt_comparison.zok
index 8de0ca28..8e9b3782 100644
--- a/zokrates_cli/examples/functions/lt_comparison.zok
+++ b/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)
diff --git a/zokrates_cli/examples/functions/multi_functions.zok b/zokrates_cli/examples/functions/multi_functions.zok
index 9a0ce961..4e3f8388 100644
--- a/zokrates_cli/examples/functions/multi_functions.zok
+++ b/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)
diff --git a/zokrates_cli/examples/functions/multi_shadowing.zok b/zokrates_cli/examples/functions/multi_shadowing.zok
index dea0b545..989477ef 100644
--- a/zokrates_cli/examples/functions/multi_shadowing.zok
+++ b/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
diff --git a/zokrates_cli/examples/functions/no_args_multiple.zok b/zokrates_cli/examples/functions/no_args_multiple.zok
index 9d466e1f..cef72d30 100644
--- a/zokrates_cli/examples/functions/no_args_multiple.zok
+++ b/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()
diff --git a/zokrates_cli/examples/functions/shadowing.zok b/zokrates_cli/examples/functions/shadowing.zok
index 844fe7c6..c1a3133c 100644
--- a/zokrates_cli/examples/functions/shadowing.zok
+++ b/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
diff --git a/zokrates_cli/examples/functions_equivalent.zok b/zokrates_cli/examples/functions_equivalent.zok
index 3bd41caa..6c253c12 100644
--- a/zokrates_cli/examples/functions_equivalent.zok
+++ b/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
diff --git a/zokrates_cli/examples/if_eq.zok b/zokrates_cli/examples/if_eq.zok
index a3670e19..d45fe1fd 100644
--- a/zokrates_cli/examples/if_eq.zok
+++ b/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
diff --git a/zokrates_cli/examples/imports/bar.zok b/zokrates_cli/examples/imports/bar.zok
index a89beb7b..c7d3af12 100644
--- a/zokrates_cli/examples/imports/bar.zok
+++ b/zokrates_cli/examples/imports/bar.zok
@@ -1,5 +1,5 @@
 struct Bar {
 }
 
-def main() -> (field):
+def main() -> field:
 	return 21
\ No newline at end of file
diff --git a/zokrates_cli/examples/imports/baz.zok b/zokrates_cli/examples/imports/baz.zok
index dff9100f..9fd704a3 100644
--- a/zokrates_cli/examples/imports/baz.zok
+++ b/zokrates_cli/examples/imports/baz.zok
@@ -1,5 +1,5 @@
 struct Baz {
 }
 
-def main() -> (field):
+def main() -> field:
 	return 123
\ No newline at end of file
diff --git a/zokrates_cli/examples/imports/foo.zok b/zokrates_cli/examples/imports/foo.zok
index 37b1d8d1..43018b20 100644
--- a/zokrates_cli/examples/imports/foo.zok
+++ b/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()
\ No newline at end of file
diff --git a/zokrates_cli/examples/imports/import.zok b/zokrates_cli/examples/imports/import.zok
index 194b3c50..bc4e7669 100644
--- a/zokrates_cli/examples/imports/import.zok
+++ b/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)
diff --git a/zokrates_cli/examples/imports/import_with_alias.zok b/zokrates_cli/examples/imports/import_with_alias.zok
index 2feb96ea..e9bb2194 100644
--- a/zokrates_cli/examples/imports/import_with_alias.zok
+++ b/zokrates_cli/examples/imports/import_with_alias.zok
@@ -1,4 +1,4 @@
 import "./foo" as d
 
-def main() -> (field):
+def main() -> field:
 	return d()
\ No newline at end of file
diff --git a/zokrates_cli/examples/left_side_call.zok b/zokrates_cli/examples/left_side_call.zok
index 43aac4b4..91670e7e 100644
--- a/zokrates_cli/examples/left_side_call.zok
+++ b/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
diff --git a/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok b/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok
index c6953b0d..d6225098 100644
--- a/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok
+++ b/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
diff --git a/zokrates_cli/examples/merkleTree/sha256PathProof3.zok b/zokrates_cli/examples/merkleTree/sha256PathProof3.zok
index ae24269a..8db1e337 100644
--- a/zokrates_cli/examples/merkleTree/sha256PathProof3.zok
+++ b/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
diff --git a/zokrates_cli/examples/multi_return.zok b/zokrates_cli/examples/multi_return.zok
index 10fcf28c..f689b1a2 100644
--- a/zokrates_cli/examples/multi_return.zok
+++ b/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
diff --git a/zokrates_cli/examples/multiple_witnesses.zok b/zokrates_cli/examples/multiple_witnesses.zok
index 3723f107..6b34e765 100644
--- a/zokrates_cli/examples/multiple_witnesses.zok
+++ b/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
diff --git a/zokrates_cli/examples/n_choose_k.zok b/zokrates_cli/examples/n_choose_k.zok
index 5abee568..a7a34d94 100644
--- a/zokrates_cli/examples/n_choose_k.zok
+++ 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))
diff --git a/zokrates_cli/examples/no_flatten.zok b/zokrates_cli/examples/no_flatten.zok
index 3f86e52d..08f05fb9 100644
--- a/zokrates_cli/examples/no_flatten.zok
+++ b/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)))
diff --git a/zokrates_cli/examples/pow.zok b/zokrates_cli/examples/pow.zok
index 7d157bae..4b76748f 100644
--- a/zokrates_cli/examples/pow.zok
+++ b/zokrates_cli/examples/pow.zok
@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
   field x = 2**4
   assert(x == 16)
   x = x**2
diff --git a/zokrates_cli/examples/pragma.zok b/zokrates_cli/examples/pragma.zok
index 59eb319f..28f94e2a 100644
--- a/zokrates_cli/examples/pragma.zok
+++ b/zokrates_cli/examples/pragma.zok
@@ -1,4 +1,4 @@
 #pragma curve bn128
 
-def main() -> ():
+def main():
 	return
\ No newline at end of file
diff --git a/zokrates_cli/examples/propagate.zok b/zokrates_cli/examples/propagate.zok
index 9b2c72e4..9b3176b0 100644
--- a/zokrates_cli/examples/propagate.zok
+++ b/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
diff --git a/zokrates_cli/examples/propagate_call.zok b/zokrates_cli/examples/propagate_call.zok
index 02518cd0..a7353e6d 100644
--- a/zokrates_cli/examples/propagate_call.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/reassignment.zok b/zokrates_cli/examples/reassignment.zok
index 33e7945e..1d48bfad 100644
--- a/zokrates_cli/examples/reassignment.zok
+++ 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
diff --git a/zokrates_cli/examples/reduceable_exponent.zok b/zokrates_cli/examples/reduceable_exponent.zok
index 955f36e4..d3c38a74 100644
--- a/zokrates_cli/examples/reduceable_exponent.zok
+++ b/zokrates_cli/examples/reduceable_exponent.zok
@@ -1,3 +1,3 @@
-def main() -> (field):
+def main() -> field:
 	field a = 2
 	return 2**(a**2 + 2)
\ No newline at end of file
diff --git a/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok b/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok
index 41dc0299..83b8f337 100644
--- a/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok
+++ b/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
diff --git a/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok b/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok
index 5ee8ca0d..ec594e62 100644
--- a/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/examples/simple_add.zok b/zokrates_cli/examples/simple_add.zok
index 2ed23110..9853b69c 100644
--- a/zokrates_cli/examples/simple_add.zok
+++ b/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
diff --git a/zokrates_cli/examples/simple_ifelse.zok b/zokrates_cli/examples/simple_ifelse.zok
index 462f3248..b478061b 100644
--- a/zokrates_cli/examples/simple_ifelse.zok
+++ 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
diff --git a/zokrates_cli/examples/simple_mul.zok b/zokrates_cli/examples/simple_mul.zok
index 97d33019..ec81fcef 100644
--- a/zokrates_cli/examples/simple_mul.zok
+++ b/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
diff --git a/zokrates_cli/examples/spaces_tabs_comments.zok b/zokrates_cli/examples/spaces_tabs_comments.zok
index 569437ff..2c3ea970 100644
--- a/zokrates_cli/examples/spaces_tabs_comments.zok
+++ b/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
diff --git a/zokrates_cli/examples/structs/add.zok b/zokrates_cli/examples/structs/add.zok
index 388ce158..e8e1f839 100644
--- a/zokrates_cli/examples/structs/add.zok
+++ b/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
diff --git a/zokrates_cli/examples/structs/set_member.zok b/zokrates_cli/examples/structs/set_member.zok
index be326580..305b28e5 100644
--- a/zokrates_cli/examples/structs/set_member.zok
+++ b/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 {
diff --git a/zokrates_cli/examples/sub.zok b/zokrates_cli/examples/sub.zok
index c500b5b6..4c4b7bbd 100644
--- a/zokrates_cli/examples/sub.zok
+++ b/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
diff --git a/zokrates_cli/examples/sudoku/prime_sudoku_checker.zok b/zokrates_cli/examples/sudoku/prime_sudoku_checker.zok
index 9ac4a216..e61db31d 100644
--- a/zokrates_cli/examples/sudoku/prime_sudoku_checker.zok
+++ b/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]]
 
diff --git a/zokrates_cli/examples/sudoku/sudoku_checker.zok b/zokrates_cli/examples/sudoku/sudoku_checker.zok
index d86c9e3b..0339e8a8 100644
--- a/zokrates_cli/examples/sudoku/sudoku_checker.zok
+++ b/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))
diff --git a/zokrates_cli/examples/synonyms.zok b/zokrates_cli/examples/synonyms.zok
index e1e52ba7..bb0e6e09 100644
--- a/zokrates_cli/examples/synonyms.zok
+++ b/zokrates_cli/examples/synonyms.zok
@@ -1,4 +1,4 @@
-def main() -> (field):
+def main() -> field:
 	field a = 1
 	field b = a
 	field c = b
diff --git a/zokrates_cli/examples/taxation.zok b/zokrates_cli/examples/taxation.zok
index f270b5e2..7371fe8f 100644
--- a/zokrates_cli/examples/taxation.zok
+++ 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
\ No newline at end of file
diff --git a/zokrates_cli/examples/test1.zok b/zokrates_cli/examples/test1.zok
index 3429b140..c51a29a9 100644
--- a/zokrates_cli/examples/test1.zok
+++ b/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
diff --git a/zokrates_cli/examples/test_lt_max_value.zok b/zokrates_cli/examples/test_lt_max_value.zok
index 8860cd40..c2b97966 100644
--- a/zokrates_cli/examples/test_lt_max_value.zok
+++ b/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
diff --git a/zokrates_cli/examples/waldo.zok b/zokrates_cli/examples/waldo.zok
new file mode 100644
index 00000000..1839354f
--- /dev/null
+++ b/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)
\ No newline at end of file
diff --git a/zokrates_cli/examples/wavelets.zok b/zokrates_cli/examples/wavelets.zok
new file mode 100644
index 00000000..f23bfccd
--- /dev/null
+++ b/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
diff --git a/zokrates_cli/tests/code/arithmetics.zok b/zokrates_cli/tests/code/arithmetics.zok
index 84ecbe31..a7aa6d2e 100644
--- a/zokrates_cli/tests/code/arithmetics.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/tests/code/if_else_false.zok b/zokrates_cli/tests/code/if_else_false.zok
index 73c7ae80..f8643cea 100644
--- a/zokrates_cli/tests/code/if_else_false.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/tests/code/if_else_true.zok b/zokrates_cli/tests/code/if_else_true.zok
index 73c7ae80..f8643cea 100644
--- a/zokrates_cli/tests/code/if_else_true.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/tests/code/multidim_update.zok b/zokrates_cli/tests/code/multidim_update.zok
index 5b182020..2ff09900 100644
--- a/zokrates_cli/tests/code/multidim_update.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/tests/code/n_choose_k.zok b/zokrates_cli/tests/code/n_choose_k.zok
index 5abee568..a7a34d94 100644
--- a/zokrates_cli/tests/code/n_choose_k.zok
+++ b/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))
diff --git a/zokrates_cli/tests/code/no_return.zok b/zokrates_cli/tests/code/no_return.zok
index 1d939baf..a7d5b3aa 100644
--- a/zokrates_cli/tests/code/no_return.zok
+++ b/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
\ No newline at end of file
diff --git a/zokrates_cli/tests/code/simple_add.zok b/zokrates_cli/tests/code/simple_add.zok
index 2ed23110..9853b69c 100644
--- a/zokrates_cli/tests/code/simple_add.zok
+++ b/zokrates_cli/tests/code/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
diff --git a/zokrates_cli/tests/code/simple_mul.zok b/zokrates_cli/tests/code/simple_mul.zok
index 976875c2..94162d43 100644
--- a/zokrates_cli/tests/code/simple_mul.zok
+++ b/zokrates_cli/tests/code/simple_mul.zok
@@ -1,2 +1,2 @@
-def main(field a, field b, field c) -> (field):
+def main(field a, field b, field c) -> field:
   return a * b * c
diff --git a/zokrates_cli/tests/code/taxation.zok b/zokrates_cli/tests/code/taxation.zok
index 263f66fa..66693670 100644
--- a/zokrates_cli/tests/code/taxation.zok
+++ b/zokrates_cli/tests/code/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(field debt, field wealth) -> (field):
+def main(field debt, field wealth) -> field:
   field tax = wtax(debt,wealth)
   return tax
\ No newline at end of file
diff --git a/zokrates_core/src/absy/from_ast.rs b/zokrates_core/src/absy/from_ast.rs
index ca33ff11..1e3aa635 100644
--- a/zokrates_core/src/absy/from_ast.rs
+++ b/zokrates_core/src/absy/from_ast.rs
@@ -680,7 +680,7 @@ mod tests {
 
     #[test]
     fn return_forty_two() {
-        let source = "def main() -> (field): return 42";
+        let source = "def main() -> field: return 42";
         let ast = pest::generate_ast(&source).unwrap();
         let expected: absy::Module<Bn128Field> = absy::Module {
             symbols: vec![absy::SymbolDeclaration {
@@ -713,7 +713,7 @@ mod tests {
 
     #[test]
     fn return_true() {
-        let source = "def main() -> (bool): return true";
+        let source = "def main() -> bool: return true";
         let ast = pest::generate_ast(&source).unwrap();
         let expected: absy::Module<Bn128Field> = absy::Module {
             symbols: vec![absy::SymbolDeclaration {
@@ -743,7 +743,7 @@ mod tests {
 
     #[test]
     fn arguments() {
-        let source = "def main(private field a, bool b) -> (field): return 42";
+        let source = "def main(private field a, bool b) -> field: return 42";
         let ast = pest::generate_ast(&source).unwrap();
 
         let expected: absy::Module<Bn128Field> = absy::Module {
@@ -799,7 +799,7 @@ mod tests {
     mod types {
         use super::*;
 
-        /// Helper method to generate the ast for `def main(private {ty} a) -> (): return` which we use to check ty
+        /// Helper method to generate the ast for `def main(private {ty} a): return` which we use to check ty
         fn wrap(ty: absy::UnresolvedType) -> absy::Module<'static, Bn128Field> {
             absy::Module {
                 symbols: vec![absy::SymbolDeclaration {
@@ -861,7 +861,7 @@ mod tests {
             ];
 
             for (ty, expected) in vectors {
-                let source = format!("def main(private {} a) -> (): return", ty);
+                let source = format!("def main(private {} a): return", ty);
                 let expected = wrap(expected);
                 let ast = pest::generate_ast(&source).unwrap();
                 assert_eq!(absy::Module::<Bn128Field>::from(ast), expected);
@@ -966,7 +966,7 @@ mod tests {
             ];
 
             for (source, expected) in vectors {
-                let source = format!("def main() -> (): return {}", source);
+                let source = format!("def main(): return {}", source);
                 let expected = wrap(expected);
                 let ast = pest::generate_ast(&source).unwrap();
                 assert_eq!(absy::Module::<Bn128Field>::from(ast), expected);
@@ -977,7 +977,7 @@ mod tests {
         #[should_panic]
         fn call_array_element() {
             // a call after an array access should be rejected
-            let source = "def main() -> (): return a[2](3)";
+            let source = "def main(): return a[2](3)";
             let ast = pest::generate_ast(&source).unwrap();
             absy::Module::<Bn128Field>::from(ast);
         }
@@ -986,7 +986,7 @@ mod tests {
         #[should_panic]
         fn call_call_result() {
             // a call after a call should be rejected
-            let source = "def main() -> (): return a(2)(3)";
+            let source = "def main(): return a(2)(3)";
             let ast = pest::generate_ast(&source).unwrap();
             absy::Module::<Bn128Field>::from(ast);
         }
diff --git a/zokrates_core/src/compile.rs b/zokrates_core/src/compile.rs
index e88dee35..ab97df45 100644
--- a/zokrates_core/src/compile.rs
+++ b/zokrates_core/src/compile.rs
@@ -272,7 +272,7 @@ mod test {
     fn no_resolver_with_imports() {
         let source = r#"
 			import "./path/to/file" as foo
-			def main() -> (field):
+			def main() -> field:
 			   return foo()
 		"#
         .to_string();
@@ -291,7 +291,7 @@ mod test {
     #[test]
     fn no_resolver_without_imports() {
         let source = r#"
-			def main() -> (field):
+			def main() -> field:
 			   return 1
 		"#
         .to_string();
@@ -328,7 +328,7 @@ mod test {
 
             let main = r#"
 from "foo" import Foo as FooMain
-def main(FooMain f) -> ():
+def main(FooMain f):
     return
 "#;
 
@@ -345,7 +345,7 @@ def main(FooMain f) -> ():
                         Ok((
                             r#"
 from "foo" import Foo as FooMain
-def main(FooMain f) -> ():
+def main(FooMain f):
     return
 "#
                             .into(),
diff --git a/zokrates_core/src/optimizer/redefinition.rs b/zokrates_core/src/optimizer/redefinition.rs
index ee6711a6..5d4847d5 100644
--- a/zokrates_core/src/optimizer/redefinition.rs
+++ b/zokrates_core/src/optimizer/redefinition.rs
@@ -426,14 +426,14 @@ mod tests {
 
     #[test]
     fn keep_existing_quadratic_variable() {
-        // def main(x, y) -> ():
+        // def main(x, y):
         //     z = x * y
         //     z = x
         //     return
 
         // ->
 
-        // def main(x, y) -> ():
+        // def main(x, y):
         //     z = x * y
         //     z = x
         //     return
diff --git a/zokrates_core/src/semantics.rs b/zokrates_core/src/semantics.rs
index 3bc91e1a..a1d86468 100644
--- a/zokrates_core/src/semantics.rs
+++ b/zokrates_core/src/semantics.rs
@@ -140,17 +140,32 @@ impl<'ast> fmt::Display for FunctionQuery<'ast> {
                 write!(f, ", ")?;
             }
         }
-        write!(f, ") -> (")?;
-        for (i, t) in self.outputs.iter().enumerate() {
-            match t {
-                Some(t) => write!(f, "{}", t)?,
-                None => write!(f, "_")?,
-            }
-            if i < self.outputs.len() - 1 {
-                write!(f, ", ")?;
+        write!(f, ")")?;
+
+        match self.outputs.len() {
+            0 => write!(f, ""),
+            1 => write!(
+                f,
+                " -> {}",
+                match &self.outputs[0] {
+                    Some(t) => format!("{}", t),
+                    None => format!("_"),
+                }
+            ),
+            _ => {
+                write!(f, " -> (")?;
+                for (i, t) in self.outputs.iter().enumerate() {
+                    match t {
+                        Some(t) => write!(f, "{}", t)?,
+                        None => write!(f, "_")?,
+                    }
+                    if i < self.outputs.len() - 1 {
+                        write!(f, ", ")?;
+                    }
+                }
+                write!(f, ")")
             }
         }
-        write!(f, ")")
     }
 }
 
@@ -2289,11 +2304,11 @@ impl<'ast> Checker<'ast> {
         query.match_funcs(&self.functions)
     }
 
-    fn enter_scope(&mut self) -> () {
+    fn enter_scope(&mut self) {
         self.level += 1;
     }
 
-    fn exit_scope(&mut self) -> () {
+    fn exit_scope(&mut self) {
         let current_level = self.level;
         self.scope
             .retain(|ref scoped_variable| scoped_variable.level < current_level);
@@ -2367,7 +2382,7 @@ mod tests {
     mod symbols {
         use super::*;
 
-        /// Helper function to create (() -> (): return)
+        /// Helper function to create ((): return)
         fn function0() -> FunctionNode<'static, Bn128Field> {
             let statements: Vec<StatementNode<Bn128Field>> = vec![Statement::Return(
                 ExpressionList {
@@ -2389,7 +2404,7 @@ mod tests {
             .mock()
         }
 
-        /// Helper function to create ((private field a) -> (): return)
+        /// Helper function to create ((private field a): return)
         fn function1() -> FunctionNode<'static, Bn128Field> {
             let statements: Vec<StatementNode<Bn128Field>> = vec![Statement::Return(
                 ExpressionList {
@@ -2451,7 +2466,7 @@ mod tests {
         #[test]
         fn imported_function() {
             // foo.zok
-            // def main() -> ():
+            // def main():
             // 		return
 
             // bar.zok
@@ -2675,7 +2690,7 @@ mod tests {
             // import first
 
             // // bar.code
-            // def main() -> (): return
+            // def main(): return
             //
             // // main.code
             // import main from "bar" as foo
@@ -2726,7 +2741,7 @@ mod tests {
             // type declaration first
 
             // // bar.code
-            // def main() -> (): return
+            // def main(): return
             //
             // // main.code
             // struct foo {}
@@ -3198,7 +3213,7 @@ mod tests {
             Err(vec![ErrorInner {
                 pos: Some((Position::mock(), Position::mock())),
                 message:
-                    "Function definition for function foo with signature () -> (field) not found."
+                    "Function definition for function foo with signature () -> field not found."
                         .into()
             }])
         );
@@ -3206,7 +3221,7 @@ mod tests {
 
     #[test]
     fn multi_return_outside_multidef() {
-        // def foo():
+        // def foo() -> (field, field):
         //   return 1, 2
         // def bar():
         //   2 == foo()
@@ -3248,7 +3263,7 @@ mod tests {
             checker.check_function(bar, &module_id, &types),
             Err(vec![ErrorInner {
                 pos: Some((Position::mock(), Position::mock())),
-                message: "Function definition for function foo with signature () -> (_) not found."
+                message: "Function definition for function foo with signature () -> _ not found."
                     .into()
             }])
         );
@@ -3291,7 +3306,7 @@ mod tests {
                 pos: Some((Position::mock(), Position::mock())),
 
                 message:
-                    "Function definition for function foo with signature () -> (field) not found."
+                    "Function definition for function foo with signature () -> field not found."
                         .into()
             }])
         );
@@ -3504,7 +3519,7 @@ mod tests {
 
     #[test]
     fn assign_to_non_variable() {
-        // def foo() -> (field):
+        // def foo() -> field:
         //  return 1
         // def main():
         //  field[1] a = [0]
@@ -3641,7 +3656,7 @@ mod tests {
             Err(vec![ErrorInner {
                 pos: Some((Position::mock(), Position::mock())),
 
-                message: "Function definition for function foo with signature () -> (_) not found."
+                message: "Function definition for function foo with signature () -> _ not found."
                     .into()
             }])
         );
diff --git a/zokrates_core/src/static_analysis/inline.rs b/zokrates_core/src/static_analysis/inline.rs
index cafb37ab..3962711e 100644
--- a/zokrates_core/src/static_analysis/inline.rs
+++ b/zokrates_core/src/static_analysis/inline.rs
@@ -10,9 +10,9 @@
 
 //! The resulting program has a single module of the form
 
-//! def main() -> ():
-//! def _SHA_256_ROUND() -> ():
-//! def _UNPACK() -> ():
+//! def main():
+//! def _SHA_256_ROUND():
+//! def _UNPACK():
 
 //! where any call in `main` must be to `_SHA_256_ROUND` or `_UNPACK`
 
@@ -576,16 +576,16 @@ mod tests {
     fn call_other_module_without_variables() {
         // // main
         // from "foo" import foo
-        // def main() -> (field):
+        // def main() -> field:
         //    return foo()
         //
         // // foo
-        // def foo() -> (field):
+        // def foo() -> field:
         //    return 42
         //
         //
         // // inlined
-        // def main() -> (field):
+        // def main() -> field:
         //    return 42
 
         let main = TypedModule {
@@ -673,16 +673,16 @@ mod tests {
     fn call_other_module_with_variables() {
         // // main
         // from "foo" import foo
-        // def main(field a) -> (field):
+        // def main(field a) -> field:
         //    return a * foo(a)
         //
         // // foo
-        // def foo(field a) -> (field):
+        // def foo(field a) -> field:
         //    return a * a
         //
         //
         // // inlined
-        // def main(a) -> (field):
+        // def main(a) -> field:
         //    field a_0 = a
         //    return a * a_0 * a_0
 
@@ -827,16 +827,16 @@ mod tests {
     #[test]
     fn memoize_local_call() {
         // // foo
-        // def foo(field a) -> (field):
+        // def foo(field a) -> field:
         //     return a
 
         // // main
-        // def main(field a) -> (field):
+        // def main(field a) -> field:
         //     field b = foo(a) + foo(a)
         //     return b
 
         // inlined
-        // def main(field a) -> (field)
+        // def main(field a) -> field
         //     field _0 = a + a
         //     return _0
 
@@ -974,19 +974,19 @@ mod tests {
     #[test]
     fn only_memoize_in_same_function() {
         // // foo
-        // def foo(field a) -> (field):
+        // def foo(field a) -> field:
         //     return a
 
         // // main
-        // def main(field a) -> (field):
+        // def main(field a) -> field:
         //     field b = foo(a) + bar(a)
         //     return b
         //
-        // def bar(field a) -> (field):
+        // def bar(field a) -> field:
         //     return foo(a)
 
         // inlined
-        // def main(field a) -> (field)
+        // def main(field a) -> field
         //     field _0 = a + a
         //     return _0
 
@@ -1184,16 +1184,16 @@ mod tests {
     #[test]
     fn multi_def_from_other_module() {
         // // foo
-        // def foo() -> (field):
+        // def foo() -> field:
         //     return 42
 
         // // main
-        // def main() -> (field):
+        // def main() -> field:
         //     field b = foo()
         //     return b
 
         // inlined
-        // def main() -> (field)
+        // def main() -> field
         //     field _0 = 42
         //     return _0
 
@@ -1295,14 +1295,14 @@ mod tests {
     #[test]
     fn multi_def_from_same_module() {
         // // main
-        // def foo() -> (field):
+        // def foo() -> field:
         //     return 42
-        // def main() -> (field):
+        // def main() -> field:
         //     field a = foo()
         //     return a
 
         // inlined
-        // def main() -> (field)
+        // def main() -> field
         //     field _0 = 42
         //     return _0
 
@@ -1388,15 +1388,15 @@ mod tests {
     #[test]
     fn recursive_call_in_other_module() {
         // // main
-        // def main(field a) -> (field):
+        // def main(field a) -> field:
         //     return id(id(a))
 
         // // id
-        // def main(field a) -> (field)
+        // def main(field a) -> field
         //     return a
 
         // inlined
-        // def main(field a) -> (field)
+        // def main(field a) -> field
         //     id_main_0_a = a
         //     id_main_1_a = id_main_0_a
         //     return id_main_1_a
diff --git a/zokrates_core/src/typed_absy/mod.rs b/zokrates_core/src/typed_absy/mod.rs
index 62eb95e6..69bbc3b2 100644
--- a/zokrates_core/src/typed_absy/mod.rs
+++ b/zokrates_core/src/typed_absy/mod.rs
@@ -196,18 +196,30 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedFunction<'ast, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "({}) -> ({}):",
+            "({})",
             self.arguments
                 .iter()
                 .map(|x| format!("{}", x))
                 .collect::<Vec<_>>()
                 .join(", "),
-            self.signature
-                .outputs
-                .iter()
-                .map(|x| format!("{}", x))
-                .collect::<Vec<_>>()
-                .join(", "),
+        )?;
+
+        write!(
+            f,
+            "{}:",
+            match self.signature.outputs.len() {
+                0 => "".into(),
+                1 => format!(" -> {}", self.signature.outputs[0]),
+                _ => format!(
+                    "{}",
+                    self.signature
+                        .outputs
+                        .iter()
+                        .map(|x| format!("{}", x))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                ),
+            }
         )?;
 
         writeln!(f, "")?;
diff --git a/zokrates_core/src/typed_absy/types.rs b/zokrates_core/src/typed_absy/types.rs
index b54bc14a..04688f46 100644
--- a/zokrates_core/src/typed_absy/types.rs
+++ b/zokrates_core/src/typed_absy/types.rs
@@ -280,14 +280,21 @@ pub mod signature {
                     write!(f, ", ")?;
                 }
             }
-            write!(f, ") -> (")?;
-            for (i, t) in self.outputs.iter().enumerate() {
-                write!(f, "{}", t)?;
-                if i < self.outputs.len() - 1 {
-                    write!(f, ", ")?;
+            write!(f, ")")?;
+            match self.outputs.len() {
+                0 => write!(f, ""),
+                1 => write!(f, " -> {}", self.outputs[0]),
+                _ => {
+                    write!(f, " -> (")?;
+                    for (i, t) in self.outputs.iter().enumerate() {
+                        write!(f, "{}", t)?;
+                        if i < self.outputs.len() - 1 {
+                            write!(f, ", ")?;
+                        }
+                    }
+                    write!(f, ")")
                 }
             }
-            write!(f, ")")
         }
     }
 
@@ -363,7 +370,7 @@ pub mod signature {
                 .inputs(vec![Type::FieldElement, Type::Boolean])
                 .outputs(vec![Type::Boolean]);
 
-            assert_eq!(s.to_string(), String::from("(field, bool) -> (bool)"));
+            assert_eq!(s.to_string(), String::from("(field, bool) -> bool"));
         }
 
         #[test]
diff --git a/zokrates_core/src/zir/types.rs b/zokrates_core/src/zir/types.rs
index 3cdb2ba8..3b45481e 100644
--- a/zokrates_core/src/zir/types.rs
+++ b/zokrates_core/src/zir/types.rs
@@ -153,14 +153,21 @@ pub mod signature {
                     write!(f, ", ")?;
                 }
             }
-            write!(f, ") -> (")?;
-            for (i, t) in self.outputs.iter().enumerate() {
-                write!(f, "{}", t)?;
-                if i < self.outputs.len() - 1 {
-                    write!(f, ", ")?;
+            write!(f, ")")?;
+            match self.outputs.len() {
+                0 => write!(f, ""),
+                1 => write!(f, " -> {}", self.outputs[0]),
+                _ => {
+                    write!(f, " -> (")?;
+                    for (i, t) in self.outputs.iter().enumerate() {
+                        write!(f, "{}", t)?;
+                        if i < self.outputs.len() - 1 {
+                            write!(f, ", ")?;
+                        }
+                    }
+                    write!(f, ")")
                 }
             }
-            write!(f, ")")
         }
     }
 
@@ -236,7 +243,7 @@ pub mod signature {
                 .inputs(vec![Type::FieldElement, Type::Boolean])
                 .outputs(vec![Type::Boolean]);
 
-            assert_eq!(s.to_string(), String::from("(field, bool) -> (bool)"));
+            assert_eq!(s.to_string(), String::from("(field, bool) -> bool"));
         }
 
         #[test]
diff --git a/zokrates_core/tests/out_of_range.rs b/zokrates_core/tests/out_of_range.rs
index 0f8ab9d8..9d345dca 100644
--- a/zokrates_core/tests/out_of_range.rs
+++ b/zokrates_core/tests/out_of_range.rs
@@ -13,7 +13,7 @@ use zokrates_field::Bn128Field;
 #[test]
 fn out_of_range() {
     let source = r#"
-		def main(private field a) -> (field):
+		def main(private field a) -> field:
 	        field x = if a < 5555 then 3333 else 4444 fi
 	        assert(x == 3333)
 			return 1
diff --git a/zokrates_core_test/tests/tests/add.zok b/zokrates_core_test/tests/tests/add.zok
index d2277712..eb0d117c 100644
--- a/zokrates_core_test/tests/tests/add.zok
+++ b/zokrates_core_test/tests/tests/add.zok
@@ -1,2 +1,2 @@
-def main(field a, field b) -> (field):
+def main(field a, field b) -> field:
 	return a + b
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/array_if.zok b/zokrates_core_test/tests/tests/array_if.zok
index cd1c8a56..2fc1aca5 100644
--- a/zokrates_core_test/tests/tests/array_if.zok
+++ b/zokrates_core_test/tests/tests/array_if.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
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/assert_one.zok b/zokrates_core_test/tests/tests/assert_one.zok
index 1b025194..e4ccf41c 100644
--- a/zokrates_core_test/tests/tests/assert_one.zok
+++ b/zokrates_core_test/tests/tests/assert_one.zok
@@ -1,3 +1,3 @@
-def main(field a) -> ():
+def main(field a):
 	assert(a == 1)
 	return
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/bool_compare.zok b/zokrates_core_test/tests/tests/bool_compare.zok
index aec45d79..e4790e77 100644
--- a/zokrates_core_test/tests/tests/bool_compare.zok
+++ b/zokrates_core_test/tests/tests/bool_compare.zok
@@ -1,2 +1,2 @@
-def main(bool a, bool b) -> (bool):
+def main(bool a, bool b) -> bool:
  return a == b
diff --git a/zokrates_core_test/tests/tests/fact_up_to_4.zok b/zokrates_core_test/tests/tests/fact_up_to_4.zok
index 44435097..d33b19c0 100644
--- a/zokrates_core_test/tests/tests/fact_up_to_4.zok
+++ b/zokrates_core_test/tests/tests/fact_up_to_4.zok
@@ -1,4 +1,4 @@
-def main(field x) -> (field):
+def main(field x) -> field:
     field f = 1
     field counter = 0
     for field i in 1..5 do
diff --git a/zokrates_core_test/tests/tests/import/dep/dep/foo.zok b/zokrates_core_test/tests/tests/import/dep/dep/foo.zok
index 4498c0fd..216ae88d 100644
--- a/zokrates_core_test/tests/tests/import/dep/dep/foo.zok
+++ b/zokrates_core_test/tests/tests/import/dep/dep/foo.zok
@@ -1,2 +1,2 @@
-def foo() -> (field):
+def foo() -> field:
 	return 1
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/import/dep/foo.zok b/zokrates_core_test/tests/tests/import/dep/foo.zok
index 93e89cff..435d4f5d 100644
--- a/zokrates_core_test/tests/tests/import/dep/foo.zok
+++ b/zokrates_core_test/tests/tests/import/dep/foo.zok
@@ -1,4 +1,4 @@
 from "./dep/foo" import foo as bar
 
-def foo() -> (field):
+def foo() -> field:
 	return 2 + bar()
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/import/import.zok b/zokrates_core_test/tests/tests/import/import.zok
index cfe5e851..a38f1018 100644
--- a/zokrates_core_test/tests/tests/import/import.zok
+++ b/zokrates_core_test/tests/tests/import/import.zok
@@ -1,4 +1,4 @@
 from "./dep/foo" import foo
 
-def main() -> (field):
+def main() -> field:
 	return foo()
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/memoize/dep.zok b/zokrates_core_test/tests/tests/memoize/dep.zok
index df49dc48..43439356 100644
--- a/zokrates_core_test/tests/tests/memoize/dep.zok
+++ b/zokrates_core_test/tests/tests/memoize/dep.zok
@@ -1,3 +1,3 @@
-def dep(field a) -> (field): // this costs 2 constraits per call
+def dep(field a) -> field: // this costs 2 constraits per call
 	field res = a ** 4
 	return res
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/memoize/memoize.zok b/zokrates_core_test/tests/tests/memoize/memoize.zok
index fa3d38b3..bb5c9d21 100644
--- a/zokrates_core_test/tests/tests/memoize/memoize.zok
+++ b/zokrates_core_test/tests/tests/memoize/memoize.zok
@@ -1,10 +1,10 @@
 from "./dep.zok" import dep as dep
 
-def local(field a) -> (field): // this costs 3 constraints per call
+def local(field a) -> field: // this costs 3 constraints per call
 	field res = a ** 8
 	return res // currently expressions in the return statement don't get memoized
 
-def main(field a) -> ():
+def main(field a):
 	// calling a local function many times with the same arg should cost only once
 	assert(local(a) + local(a) + local(a) + local(a) + local(a) == 5 * (a ** 8))
 
diff --git a/zokrates_core_test/tests/tests/precedence.zok b/zokrates_core_test/tests/tests/precedence.zok
index e6120517..0d699a9a 100644
--- a/zokrates_core_test/tests/tests/precedence.zok
+++ b/zokrates_core_test/tests/tests/precedence.zok
@@ -1,4 +1,4 @@
-def main() -> ():
+def main():
   assert(9 == 1 + 2 * 2 ** 2)                                      // Checks precedence of arithmetic operators (expecting transitive behaviour)
   assert(9 == 2 ** 2 * 2 + 1)
   assert(7 == 2 ** 2 * 2 - 1)
diff --git a/zokrates_core_test/tests/tests/single_return.zok b/zokrates_core_test/tests/tests/single_return.zok
index 1c6f36a6..653fdb5b 100644
--- a/zokrates_core_test/tests/tests/single_return.zok
+++ b/zokrates_core_test/tests/tests/single_return.zok
@@ -1,6 +1,6 @@
-def foo() -> (field):
+def foo() -> field:
 	return 42
 
-def main() -> ():
+def main():
 	field a = foo()
 	return
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/add.zok b/zokrates_core_test/tests/tests/uint/add.zok
index c2737d4d..925f2208 100644
--- a/zokrates_core_test/tests/tests/uint/add.zok
+++ b/zokrates_core_test/tests/tests/uint/add.zok
@@ -1,2 +1,2 @@
-def main(u8 a, u8 b) -> (u8):
+def main(u8 a, u8 b) -> u8:
 	return a + b
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/add_loop.zok b/zokrates_core_test/tests/tests/uint/add_loop.zok
index 328b4b9d..53a0c19b 100644
--- a/zokrates_core_test/tests/tests/uint/add_loop.zok
+++ b/zokrates_core_test/tests/tests/uint/add_loop.zok
@@ -1,5 +1,5 @@
 // 32 constraints for input constraining
-def main(u32 a) -> (u32):
+def main(u32 a) -> u32:
 	u32 res = 0x00000000
 	for field i in 0..10 do
 		res = res + a
diff --git a/zokrates_core_test/tests/tests/uint/and.zok b/zokrates_core_test/tests/tests/uint/and.zok
index 7936b883..f53e0ee4 100644
--- a/zokrates_core_test/tests/tests/uint/and.zok
+++ b/zokrates_core_test/tests/tests/uint/and.zok
@@ -1,2 +1,2 @@
-def main(u8 a, u8 b) -> (u8):
+def main(u8 a, u8 b) -> u8:
 	return a & b
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/ch.zok b/zokrates_core_test/tests/tests/uint/ch.zok
index 70465447..42a25701 100644
--- a/zokrates_core_test/tests/tests/uint/ch.zok
+++ b/zokrates_core_test/tests/tests/uint/ch.zok
@@ -1,2 +1,2 @@
-def main(u32 e, u32 f, u32 g) -> (u32):
+def main(u32 e, u32 f, u32 g) -> u32:
 	return (e & f) ^ (!e & g)
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/constant.zok b/zokrates_core_test/tests/tests/uint/constant.zok
index 2c2d69ff..68a0c7e8 100644
--- a/zokrates_core_test/tests/tests/uint/constant.zok
+++ b/zokrates_core_test/tests/tests/uint/constant.zok
@@ -1,2 +1,2 @@
-def main() -> (u32):
+def main() -> u32:
 	return 0x01234567
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/eq.zok b/zokrates_core_test/tests/tests/uint/eq.zok
index 07eadf24..f6ca06f6 100644
--- a/zokrates_core_test/tests/tests/uint/eq.zok
+++ b/zokrates_core_test/tests/tests/uint/eq.zok
@@ -1,3 +1,3 @@
-def main(private u32 a, u32 b) -> (field):
+def main(private u32 a, u32 b) -> field:
   field result = if a * a == b then 1 else 0 fi
   return result
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/extend.zok b/zokrates_core_test/tests/tests/uint/extend.zok
index f55f4f51..576db364 100644
--- a/zokrates_core_test/tests/tests/uint/extend.zok
+++ b/zokrates_core_test/tests/tests/uint/extend.zok
@@ -1,48 +1,48 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_2(u32 e) -> (u32):
+def right_rotate_2(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[30..], ...b[..30]])
 
-def right_rotate_6(u32 e) -> (u32):
+def right_rotate_6(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[26..], ...b[..26]])
 
-def right_rotate_7(u32 e) -> (u32):
+def right_rotate_7(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[25..], ...b[..25]])
 
-def right_rotate_11(u32 e) -> (u32):
+def right_rotate_11(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[21..], ...b[..21]])
 
-def right_rotate_13(u32 e) -> (u32):
+def right_rotate_13(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[19..], ...b[..19]])
 
-def right_rotate_17(u32 e) -> (u32):
+def right_rotate_17(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[15..], ...b[..15]])
 
-def right_rotate_18(u32 e) -> (u32):
+def right_rotate_18(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[14..], ...b[..14]])
 
-def right_rotate_19(u32 e) -> (u32):
+def right_rotate_19(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[13..], ...b[..13]])
 
-def right_rotate_22(u32 e) -> (u32):
+def right_rotate_22(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[10..], ...b[..10]])
 
-def right_rotate_25(u32 e) -> (u32):
+def right_rotate_25(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[7..], ...b[..7]])
 
 // already paying 33 * 64 = 2112 constraints for input constraining. in sha this is done only once. So this is just ~ 152 constraints
-def main(u32[64] w) -> (u32):
+def main(u32[64] w) -> u32:
 	field i = 16
 	u32 s0 = right_rotate_7(w[i-15]) ^ right_rotate_18(w[i-15]) ^ (w[i-15] >> 3)
     u32 s1 = right_rotate_17(w[i-2]) ^ right_rotate_19(w[i-2]) ^ (w[i-2] >> 10)
diff --git a/zokrates_core_test/tests/tests/uint/if_else.zok b/zokrates_core_test/tests/tests/uint/if_else.zok
index b487bb84..ad624b3d 100644
--- a/zokrates_core_test/tests/tests/uint/if_else.zok
+++ b/zokrates_core_test/tests/tests/uint/if_else.zok
@@ -1,2 +1,2 @@
-def main(bool condition, u8 consequence, u8 alternative) -> (u8):
+def main(bool condition, u8 consequence, u8 alternative) -> u8:
 	return if condition then consequence else alternative fi
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/maj.zok b/zokrates_core_test/tests/tests/uint/maj.zok
index b264f227..79fb0a9e 100644
--- a/zokrates_core_test/tests/tests/uint/maj.zok
+++ b/zokrates_core_test/tests/tests/uint/maj.zok
@@ -1,3 +1,3 @@
-def main(u32 a, u32 c) -> (u32):
+def main(u32 a, u32 c) -> u32:
 	u32 b = 0x12345678
 	return (a & b) ^ (a & c) ^ (b & c)
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/mul.zok b/zokrates_core_test/tests/tests/uint/mul.zok
index 2f7e6fed..195ff2b4 100644
--- a/zokrates_core_test/tests/tests/uint/mul.zok
+++ b/zokrates_core_test/tests/tests/uint/mul.zok
@@ -1,2 +1,2 @@
-def main(u8 a, u8 b) -> (u8):
+def main(u8 a, u8 b) -> u8:
 	return a * b
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/operations.zok b/zokrates_core_test/tests/tests/uint/operations.zok
index 4ef034b9..e5bd49eb 100644
--- a/zokrates_core_test/tests/tests/uint/operations.zok
+++ b/zokrates_core_test/tests/tests/uint/operations.zok
@@ -1,62 +1,62 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_2(u32 e) -> (u32):
+def right_rotate_2(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[30..], ...b[..30]])
 	return res
 
-def right_rotate_4(u32 e) -> (u32):
+def right_rotate_4(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[28..], ...b[..28]])
 	return res
 
-def right_rotate_6(u32 e) -> (u32):
+def right_rotate_6(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[26..], ...b[..26]])
 	return res
 
-def right_rotate_7(u32 e) -> (u32):
+def right_rotate_7(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[25..], ...b[..25]])
 	return res
 
-def right_rotate_11(u32 e) -> (u32):
+def right_rotate_11(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[21..], ...b[..21]])
 	return res
 
-def right_rotate_13(u32 e) -> (u32):
+def right_rotate_13(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[19..], ...b[..19]])
 	return res
 
-def right_rotate_17(u32 e) -> (u32):
+def right_rotate_17(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[15..], ...b[..15]])
 	return res
 
-def right_rotate_18(u32 e) -> (u32):
+def right_rotate_18(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[14..], ...b[..14]])
 	return res
 
-def right_rotate_19(u32 e) -> (u32):
+def right_rotate_19(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[13..], ...b[..13]])
 	return res
 
-def right_rotate_22(u32 e) -> (u32):
+def right_rotate_22(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[10..], ...b[..10]])
 	return res
 
-def right_rotate_25(u32 e) -> (u32):
+def right_rotate_25(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[7..], ...b[..7]])
 	return res
 
-def main(u32 e, u32 f, u32[4] terms) -> ():
+def main(u32 e, u32 f, u32[4] terms):
 
 	// rotate
 	u32 rotated = right_rotate_4(e)
diff --git a/zokrates_core_test/tests/tests/uint/or.zok b/zokrates_core_test/tests/tests/uint/or.zok
index 1cdd1ba5..fbd290b0 100644
--- a/zokrates_core_test/tests/tests/uint/or.zok
+++ b/zokrates_core_test/tests/tests/uint/or.zok
@@ -1,2 +1,2 @@
-def main(u8 x, u8 y) -> (u8):
+def main(u8 x, u8 y) -> u8:
 	return x | y
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/propagation/rotate.zok b/zokrates_core_test/tests/tests/uint/propagation/rotate.zok
index a501c0db..6d0184bb 100644
--- a/zokrates_core_test/tests/tests/uint/propagation/rotate.zok
+++ b/zokrates_core_test/tests/tests/uint/propagation/rotate.zok
@@ -1,63 +1,63 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_2(u32 e) -> (u32):
+def right_rotate_2(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[30..], ...b[..30]])
 	return res
 
-def right_rotate_4(u32 e) -> (u32):
+def right_rotate_4(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[28..], ...b[..28]])
 	return res
 
-def right_rotate_6(u32 e) -> (u32):
+def right_rotate_6(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[26..], ...b[..26]])
 	return res
 
-def right_rotate_7(u32 e) -> (u32):
+def right_rotate_7(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[25..], ...b[..25]])
 	return res
 
-def right_rotate_11(u32 e) -> (u32):
+def right_rotate_11(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[21..], ...b[..21]])
 	return res
 
-def right_rotate_13(u32 e) -> (u32):
+def right_rotate_13(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[19..], ...b[..19]])
 	return res
 
-def right_rotate_17(u32 e) -> (u32):
+def right_rotate_17(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[15..], ...b[..15]])
 	return res
 
-def right_rotate_18(u32 e) -> (u32):
+def right_rotate_18(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[14..], ...b[..14]])
 	return res
 
-def right_rotate_19(u32 e) -> (u32):
+def right_rotate_19(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[13..], ...b[..13]])
 	return res
 
-def right_rotate_22(u32 e) -> (u32):
+def right_rotate_22(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[10..], ...b[..10]])
 	return res
 
-def right_rotate_25(u32 e) -> (u32):
+def right_rotate_25(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	u32 res = from_bits([...b[7..], ...b[..7]])
 
 	return res
 
-def main() -> ():
+def main():
 	u32 e = 0x12345678
 	u32 f = 0x01234567
 
diff --git a/zokrates_core_test/tests/tests/uint/rotate.zok b/zokrates_core_test/tests/tests/uint/rotate.zok
index 7d2f63ce..dd0a6ab4 100644
--- a/zokrates_core_test/tests/tests/uint/rotate.zok
+++ b/zokrates_core_test/tests/tests/uint/rotate.zok
@@ -1,9 +1,9 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_4(u32 e) -> (u32):
+def right_rotate_4(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[28..], ...b[..28]])
 
-def main(u32 e) -> (u32):
+def main(u32 e) -> u32:
 	return right_rotate_4(e)
diff --git a/zokrates_core_test/tests/tests/uint/sha256.zok b/zokrates_core_test/tests/tests/uint/sha256.zok
index 5cf72852..3b7a1043 100644
--- a/zokrates_core_test/tests/tests/uint/sha256.zok
+++ b/zokrates_core_test/tests/tests/uint/sha256.zok
@@ -1,52 +1,52 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_2(u32 e) -> (u32):
+def right_rotate_2(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[30..], ...b[..30]])
 
-def right_rotate_6(u32 e) -> (u32):
+def right_rotate_6(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[26..], ...b[..26]])
 
-def right_rotate_7(u32 e) -> (u32):
+def right_rotate_7(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[25..], ...b[..25]])
 
-def right_rotate_11(u32 e) -> (u32):
+def right_rotate_11(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[21..], ...b[..21]])
 
-def right_rotate_13(u32 e) -> (u32):
+def right_rotate_13(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[19..], ...b[..19]])
 
-def right_rotate_17(u32 e) -> (u32):
+def right_rotate_17(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[15..], ...b[..15]])
 
-def right_rotate_18(u32 e) -> (u32):
+def right_rotate_18(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[14..], ...b[..14]])
 
-def right_rotate_19(u32 e) -> (u32):
+def right_rotate_19(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[13..], ...b[..13]])
 
-def right_rotate_22(u32 e) -> (u32):
+def right_rotate_22(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[10..], ...b[..10]])
 
-def right_rotate_25(u32 e) -> (u32):
+def right_rotate_25(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[7..], ...b[..7]])
 
-def extend(u32[64] w, field i) -> (u32):
+def extend(u32[64] w, field i) -> u32:
 	u32 s0 = right_rotate_7(w[i-15]) ^ right_rotate_18(w[i-15]) ^ (w[i-15] >> 3)
     u32 s1 = right_rotate_17(w[i-2]) ^ right_rotate_19(w[i-2]) ^ (w[i-2] >> 10)
     return w[i-16] + s0 + w[i-7] + s1
 
-def temp1(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> (u32):
+def temp1(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> u32:
 	// ch := (e and f) xor ((not e) and g)
 	u32 ch = (e & f) ^ ((!e) & g)
 
@@ -56,7 +56,7 @@ def temp1(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> (u32):
 	// temp1 := h + S1 + ch + k + w
 	return h + S1 + ch + k + w
 
-def temp2(u32 a, u32 b, u32 c) -> (u32):
+def temp2(u32 a, u32 b, u32 c) -> u32:
 	// maj := (a and b) xor (a and c) xor (b and c)
     u32 maj = (a & b) ^ (a & c) ^ (b & c)
 
@@ -66,7 +66,7 @@ def temp2(u32 a, u32 b, u32 c) -> (u32):
     // temp2 := S0 + maj
     return S0 + maj
 
-def main(u32[1][16] input) -> (u32[8]):	
+def main(u32[1][16] input) -> u32[8]:	
 
 	u32 h0 = 0x6a09e667
 	u32 h1 = 0xbb67ae85
diff --git a/zokrates_core_test/tests/tests/uint/shift.zok b/zokrates_core_test/tests/tests/uint/shift.zok
index efacac9c..07ae5949 100644
--- a/zokrates_core_test/tests/tests/uint/shift.zok
+++ b/zokrates_core_test/tests/tests/uint/shift.zok
@@ -1,2 +1,2 @@
-def main(u32 a) -> (u32):
+def main(u32 a) -> u32:
 	return a >> 4
\ No newline at end of file
diff --git a/zokrates_core_test/tests/tests/uint/temp1.zok b/zokrates_core_test/tests/tests/uint/temp1.zok
index ecbabe83..4b3d1e54 100644
--- a/zokrates_core_test/tests/tests/uint/temp1.zok
+++ b/zokrates_core_test/tests/tests/uint/temp1.zok
@@ -1,20 +1,20 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_6(u32 e) -> (u32):
+def right_rotate_6(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[26..], ...b[..26]])
 
-def right_rotate_11(u32 e) -> (u32):
+def right_rotate_11(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[21..], ...b[..21]])
 
-def right_rotate_25(u32 e) -> (u32):
+def right_rotate_25(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[7..], ...b[..7]])
 
 // input constraining costs 6 * 33 = 198 constraints, the rest 200
-def main(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> (u32):
+def main(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> u32:
 	// ch := (e and f) xor ((not e) and g)
 	u32 ch = (e & f) ^ ((!e) & g) // should be 100 constraints
 
diff --git a/zokrates_core_test/tests/tests/uint/temp2.zok b/zokrates_core_test/tests/tests/uint/temp2.zok
index 69833558..ba3b5f10 100644
--- a/zokrates_core_test/tests/tests/uint/temp2.zok
+++ b/zokrates_core_test/tests/tests/uint/temp2.zok
@@ -1,20 +1,20 @@
 import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 
-def right_rotate_2(u32 e) -> (u32):
+def right_rotate_2(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[30..], ...b[..30]])
 
-def right_rotate_13(u32 e) -> (u32):
+def right_rotate_13(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[19..], ...b[..19]])
 
-def right_rotate_22(u32 e) -> (u32):
+def right_rotate_22(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[10..], ...b[..10]])
 
 // input constraining is 99 constraints, the rest is 265 -> total 364
-def main(u32 a, u32 b, u32 c) -> (u32):
+def main(u32 a, u32 b, u32 c) -> u32:
 	// maj := (a and b) xor (a and c) xor (b and c)
     u32 maj = (a & b) ^ (a & c) ^ (b & c) // 165 constraints
 
diff --git a/zokrates_core_test/tests/tests/uint/xor.zok b/zokrates_core_test/tests/tests/uint/xor.zok
index 827e3db0..e2b4ac52 100644
--- a/zokrates_core_test/tests/tests/uint/xor.zok
+++ b/zokrates_core_test/tests/tests/uint/xor.zok
@@ -1,2 +1,2 @@
-def main(u8 a, u8 b) -> (u8):
+def main(u8 a, u8 b) -> u8:
 	return a ^ b
\ No newline at end of file
diff --git a/zokrates_js/README.md b/zokrates_js/README.md
index 96119fb6..8fbbd000 100644
--- a/zokrates_js/README.md
+++ b/zokrates_js/README.md
@@ -6,4 +6,4 @@ JavaScript bindings for [ZoKrates](https://github.com/Zokrates/ZoKrates) project
 npm install zokrates-js
 ```
 
-Check the offical [ZoKrates documentation](https://zokrates.github.io/toolbox/zokrates_js.html) for more details.
\ No newline at end of file
+Check the offical [ZoKrates documentation](https://zokrates.github.io/toolbox/zokrates_js.html) for more details.
diff --git a/zokrates_js/tests/tests.js b/zokrates_js/tests/tests.js
index 2c3dbf7e..57d4a79c 100644
--- a/zokrates_js/tests/tests.js
+++ b/zokrates_js/tests/tests.js
@@ -14,7 +14,7 @@ describe('tests', function() {
     describe("compilation", () => {
         it('should compile', function() {
             assert.doesNotThrow(() => {
-                const artifacts = this.zokrates.compile("def main() -> (field): return 42");
+                const artifacts = this.zokrates.compile("def main() -> field: return 42");
                 assert.ok(artifacts !== undefined);
             })
         });
@@ -26,14 +26,14 @@ describe('tests', function() {
         it('should resolve stdlib module', function() {
             const stdlib = require('../stdlib.json');
             assert.doesNotThrow(() => {
-                const code = `import "${Object.keys(stdlib)[0]}" as func\ndef main() -> (): return`;
+                const code = `import "${Object.keys(stdlib)[0]}" as func\ndef main(): return`;
                 this.zokrates.compile(code);
             });
         });
     
         it('should resolve user module', function() {
             assert.doesNotThrow(() => {
-                const code = 'import "test" as test\ndef main() -> (field): return test()';
+                const code = 'import "test" as test\ndef main() -> field: return test()';
                 const options = {
                     resolveCallback: (_, path) => {
                         return {
@@ -48,7 +48,7 @@ describe('tests', function() {
 
         it('should throw on unresolved module', function() {
             assert.throws(() => {
-                const code = 'import "test" as test\ndef main() -> (field): return test()';
+                const code = 'import "test" as test\ndef main() -> field: return test()';
                 this.zokrates.compile(code);
             });
         });
@@ -57,7 +57,7 @@ describe('tests', function() {
     describe("computation", () => {
         it('should compute with valid inputs', function() {
             assert.doesNotThrow(() => {
-                const code = 'def main(private field a) -> (field): return a * a';
+                const code = 'def main(private field a) -> field: return a * a';
                 const artifacts = this.zokrates.compile(code);
     
                 const result = this.zokrates.computeWitness(artifacts, ["2"]);
@@ -69,7 +69,7 @@ describe('tests', function() {
 
         it('should throw on invalid input count', function() {
             assert.throws(() => {
-                const code = 'def main(private field a) -> (field): return a * a';
+                const code = 'def main(private field a) -> field: return a * a';
                 const artifacts = this.zokrates.compile(code);
     
                 this.zokrates.computeWitness(artifacts, ["1", "2"]);
@@ -78,7 +78,7 @@ describe('tests', function() {
 
         it('should throw on invalid input type', function() {
             assert.throws(() => {
-                const code = 'def main(private field a) -> (field): return a * a';
+                const code = 'def main(private field a) -> field: return a * a';
                 const artifacts = this.zokrates.compile(code);
     
                 this.zokrates.computeWitness(artifacts, [true]);
@@ -89,7 +89,7 @@ describe('tests', function() {
     describe("setup", () => {
         it('should run setup', function() {
             assert.doesNotThrow(() => {
-                const code = 'def main(private field a) -> (field): return a * a';
+                const code = 'def main(private field a) -> field: return a * a';
                 const artifacts = this.zokrates.compile(code);
     
                 this.zokrates.setup(artifacts.program);
@@ -100,7 +100,7 @@ describe('tests', function() {
     describe("export-verifier", () => {
         it('should export solidity verifier', function() {
             assert.doesNotThrow(() => {
-                const code = 'def main(private field a) -> (field): return a * a';
+                const code = 'def main(private field a) -> field: return a * a';
                 const artifacts = this.zokrates.compile(code);
                 const keypair = this.zokrates.setup(artifacts.program);
 
@@ -113,7 +113,7 @@ describe('tests', function() {
     describe("generate-proof", () => {
         it('should generate proof', function() {
             assert.doesNotThrow(() => {
-                const code = 'def main(private field a) -> (field): return a * a';
+                const code = 'def main(private field a) -> field: return a * a';
                 const artifacts = this.zokrates.compile(code);
                 const computationResult = this.zokrates.computeWitness(artifacts, ["2"])
                 const keypair = this.zokrates.setup(artifacts.program);
diff --git a/zokrates_parser/src/zokrates.pest b/zokrates_parser/src/zokrates.pest
index a19f915d..40c7b1c6 100644
--- a/zokrates_parser/src/zokrates.pest
+++ b/zokrates_parser/src/zokrates.pest
@@ -8,7 +8,8 @@ import_directive = { main_import_directive | from_import_directive }
 from_import_directive = { "from" ~ "\"" ~ import_source ~ "\"" ~ "import" ~ identifier ~ ("as" ~ identifier)? ~ NEWLINE*}
 main_import_directive = {"import" ~ "\"" ~ import_source ~ "\"" ~ ("as" ~ identifier)? ~ NEWLINE+}
 import_source = @{(!"\"" ~ ANY)*}
-function_definition = {"def" ~ identifier ~ "(" ~ parameter_list ~ ")" ~ "->" ~ "(" ~ type_list ~ ")" ~ ":" ~ NEWLINE* ~ statement* }
+function_definition = {"def" ~ identifier ~ "(" ~ parameter_list ~ ")" ~ return_types ~ ":" ~ NEWLINE* ~ statement* }
+return_types = _{ ( "->" ~ ( "(" ~ type_list ~ ")" | ty ))? }
 
 parameter_list = _{(parameter ~ ("," ~ parameter)*)?}
 parameter = {vis? ~ ty ~ identifier}
diff --git a/zokrates_stdlib/stdlib/ecc/babyjubjubParams.zok b/zokrates_stdlib/stdlib/ecc/babyjubjubParams.zok
index 388fc9e7..53bf7b8f 100644
--- a/zokrates_stdlib/stdlib/ecc/babyjubjubParams.zok
+++ b/zokrates_stdlib/stdlib/ecc/babyjubjubParams.zok
@@ -15,7 +15,7 @@ struct BabyJubJubParams {
 	field Gv
 }
 
-def main() -> (BabyJubJubParams):
+def main() -> BabyJubJubParams:
 
 // Order of the curve E
     field JUBJUBE = 21888242871839275222246405745257275088614511777268538073601725287587578984328
diff --git a/zokrates_stdlib/stdlib/ecc/edwardsAdd.zok b/zokrates_stdlib/stdlib/ecc/edwardsAdd.zok
index 29874296..8202c639 100644
--- a/zokrates_stdlib/stdlib/ecc/edwardsAdd.zok
+++ b/zokrates_stdlib/stdlib/ecc/edwardsAdd.zok
@@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 // Add two points on a twisted Edwards curve
 // Curve parameters are defined with the last argument
 // https://en.wikipedia.org/wiki/Twisted_Edwards_curve#Addition_on_twisted_Edwards_curves
-def main(field[2] pt1, field[2] pt2, BabyJubJubParams context) -> (field[2]):
+def main(field[2] pt1, field[2] pt2, BabyJubJubParams context) -> field[2]:
 
     field a = context.JUBJUBA
     field d = context.JUBJUBD
diff --git a/zokrates_stdlib/stdlib/ecc/edwardsCompress.zok b/zokrates_stdlib/stdlib/ecc/edwardsCompress.zok
index 0c6efe6d..4f59c480 100644
--- a/zokrates_stdlib/stdlib/ecc/edwardsCompress.zok
+++ b/zokrates_stdlib/stdlib/ecc/edwardsCompress.zok
@@ -7,7 +7,7 @@ import "utils/pack/bool/nonStrictUnpack256" as unpack256
 // 	y = self.y.n
 // 	return int.to_bytes(y | ((x & 1) << 255), 32, "big")
 
-def main(field[2] pt)  -> (bool[256]):
+def main(field[2] pt)  -> bool[256]:
 	field x = pt[0]
 	field y = pt[1]
 
diff --git a/zokrates_stdlib/stdlib/ecc/edwardsNegate.zok b/zokrates_stdlib/stdlib/ecc/edwardsNegate.zok
index 43ac5cbf..f8d78178 100644
--- a/zokrates_stdlib/stdlib/ecc/edwardsNegate.zok
+++ b/zokrates_stdlib/stdlib/ecc/edwardsNegate.zok
@@ -1,7 +1,7 @@
 // Negate a point on an Edwards curve
 // Curve parameters are defined with the last argument
 // Twisted Edwards Curves, BBJLP-2008, section 2 pg 2
-def main(field[2] pt) -> (field[2]):
+def main(field[2] pt) -> field[2]:
 
     field u = pt[0]
     field v = pt[1]
diff --git a/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok b/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok
index 2fc71e66..a76dcc4c 100644
--- a/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok
+++ b/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok
@@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 // Curve parameters are defined with the last argument
 // See appendix 3.3.1 of Zcash protocol specification:
 // https://github.com/zcash/zips/blob/master/protocol/protocol.pdf
-def main(field[2] pt, BabyJubJubParams context) -> (bool):
+def main(field[2] pt, BabyJubJubParams context) -> bool:
 
     field a = context.JUBJUBA
     field d = context.JUBJUBD
diff --git a/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok b/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok
index cd92016c..85f5ded5 100644
--- a/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok
+++ b/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok
@@ -9,7 +9,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 // Returns true if the point is not one of the low-order points, false otherwise.
 // Curve parameters are defined with the last argument
 // https://github.com/zcash-hackworks/sapling-crypto/blob/master/src/jubjub/edwards.rs#L166
-def main(field[2] pt, BabyJubJubParams context) -> (bool):
+def main(field[2] pt, BabyJubJubParams context) -> bool:
 
     field cofactor = context.JUBJUBC
 
diff --git a/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok b/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok
index 5c6b7a5c..dd7b4300 100644
--- a/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok
+++ b/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok
@@ -8,7 +8,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 // curve parameters.
 // Note that the exponent array is not check to be boolean in this gadget
 // Reference: https://github.com/zcash-hackworks/sapling-crypto/blob/master/src/jubjub/fs.rs#L555
-def main(bool[256] exponent, field[2] pt, BabyJubJubParams context) -> (field[2]):
+def main(bool[256] exponent, field[2] pt, BabyJubJubParams context) -> field[2]:
 
     field[2] infinity = context.INFINITY
 
diff --git a/zokrates_stdlib/stdlib/ecc/proofOfOwnership.zok b/zokrates_stdlib/stdlib/ecc/proofOfOwnership.zok
index 4262d946..57ba51db 100644
--- a/zokrates_stdlib/stdlib/ecc/proofOfOwnership.zok
+++ b/zokrates_stdlib/stdlib/ecc/proofOfOwnership.zok
@@ -17,7 +17,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 ///
 /// Returns:
 ///     Return true for pk/sk being a valid keypair, false otherwise.
-def main(field[2] pk, field sk, BabyJubJubParams context) -> (bool):
+def main(field[2] pk, field sk, BabyJubJubParams context) -> bool:
 
     field[2] G = [context.Gu, context.Gv]
 
diff --git a/zokrates_stdlib/stdlib/hashes/mimc7/constants.zok b/zokrates_stdlib/stdlib/hashes/mimc7/constants.zok
index 9a2f4185..b4780cbb 100644
--- a/zokrates_stdlib/stdlib/hashes/mimc7/constants.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimc7/constants.zok
@@ -1,4 +1,4 @@
-def main() -> (field[91]):
+def main() -> field[91]:
 	return [
 		0,
 		20888961410941983456478427210666206549300505294776164667214940546594746570981,
diff --git a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R10.zok b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R10.zok
index 09b02a36..d3a58e6b 100644
--- a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R10.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R10.zok
@@ -1,6 +1,6 @@
 import "./constants" as constants
 
-def main(field x_in, field k) -> (field):
+def main(field x_in, field k) -> field:
 	field[91] c = constants()
 	field t = 0
 	field[10] t2 = [0; 10]
diff --git a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R20.zok b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R20.zok
index 067430c1..f231662f 100644
--- a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R20.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R20.zok
@@ -1,6 +1,6 @@
 import "./constants" as constants
 
-def main(field x_in, field k) -> (field):
+def main(field x_in, field k) -> field:
 	field[91] c = constants()
 	field t = 0
 	field[20] t2 = [0; 20]
diff --git a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R50.zok b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R50.zok
index 972d6688..c3dc3d1e 100644
--- a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R50.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R50.zok
@@ -1,6 +1,6 @@
 import "./constants" as constants
 
-def main(field x_in, field k) -> (field):
+def main(field x_in, field k) -> field:
 	field[91] c = constants()
 	field t = 0
 	field[50] t2 = [0; 50]
diff --git a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R90.zok b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R90.zok
index 9cd91403..83698aae 100644
--- a/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R90.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimc7/mimc7R90.zok
@@ -1,6 +1,6 @@
 import "./constants" as constants
 
-def main(field x_in, field k) -> (field):
+def main(field x_in, field k) -> field:
 	field[91] c = constants()
 	field t = 0
 	field[90] t2 = [0; 90]
diff --git a/zokrates_stdlib/stdlib/hashes/mimcSponge/IVconstants.zok b/zokrates_stdlib/stdlib/hashes/mimcSponge/IVconstants.zok
index 417ceee0..bc2caf7a 100644
--- a/zokrates_stdlib/stdlib/hashes/mimcSponge/IVconstants.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimcSponge/IVconstants.zok
@@ -1,4 +1,4 @@
-def main() -> (field[220]):
+def main() -> field[220]:
 	return [
 		0,
 		7120861356467848435263064379192047478074060781135320967663101236819528304084,
diff --git a/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcFeistel.zok b/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcFeistel.zok
index 62515cff..7257c39a 100644
--- a/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcFeistel.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcFeistel.zok
@@ -1,7 +1,7 @@
 // MiMCFeistel configured with 220 rounds
 
 import "./IVconstants" as IVconstants
-def main(field xL_in, field xR_in, field k) -> (field[2]):
+def main(field xL_in, field xR_in, field k) -> field[2]:
 	field[220] IV = IVconstants()
 
 	field t = 0
diff --git a/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcSponge.zok b/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcSponge.zok
index 05275d07..033617ad 100644
--- a/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcSponge.zok
+++ b/zokrates_stdlib/stdlib/hashes/mimcSponge/mimcSponge.zok
@@ -1,6 +1,6 @@
 import "./mimcFeistel" as MiMCFeistel
 
-def main(field[2] ins, field k) -> (field[3]):
+def main(field[2] ins, field k) -> field[3]:
 	//nInputs = 2, nOutputs = 3,
 	field nInputs = 2
 	field nOutputs = 3 
diff --git a/zokrates_stdlib/stdlib/hashes/pedersen/512bit.zok b/zokrates_stdlib/stdlib/hashes/pedersen/512bit.zok
index 1dc58b4f..ec5be80c 100644
--- a/zokrates_stdlib/stdlib/hashes/pedersen/512bit.zok
+++ b/zokrates_stdlib/stdlib/hashes/pedersen/512bit.zok
@@ -18,7 +18,7 @@ import "EMBED/u32_from_bits" as from_bits
 // print(hasher.dsl_code)
 
 // 512bit to 256bit Pedersen hash using compression of the field elements
-def main(u32[16] input) -> (u32[8]):
+def main(u32[16] input) -> u32[8]:
 
 	bool[512] e = [ \
 		...to_bits(input[0]),
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/1024bit.zok b/zokrates_stdlib/stdlib/hashes/sha256/1024bit.zok
index 502c31a5..6f52a95a 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/1024bit.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/1024bit.zok
@@ -5,7 +5,7 @@ import "./shaRound" as sha256
 // and returns their sha256 compression as a u32[8].
 // Note: no padding is applied
 
-def main(u32[8] a, u32[8] b, u32[8] c, u32[8] d) -> (u32[8]):
+def main(u32[8] a, u32[8] b, u32[8] c, u32[8] d) -> u32[8]:
 
     u32[8] IV =  IVconstants()
     u32[8] digest1 =  sha256([...a, ...b], IV)
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/1024bitPadded.zok b/zokrates_stdlib/stdlib/hashes/sha256/1024bitPadded.zok
index c336e389..dd8e767b 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/1024bitPadded.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/1024bitPadded.zok
@@ -2,7 +2,7 @@ import "./1536bit" as sha256
 
 // A function that takes four u32[8] array as input, concatenates them, pads the result,
 // and returns the sha256 output as a u32[8]
-def main(u32[8] a, u32[8] b, u32[8] c, u32[8] d) -> (u32[8]):
+def main(u32[8] a, u32[8] b, u32[8] c, u32[8] d) -> u32[8]:
 
     // Hash is computed on the full 1024bit block size
     // padding does not fit in the first two blocks
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/1536bit.zok b/zokrates_stdlib/stdlib/hashes/sha256/1536bit.zok
index 3e53f9fc..f1b8860c 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/1536bit.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/1536bit.zok
@@ -5,7 +5,7 @@ import "./shaRound" as sha256
 // and returns their sha256 compression as a u32[8].
 // Note: no padding is applied
 
-def main(u32[8] a, u32[8] b, u32[8] c, u32[8] d, u32[8] e, u32[8] f) -> (u32[8]):
+def main(u32[8] a, u32[8] b, u32[8] c, u32[8] d, u32[8] e, u32[8] f) -> u32[8]:
 
     u32[8] IV =  IVconstants()
     u32[8] digest1 =  sha256([...a, ...b], IV)
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/256bitPadded.zok b/zokrates_stdlib/stdlib/hashes/sha256/256bitPadded.zok
index e0b1a5c7..8d478666 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/256bitPadded.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/256bitPadded.zok
@@ -2,7 +2,7 @@ import "./512bit" as sha256
 
 // A function that takes a u32[8] array as input, pads it,
 // and returns the sha256 output as a u32[8]
-def main(u32[8] a) -> (u32[8]):
+def main(u32[8] a) -> u32[8]:
 
     // Hash is computed on 256 bits of input
     // padding fits in the remaining 256 bits of the first block
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/512bit.zok b/zokrates_stdlib/stdlib/hashes/sha256/512bit.zok
index a0b3f63e..e7772a13 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/512bit.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/512bit.zok
@@ -5,6 +5,6 @@ import "./shaRound" as sha256
 // and returns their sha256 compression as a u32[8].
 // Note: no padding is applied
 
-def main(u32[8] a, u32[8] b) -> (u32[8]):
+def main(u32[8] a, u32[8] b) -> u32[8]:
 
     return sha256([...a, ...b], IVconstants())
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/512bitPacked.zok b/zokrates_stdlib/stdlib/hashes/sha256/512bitPacked.zok
index 049ddf5f..8e7fb6fa 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/512bitPacked.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/512bitPacked.zok
@@ -4,7 +4,7 @@ import "./512bitPadded" as sha256
 // A function that takes an array of 4 field elements as input, unpacks each of them to 128
 // bits (big endian), concatenates them and applies sha256.
 // It then returns an array of two field elements, each representing 128 bits of the result.
-def main(field[4] preimage) -> (field[2]):
+def main(field[4] preimage) -> field[2]:
 
     u32[4] a_bits = unpack128(preimage[0])
     u32[4] b_bits = unpack128(preimage[1])
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/512bitPadded.zok b/zokrates_stdlib/stdlib/hashes/sha256/512bitPadded.zok
index 33b59bb1..6e00c191 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/512bitPadded.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/512bitPadded.zok
@@ -2,7 +2,7 @@ import "./1024bit" as sha256
 
 // A function that takes 2 u32[8] arrays as inputs, concatenates them, pads them,
 // and returns their sha256 hash as a u32[8]
-def main(u32[8] a, u32[8] b) -> (u32[8]):
+def main(u32[8] a, u32[8] b) -> u32[8]:
 
     // Hash is computed on the full 512bit block size
     // padding does not fit in the primary block
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/IVconstants.zok b/zokrates_stdlib/stdlib/hashes/sha256/IVconstants.zok
index a62cb51e..5d5f558a 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/IVconstants.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/IVconstants.zok
@@ -1,4 +1,4 @@
 // SHA-256 is specified in FIPS 180-3 and initial values are listed in section 5.3.3
 // https://csrc.nist.gov/csrc/media/publications/fips/180/3/archive/2008-10-31/documents/fips180-3_final.pdf
-def main() -> (u32[8]):
+def main() -> u32[8]:
 	return [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
diff --git a/zokrates_stdlib/stdlib/hashes/sha256/shaRound.zok b/zokrates_stdlib/stdlib/hashes/sha256/shaRound.zok
index 2cdf2cef..00349c3e 100644
--- a/zokrates_stdlib/stdlib/hashes/sha256/shaRound.zok
+++ b/zokrates_stdlib/stdlib/hashes/sha256/shaRound.zok
@@ -2,52 +2,52 @@ import "EMBED/u32_to_bits" as to_bits
 import "EMBED/u32_from_bits" as from_bits
 import "./IVconstants.zok"
 
-def right_rotate_2(u32 e) -> (u32):
+def right_rotate_2(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[30..], ...b[..30]])
 
-def right_rotate_6(u32 e) -> (u32):
+def right_rotate_6(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[26..], ...b[..26]])
 
-def right_rotate_7(u32 e) -> (u32):
+def right_rotate_7(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[25..], ...b[..25]])
 
-def right_rotate_11(u32 e) -> (u32):
+def right_rotate_11(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[21..], ...b[..21]])
 
-def right_rotate_13(u32 e) -> (u32):
+def right_rotate_13(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[19..], ...b[..19]])
 
-def right_rotate_17(u32 e) -> (u32):
+def right_rotate_17(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[15..], ...b[..15]])
 
-def right_rotate_18(u32 e) -> (u32):
+def right_rotate_18(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[14..], ...b[..14]])
 
-def right_rotate_19(u32 e) -> (u32):
+def right_rotate_19(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[13..], ...b[..13]])
 
-def right_rotate_22(u32 e) -> (u32):
+def right_rotate_22(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[10..], ...b[..10]])
 
-def right_rotate_25(u32 e) -> (u32):
+def right_rotate_25(u32 e) -> u32:
 	bool[32] b = to_bits(e)
 	return from_bits([...b[7..], ...b[..7]])
 
-def extend(u32[64] w, field i) -> (u32):
+def extend(u32[64] w, field i) -> u32:
 	u32 s0 = right_rotate_7(w[i-15]) ^ right_rotate_18(w[i-15]) ^ (w[i-15] >> 3)
     u32 s1 = right_rotate_17(w[i-2]) ^ right_rotate_19(w[i-2]) ^ (w[i-2] >> 10)
     return w[i-16] + s0 + w[i-7] + s1
 
-def temp1(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> (u32):
+def temp1(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> u32:
 	// ch := (e and f) xor ((not e) and g)
 	u32 ch = (e & f) ^ ((!e) & g)
 
@@ -57,7 +57,7 @@ def temp1(u32 e, u32 f, u32 g, u32 h, u32 k, u32 w) -> (u32):
 	// temp1 := h + S1 + ch + k + w
 	return h + S1 + ch + k + w
 
-def temp2(u32 a, u32 b, u32 c) -> (u32):
+def temp2(u32 a, u32 b, u32 c) -> u32:
 	// maj := (a and b) xor (a and c) xor (b and c)
     u32 maj = (a & b) ^ (a & c) ^ (b & c)
 
@@ -69,7 +69,7 @@ def temp2(u32 a, u32 b, u32 c) -> (u32):
 
 // A function that computes one round of the SHA256 compression function given an input and the current value of the hash
 // this is used by other components however many times needed
-def main(u32[16] input, u32[8] current) -> (u32[8]):
+def main(u32[16] input, u32[8] current) -> u32[8]:
 
 	u32 h0 = current[0]
 	u32 h1 = current[1]
diff --git a/zokrates_stdlib/stdlib/hashes/utils/256bitsDirectionHelper.zok b/zokrates_stdlib/stdlib/hashes/utils/256bitsDirectionHelper.zok
index 8b2db310..76d69f20 100644
--- a/zokrates_stdlib/stdlib/hashes/utils/256bitsDirectionHelper.zok
+++ b/zokrates_stdlib/stdlib/hashes/utils/256bitsDirectionHelper.zok
@@ -1,3 +1,3 @@
 // Concatenate two u32[8] arrays in an order defined by a boolean selector
-def main(bool selector, u32[8] lhs, u32[8] rhs) -> (u32[16]):
+def main(bool selector, u32[8] lhs, u32[8] rhs) -> u32[16]:
 	return if selector then [...rhs, ...lhs] else [...lhs, ...rhs] fi
\ No newline at end of file
diff --git a/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok b/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok
index a5367667..d9998f28 100644
--- a/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok
+++ b/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok
@@ -29,7 +29,7 @@ import "utils/casts/u32_8_to_bool_256"
 ///
 /// Returns:
 ///     Return true for S being a valid EdDSA Signature, false otherwise.
-def main(private field[2] R, private field S, field[2] A, u32[8] M0, u32[8] M1, BabyJubJubParams context) -> (bool):
+def main(private field[2] R, private field S, field[2] A, u32[8] M0, u32[8] M1, BabyJubJubParams context) -> bool:
 
     field[2] G = [context.Gu, context.Gv]
 
diff --git a/zokrates_stdlib/stdlib/utils/casts/bool_128_to_u32_4.zok b/zokrates_stdlib/stdlib/utils/casts/bool_128_to_u32_4.zok
index 481a0c9d..222835bf 100644
--- a/zokrates_stdlib/stdlib/utils/casts/bool_128_to_u32_4.zok
+++ b/zokrates_stdlib/stdlib/utils/casts/bool_128_to_u32_4.zok
@@ -1,4 +1,4 @@
 import "EMBED/u32_from_bits" as from_bits
 
-def main(bool[128] bits) -> (u32[4]):
+def main(bool[128] bits) -> u32[4]:
 	return [from_bits(bits[0..32]), from_bits(bits[32..64]), from_bits(bits[64..96]), from_bits(bits[96..128])]
diff --git a/zokrates_stdlib/stdlib/utils/casts/bool_256_to_u32_8.zok b/zokrates_stdlib/stdlib/utils/casts/bool_256_to_u32_8.zok
index 812f8e3e..538cde8b 100644
--- a/zokrates_stdlib/stdlib/utils/casts/bool_256_to_u32_8.zok
+++ b/zokrates_stdlib/stdlib/utils/casts/bool_256_to_u32_8.zok
@@ -1,4 +1,4 @@
 import "EMBED/u32_from_bits" as from_bits
 
-def main(bool[256] bits) -> (u32[8]):
+def main(bool[256] bits) -> u32[8]:
 	return [from_bits(bits[0..32]), from_bits(bits[32..64]), from_bits(bits[64..96]), from_bits(bits[96..128]), from_bits(bits[128..160]), from_bits(bits[160..192]), from_bits(bits[192..224]), from_bits(bits[224..256])]
diff --git a/zokrates_stdlib/stdlib/utils/casts/u32_4_to_bool_128.zok b/zokrates_stdlib/stdlib/utils/casts/u32_4_to_bool_128.zok
index 166a22f7..35ad6188 100644
--- a/zokrates_stdlib/stdlib/utils/casts/u32_4_to_bool_128.zok
+++ b/zokrates_stdlib/stdlib/utils/casts/u32_4_to_bool_128.zok
@@ -1,4 +1,4 @@
 import "EMBED/u32_to_bits" as to_bits
 
-def main(u32[4] input) -> (bool[128]):
+def main(u32[4] input) -> bool[128]:
 	return [...to_bits(input[0]), ...to_bits(input[1]), ...to_bits(input[2]), ...to_bits(input[3])]
diff --git a/zokrates_stdlib/stdlib/utils/casts/u32_8_to_bool_256.zok b/zokrates_stdlib/stdlib/utils/casts/u32_8_to_bool_256.zok
index e47013d5..84564fa7 100644
--- a/zokrates_stdlib/stdlib/utils/casts/u32_8_to_bool_256.zok
+++ b/zokrates_stdlib/stdlib/utils/casts/u32_8_to_bool_256.zok
@@ -1,4 +1,4 @@
 import "EMBED/u32_to_bits" as to_bits
 
-def main(u32[8] input) -> (bool[256]):
+def main(u32[8] input) -> bool[256]:
 	return [...to_bits(input[0]), ...to_bits(input[1]), ...to_bits(input[2]), ...to_bits(input[3]), ...to_bits(input[4]), ...to_bits(input[5]), ...to_bits(input[6]), ...to_bits(input[7])]
diff --git a/zokrates_stdlib/stdlib/utils/multiplexer/lookup1bit.zok b/zokrates_stdlib/stdlib/utils/multiplexer/lookup1bit.zok
index 67b68cf2..1deabf1c 100644
--- a/zokrates_stdlib/stdlib/utils/multiplexer/lookup1bit.zok
+++ b/zokrates_stdlib/stdlib/utils/multiplexer/lookup1bit.zok
@@ -1,6 +1,6 @@
 // One-bit window lookup table using one constraint
-def main(bool selector, field[2] target) -> (field):
+def main(bool selector, field[2] target) -> field:
 
 	field out = if selector then target[1] else target[0] fi
 
-  return out
\ No newline at end of file
+	return out
\ No newline at end of file
diff --git a/zokrates_stdlib/stdlib/utils/multiplexer/lookup2bit.zok b/zokrates_stdlib/stdlib/utils/multiplexer/lookup2bit.zok
index 4713d7dd..b3e28461 100644
--- a/zokrates_stdlib/stdlib/utils/multiplexer/lookup2bit.zok
+++ b/zokrates_stdlib/stdlib/utils/multiplexer/lookup2bit.zok
@@ -1,6 +1,6 @@
 // Two-bit window lookup table using one constraint
 // Maps the bits `b` to a list of field elements `c`
-def main(bool[2] b, field[4] c) -> (field):
+def main(bool[2] b, field[4] c) -> field:
 
 	field alpha = c[1] - c[0] + if b[1] then (c[3] - c[2] - c[1] + c[0]) else 0 fi
 	field out = if b[0] then alpha else 0 fi + c[0] - (if b[1] then (0 - c[2] + c[0]) else 0 fi)
diff --git a/zokrates_stdlib/stdlib/utils/multiplexer/lookup3bitSigned.zok b/zokrates_stdlib/stdlib/utils/multiplexer/lookup3bitSigned.zok
index f6e8cc4b..19267ac6 100644
--- a/zokrates_stdlib/stdlib/utils/multiplexer/lookup3bitSigned.zok
+++ b/zokrates_stdlib/stdlib/utils/multiplexer/lookup3bitSigned.zok
@@ -1,7 +1,8 @@
 import "./lookup2bit" as lookup
+
 // Three-bit window lookup (2bits + signature bit) in 2bit table
 // using two constraints. Maps the bits `b` to a list of constants `c`
-def main(bool[3] b, field[4] c) -> (field):
+def main(bool[3] b, field[4] c) -> field:
 
 	field alpha = lookup([b[0], b[1]], c)
 	field out = alpha - 2 * if b[2] then alpha else 0 fi
diff --git a/zokrates_stdlib/stdlib/utils/pack/bool/nonStrictUnpack256.zok b/zokrates_stdlib/stdlib/utils/pack/bool/nonStrictUnpack256.zok
index da139dcb..ca356e8c 100644
--- a/zokrates_stdlib/stdlib/utils/pack/bool/nonStrictUnpack256.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/bool/nonStrictUnpack256.zok
@@ -5,7 +5,7 @@ import "EMBED/unpack" as unpack
 // Unpack a field element as 256 big-endian bits
 // Note: uniqueness of the output is not guaranteed
 // For example, `0` can map to `[0, 0, ..., 0]` or to `bits(p)`
-def main(field i) -> (bool[256]):
+def main(field i) -> bool[256]:
 
     bool[254] b = unpack(i)
 
diff --git a/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok b/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok
index 93a05d6c..e69ac943 100644
--- a/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok
@@ -1,7 +1,7 @@
 #pragma curve bn128
 
 // pack 128 big-endian bits into one field element
-def main(bool[128] bits) -> (field):
+def main(bool[128] bits) -> field:
 
 	field out = 0
 
diff --git a/zokrates_stdlib/stdlib/utils/pack/bool/pack256.zok b/zokrates_stdlib/stdlib/utils/pack/bool/pack256.zok
index 1c76c7ff..7c5ce385 100644
--- a/zokrates_stdlib/stdlib/utils/pack/bool/pack256.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/bool/pack256.zok
@@ -3,7 +3,7 @@
 // pack 256 big-endian bits into one field element
 // Note: This is not a injective operation as `p` is smaller than `2**256 - 1` for bn128
 // For example, `[0, 0,..., 0]` and `bits(p)` both point to `0`
-def main(bool[256] input) -> (field):
+def main(bool[256] input) -> field:
 
 	field out = 0
 
diff --git a/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok b/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok
index 1d950a40..66d89557 100644
--- a/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok
@@ -4,7 +4,7 @@ import "EMBED/unpack" as unpack
 
 // Unpack a field element as 128 big-endian bits
 // Precondition: the input is smaller or equal to `2**128 - 1`
-def main(field i) -> (bool[128]):
+def main(field i) -> bool[128]:
 
     bool[254] b = unpack(i)
 
diff --git a/zokrates_stdlib/stdlib/utils/pack/u32/nonStrictUnpack256.zok b/zokrates_stdlib/stdlib/utils/pack/u32/nonStrictUnpack256.zok
index a38a80da..d1bca832 100644
--- a/zokrates_stdlib/stdlib/utils/pack/u32/nonStrictUnpack256.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/u32/nonStrictUnpack256.zok
@@ -6,6 +6,6 @@ import "../../casts/bool_256_to_u32_8" as from_bits
 // Unpack a field element as a u32[8] (big-endian)
 // Note: uniqueness of the output is not guaranteed
 // For example, `0` can map to `[0, 0, ..., 0]` or to `bits(p)`
-def main(field i) -> (u32[8]):
+def main(field i) -> u32[8]:
 
 	return from_bits(unpack(i))
\ No newline at end of file
diff --git a/zokrates_stdlib/stdlib/utils/pack/u32/pack128.zok b/zokrates_stdlib/stdlib/utils/pack/u32/pack128.zok
index 2de7c0dd..42ea81aa 100644
--- a/zokrates_stdlib/stdlib/utils/pack/u32/pack128.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/u32/pack128.zok
@@ -4,7 +4,7 @@ import "EMBED/u32_to_bits" as to_bits
 import "../bool/pack128"
 
 // pack 128 big-endian bits into one field element
-def main(u32[4] input) -> (field):
+def main(u32[4] input) -> field:
 
 	bool[128] bits = [...to_bits(input[0]), ...to_bits(input[1]), ...to_bits(input[2]), ...to_bits(input[3])]
 
diff --git a/zokrates_stdlib/stdlib/utils/pack/u32/pack256.zok b/zokrates_stdlib/stdlib/utils/pack/u32/pack256.zok
index 36d12a69..5a89e644 100644
--- a/zokrates_stdlib/stdlib/utils/pack/u32/pack256.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/u32/pack256.zok
@@ -6,7 +6,7 @@ import "../bool/pack256"
 // pack 256 big-endian bits into one field element
 // Note: This is not a injective operation as `p` is smaller than `2**256 - 1 for bn128
 // For example, `[0, 0,..., 0]` and `bits(p)` both point to `0`
-def main(u32[8] input) -> (field):
+def main(u32[8] input) -> field:
 
 	bool[256] bits = [...to_bits(input[0]), ...to_bits(input[1]), ...to_bits(input[2]), ...to_bits(input[3]), ...to_bits(input[4]), ...to_bits(input[5]), ...to_bits(input[6]), ...to_bits(input[7])]
 
diff --git a/zokrates_stdlib/stdlib/utils/pack/u32/unpack128.zok b/zokrates_stdlib/stdlib/utils/pack/u32/unpack128.zok
index 90bddcd9..ebdb7544 100644
--- a/zokrates_stdlib/stdlib/utils/pack/u32/unpack128.zok
+++ b/zokrates_stdlib/stdlib/utils/pack/u32/unpack128.zok
@@ -5,5 +5,6 @@ import "../../casts/bool_128_to_u32_4" as from_bits
 
 // Unpack a field element as 128 big-endian bits
 // Precondition: the input is smaller or equal to `2**128 - 1`
-def main(field i) -> (u32[4]):
+def main(field i) -> u32[4]:
+
 	return from_bits(unpack(i))
\ No newline at end of file
diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok b/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok
index 9d3fe6b3..cfdd1ffc 100644
--- a/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok
+++ b/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok
@@ -5,7 +5,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 
 // Code to create test cases:
 // https://github.com/Zokrates/pycrypto
-def testDoubleViaAdd() -> (bool):
+def testDoubleViaAdd() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 	
@@ -16,7 +16,7 @@ def testDoubleViaAdd() -> (bool):
 
 	return true
 
-def testIdentities() -> (bool):
+def testIdentities() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 	field[2] inf = context.INFINITY
@@ -30,7 +30,7 @@ def testIdentities() -> (bool):
 
 	return true
 
-def main() -> ():
+def main():
 
 	assert(testDoubleViaAdd())
 	assert(testIdentities())
diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok b/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok
index be2d054f..06f5dfe3 100644
--- a/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok
+++ b/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok
@@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 
 // Code to create test cases:
 // https://github.com/Zokrates/pycrypto
-def testCompress() -> (bool):
+def testCompress() -> bool:
 	BabyJubJubParams context = context()
 
 	field Gu = context.Gu
@@ -16,7 +16,7 @@ def testCompress() -> (bool):
 
 	return true
 
-def main() -> ():
+def main():
 
 	assert(testCompress())
 
diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok b/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok
index e25c0415..6738162a 100644
--- a/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok
+++ b/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok
@@ -4,7 +4,7 @@ import "ecc/edwardsOnCurve" as onCurve
 
 // Code to create test cases:
 // https://github.com/Zokrates/pycrypto
-def testOnCurveTrue() -> (bool):
+def testOnCurveTrue() -> bool:
 	BabyJubJubParams context = context()
 
 	field testU = 17324563846726889236817837922625232543153115346355010501047597319863650987830
@@ -14,7 +14,7 @@ def testOnCurveTrue() -> (bool):
 	
 	return true
 
-def main() -> ():
+def main():
 
 	assert(testOnCurveTrue())
 	// onCurve throws for false
diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok b/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok
index aa98d2c6..3a719fe0 100644
--- a/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok
+++ b/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok
@@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 
 // Code to create test cases:
 // https://github.com/Zokrates/pycrypto
-def testOrderCheckTrue() -> (bool):
+def testOrderCheckTrue() -> bool:
 	BabyJubJubParams context = context()
 
 	field testU = 17324563846726889236817837922625232543153115346355010501047597319863650987830
@@ -15,7 +15,7 @@ def testOrderCheckTrue() -> (bool):
 
 	return true
 
-def testOrderCheckFalse() -> (bool):
+def testOrderCheckFalse() -> bool:
 	BabyJubJubParams context = context()
 
 	field testU = 4342719913949491028786768530115087822524712248835451589697801404893164183326
@@ -26,7 +26,7 @@ def testOrderCheckFalse() -> (bool):
 
 	return true
 
-def main() -> ():
+def main():
 
 	assert(testOrderCheckFalse())
 	assert(testOrderCheckTrue())
diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok b/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok
index 93c42a55..fd494c90 100644
--- a/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok
+++ b/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok
@@ -4,7 +4,7 @@ import "ecc/edwardsScalarMult" as mul
 
 // Code to create test cases:
 // https://github.com/Zokrates/pycrypto
-def testCyclic() -> (bool):
+def testCyclic() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 
@@ -17,7 +17,7 @@ def testCyclic() -> (bool):
 	
 	return true
 
-def testMul2() -> (bool):
+def testMul2() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 	
@@ -30,7 +30,7 @@ def testMul2() -> (bool):
 
 	return true
 
-def testAssociativity() -> (bool):
+def testAssociativity() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 
@@ -61,7 +61,7 @@ def testAssociativity() -> (bool):
 
 	return true
 
-def testMultiplicative() -> (bool):
+def testMultiplicative() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 
@@ -87,7 +87,7 @@ def testMultiplicative() -> (bool):
 
 	return true
 	
-def main() -> ():
+def main():
 	assert(testMul2())
 	assert(testCyclic())
 	assert(testAssociativity())
diff --git a/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok b/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok
index 11f18dc7..0facb911 100644
--- a/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok
+++ b/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok
@@ -5,7 +5,7 @@ import "ecc/edwardsScalarMult" as multiply
 
 // Code to create test cases:
 // https://github.com/Zokrates/pycrypto
-def testOwnershipTrue() -> (bool):
+def testOwnershipTrue() -> bool:
 	BabyJubJubParams context = context()
 	field[2] G = [context.Gu, context.Gv]
 
@@ -17,7 +17,7 @@ def testOwnershipTrue() -> (bool):
 	assert(out)
 	return true
 
-def testtOwnershipFalse() -> (bool):
+def testtOwnershipFalse() -> bool:
 	BabyJubJubParams context = context()
 
 	field[2] Pk = [16328093915569409528980874702678312730273137210288183490878184636452430630129, 9377227749598842756429258362864743065769435972445705966557343775367597326529]
@@ -27,7 +27,7 @@ def testtOwnershipFalse() -> (bool):
 	assert(!out)
 	return true
 
-def main() -> ():
+def main():
 
 	assert(testOwnershipTrue())
 	assert(testtOwnershipFalse())
diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok
index c1f686b8..aa935a7f 100644
--- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok
+++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok
@@ -1,6 +1,6 @@
 import "hashes/mimc7/mimc7R10"
 
-def main() -> ():
+def main():
 	assert(mimc7R10(0, 0) == 6004544488495356385698286530147974336054653445122716140990101827963729149289)
 	assert(mimc7R10(100, 0) == 2977550761518141183167168643824354554080911485709001361112529600968315693145)
 	assert(mimc7R10(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 2977550761518141183167168643824354554080911485709001361112529600968315693145)
diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok
index 9e2047d1..b72fe66c 100644
--- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok
+++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok
@@ -1,6 +1,6 @@
 import "hashes/mimc7/mimc7R20"
 
-def main() -> ():
+def main():
 	assert(mimc7R20(0, 0) == 19139739902058628561064841933381604453445216873412991992755775746150759284829)
 	assert(mimc7R20(100, 0) == 8623418512398828792274158979964869393034224267928014534933203776818702139758)
 	assert(mimc7R20(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 8623418512398828792274158979964869393034224267928014534933203776818702139758)
diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok
index 6c25fc3a..500d6a9e 100644
--- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok
+++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok
@@ -1,6 +1,6 @@
 import "hashes/mimc7/mimc7R50"
 
-def main() -> ():
+def main():
 	assert(mimc7R50(0, 0) == 3049953358280347916081509186284461274525472221619157672645224540758481713173)
 	assert(mimc7R50(100, 0) == 18511388995652647480418174218630545482006454713617579894396683237092568946789)
 	assert(mimc7R50(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 18511388995652647480418174218630545482006454713617579894396683237092568946789)
diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok
index 0fcceeb7..4d31337a 100644
--- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok
+++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok
@@ -1,6 +1,6 @@
 import "hashes/mimc7/mimc7R90"
 
-def main() -> ():
+def main():
 	assert(mimc7R90(0, 0) == 20281265111705407344053532742843085357648991805359414661661476832595822221514)
 	assert(mimc7R90(100, 0) == 1010054095264022068840870550831559811104631937745987065544478027572003292636)
 	assert(mimc7R90(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 1010054095264022068840870550831559811104631937745987065544478027572003292636)
diff --git a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.zok b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.zok
index 8987ad05..e0316ea8 100644
--- a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.zok
+++ b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcFeistel.zok
@@ -1,4 +1,4 @@
 import "hashes/mimcSponge/mimcFeistel" as mimcFeistel
 
-def main(field a, field b, field c) -> (field[2]):
+def main(field a, field b, field c) -> field[2]:
 	return mimcFeistel(a, b, c)
\ No newline at end of file
diff --git a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok
index 5785ecee..5ada9cc5 100644
--- a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok
+++ b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok
@@ -1,6 +1,6 @@
 import "hashes/mimcSponge/mimcSponge" as mimcSponge
 
-def main() -> ():
+def main():
 	assert(mimcSponge([1,2], 3) == [20225509322021146255705869525264566735642015554514977326536820959638320229084,13871743498877225461925335509899475799121918157213219438898506786048812913771,21633608428713573518356618235457250173701815120501233429160399974209848779097])
 	assert(mimcSponge([0,0], 0) == [20636625426020718969131298365984859231982649550971729229988535915544421356929,6046202021237334713296073963481784771443313518730771623154467767602059802325,16227963524034219233279650312501310147918176407385833422019760797222680144279])
 	assert(mimcSponge([21888242871839275222246405745257275088548364400416034343698204186575808495617, 0], 0) == [20636625426020718969131298365984859231982649550971729229988535915544421356929,6046202021237334713296073963481784771443313518730771623154467767602059802325,16227963524034219233279650312501310147918176407385833422019760797222680144279])
diff --git a/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok b/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok
index bbc04218..db834287 100644
--- a/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok
+++ b/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok
@@ -14,7 +14,7 @@
 
 import "hashes/pedersen/512bit" as pedersen
 
-def main() -> ():
+def main():
 	
 	u32[16] e = [0x17d2e6d9, 0x5c74e97c, 0x4bf60cc0, 0xc6a6b417, 0xbafc54e9, 0x205c8080, 0x261f4244, 0x9634d6df, 0x8e7f5e06, 0x6a296ecf, 0x1dc1838c, 0x791c8f5a, 0xee9eca33, 0x2100f189, 0xc96b0288, 0xc6b1501f]
 
diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok b/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok
index ab7e2064..cc4de81e 100644
--- a/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok
+++ b/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok
@@ -15,7 +15,7 @@
 // bin(int(digest, 16))
 // # '0b1110111110100100000111001010010010100101110001110110101101001001010111010101010111011111110110111111100100010111010100110010000001000000010010110011110010000000010010001011001110001110101100011000011100111010101001100110001100111010001101100011100010000011'
 import "hashes/sha256/1024bitPadded" as sha256
-def main() -> ():
+def main():
 
 	u32[8] a = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000]
 	u32[8] b = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000]
diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok b/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok
index d68e2e25..5e06ff90 100644
--- a/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok
+++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok
@@ -1,5 +1,5 @@
 import "hashes/sha256/512bit" as sha256
-def main() -> ():
+def main():
 
 u32[8] a = [0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89]
 u32[8] b = [0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917]
diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok
index 80ef3436..51543ddb 100644
--- a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok
+++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok
@@ -16,7 +16,7 @@
 // # 65303172752238645975888084098459749904
 
 import "hashes/sha256/512bitPacked" as sha256packed
-def main() -> ():
+def main():
 
 	field a = 0
 	field b = 0
diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok
index 46ac6f51..af46ae62 100644
--- a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok
+++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok
@@ -13,7 +13,7 @@
 // bin(int(digest, 16))
 // # '0b1100011001001000000111100010001011000101111111110100000101100100101011110110100000001011100011001111101010100101111010001110110100110001001000001110111011111111100010011100010011110011000001111100010010100110111110101010101011100000010110011100111000010000'
 import "hashes/sha256/512bitPadded" as sha256
-def main() -> ():
+def main():
 
 	u32[8] a = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000]
 	u32[8] b = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000005]
diff --git a/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok b/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok
index 56bd6ae5..f75b5ecc 100644
--- a/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok
+++ b/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok
@@ -14,7 +14,7 @@
 
 import "hashes/utils/256bitsDirectionHelper" as direction
 
-def left() -> (bool):
+def left() -> bool:
 
 	u32[8] a = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38]
 	u32[8] b = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557]
@@ -23,7 +23,7 @@ def left() -> (bool):
 	assert(out == [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38, 0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557])
 	return true
 
-def right() -> (bool):
+def right() -> bool:
 
 	u32[8] a = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38]
 	u32[8] b = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557]
@@ -32,7 +32,7 @@ def right() -> (bool):
 	assert(out == [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557, 0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38])
 	return true
 
-def main() -> ():
+def main():
 	
 	assert(left())
 	assert(right())
diff --git a/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok b/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok
index b67471df..fe71adb7 100644
--- a/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok
+++ b/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok
@@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams
 
 // Code to create test case:
 // https://github.com/Zokrates/pycrypto
-def main() -> ():
+def main():
 
 	BabyJubJubParams context = context()
 
diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok
index 76cd4ef3..e77fad15 100644
--- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok
+++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok
@@ -1,6 +1,6 @@
 import "utils/multiplexer/lookup1bit" as lookup
 
-def left() -> (bool):
+def left() -> bool:
 	bool sel = false  //left
 	field[2] t  = [0, 1]
 	
@@ -8,7 +8,7 @@ def left() -> (bool):
 	
 	return true
 	
-def right() -> (bool):
+def right() -> bool:
 	bool sel = true  //right
 	field[2] t = [0, 1]
 	
@@ -16,7 +16,7 @@ def right() -> (bool):
 	
 	return true
 	
-def main() -> ():
+def main():
 
 	assert(left())
 	assert(right())
diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok
index 58185aac..efc6be2a 100644
--- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok
+++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok
@@ -1,6 +1,6 @@
 import "utils/multiplexer/lookup2bit" as lookup
 
-def first() -> (bool):
+def first() -> bool:
 	bool[2] sel = [false, false]
 	field[4] t  = [0, 1, 2, 3]
 	
@@ -8,7 +8,7 @@ def first() -> (bool):
 	
 	return true
 	
-def second() -> (bool):
+def second() -> bool:
 	bool[2] sel = [true, false]
 	field[4] t  = [0, 1, 2, 3]
 	
@@ -16,7 +16,7 @@ def second() -> (bool):
 	
 	return true
 	
-def third() -> (bool):
+def third() -> bool:
 	bool[2] sel = [false, true]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -24,7 +24,7 @@ def third() -> (bool):
 	
 	return true
 
-def fourth() -> (bool):
+def fourth() -> bool:
 	bool[2] sel = [true, true]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -32,7 +32,7 @@ def fourth() -> (bool):
 	
 	return true
 	
-def main() -> ():
+def main():
 
 	assert(first())
 	assert(second())
diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok
index f42c52bd..bfbd18a7 100644
--- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok
+++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok
@@ -1,6 +1,6 @@
 import "utils/multiplexer/lookup3bitSigned" as lookup
 
-def first() -> (bool):
+def first() -> bool:
 	bool[3] sel = [false,false,false]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -8,7 +8,7 @@ def first() -> (bool):
 	
 	return true
 
-def firstNeg() -> (bool):
+def firstNeg() -> bool:
 	bool[3] sel = [false,false,true]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -16,7 +16,7 @@ def firstNeg() -> (bool):
 	
 	return true
 
-def second() -> (bool):
+def second() -> bool:
 	bool[3] sel = [true,false,false]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -24,7 +24,7 @@ def second() -> (bool):
 	
 	return true
 
-def secondNeg() -> (bool):
+def secondNeg() -> bool:
 	bool[3] sel = [true,false,true]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -33,7 +33,7 @@ def secondNeg() -> (bool):
 	
 	return true
 
-def thrid() -> (bool):
+def thrid() -> bool:
 	bool[3] sel = [false,true,false]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -41,7 +41,7 @@ def thrid() -> (bool):
 	
 	return true
 
-def thridNeg() -> (bool):
+def thridNeg() -> bool:
 	bool[3] sel = [false,true,true]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -50,7 +50,7 @@ def thridNeg() -> (bool):
 	
 	return true
 
-def fourth() -> (bool):
+def fourth() -> bool:
 	bool[3] sel = [true,true,false]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -58,7 +58,7 @@ def fourth() -> (bool):
 	
 	return true
 
-def fourthNeg() -> (bool):
+def fourthNeg() -> bool:
 	bool[3] sel = [true,true,true]
 	field[4] t  = [0, 1, 2 , 3]
 	
@@ -67,7 +67,7 @@ def fourthNeg() -> (bool):
 	
 	return true
 	
-def main() -> ():
+def main():
 
 	assert(first())
 	assert(firstNeg())
diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok b/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok
index c42b3c54..5a39629e 100644
--- a/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok
+++ b/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok
@@ -1,6 +1,6 @@
 import "utils/pack/bool/nonStrictUnpack256" as unpack256
 
-def testFive() -> (bool):
+def testFive() -> bool:
 
 	bool[256] b = unpack256(5)
 
@@ -8,7 +8,7 @@ def testFive() -> (bool):
 
 	return true
 
-def testZero() -> (bool):
+def testZero() -> bool:
 
 	bool[256] b = unpack256(0)
 
@@ -16,7 +16,7 @@ def testZero() -> (bool):
 
 	return true
 
-def testLarge() -> (bool):
+def testLarge() -> bool:
 
 	bool[256] b = unpack256(14474011154664524427946373126085988481658748083205070504932198000989141204991)
 
@@ -24,7 +24,7 @@ def testLarge() -> (bool):
 
 	return true
 
-def testMax() -> (bool):
+def testMax() -> bool:
 
 	bool[256] b = unpack256(21888242871839275222246405745257275088548364400416034343698204186575808495616)
 
@@ -32,7 +32,7 @@ def testMax() -> (bool):
 
 	return true
 
- def main() -> ():
+ def main():
 
 	assert(testFive())
 	assert(testMax())
diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok b/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok
index 6a1cec82..09641c33 100644
--- a/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok
+++ b/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok
@@ -1,6 +1,6 @@
 import "utils/pack/bool/pack128" as pack128
 
-def testFive() -> (bool):
+def testFive() -> bool:
 
 	bool[128] b = [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true]
 	field n = pack128(b)
@@ -9,7 +9,7 @@ def testFive() -> (bool):
 
 	return true
 
-def testZero() -> (bool):
+def testZero() -> bool:
 
 	bool[128] b = [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
 	field n = pack128(b)
@@ -18,7 +18,7 @@ def testZero() -> (bool):
 
 	return true
 
-def testMax() -> (bool):
+def testMax() -> bool:
 
 	bool[128] b = [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]
 	field n = pack128(b)
@@ -27,7 +27,7 @@ def testMax() -> (bool):
 
 	return true
 
- def main() -> ():
+ def main():
 
 	assert(testFive())
 	assert(testMax())
diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok b/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok
index bb3097a0..8ec98853 100644
--- a/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok
+++ b/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok
@@ -1,6 +1,6 @@
 import "utils/pack/bool/unpack128" as unpack128
 
-def testFive() -> (bool):
+def testFive() -> bool:
 
 	bool[128] b = unpack128(5)
 
@@ -8,7 +8,7 @@ def testFive() -> (bool):
 
 	return true
 
-def testZero() -> (bool):
+def testZero() -> bool:
 
 	bool[128] b = unpack128(0)
 
@@ -16,7 +16,7 @@ def testZero() -> (bool):
 
 	return true
 
-def testMax() -> (bool):
+def testMax() -> bool:
 
 	bool[128] b = unpack128(340282366920938463463374607431768211455)
 
@@ -24,7 +24,7 @@ def testMax() -> (bool):
 
 	return true
 
- def main() -> ():
+ def main():
 
 	assert(testFive())
 	assert(testMax())
diff --git a/zokrates_stdlib/tests/tests/utils/pack/u32/nonStrictUnpack256.zok b/zokrates_stdlib/tests/tests/utils/pack/u32/nonStrictUnpack256.zok
index 04527ff4..7f4654d5 100644
--- a/zokrates_stdlib/tests/tests/utils/pack/u32/nonStrictUnpack256.zok
+++ b/zokrates_stdlib/tests/tests/utils/pack/u32/nonStrictUnpack256.zok
@@ -1,6 +1,6 @@
 import "utils/pack/u32/nonStrictUnpack256" as unpack256
 
-def testFive() -> (bool):
+def testFive() -> bool:
 
 	u32[8] b = unpack256(5)
 
@@ -8,7 +8,7 @@ def testFive() -> (bool):
 
 	return true
 
-def testZero() -> (bool):
+def testZero() -> bool:
 
 	u32[8] b = unpack256(0)
 
@@ -16,7 +16,7 @@ def testZero() -> (bool):
 
 	return true
 
-def testLarge() -> (bool):
+def testLarge() -> bool:
 
 	u32[8] b = unpack256(14474011154664524427946373126085988481658748083205070504932198000989141204991)
 
@@ -24,7 +24,7 @@ def testLarge() -> (bool):
 
 	return true
 
-def testMax() -> (bool):
+def testMax() -> bool:
 
 	u32[8] b = unpack256(21888242871839275222246405745257275088548364400416034343698204186575808495616)
 
@@ -32,7 +32,7 @@ def testMax() -> (bool):
 
 	return true
 
- def main() -> ():
+ def main():
 
 	assert(testFive())
 	assert(testMax())
diff --git a/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.zok b/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.zok
index bfca790a..61ba7919 100644
--- a/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.zok
+++ b/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.zok
@@ -1,6 +1,6 @@
 import "utils/pack/u32/pack128" as pack128
 
-def testFive() -> (bool):
+def testFive() -> bool:
 
 	u32[4] b = [0x00000000, 0x00000000, 0x00000000, 0x00000005]
 	field n = pack128(b)
@@ -9,7 +9,7 @@ def testFive() -> (bool):
 
 	return true
 
-def testZero() -> (bool):
+def testZero() -> bool:
 
 	u32[4] b = [0x00000000, 0x00000000, 0x00000000, 0x00000000]
 	field n = pack128(b)
@@ -18,7 +18,7 @@ def testZero() -> (bool):
 
 	return true
 
-def testMax() -> (bool):
+def testMax() -> bool:
 
 	u32[4] b = [0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]
 	field n = pack128(b)
@@ -27,7 +27,7 @@ def testMax() -> (bool):
 
 	return true
 
- def main() -> ():
+ def main():
 
 	assert(testFive())
 	assert(testMax())
diff --git a/zokrates_stdlib/tests/tests/utils/pack/u32/unpack128.zok b/zokrates_stdlib/tests/tests/utils/pack/u32/unpack128.zok
index cec01e30..3657b033 100644
--- a/zokrates_stdlib/tests/tests/utils/pack/u32/unpack128.zok
+++ b/zokrates_stdlib/tests/tests/utils/pack/u32/unpack128.zok
@@ -1,6 +1,6 @@
 import "utils/pack/u32/unpack128" as unpack128
 
-def testFive() -> (bool):
+def testFive() -> bool:
 
 	u32[4] b = unpack128(5)
 
@@ -8,7 +8,7 @@ def testFive() -> (bool):
 
 	return true
 
-def testZero() -> (bool):
+def testZero() -> bool:
 
 	u32[4] b = unpack128(0)
 
@@ -16,7 +16,7 @@ def testZero() -> (bool):
 
 	return true
 
-def testMax() -> (bool):
+def testMax() -> bool:
 
 	u32[4] b = unpack128(2**128 - 1)
 
@@ -24,7 +24,7 @@ def testMax() -> (bool):
 
 	return true
 
- def main() -> ():
+ def main():
 
 	assert(testFive())
 	assert(testMax())