port most examples to new syntax

zokrates_cli/examples/add.code

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

zokrates_cli/examples/argument_reassign.code

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

zokrates_cli/examples/brackets.code

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

zokrates_cli/examples/comments.code

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

zokrates_cli/examples/conditions.code

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

zokrates_cli/examples/flatten.code

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

zokrates_cli/examples/for.code

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

zokrates_cli/examples/functions/expressions.code

@@ -1,10 +1,10 @@
-def add(a,b):
-  v = a + b
+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(a,b):
-   c = add(a*2+3*b-a,b-1)
-   d = add(a*b+2, a*b*c)
-   e = add(add(a,d),add(a,b))
+   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))
   return e

zokrates_cli/examples/functions/functions.code

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

zokrates_cli/examples/functions/lt_comparison

@@ -1,11 +1,11 @@
-def lt(a,b):
+def lt(field a,field b) -> (field):
     return if a < b then 1 else 0 fi
 
-def cutoff():
+def cutoff() -> (field):
     return 31337
 
-def getThing(index):
-    result = 3
+def getThing(index) -> (field):
+    field result = 3
     result = if index == 0 then 13 else result fi
     result = if index == 1 then 23 else result fi
     result = if index == 2 then 43 else result fi
@@ -14,10 +14,10 @@ def getThing(index):
     result = if index == 5 then 83 else result fi
     return result
 
-def cubeThing(thing):
+def cubeThing(field thing) -> (field):
     return thing**3
 
-def main(index):
-    thing = getThing(index)
+def main(field index) -> (field):
+    field thing = getThing(index)
     thing = cubeThing(thing)
     return lt(cutoff(), thing)

zokrates_cli/examples/functions/multi_functions.code

@@ -1,13 +1,13 @@
-def add(a,b):
-  v = a + b
+def add(field a, field b) -> (field):
+  field v = a + b
   return v + a
 
-def main(a,b,c,d):
-  g = a + b
-  x = add(a,b)
-  y = add(c,d)
+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)
+  field g = add(x, g)
   g = add(x, g)
-  g = add(x, g)
-  f = c + d + a
-  g = add(g+a, add(x,b))
+  field f = c + d + a
+  field g = add(g+a, add(x,b))
   return x + y + g + f

zokrates_cli/examples/functions/multi_shadowing.code

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

zokrates_cli/examples/functions/no_args_multiple.code

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

zokrates_cli/examples/functions/shadowing.code

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

zokrates_cli/examples/functions_equivalent.code

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

zokrates_cli/examples/if_eq.code

@@ -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(x):
-  y = if x + 2 == 3 then 1 else 5 fi
-  z = if y == x then x**3 else y**3 fi
+def main(field x) -> (field):
+  field y = if x + 2 == 3 then 1 else 5 fi
+  field z = if y == x then x**3 else y**3 fi
   return x + y + z

zokrates_cli/examples/imports/bar.code

@@ -1,2 +1,2 @@
-def main():
+def main() -> (field):
 	return 21

zokrates_cli/examples/imports/baz.code

@@ -1,2 +1,2 @@
-def main():
+def main() -> (field):
 	return 123

zokrates_cli/examples/imports/foo.code

@@ -1,4 +1,4 @@
 import "./baz.code"
 
-def main():
+def main() -> (field):
 	return baz()

zokrates_cli/examples/imports/import.code

@@ -1,5 +1,5 @@
 import "./foo.code"
 import "./bar.code"
 
-def main():
+def main() -> (field):
 	return foo() + bar()

zokrates_cli/examples/imports/import_with_alias.code

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

zokrates_cli/examples/left_side_call.code

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

zokrates_cli/examples/multi_return.code

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

zokrates_cli/examples/multi_return_sum.code

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

zokrates_cli/examples/multiple_witnesses.code

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

zokrates_cli/examples/n_choose_k.code

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

zokrates_cli/examples/no_flatten.code

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

zokrates_cli/examples/reassignment.code

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

zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.code

@@ -1,8 +1,8 @@
 // we can compare numbers up to 2^(pbits - 2) - 1, ie any number which fits in (pbits - 2) bits
 // lt should not work for the maxvalue = 2^(pbits - 2) - 1 augmented by one
 
-def main(a):
-  pbits = 254
+def main(field a) -> (field):
+  field pbits = 254
   // maxvalue = 2**252 - 1
-  maxvalue = 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1
+  field maxvalue = 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1
   return if 0 < (maxvalue + 1) then 1 else 0 fi

zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.code

@@ -1,5 +1,5 @@
 // as p - 1 is greater than p/2, comparing to it should fail
 
-def main(a):
-  p = 21888242871839275222246405745257275088548364400416034343698204186575808495617
+def main(field a) -> (field):
+  field p = 21888242871839275222246405745257275088548364400416034343698204186575808495617
   return if 0 < p - 1 then 1 else 0 fi

zokrates_cli/examples/sha256/binary/and.code

@@ -1,3 +1,3 @@
 // AND
-def main(x, y):
+def main(field x, field y) -> (field):
 	return x * y

zokrates_cli/examples/sha256/binary/andxorandxorand.code

@@ -3,5 +3,5 @@
 import "./xor.code" as XOR
 import "./and.code" as AND
 
-def main(a, b, c):
+def main(field a, field b, field c) -> (field):
 	return XOR(XOR(AND(a, b), AND(a, c)), AND(b, c))

zokrates_cli/examples/sha256/binary/andxornotand.code

@@ -4,5 +4,5 @@ import "./and.code" as AND
 import "./xor.code" as XOR
 import "./not.code" as NOT
 
-def main(a, b, c):
+def main(field a, field b, field c) -> (field):
 	return XOR(AND(a, b), AND(NOT(a), c))

zokrates_cli/examples/sha256/binary/fulladd.code

@@ -3,7 +3,7 @@
 import "./halfadd.code" as HALFADD
 import "./or.code" as OR
 
-def main(a, b, car):
+def main(field a, field b, field car) -> (field):
 	out1, car1 = HALFADD(a, b)
 	out2, car2 = HALFADD(out1, car)
 	car3 = OR(car1, car2)

zokrates_cli/examples/sha256/binary/halfadd.code

@@ -3,5 +3,5 @@
 import "./xor.code" as XOR
 import "./and.code" as AND
 
-def main(a, b):
+def main(field a, field b):
 	return XOR(a, b), AND(a, b)

zokrates_cli/examples/sha256/binary/not.code

@@ -1,3 +1,3 @@
 // NOT
-def main(x):
+def main(field x) -> (field):
 	return 1 - x

zokrates_cli/examples/sha256/binary/or.code

@@ -3,5 +3,5 @@
 import "./and.code" as AND
 import "./not.code" as NOT
 
-def main(x, y):
+def main(field x, field y) -> (field):
 	return NOT(AND(NOT(x), NOT(y)))

zokrates_cli/examples/sha256/binary/xor.code

@@ -1,4 +1,4 @@
 // XOR
 
-def main(x, y):
+def main(field x, field y) -> (field):
 	return x + y - 2 * x * y

zokrates_cli/examples/sha256/bitwise/32/and.code

@@ -2,5 +2,5 @@
 
 import "./../../binary/and.code" as AND
 
-def main(b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, c31, c30, c29, c28, c27, c26, c25, c24, c23, c22, c21, c20, c19, c18, c17, c16, c15, c14, c13, c12, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0):
+def main(field b31, field b30, field b29, field b28, field b27, field b26, field b25, field b24, field b23, field b22, field b21, field b20, field b19, field b18, field b17, field b16, field b15, field b14, field b13, field b12, field b11, field b10, field b9, field b8, field b7, field b6, field b5, field b4, field b3, field b2, field b1, field b0, field c31, field c30, field c29, field c28, field c27, field c26, field c25, field c24, field c23, field c22, field c21, field c20, field c19, field c18, field c17, field c16, field c15, field c14, field c13, field c12, field c11, field c10, field c9, field c8, field c7, field c6, field c5, field c4, field c3, field c2, field c1, field c0):
 	return AND(b31, c31), AND(b30, c30), AND(b29, c29), AND(b28, c28), AND(b27, c27), AND(b26, c26), AND(b25, c25), AND(b24, c24), AND(b23, c23), AND(b22, c22), AND(b21, c21), AND(b20, c20), AND(b19, c19), AND(b18, c18), AND(b17, c17), AND(b16, c16), AND(b15, c15), AND(b14, c14), AND(b13, c13), AND(b12, c12), AND(b11, c11), AND(b10, c10), AND(b9, c9), AND(b8, c8), AND(b7, c7), AND(b6, c6), AND(b5, c5), AND(b4, c4), AND(b3, c3), AND(b2, c2), AND(b1, c1), AND(b0, c0)

zokrates_cli/examples/sha256/bitwise/32/andxorandxorand.code

@@ -1,6 +1,6 @@
 // ANDXORANDXORAND
 
-import "./../../binary/andxorandxorand.code" as ANDXORANDXORAND
+import "./../../field binary/andxorandxorand.code" as ANDXORANDXORAND
 
-def main(a31, a30, a29, a28, a27, a26, a25, a24, a23, a22, a21, a20, a19, a18, a17, a16, a15, a14, a13, a12, a11, a10, a9, a8, a7, a6, a5, a4, a3, a2, a1, a0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, c31, c30, c29, c28, c27, c26, c25, c24, c23, c22, c21, c20, c19, c18, c17, c16, c15, c14, c13, c12, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0):
-	return ANDXORANDXORAND(a31, b31, c31), ANDXORANDXORAND(a30, b30, c30), ANDXORANDXORAND(a29, b29, c29), ANDXORANDXORAND(a28, b28, c28), ANDXORANDXORAND(a27, b27, c27), ANDXORANDXORAND(a26, b26, c26), ANDXORANDXORAND(a25, b25, c25), ANDXORANDXORAND(a24, b24, c24), ANDXORANDXORAND(a23, b23, c23), ANDXORANDXORAND(a22, b22, c22), ANDXORANDXORAND(a21, b21, c21), ANDXORANDXORAND(a20, b20, c20), ANDXORANDXORAND(a19, b19, c19), ANDXORANDXORAND(a18, b18, c18), ANDXORANDXORAND(a17, b17, c17), ANDXORANDXORAND(a16, b16, c16), ANDXORANDXORAND(a15, b15, c15), ANDXORANDXORAND(a14, b14, c14), ANDXORANDXORAND(a13, b13, c13), ANDXORANDXORAND(a12, b12, c12), ANDXORANDXORAND(a11, b11, c11), ANDXORANDXORAND(a10, b10, c10), ANDXORANDXORAND(a9, b9, c9), ANDXORANDXORAND(a8, b8, c8), ANDXORANDXORAND(a7, b7, c7), ANDXORANDXORAND(a6, b6, c6), ANDXORANDXORAND(a5, b5, c5), ANDXORANDXORAND(a4, b4, c4), ANDXORANDXORAND(a3, b3, c3), ANDXORANDXORAND(a2, b2, c2), ANDXORANDXORAND(a1, b1, c1), ANDXORANDXORAND(a0, b0, c0)
+def main(field a31, field a30, field a29, field a28, field a27, field a26, field a25, field a24, field a23, field a22, field a21, field a20, field a19, field a18, field a17, field a16, field a15, field a14, field a13, field a12, field a11, field a10, field a9, field a8, field a7, field a6, field a5, field a4, field a3, field a2, field a1, field a0, field b31, field b30, field b29, field b28, field b27, field b26, field b25, field b24, field b23, field b22, field b21, field b20, field b19, field b18, field b17, field b16, field b15, field b14, field b13, field b12, field b11, field b10, field b9, field b8, field b7, field b6, field b5, field b4, field b3, field b2, field b1, field b0, field c31, field c30, field c29, field c28, field c27, field c26, field c25, field c24, field c23, field c22, field c21, field c20, field c19, field c18, field c17, field c16, field c15, field c14, field c13, field c12, field c11, field c10, field c9, field c8, field c7, field c6, field c5, field c4, field c3, field c2, field c1, field c0) -> (field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field):
+	return ANDXORANDXORAND(a31, field b31, c31), ANDXORANDXORAND(a30, b30, c30), ANDXORANDXORAND(a29, b29, c29), ANDXORANDXORAND(a28, b28, c28), ANDXORANDXORAND(a27, b27, c27), ANDXORANDXORAND(a26, b26, c26), ANDXORANDXORAND(a25, b25, c25), ANDXORANDXORAND(a24, b24, c24), ANDXORANDXORAND(a23, b23, c23), ANDXORANDXORAND(a22, b22, c22), ANDXORANDXORAND(a21, b21, c21), ANDXORANDXORAND(a20, b20, c20), ANDXORANDXORAND(a19, b19, c19), ANDXORANDXORAND(a18, b18, c18), ANDXORANDXORAND(a17, b17, c17), ANDXORANDXORAND(a16, b16, c16), ANDXORANDXORAND(a15, b15, c15), ANDXORANDXORAND(a14, b14, c14), ANDXORANDXORAND(a13, b13, c13), ANDXORANDXORAND(a12, b12, c12), ANDXORANDXORAND(a11, b11, c11), ANDXORANDXORAND(a10, b10, c10), ANDXORANDXORAND(a9, b9, c9), ANDXORANDXORAND(a8, b8, c8), ANDXORANDXORAND(a7, b7, c7), ANDXORANDXORAND(a6, b6, c6), ANDXORANDXORAND(a5, b5, c5), ANDXORANDXORAND(a4, b4, c4), ANDXORANDXORAND(a3, b3, c3), ANDXORANDXORAND(a2, b2, c2), ANDXORANDXORAND(a1, b1, c1), ANDXORANDXORAND(a0, b0, c0)

zokrates_cli/examples/sha256/bitwise/32/andxornotand.code

@@ -2,5 +2,5 @@
 
 import "./../../binary/andxornotand.code" as ANDXORNOTAND
 
-def main(a31, a30, a29, a28, a27, a26, a25, a24, a23, a22, a21, a20, a19, a18, a17, a16, a15, a14, a13, a12, a11, a10, a9, a8, a7, a6, a5, a4, a3, a2, a1, a0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, c31, c30, c29, c28, c27, c26, c25, c24, c23, c22, c21, c20, c19, c18, c17, c16, c15, c14, c13, c12, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0):
+def main(field a31, field a30, field a29, field a28, field a27, field a26, field a25, field a24, field a23, field a22, field a21, field a20, field a19, field a18, field a17, field a16, field a15, field a14, field a13, field a12, field a11, field a10, field a9, field a8, field a7, field a6, field a5, field a4, field a3, field a2, field a1, field a0, field b31, field b30, field b29, field b28, field b27, field b26, field b25, field b24, field b23, field b22, field b21, field b20, field b19, field b18, field b17, field b16, field b15, field b14, field b13, field b12, field b11, field b10, field b9, field b8, field b7, field b6, field b5, field b4, field b3, field b2, field b1, field b0, field c31, field c30, field c29, field c28, field c27, field c26, field c25, field c24, field c23, field c22, field c21, field c20, field c19, field c18, field c17, field c16, field c15, field c14, field c13, field c12, field c11, field c10, field c9, field c8, field c7, field c6, field c5, field c4, field c3, field c2, field c1, field c0) -> (field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field):
 	return ANDXORNOTAND(a31, b31, c31), ANDXORNOTAND(a30, b30, c30), ANDXORNOTAND(a29, b29, c29), ANDXORNOTAND(a28, b28, c28), ANDXORNOTAND(a27, b27, c27), ANDXORNOTAND(a26, b26, c26), ANDXORNOTAND(a25, b25, c25), ANDXORNOTAND(a24, b24, c24), ANDXORNOTAND(a23, b23, c23), ANDXORNOTAND(a22, b22, c22), ANDXORNOTAND(a21, b21, c21), ANDXORNOTAND(a20, b20, c20), ANDXORNOTAND(a19, b19, c19), ANDXORNOTAND(a18, b18, c18), ANDXORNOTAND(a17, b17, c17), ANDXORNOTAND(a16, b16, c16), ANDXORNOTAND(a15, b15, c15), ANDXORNOTAND(a14, b14, c14), ANDXORNOTAND(a13, b13, c13), ANDXORNOTAND(a12, b12, c12), ANDXORNOTAND(a11, b11, c11), ANDXORNOTAND(a10, b10, c10), ANDXORNOTAND(a9, b9, c9), ANDXORNOTAND(a8, b8, c8), ANDXORNOTAND(a7, b7, c7), ANDXORNOTAND(a6, b6, c6), ANDXORNOTAND(a5, b5, c5), ANDXORNOTAND(a4, b4, c4), ANDXORNOTAND(a3, b3, c3), ANDXORNOTAND(a2, b2, c2), ANDXORNOTAND(a1, b1, c1), ANDXORNOTAND(a0, b0, c0)

zokrates_cli/examples/sha256/bitwise/32/copy.code

@@ -1,4 +1,4 @@
 // COPY
 
-def main(b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0):
+def main(field b31, field b30, field b29, field b28, field b27, field b26, field b25, field b24, field b23, field b22, field b21, field b20, field b19, field b18, field b17, field b16, field b15, field b14, field b13, field b12, field b11, field b10, field b9, field b8, field b7, field b6, field b5, field b4, field b3, field b2, field b1, field b0) -> (field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field):
 	return b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0

zokrates_cli/examples/sha256/bitwise/32/not.code

@@ -2,5 +2,5 @@
 
 import "./../../binary/not.code" as NOT
 
-def main(b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0):
+def main(field b31, field b30, field b29, field b28, field b27, field b26, field b25, field b24, field b23, field b22, field b21, field b20, field b19, field b18, field b17, field b16, field b15, field b14, field b13, field b12, field b11, field b10, field b9, field b8, field b7, field b6, field b5, field b4, field b3, field b2, field b1, field b0) -> (field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field, field):
 	return NOT(b31), NOT(b30), NOT(b29), NOT(b28), NOT(b27), NOT(b26), NOT(b25), NOT(b24), NOT(b23), NOT(b22), NOT(b21), NOT(b20), NOT(b19), NOT(b18), NOT(b17), NOT(b16), NOT(b15), NOT(b14), NOT(b13), NOT(b12), NOT(b11), NOT(b10), NOT(b9), NOT(b8), NOT(b7), NOT(b6), NOT(b5), NOT(b4), NOT(b3), NOT(b2), NOT(b1), NOT(b0)

zokrates_cli/examples/sha256/bitwise/32/xor.code

@@ -2,5 +2,5 @@
 
 import "./../../binary/xor.code" as XOR
 
-def main(b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, c31, c30, c29, c28, c27, c26, c25, c24, c23, c22, c21, c20, c19, c18, c17, c16, c15, c14, c13, c12, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0):
+def main(field b31, field b30, field b29, field b28, field b27, field b26, field b25, field b24, field b23, field b22, field b21, field b20, field b19, field b18, field b17, field b16, field b15, field b14, field b13, field b12, field b11, field b10, field b9, field b8, field b7, field b6, field b5, field b4, field b3, field b2, field b1, field b0, field c31, field c30, field c29, field c28, field c27, field c26, field c25, field c24, field c23, field c22, field c21, field c20, field c19, field c18, field c17, field c16, field c15, field c14, field c13, field c12, field c11, field c10, field c9, field c8, field c7, field c6, field c5, field c4, field c3, field c2, field c1, field c0):
 	return XOR(b31, c31), XOR(b30, c30), XOR(b29, c29), XOR(b28, c28), XOR(b27, c27), XOR(b26, c26), XOR(b25, c25), XOR(b24, c24), XOR(b23, c23), XOR(b22, c22), XOR(b21, c21), XOR(b20, c20), XOR(b19, c19), XOR(b18, c18), XOR(b17, c17), XOR(b16, c16), XOR(b15, c15), XOR(b14, c14), XOR(b13, c13), XOR(b12, c12), XOR(b11, c11), XOR(b10, c10), XOR(b9, c9), XOR(b8, c8), XOR(b7, c7), XOR(b6, c6), XOR(b5, c5), XOR(b4, c4), XOR(b3, c3), XOR(b2, c2), XOR(b1, c1), XOR(b0, c0)

zokrates_cli/examples/simple_add.code

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

zokrates_cli/examples/simple_ifelse.code

@@ -1,7 +1,7 @@
 // simple ifelse example
 // x = 2 -> 2 + 1 + 2**3 = 11
 // x = 5 -> 5 + 5 + 5**3 = 135
-def main(x):
-  y = if x < 3 then 1 else 5 fi
-  z = if y < x then x**3 else y**3 fi
+def main(field x) -> (field):
+  field y = if x < 3 then 1 else 5 fi
+  field z = if y < x then x**3 else y**3 fi
   return x + y + z

zokrates_cli/examples/simple_mul.code

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

zokrates_cli/examples/spaces_tabs_comments.code

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

zokrates_cli/examples/sub.code

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

zokrates_cli/examples/sudokuchecker.code

@@ -8,7 +8,7 @@
 // --------------------------
 // | c21 | c22 || d21 | d22 |
 
-def checkEquality(e11,e12,e21,e22):
+def checkEquality(field e11,field e12,field e21,field e22) -> (field):
 counter = if e11 == e12 then 1 else 0 fi
 counter = counter + if e11 == e21 then 1 else 0 fi
 counter = counter + if e11 == e22 then 1 else 0 fi
@@ -18,11 +18,11 @@ counter = counter + if e21 == e22 then 1 else 0 fi
 return counter
 
 // returns 0 for x in (1..4)
-def validateInput(x):
+def validateInput(field x) -> (field):
 return (x-1)*(x-2)*(x-3)*(x-4)
 
 // variables naming: box'row''column'
-def main(a21, b11, b22, c11, c22, d21, private a11, private a12, private a22, private b12, private b21, private c12, private c21, private d11, private d12, private d22):
+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) -> (field):
 
 // validate inputs
 0 == validateInput(a11)
@@ -45,7 +45,7 @@ def main(a21, b11, b22, c11, c22, d21, private a11, private a12, private a22, pr
 0 == validateInput(d21)
 0 == validateInput(d22)
 
-counter = 0 // globally counts duplicate entries in boxes, rows and columns
+field counter = 0 // globally counts duplicate entries in boxes, rows and columns
 
 // check box correctness
 

zokrates_cli/examples/synonyms.code

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

zokrates_cli/examples/test1.code

@@ -1,13 +1,13 @@
 // only using sub, no need to flatten
-def main(x):
-  a = 5
-  b = 7
-  c = if a == b then 4 else 3 fi
+def main(field x) -> (field):
+  field a = 5
+  field b = 7
+  field c = if a == b then 4 else 3 fi
   c == 3
-  d = if a == 5 then 1 else 2 fi
+  field d = if a == 5 then 1 else 2 fi
   d == 1
-  e = if a < b then 5 else 6 fi
+  field e = if a < b then 5 else 6 fi
   e == 5
-  f = if b < a then 7 else 8 fi
+  field f = if b < a then 7 else 8 fi
   f == 8
   return x

zokrates_cli/examples/test_lt_max_value.code

@@ -1,8 +1,8 @@
 // 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(a):
-  pbits = 254
+def main(field a) -> (field):
+  field pbits = 254
   // maxvalue = 2**252 - 1
-  maxvalue = 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1
+  field maxvalue = 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1
   return if 0 < maxvalue then 1 else 0 fi

zokrates_cli/examples/waldo.code

@@ -2,12 +2,12 @@
 // 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(a, p, q):
+def isWaldo(field a, field p, field q) -> (field):
   // make sure that p and q are both non zero
   // we can't check inequalities, so let's create binary
   // variables
-  p1 = if p == 1 then 0 else 1 fi // "p != 1"
-  q1 = if q == 1 then 0 else 1 fi // "q != 1"
+  field p1 = if p == 1 then 0 else 1 fi // "p != 1"
+  field q1 = if q == 1 then 0 else 1 fi // "q != 1"
   q1 * p1 == 1 // "p1 and q1"
 
   // we know how to factor a
@@ -16,9 +16,9 @@ def isWaldo(a, p, q):
   return 1
 
 // define all
-def main(a0, a1, a2, a3, private index, private p, private q):
+def main(field a0, field a1, field a2, field a3, private field index, private field p, private field q):
   // prover provides the index of Waldo
-  waldo = if index == 0 then a0 else 0 fi 
+  field waldo = if index == 0 then a0 else 0 fi 
   waldo = waldo + if index == 1 then a1 else 0 fi 
   waldo = waldo + if index == 2 then a2 else 0 fi 
   waldo = waldo + if index == 3 then a3 else 0 fi

zokrates_cli/examples/wavelets.code

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