merge type system changes

zokrates_cli/Cargo.toml

@@ -22,4 +22,4 @@ serde_json = "1.0"
 
 [[bin]]
 name = "zokrates"
-path = "src/bin.rs"
+path = "src/bin.rs"

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,6 +1,6 @@
-def sub(a):
+def sub(field a) -> (field):
   a = a + 3
   return a
 
-def main():
+def main() -> (field):
    return sub(4)

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/callcall.code

@@ -1,10 +0,0 @@
-def bar(a):
-	return a + 42
-
-def foo():
-	a = 3
-	return a + bar(a)
-
-def main():
-	a = foo()
-	return a

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):
+  field b = (a + 5) * 6
   2 * b == a * 12 + 60
-  c = 7 * (b + a)
+  field c = 7 * (b + a)
   c == 7 * b + 7 * a
   return b + c

zokrates_cli/examples/error/duplicate_declaration.code

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

zokrates_cli/examples/error/unassigned.code

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

zokrates_cli/examples/factorization.code

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

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,6 +1,6 @@
-def main(a):
-  x = 7
-  for i in 0..10 do
+def main(field a) -> (field):
+  field x = 7
+  for field i in 0..10 do
     // x = x + a
     x = x + a
   endfor

zokrates_cli/examples/functions/expressions.code

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

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):
+def main(field a, field b) -> (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
+def main(field a, field b,field c, field d) -> (field):
+  field g = a + b
   x = add(a,b)
   y = add(c,d)
   g = add(x, g)
   g = add(x, g)
-  f = c + d + a
+  field f = c + d + a
   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):
+def main(field a, field b) -> (field):
   c = add(a,b)
   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):
+def add(field a,field b) -> (field):
   a=const()
   return a+b
 
-def main(a,b):
-  c = add(a, b+const())
+def main(field a,field 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, field, field):
+	field b = 12*a
 	return a, 2*a, 5*b, a*b
 
-def main(i):
-	x, y, z, t = foo(i)
+def main(field i) -> (field):
+	field x, field y, field z, field 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():
-   a, b = foo()
+def main() -> (field, field):
+   field a, field 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/pow.code

@@ -0,0 +1,16 @@
+def main() -> (field):
+  field x = 2**4
+  x == 16
+  x = x**2
+  x == 256
+  field y = 3**3
+  y == 27
+  field z = y**2
+  z == 729
+  field a = 5**2
+  a == 25
+  a = a**2
+  a == 625
+  a = 5**5
+  a == 3125
+  return 1

zokrates_cli/examples/reassignment.code

@@ -1,7 +1,7 @@
-def main(x):
-  a = x + 5
-  b = a + x
+def main(field x) -> (field):
+  field a = x + 5
+  field b = a + x
   a = 7
-  c = a + b
+  field c = a + b
   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, 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) -> (field, field):
 	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) -> (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 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

@@ -2,5 +2,5 @@
 
 import "./../../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):
+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, 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) -> (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 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/sha256/sha256_complete_tests.code

@@ -1,268 +0,0 @@
-import "./sha256.code" as SHA256COMPRESS
-
-def test000():
-	h255, h254, h253, h252, h251, h250, h249, h248, h247, h246, h245, h244, h243, h242, h241, h240, h239, h238, h237, h236, h235, h234, h233, h232, h231, h230, h229, h228, h227, h226, h225, h224, h223, h222, h221, h220, h219, h218, h217, h216, h215, h214, h213, h212, h211, h210, h209, h208, h207, h206, h205, h204, h203, h202, h201, h200, h199, h198, h197, h196, h195, h194, h193, h192, h191, h190, h189, h188, h187, h186, h185, h184, h183, h182, h181, h180, h179, h178, h177, h176, h175, h174, h173, h172, h171, h170, h169, h168, h167, h166, h165, h164, h163, h162, h161, h160, h159, h158, h157, h156, h155, h154, h153, h152, h151, h150, h149, h148, h147, h146, h145, h144, h143, h142, h141, h140, h139, h138, h137, h136, h135, h134, h133, h132, h131, h130, h129, h128, h127, h126, h125, h124, h123, h122, h121, h120, h119, h118, h117, h116, h115, h114, h113, h112, h111, h110, h109, h108, h107, h106, h105, h104, h103, h102, h101, h100, h99, h98, h97, h96, h95, h94, h93, h92, h91, h90, h89, h88, h87, h86, h85, h84, h83, h82, h81, h80, h79, h78, h77, h76, h75, h74, h73, h72, h71, h70, h69, h68, h67, h66, h65, h64, h63, h62, h61, h60, h59, h58, h57, h56, h55, h54, h53, h52, h51, h50, h49, h48, h47, h46, h45, h44, h43, h42, h41, h40, h39, h38, h37, h36, h35, h34, h33, h32, h31, h30, h29, h28, h27, h26, h25, h24, h23, h22, h21, h20, h19, h18, h17, h16, h15, h14, h13, h12, h11, h10, h9, h8, h7, h6, h5, h4, h3, h2, h1, h0 = SHA256COMPRESS(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
-
-h255 == 1
-h254 == 1
-h253 == 1
-h252 == 1
-h251 == 1
-h250 == 1
-h249 == 1
-h248 == 1
-h247 == 1
-h246 == 1
-h245 == 1
-h244 == 1
-h243 == 1
-h242 == 1
-h241 == 1
-h240 == 1
-h239 == 1
-h238 == 1
-h237 == 1
-h236 == 1
-h235 == 1
-h234 == 1
-h233 == 1
-h232 == 1
-h231 == 1
-h230 == 1
-h229 == 1
-h228 == 1
-h227 == 1
-h226 == 1
-h225 == 1
-h224 == 1
-h223 == 1
-h222 == 1
-h221 == 1
-h220 == 1
-h219 == 1
-h218 == 1
-h217 == 1
-h216 == 1
-h215 == 1
-h214 == 1
-h213 == 1
-h212 == 1
-h211 == 1
-h210 == 1
-h209 == 1
-h208 == 1
-h207 == 1
-h206 == 1
-h205 == 1
-h204 == 1
-h203 == 1
-h202 == 1
-h201 == 1
-h200 == 1
-h199 == 1
-h198 == 1
-h197 == 1
-h196 == 1
-h195 == 1
-h194 == 1
-h193 == 1
-h192 == 1
-h191 == 1
-h190 == 1
-h189 == 1
-h188 == 1
-h187 == 1
-h186 == 1
-h185 == 1
-h184 == 1
-h183 == 1
-h182 == 1
-h181 == 1
-h180 == 1
-h179 == 1
-h178 == 1
-h177 == 1
-h176 == 1
-h175 == 1
-h174 == 1
-h173 == 1
-h172 == 1
-h171 == 1
-h170 == 1
-h169 == 1
-h168 == 1
-h167 == 1
-h166 == 1
-h165 == 1
-h164 == 1
-h163 == 1
-h162 == 1
-h161 == 1
-h160 == 1
-h159 == 1
-h158 == 1
-h157 == 1
-h156 == 1
-h155 == 1
-h154 == 1
-h153 == 1
-h152 == 1
-h151 == 1
-h150 == 1
-h149 == 1
-h148 == 1
-h147 == 1
-h146 == 1
-h145 == 1
-h144 == 1
-h143 == 1
-h142 == 1
-h141 == 1
-h140 == 1
-h139 == 1
-h138 == 1
-h137 == 1
-h136 == 1
-h135 == 1
-h134 == 1
-h133 == 1
-h132 == 1
-h131 == 1
-h130 == 1
-h129 == 1
-h128 == 1
-h127 == 1
-h126 == 1
-h125 == 1
-h124 == 1
-h123 == 1
-h122 == 1
-h121 == 1
-h120 == 1
-h119 == 1
-h118 == 1
-h117 == 1
-h116 == 1
-h115 == 1
-h114 == 1
-h113 == 1
-h112 == 1
-h111 == 1
-h110 == 1
-h109 == 1
-h108 == 1
-h107 == 1
-h106 == 1
-h105 == 1
-h104 == 1
-h103 == 1
-h102 == 1
-h101 == 1
-h100 == 1
-h99 == 1
-h98 == 1
-h97 == 1
-h96 == 1
-h95 == 1
-h94 == 1
-h93 == 1
-h92 == 1
-h91 == 1
-h90 == 1
-h89 == 1
-h88 == 1
-h87 == 1
-h86 == 1
-h85 == 1
-h84 == 1
-h83 == 1
-h82 == 1
-h81 == 1
-h80 == 1
-h79 == 1
-h78 == 1
-h77 == 1
-h76 == 1
-h75 == 1
-h74 == 1
-h73 == 1
-h72 == 1
-h71 == 1
-h70 == 1
-h69 == 1
-h68 == 1
-h67 == 1
-h66 == 1
-h65 == 1
-h64 == 1
-h63 == 1
-h62 == 1
-h61 == 1
-h60 == 1
-h59 == 1
-h58 == 1
-h57 == 1
-h56 == 1
-h55 == 1
-h54 == 1
-h53 == 1
-h52 == 1
-h51 == 1
-h50 == 1
-h49 == 1
-h48 == 1
-h47 == 1
-h46 == 1
-h45 == 1
-h44 == 1
-h43 == 1
-h42 == 1
-h41 == 1
-h40 == 1
-h39 == 1
-h38 == 1
-h37 == 1
-h36 == 1
-h35 == 1
-h34 == 1
-h33 == 1
-h32 == 1
-h31 == 1
-h30 == 1
-h29 == 1
-h28 == 1
-h27 == 1
-h26 == 1
-h25 == 1
-h24 == 1
-h23 == 1
-h22 == 1
-h21 == 1
-h20 == 1
-h19 == 1
-h18 == 1
-h17 == 1
-h16 == 1
-h15 == 1
-h14 == 1
-h13 == 1
-h12 == 1
-h11 == 1
-h10 == 1
-h9 == 1
-h8 == 1
-h7 == 1
-h6 == 1
-h5 == 1
-h4 == 1
-h3 == 1
-h2 == 1
-h1 == 1
-h0 == 1
-return 1
-
-
-
-def main():
-	r = test000()
-	return 1

zokrates_cli/examples/sha256/sha256tests.code

@@ -15,21 +15,21 @@ import "./bitwise/32/andxorandxorand.code" as ANDXORANDXORAND
 import "./bitwise/32/copy.code" as COPY
 import "./utils/32/extend.code" as EXTEND
 
-def ANDtest():
+def ANDtest() -> (field):
 	1 == AND(1, 1)
  	0 == AND(1, 0)
  	0 == AND(0, 1)
  	0 == AND(0, 0)
  	return 1
 
-def ORtest():
+def ORtest() -> (field):
  	1 == OR(1, 0)
  	1 == OR(0, 1)
  	0 == OR(0, 0)
  	1 == OR(1, 1)
  	return 1
 
-def XORtest():
+def XORtest() -> (field):
  	1 == XOR(1, 0)
  	0 == XOR(0, 0)
  	1 == XOR(0, 1)
@@ -37,7 +37,7 @@ def XORtest():
  	return 1
 
 
-def NOTtest():
+def NOTtest() -> (field):
  	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 = NOT(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
  	b18 == 1
  	b17 == 1
@@ -47,7 +47,7 @@ def NOTtest():
  	b13 == 1
  	return 1
 
-def FULLADDtest():
+def FULLADDtest() -> (field):
 	a, b = FULLADD(0,0,0)
  	a == 0
  	b == 0
@@ -73,7 +73,7 @@ def FULLADDtest():
  	a == 1
  	b == 1
  	return 1
-def AR6XORAR11XORAR25test():
+def AR6XORAR11XORAR25test() -> (field):
 	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 = AR6XAR11XAR25(0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1)
 	b31 == 1
 	b30 == 1
@@ -109,7 +109,7 @@ def AR6XORAR11XORAR25test():
 	b0 == 1
 	return 1
 
-def AR2XORAR13XORAR22test():
+def AR2XORAR13XORAR22test() -> (field):
 	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 = AR2XAR13XAR22(0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1)
 	b31 == 0
 	b30 == 0
@@ -145,7 +145,7 @@ def AR2XORAR13XORAR22test():
 	b0 == 1
 	return 1
 
-def AR7XORAR18XORAR3test():
+def AR7XORAR18XORAR3test() -> (field):
 	// s0 of last digest message of empty message
 	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 = AR7XAR18XAR3(1,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,0,0,1,1,0,0,1,0,1)
 	b31 == 0
@@ -182,7 +182,7 @@ def AR7XORAR18XORAR3test():
 	b0 == 1
 	return 1
 
-def AR17XORAR19XORAR10test():
+def AR17XORAR19XORAR10test() -> (field):
  	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 = AR17XAR19XAR10(1,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0)
  	b31 == 0
 	b30 == 1
@@ -221,7 +221,7 @@ def AR17XORAR19XORAR10test():
 // 00000101000010001001010101000010 -> 01011000000010000000000000000000 DOESN'T PASS
 // 00100010000000000000100000000000 -> 00000101000010001001010101000010 PASSES
 
-def AR17XORAR19XORAR10testnull():
+def AR17XORAR19XORAR10testnull() -> (field):
  	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 = AR17XAR19XAR10(0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0)
  	b31 == 0
 	b30 == 1
@@ -257,7 +257,7 @@ def AR17XORAR19XORAR10testnull():
 	b0 == 0
 	return 1
 
-def ADDtest():
+def ADDtest() -> (field):
 	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 = ADD(0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1)
 	b31 == 1
 	b30 == 0
@@ -293,7 +293,7 @@ def ADDtest():
 	b0 == 0
 	return 1
 
-def COPYtest():
+def COPYtest() -> (field):
 	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 = COPY(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0)
  	b18 == 0
  	b17 == 0
@@ -303,7 +303,7 @@ def COPYtest():
  	b13 == 1
  	return 1
 
-def ANDXORANDXORANDtest():
+def ANDXORANDXORANDtest() -> (field):
 	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 = ANDXORANDXORAND(0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,0,0,1)
 	b31 == 0
 	b30 == 1
@@ -339,7 +339,7 @@ def ANDXORANDXORANDtest():
 	b0 == 1
 	return 1
 
-def ANDXORNOTANDtest():
+def ANDXORNOTANDtest() -> (field):
 	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 = ANDXORNOTAND(0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,0,0,1)
 	b31 == 0
 	b30 == 1
@@ -375,7 +375,7 @@ def ANDXORNOTANDtest():
 	b0 == 1
 	return 1
 
-def EXTENDtest():
+def EXTENDtest() -> (field):
 	wfb31, wfb30, wfb29, wfb28, wfb27, wfb26, wfb25, wfb24, wfb23, wfb22, wfb21, wfb20, wfb19, wfb18, wfb17, wfb16, wfb15, wfb14, wfb13, wfb12, wfb11, wfb10, wfb9, wfb8, wfb7, wfb6, wfb5, wfb4, wfb3, wfb2, wfb1, wfb0 = EXTEND(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
 	wfb31 == 1
 	wfb30 == 0
@@ -412,19 +412,19 @@ def EXTENDtest():
 	return 1
 
 
-def main():
-	a = ANDtest()
-	b = ORtest()
-	c = XORtest()
-	d = NOTtest()
-	e = FULLADDtest()
-	h = AR6XORAR11XORAR25test()
-	i = AR2XORAR13XORAR22test()
-	j = AR7XORAR18XORAR3test()
-	k = AR17XORAR19XORAR10testnull()
-	l = ADDtest()
-	m = COPYtest()
-	n = ANDXORANDXORANDtest()
-	o = ANDXORNOTANDtest()	
-	p = EXTENDtest()
+def main() -> (field):
+	field a = ANDtest()
+	field b = ORtest()
+	field c = XORtest()
+	field d = NOTtest()
+	field e = FULLADDtest()
+	field h = AR6XORAR11XORAR25test()
+	field i = AR2XORAR13XORAR22test()
+	field j = AR7XORAR18XORAR3test()
+	field k = AR17XORAR19XORAR10testnull()
+	field l = ADDtest()
+	field m = COPYtest()
+	field n = ANDXORANDXORANDtest()
+	field o = ANDXORNOTANDtest()	
+	field p = EXTENDtest()
  	return 1

zokrates_cli/examples/sha256/testest

@@ -1,71 +0,0 @@
-def NOT(x):
-	return 1 - x
-
-def AND(x, y):
-	return x * y
-
-def OR(x, y):
-	return NOT(AND(NOT(x), NOT(y)))
-
-def XOR(x, y):
-	return AND(OR(x, y), NOT(AND(x,y)))
-
-def XOR(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 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)
-
-def RIGHTROTATE10(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):
-	return b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10
-
-def RIGHTROTATE17(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):
-	return b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17
-
-def RIGHTROTATE19(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):
-	return b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19
-
-def AR17XORAR19XORAR10(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):
-	u31, u30, u29, u28, u27, u26, u25, u24, u23, u22, u21, u20, u19, u18, u17, u16, u15, u14, u13, u12, u11, u10, u9, u8, u7, u6, u5, u4, u3, u2, u1, u0 = RIGHTROTATE17(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)
-	v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0 = RIGHTROTATE19(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)
-	w31, w30, w29, w28, w27, w26, w25, w24, w23, w22, w21, w20, w19, w18, w17, w16, w15, w14, w13, w12, w11, w10, w9, w8, w7, w6, w5, w4, w3, w2, w1, w0 = RIGHTROTATE10(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)
-	x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0 = XOR(u31, u30, u29, u28, u27, u26, u25, u24, u23, u22, u21, u20, u19, u18, u17, u16, u15, u14, u13, u12, u11, u10, u9, u8, u7, u6, u5, u4, u3, u2, u1, u0, v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0)
-	z31, z30, z29, z28, z27, z26, z25, z24, z23, z22, z21, z20, z19, z18, z17, z16, z15, z14, z13, z12, z11, z10, z9, z8, z7, z6, z5, z4, z3, z2, z1, z0 = XOR(w31, w30, w29, w28, w27, w26, w25, w24, w23, w22, w21, w20, w19, w18, w17, w16, w15, w14, w13, w12, w11, w10, w9, w8, w7, w6, w5, w4, w3, w2, w1, w0, x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0)
-	return z31, z30, z29, z28, z27, z26, z25, z24, z23, z22, z21, z20, z19, z18, z17, z16, z15, z14, z13, z12, z11, z10, z9, z8, z7, z6, z5, z4, z3, z2, z1, z0
-
-def AR17XORAR19XORAR10test():
- 	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 = AR17XORAR19XORAR10(0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,1)
- 	b31 == 0
-	b30 == 1
-	b29 == 0
-	b28 == 0
-	b27 == 1
-	b26 == 1
-	b25 == 1
-	b24 == 0
-	b23 == 0
-	b22 == 0
-	b21 == 1
-	b20 == 0
-	b19 == 1
-	b18 == 1
-	b17 == 1
-	b16 == 0
-	b15 == 0
-	b14 == 0
-	b13 == 0
-	b12 == 1
-	b11 == 0
-	b10 == 1
-	b9 == 0
-	b8 == 1
-	b7 == 0
-	b6 == 0
-	b5 == 1
-	b4 == 0
-	b3 == 1
-	b2 == 0
-	b1 == 0
-	b0 == 1
-	return 1
-
-def main():
-	k = AR17XORAR19XORAR10test()
- 	return 

zokrates_cli/examples/sha256/utils/32/add.code

@@ -2,7 +2,7 @@
 
 import "./../../binary/fulladd.code" as FULLADD
 
-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) -> (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):
 	d0, car1 = FULLADD(b0, c0, 0)
 	d1, car2 = FULLADD(b1, c1, car1)
 	d2, car3 = FULLADD(b2, c2, car2)

zokrates_cli/examples/sha256/utils/32/ar17xar19xars10.code

@@ -2,16 +2,16 @@
 
 import "./../../bitwise/32/xor.code" as XOR
 
-def RR17(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 RR17(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 b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17
 
-def RR19(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 RR19(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 b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19
 
-def RS10(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 RS10(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 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10
 
-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):
+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, 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):
 	u31, u30, u29, u28, u27, u26, u25, u24, u23, u22, u21, u20, u19, u18, u17, u16, u15, u14, u13, u12, u11, u10, u9, u8, u7, u6, u5, u4, u3, u2, u1, u0 = RR17(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)
 	v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0 = RR19(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)
 	w31, w30, w29, w28, w27, w26, w25, w24, w23, w22, w21, w20, w19, w18, w17, w16, w15, w14, w13, w12, w11, w10, w9, w8, w7, w6, w5, w4, w3, w2, w1, w0 = RS10(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)

zokrates_cli/examples/sha256/utils/32/ar2xar13xar22.code

@@ -2,16 +2,16 @@
 
 import "./../../bitwise/32/xor.code" as XOR
 
-def RR2(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 RR2(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 b1, b0, 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
 
-def RR13(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 RR13(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 b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13
 
-def RR22(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 RR22(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 b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22
 
-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):
+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, 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):
 	u31, u30, u29, u28, u27, u26, u25, u24, u23, u22, u21, u20, u19, u18, u17, u16, u15, u14, u13, u12, u11, u10, u9, u8, u7, u6, u5, u4, u3, u2, u1, u0 = RR2(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)
 	v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0 = RR13(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)
 	w31, w30, w29, w28, w27, w26, w25, w24, w23, w22, w21, w20, w19, w18, w17, w16, w15, w14, w13, w12, w11, w10, w9, w8, w7, w6, w5, w4, w3, w2, w1, w0 = RR22(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)

zokrates_cli/examples/sha256/utils/32/ar6xar11xar25.code

@@ -2,16 +2,16 @@
 
 import "./../../bitwise/32/xor.code" as XOR
 
-def RR6(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 RR6(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 b5, b4, b3, b2, b1, b0, 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
 
-def RR11(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 RR11(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 b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18, b17, b16, b15, b14, b13, b12, b11
 
-def RR25(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 RR25(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 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, b31, b30, b29, b28, b27, b26, b25
 
-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):
+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, 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):
 	u31, u30, u29, u28, u27, u26, u25, u24, u23, u22, u21, u20, u19, u18, u17, u16, u15, u14, u13, u12, u11, u10, u9, u8, u7, u6, u5, u4, u3, u2, u1, u0 = RR6(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)
 	v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0 = RR11(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)
 	w31, w30, w29, w28, w27, w26, w25, w24, w23, w22, w21, w20, w19, w18, w17, w16, w15, w14, w13, w12, w11, w10, w9, w8, w7, w6, w5, w4, w3, w2, w1, w0 = RR25(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)

zokrates_cli/examples/sha256/utils/32/ar7xar18xars3.code

@@ -2,16 +2,16 @@
 
 import "./../../bitwise/32/xor.code" as XOR
 
-def RR7(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 RR7(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 b6, b5, b4, b3, b2, b1, b0, 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
 
-def RR18(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 RR18(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 b17, b16, b15, b14, b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0, b31, b30, b29, b28, b27, b26, b25, b24, b23, b22, b21, b20, b19, b18
 
-def RS3(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 RS3(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 0, 0, 0, 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
 
-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):
+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, 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):
 	u31, u30, u29, u28, u27, u26, u25, u24, u23, u22, u21, u20, u19, u18, u17, u16, u15, u14, u13, u12, u11, u10, u9, u8, u7, u6, u5, u4, u3, u2, u1, u0 = RR7(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)
 	v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0 = RR18(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)
 	w31, w30, w29, w28, w27, w26, w25, w24, w23, w22, w21, w20, w19, w18, w17, w16, w15, w14, w13, w12, w11, w10, w9, w8, w7, w6, w5, w4, w3, w2, w1, w0 = RS3(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)

zokrates_cli/examples/sha256/utils/32/extend.code

@@ -4,13 +4,13 @@ import "./ar7xar18xars3.code" as AR7XAR18XAR3
 import "./ar17xar19xars10.code" as AR17XAR19XAR10
 import "./add.code" as ADD
 
-def ADD(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, d31, d30, d29, d28, d27, d26, d25, d24, d23, d22, d21, d20, d19, d18, d17, d16, d15, d14, d13, d12, d11, d10, d9, d8, d7, d6, d5, d4, d3, d2, d1, d0):
+def ADD(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 d31, field d30, field d29, field d28, field d27, field d26, field d25, field d24, field d23, field d22, field d21, field d20, field d19, field d18, field d17, field d16, field d15, field d14, field d13, field d12, field d11, field d10, field d9, field d8, field d7, field d6, field d5, field d4, field d3, field d2, field d1, field d0) -> (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):
 	ab31, ab30, ab29, ab28, ab27, ab26, ab25, ab24, ab23, ab22, ab21, ab20, ab19, ab18, ab17, ab16, ab15, ab14, ab13, ab12, ab11, ab10, ab9, ab8, ab7, ab6, ab5, ab4, ab3, ab2, ab1, ab0 = ADD(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)
 	cd31, cd30, cd29, cd28, cd27, cd26, cd25, cd24, cd23, cd22, cd21, cd20, cd19, cd18, cd17, cd16, cd15, cd14, cd13, cd12, cd11, cd10, cd9, cd8, cd7, cd6, cd5, cd4, cd3, cd2, cd1, cd0 = ADD(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, d31, d30, d29, d28, d27, d26, d25, d24, d23, d22, d21, d20, d19, d18, d17, d16, d15, d14, d13, d12, d11, d10, d9, d8, d7, d6, d5, d4, d3, d2, d1, d0)
 	abcd31, abcd30, abcd29, abcd28, abcd27, abcd26, abcd25, abcd24, abcd23, abcd22, abcd21, abcd20, abcd19, abcd18, abcd17, abcd16, abcd15, abcd14, abcd13, abcd12, abcd11, abcd10, abcd9, abcd8, abcd7, abcd6, abcd5, abcd4, abcd3, abcd2, abcd1, abcd0 = ADD(ab31, ab30, ab29, ab28, ab27, ab26, ab25, ab24, ab23, ab22, ab21, ab20, ab19, ab18, ab17, ab16, ab15, ab14, ab13, ab12, ab11, ab10, ab9, ab8, ab7, ab6, ab5, ab4, ab3, ab2, ab1, ab0, cd31, cd30, cd29, cd28, cd27, cd26, cd25, cd24, cd23, cd22, cd21, cd20, cd19, cd18, cd17, cd16, cd15, cd14, cd13, cd12, cd11, cd10, cd9, cd8, cd7, cd6, cd5, cd4, cd3, cd2, cd1, cd0)
 	return abcd31, abcd30, abcd29, abcd28, abcd27, abcd26, abcd25, abcd24, abcd23, abcd22, abcd21, abcd20, abcd19, abcd18, abcd17, abcd16, abcd15, abcd14, abcd13, abcd12, abcd11, abcd10, abcd9, abcd8, abcd7, abcd6, abcd5, abcd4, abcd3, abcd2, abcd1, abcd0
 
-def main(wm15b31, wm15b30, wm15b29, wm15b28, wm15b27, wm15b26, wm15b25, wm15b24, wm15b23, wm15b22, wm15b21, wm15b20, wm15b19, wm15b18, wm15b17, wm15b16, wm15b15, wm15b14, wm15b13, wm15b12, wm15b11, wm15b10, wm15b9, wm15b8, wm15b7, wm15b6, wm15b5, wm15b4, wm15b3, wm15b2, wm15b1, wm15b0, wm2b31, wm2b30, wm2b29, wm2b28, wm2b27, wm2b26, wm2b25, wm2b24, wm2b23, wm2b22, wm2b21, wm2b20, wm2b19, wm2b18, wm2b17, wm2b16, wm2b15, wm2b14, wm2b13, wm2b12, wm2b11, wm2b10, wm2b9, wm2b8, wm2b7, wm2b6, wm2b5, wm2b4, wm2b3, wm2b2, wm2b1, wm2b0, wm16b31, wm16b30, wm16b29, wm16b28, wm16b27, wm16b26, wm16b25, wm16b24, wm16b23, wm16b22, wm16b21, wm16b20, wm16b19, wm16b18, wm16b17, wm16b16, wm16b15, wm16b14, wm16b13, wm16b12, wm16b11, wm16b10, wm16b9, wm16b8, wm16b7, wm16b6, wm16b5, wm16b4, wm16b3, wm16b2, wm16b1, wm16b0, wm7b31, wm7b30, wm7b29, wm7b28, wm7b27, wm7b26, wm7b25, wm7b24, wm7b23, wm7b22, wm7b21, wm7b20, wm7b19, wm7b18, wm7b17, wm7b16, wm7b15, wm7b14, wm7b13, wm7b12, wm7b11, wm7b10, wm7b9, wm7b8, wm7b7, wm7b6, wm7b5, wm7b4, wm7b3, wm7b2, wm7b1, wm7b0):
+def main(field wm15b31, field wm15b30, field wm15b29, field wm15b28, field wm15b27, field wm15b26, field wm15b25, field wm15b24, field wm15b23, field wm15b22, field wm15b21, field wm15b20, field wm15b19, field wm15b18, field wm15b17, field wm15b16, field wm15b15, field wm15b14, field wm15b13, field wm15b12, field wm15b11, field wm15b10, field wm15b9, field wm15b8, field wm15b7, field wm15b6, field wm15b5, field wm15b4, field wm15b3, field wm15b2, field wm15b1, field wm15b0, field wm2b31, field wm2b30, field wm2b29, field wm2b28, field wm2b27, field wm2b26, field wm2b25, field wm2b24, field wm2b23, field wm2b22, field wm2b21, field wm2b20, field wm2b19, field wm2b18, field wm2b17, field wm2b16, field wm2b15, field wm2b14, field wm2b13, field wm2b12, field wm2b11, field wm2b10, field wm2b9, field wm2b8, field wm2b7, field wm2b6, field wm2b5, field wm2b4, field wm2b3, field wm2b2, field wm2b1, field wm2b0, field wm16b31, field wm16b30, field wm16b29, field wm16b28, field wm16b27, field wm16b26, field wm16b25, field wm16b24, field wm16b23, field wm16b22, field wm16b21, field wm16b20, field wm16b19, field wm16b18, field wm16b17, field wm16b16, field wm16b15, field wm16b14, field wm16b13, field wm16b12, field wm16b11, field wm16b10, field wm16b9, field wm16b8, field wm16b7, field wm16b6, field wm16b5, field wm16b4, field wm16b3, field wm16b2, field wm16b1, field wm16b0, field wm7b31, field wm7b30, field wm7b29, field wm7b28, field wm7b27, field wm7b26, field wm7b25, field wm7b24, field wm7b23, field wm7b22, field wm7b21, field wm7b20, field wm7b19, field wm7b18, field wm7b17, field wm7b16, field wm7b15, field wm7b14, field wm7b13, field wm7b12, field wm7b11, field wm7b10, field wm7b9, field wm7b8, field wm7b7, field wm7b6, field wm7b5, field wm7b4, field wm7b3, field wm7b2, field wm7b1, field wm7b0) -> (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):
 	// s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift 3)
 	szero31, szero30, szero29, szero28, szero27, szero26, szero25, szero24, szero23, szero22, szero21, szero20, szero19, szero18, szero17, szero16, szero15, szero14, szero13, szero12, szero11, szero10, szero9, szero8, szero7, szero6, szero5, szero4, szero3, szero2, szero1, szero0 = AR7XAR18XAR3(wm15b31, wm15b30, wm15b29, wm15b28, wm15b27, wm15b26, wm15b25, wm15b24, wm15b23, wm15b22, wm15b21, wm15b20, wm15b19, wm15b18, wm15b17, wm15b16, wm15b15, wm15b14, wm15b13, wm15b12, wm15b11, wm15b10, wm15b9, wm15b8, wm15b7, wm15b6, wm15b5, wm15b4, wm15b3, wm15b2, wm15b1, wm15b0)
 	// s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor (w[i-2] rightshift 10)

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,8 +8,8 @@
 // --------------------------
 // | c21 | c22 || d21 | d22 |
 
-def checkEquality(e11,e12,e21,e22):
-counter = if e11 == e12 then 1 else 0 fi
+def checkEquality(field e11,field e12,field e21,field e22) -> (field):
+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
 counter = counter + if e12 == e21 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/taxation.code

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

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) -> (field):
   // 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

zokrates_cli/src/bin.rs

@@ -404,10 +404,24 @@ fn main() {
             let pk_path = sub_matches.value_of("proving-key-path").unwrap();
             let vk_path = sub_matches.value_of("verification-key-path").unwrap();
 
+            let public_inputs_indices = main_flattened.arguments.iter().enumerate()
+                .filter_map(|(index, x)| match x.private {
+                    true => None,
+                    false => Some(index),
+                });
+
+            let public_inputs = public_inputs_indices
+                .map(|i| main_flattened.signature.inputs[i].get_primitive_count())
+                .fold(0, |acc, e| acc + e);
+
+            let outputs = main_flattened.signature.outputs.iter().map(|t| t.get_primitive_count())
+                .fold(0, |acc, e| acc + e);
+
+            let num_inputs = public_inputs + outputs;
+
             // run setup phase
             #[cfg(feature="libsnark")]{
                 // number of inputs in the zkSNARK sense, i.e., input variables + output variables
-                let num_inputs = main_flattened.arguments.iter().filter(|x| !x.private).count() + main_flattened.return_count;
                 println!("setup successful: {:?}", setup(variables, a, b, c, num_inputs, pk_path, vk_path));
             }
         }
@@ -557,19 +571,22 @@ mod tests {
 
     #[test]
     fn examples() {
-        for p in glob("./examples/*.code").expect("Failed to read glob pattern") {
+        for p in glob("./examples/**/*.code").expect("Failed to read glob pattern") {
             let path = match p {
                 Ok(x) => x,
                 Err(why) => panic!("Error: {:?}", why),
             };
 
+            if path.to_str().unwrap().contains("error") {
+                continue
+            }
+
             println!("Testing {:?}", path);
 
             let file = File::open(path.clone()).unwrap();
 
-            let location = path.parent().unwrap().to_path_buf().into_os_string().into_string().unwrap();
-
             let mut reader = BufReader::new(file);
+            let location = path.parent().unwrap().to_path_buf().into_os_string().into_string().unwrap();
 
             let program_flattened: FlatProg<FieldPrime> =
                 compile(&mut reader, Some(location), Some(fs_resolve), true, false).unwrap();
@@ -580,7 +597,7 @@ mod tests {
 
     #[test]
     fn examples_with_input_success() {
-        // these examples should compile and run
+        //these examples should compile and run
         for p in glob("./examples/test*.code").expect("Failed to read glob pattern") {
             let path = match p {
                 Ok(x) => x,
@@ -595,7 +612,8 @@ mod tests {
             let mut reader = BufReader::new(file);
 
             let program_flattened: FlatProg<FieldPrime> =
-                compile(&mut reader, Some(location), Some(fs_resolve), true, false).unwrap();
+
+            compile(&mut reader, Some(location), Some(fs_resolve), true, false).unwrap();
 
             let (..) = r1cs_program(&program_flattened);
             let _ = program_flattened.get_witness(vec![FieldPrime::from(0)]).unwrap();
@@ -604,7 +622,7 @@ mod tests {
 
     #[test]
     fn examples_with_input_failure() {
-        // these examples should compile but not run
+        //these examples should compile but not run
         for p in glob("./examples/runtime_errors/*.code").expect("Failed to read glob pattern") {
             let path = match p {
                 Ok(x) => x,
@@ -619,7 +637,8 @@ mod tests {
             let mut reader = BufReader::new(file);
 
             let program_flattened: FlatProg<FieldPrime> =
-                compile(&mut reader, Some(location), Some(fs_resolve), true, false).unwrap();
+
+            compile(&mut reader, Some(location), Some(fs_resolve), true, false).unwrap();
 
             let (..) = r1cs_program(&program_flattened);
 

zokrates_cli/tests/code/if_else_false.code

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

zokrates_cli/tests/code/if_else_true.code

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

zokrates_cli/tests/code/sha_libsnark.code

@@ -1,4 +1,4 @@
-def main(a):
+def main(field a) -> (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, 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, 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, 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, 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, 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, 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, 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):
 	o255, o254, o253, o252, o251, o250, o249, o248, o247, o246, o245, o244, o243, o242, o241, o240, o239, o238, o237, o236, o235, o234, o233, o232, o231, o230, o229, o228, o227, o226, o225, o224, o223, o222, o221, o220, o219, o218, o217, o216, o215, o214, o213, o212, o211, o210, o209, o208, o207, o206, o205, o204, o203, o202, o201, o200, o199, o198, o197, o196, o195, o194, o193, o192, o191, o190, o189, o188, o187, o186, o185, o184, o183, o182, o181, o180, o179, o178, o177, o176, o175, o174, o173, o172, o171, o170, o169, o168, o167, o166, o165, o164, o163, o162, o161, o160, o159, o158, o157, o156, o155, o154, o153, o152, o151, o150, o149, o148, o147, o146, o145, o144, o143, o142, o141, o140, o139, o138, o137, o136, o135, o134, o133, o132, o131, o130, o129, o128, o127, o126, o125, o124, o123, o122, o121, o120, o119, o118, o117, o116, o115, o114, o113, o112, o111, o110, o109, o108, o107, o106, o105, o104, o103, o102, o101, o100, o99, o98, o97, o96, o95, o94, o93, o92, o91, o90, o89, o88, o87, o86, o85, o84, o83, o82, o81, o80, o79, o78, o77, o76, o75, o74, o73, o72, o71, o70, o69, o68, o67, o66, o65, o64, o63, o62, o61, o60, o59, o58, o57, o56, o55, o54, o53, o52, o51, o50, o49, o48, o47, o46, o45, o44, o43, o42, o41, o40, o39, o38, o37, o36, o35, o34, o33, o32, o31, o30, o29, o28, o27, o26, o25, o24, o23, o22, o21, o20, o19, o18, o17, o16, o15, o14, o13, o12, o11, o10, o9, o8, o7, o6, o5, o4, o3, o2, o1, o0 = sha256libsnark(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,1,0,0,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,1,0,1,0,0,0,0,1,1,0,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,1,0,0,0,1,0,0,1,1,1,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,0,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,0,1,1,1,1,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,1,0,0,1,1,0,0,1,0,0,0,1,1,0,0,1,1,0,0,1,1,0,1,0,0,0,0,1,1,0,1,0,1,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,1,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,1,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,1,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,1)
 	return o255, o254, o253, o252, o251, o250, o249, o248, o247, o246, o245, o244, o243, o242, o241, o240, o239, o238, o237, o236, o235, o234, o233, o232, o231, o230, o229, o228, o227, o226, o225, o224, o223, o222, o221, o220, o219, o218, o217, o216, o215, o214, o213, o212, o211, o210, o209, o208, o207, o206, o205, o204, o203, o202, o201, o200, o199, o198, o197, o196, o195, o194, o193, o192, o191, o190, o189, o188, o187, o186, o185, o184, o183, o182, o181, o180, o179, o178, o177, o176, o175, o174, o173, o172, o171, o170, o169, o168, o167, o166, o165, o164, o163, o162, o161, o160, o159, o158, o157, o156, o155, o154, o153, o152, o151, o150, o149, o148, o147, o146, o145, o144, o143, o142, o141, o140, o139, o138, o137, o136, o135, o134, o133, o132, o131, o130, o129, o128, o127, o126, o125, o124, o123, o122, o121, o120, o119, o118, o117, o116, o115, o114, o113, o112, o111, o110, o109, o108, o107, o106, o105, o104, o103, o102, o101, o100, o99, o98, o97, o96, o95, o94, o93, o92, o91, o90, o89, o88, o87, o86, o85, o84, o83, o82, o81, o80, o79, o78, o77, o76, o75, o74, o73, o72, o71, o70, o69, o68, o67, o66, o65, o64, o63, o62, o61, o60, o59, o58, o57, o56, o55, o54, o53, o52, o51, o50, o49, o48, o47, o46, o45, o44, o43, o42, o41, o40, o39, o38, o37, o36, o35, o34, o33, o32, o31, o30, o29, o28, o27, o26, o25, o24, o23, o22, o21, o20, o19, o18, o17, o16, o15, o14, o13, o12, o11, o10, o9, o8, o7, o6, o5, o4, o3, o2, o1, o0
 	

zokrates_cli/tests/code/sha_libsnark_null.code

@@ -1,4 +1,4 @@
-def main(a):
+def main(field a) -> (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, 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, 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, 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, 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, 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, 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, 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):
 	o255, o254, o253, o252, o251, o250, o249, o248, o247, o246, o245, o244, o243, o242, o241, o240, o239, o238, o237, o236, o235, o234, o233, o232, o231, o230, o229, o228, o227, o226, o225, o224, o223, o222, o221, o220, o219, o218, o217, o216, o215, o214, o213, o212, o211, o210, o209, o208, o207, o206, o205, o204, o203, o202, o201, o200, o199, o198, o197, o196, o195, o194, o193, o192, o191, o190, o189, o188, o187, o186, o185, o184, o183, o182, o181, o180, o179, o178, o177, o176, o175, o174, o173, o172, o171, o170, o169, o168, o167, o166, o165, o164, o163, o162, o161, o160, o159, o158, o157, o156, o155, o154, o153, o152, o151, o150, o149, o148, o147, o146, o145, o144, o143, o142, o141, o140, o139, o138, o137, o136, o135, o134, o133, o132, o131, o130, o129, o128, o127, o126, o125, o124, o123, o122, o121, o120, o119, o118, o117, o116, o115, o114, o113, o112, o111, o110, o109, o108, o107, o106, o105, o104, o103, o102, o101, o100, o99, o98, o97, o96, o95, o94, o93, o92, o91, o90, o89, o88, o87, o86, o85, o84, o83, o82, o81, o80, o79, o78, o77, o76, o75, o74, o73, o72, o71, o70, o69, o68, o67, o66, o65, o64, o63, o62, o61, o60, o59, o58, o57, o56, o55, o54, o53, o52, o51, o50, o49, o48, o47, o46, o45, o44, o43, o42, o41, o40, o39, o38, o37, o36, o35, o34, o33, o32, o31, o30, o29, o28, o27, o26, o25, o24, o23, o22, o21, o20, o19, o18, o17, o16, o15, o14, o13, o12, o11, o10, o9, o8, o7, o6, o5, o4, o3, o2, o1, o0 = sha256libsnark(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
 	return o255, o254, o253, o252, o251, o250, o249, o248, o247, o246, o245, o244, o243, o242, o241, o240, o239, o238, o237, o236, o235, o234, o233, o232, o231, o230, o229, o228, o227, o226, o225, o224, o223, o222, o221, o220, o219, o218, o217, o216, o215, o214, o213, o212, o211, o210, o209, o208, o207, o206, o205, o204, o203, o202, o201, o200, o199, o198, o197, o196, o195, o194, o193, o192, o191, o190, o189, o188, o187, o186, o185, o184, o183, o182, o181, o180, o179, o178, o177, o176, o175, o174, o173, o172, o171, o170, o169, o168, o167, o166, o165, o164, o163, o162, o161, o160, o159, o158, o157, o156, o155, o154, o153, o152, o151, o150, o149, o148, o147, o146, o145, o144, o143, o142, o141, o140, o139, o138, o137, o136, o135, o134, o133, o132, o131, o130, o129, o128, o127, o126, o125, o124, o123, o122, o121, o120, o119, o118, o117, o116, o115, o114, o113, o112, o111, o110, o109, o108, o107, o106, o105, o104, o103, o102, o101, o100, o99, o98, o97, o96, o95, o94, o93, o92, o91, o90, o89, o88, o87, o86, o85, o84, o83, o82, o81, o80, o79, o78, o77, o76, o75, o74, o73, o72, o71, o70, o69, o68, o67, o66, o65, o64, o63, o62, o61, o60, o59, o58, o57, o56, o55, o54, o53, o52, o51, o50, o49, o48, o47, o46, o45, o44, o43, o42, o41, o40, o39, o38, o37, o36, o35, o34, o33, o32, o31, o30, o29, o28, o27, o26, o25, o24, o23, o22, o21, o20, o19, o18, o17, o16, o15, o14, o13, o12, o11, o10, o9, o8, o7, o6, o5, o4, o3, o2, o1, o0
 	

zokrates_cli/tests/code/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/tests/code/simple_mul.code

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

zokrates_cli/tests/code/taxation.code

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

zokrates_cli/tests/integration.rs

@@ -65,7 +65,7 @@ mod integration {
         fs::create_dir(test_case_path).unwrap();
 
         // prepare compile arguments
-        let mut compile = vec!["../target/debug/zokrates", "compile", "-i", program_path.to_str().unwrap(), "-o", flattened_path.to_str().unwrap()];
+        let mut compile = vec!["../target/debug/zokrates", "compile", "-i", program_path.to_str().unwrap(), "-o", flattened_path.to_str().unwrap(), "--light"];
 
         if program_name.contains("sha_libsnark") {
             compile.push("--gadgets");

zokrates_core/src/absy/mod.rs

@@ -123,16 +123,18 @@ impl<T: Field> fmt::Debug for Function<T> {
 #[derive(Clone, Serialize, Deserialize, PartialEq)]
 pub enum Statement<T: Field> {
     Return(ExpressionList<T>),
-    Definition(Variable, Expression<T>),
+    Declaration(Variable),
+    Definition(String, Expression<T>),
     Condition(Expression<T>, Expression<T>),
     For(Variable, T, T, Vec<Statement<T>>),
-    MultipleDefinition(Vec<Variable>, Expression<T>),
+    MultipleDefinition(Vec<String>, Expression<T>),
 }
 
 impl<T: Field> fmt::Display for Statement<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Statement::Return(ref expr) => write!(f, "return {}", expr),
+            Statement::Declaration(ref var) => write!(f, "{}", var),
             Statement::Definition(ref lhs, ref rhs) => write!(f, "{} = {}", lhs, rhs),
             Statement::Condition(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs),
             Statement::For(ref var, ref start, ref stop, ref list) => {
@@ -159,6 +161,7 @@ impl<T: Field> fmt::Debug for Statement<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Statement::Return(ref expr) => write!(f, "Return({:?})", expr),
+            Statement::Declaration(ref var) => write!(f, "Declaration({:?})", var),
             Statement::Definition(ref lhs, ref rhs) => {
                 write!(f, "Definition({:?}, {:?})", lhs, rhs)
             }
@@ -186,8 +189,13 @@ pub enum Expression<T: Field> {
     Mult(Box<Expression<T>>, Box<Expression<T>>),
     Div(Box<Expression<T>>, Box<Expression<T>>),
     Pow(Box<Expression<T>>, Box<Expression<T>>),
-    IfElse(Box<Condition<T>>, Box<Expression<T>>, Box<Expression<T>>),
+    IfElse(Box<Expression<T>>, Box<Expression<T>>, Box<Expression<T>>),
     FunctionCall(String, Vec<Expression<T>>),
+    Lt(Box<Expression<T>>, Box<Expression<T>>),
+    Le(Box<Expression<T>>, Box<Expression<T>>),
+    Eq(Box<Expression<T>>, Box<Expression<T>>),
+    Ge(Box<Expression<T>>, Box<Expression<T>>),
+    Gt(Box<Expression<T>>, Box<Expression<T>>),
 }
 
 impl<T: Field> fmt::Display for Expression<T> {
@@ -217,6 +225,11 @@ impl<T: Field> fmt::Display for Expression<T> {
                 }
                 write!(f, ")")
             },
+            Expression::Lt(ref lhs, ref rhs) => write!(f, "{} < {}", lhs, rhs),
+            Expression::Le(ref lhs, ref rhs) => write!(f, "{} <= {}", lhs, rhs),
+            Expression::Eq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs),
+            Expression::Ge(ref lhs, ref rhs) => write!(f, "{} >= {}", lhs, rhs),
+            Expression::Gt(ref lhs, ref rhs) => write!(f, "{} > {}", lhs, rhs),
         }
     }
 }
@@ -243,6 +256,11 @@ impl<T: Field> fmt::Debug for Expression<T> {
                 try!(f.debug_list().entries(p.iter()).finish());
                 write!(f, ")")
             },
+            Expression::Lt(ref lhs, ref rhs) => write!(f, "{} < {}", lhs, rhs),
+            Expression::Le(ref lhs, ref rhs) => write!(f, "{} <= {}", lhs, rhs),
+            Expression::Eq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs),
+            Expression::Ge(ref lhs, ref rhs) => write!(f, "{} >= {}", lhs, rhs),
+            Expression::Gt(ref lhs, ref rhs) => write!(f, "{} > {}", lhs, rhs),
         }
     }
 }
@@ -277,30 +295,3 @@ impl<T: Field> fmt::Debug for ExpressionList<T> {
         write!(f, "ExpressionList({:?})", self.expressions)
     }
 }
-
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub enum Condition<T: Field> {
-    Lt(Expression<T>, Expression<T>),
-    Le(Expression<T>, Expression<T>),
-    Eq(Expression<T>, Expression<T>),
-    Ge(Expression<T>, Expression<T>),
-    Gt(Expression<T>, Expression<T>),
-}
-
-impl<T: Field> fmt::Display for Condition<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Condition::Lt(ref lhs, ref rhs) => write!(f, "{} < {}", lhs, rhs),
-            Condition::Le(ref lhs, ref rhs) => write!(f, "{} <= {}", lhs, rhs),
-            Condition::Eq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs),
-            Condition::Ge(ref lhs, ref rhs) => write!(f, "{} >= {}", lhs, rhs),
-            Condition::Gt(ref lhs, ref rhs) => write!(f, "{} > {}", lhs, rhs),
-        }
-    }
-}
-
-impl<T: Field> fmt::Debug for Condition<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self)
-    }
-}

zokrates_core/src/absy/parameter.rs

@@ -10,7 +10,7 @@ pub struct Parameter {
 impl fmt::Display for Parameter {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let visibility = if self.private { "private " } else { "" };
-        write!(f, "{}{} {}", visibility, self.id._type, self.id.id)
+        write!(f, "{}{} {}", visibility, self.id.get_type(), self.id.id)
     }
 }
 

zokrates_core/src/absy/variable.rs

@@ -8,18 +8,30 @@ pub struct Variable {
 }
 
 impl Variable {
-    pub fn get_type(&self) -> Type {
-        self._type.clone()
-    }
-}
-
-impl<S: Into<String>> From<S> for Variable {
-    fn from(s: S) -> Self {
+    pub fn new<S: Into<String>>(id: S, t: Type) -> Variable {
         Variable {
-            id: s.into(),
+            id: id.into(),
+            _type: t
+        }
+    }
+
+    pub fn field_element<S: Into<String>>(id: S) -> Variable {
+        Variable {
+            id: id.into(),
             _type: Type::FieldElement
         }
     }
+
+    pub fn boolean<S: Into<String>>(id: S) -> Variable {
+        Variable {
+            id: id.into(),
+            _type: Type::Boolean
+        }
+    }
+
+    pub fn get_type(&self) -> Type {
+        self._type.clone()
+    }
 }
 
 impl fmt::Display for Variable {

zokrates_core/src/compile.rs

@@ -72,51 +72,10 @@ pub fn compile<T: Field, R: BufRead, S: BufRead, E: Into<imports::Error>>(reader
 	}
 }
 
-fn compile_aux<T: Field, R: BufRead, S: BufRead, E: Into<imports::Error>>(reader: &mut R, location: Option<String>, resolve_option: Option<fn(&Option<String>, &String) -> Result<(S, String, String), E>>, should_include_gadgets: bool) -> Result<FlatProg<T>, CompileError<T>> {
+pub fn compile_aux<T: Field, R: BufRead, S: BufRead, E: Into<imports::Error>>(reader: &mut R, location: Option<String>, resolve_option: Option<fn(&Option<String>, &String) -> Result<(S, String, String), E>>, should_include_gadgets: bool) -> Result<FlatProg<T>, CompileError<T>> {
     let program_ast_without_imports: Prog<T> = parse_program(reader)?;
-
-    let mut compiled_imports: Vec<(FlatProg<T>, String)> = vec![];
-
-    // to resolve imports, we need a resolver
-    match resolve_option {
-    	Some(resolve) => {
-    		// we have a resolver, pass each import through it
-	    	for import in program_ast_without_imports.imports.iter() {
-			match resolve(&location, import.get_source()) {
-	    			Ok((mut res, file_location, default_alias)) => {
-			    		let compiled = compile_aux(&mut res, Some(file_location), resolve_option, should_include_gadgets)?;
-			    		let alias = match import.get_alias() {
-			    			&Some(ref custom_alias) => custom_alias.clone(),
-			    			&None => default_alias
-			    		};
-				    	compiled_imports.push((compiled, alias));
-			    	},
-	    			Err(err) => return Err(CompileError::ImportError(err.into()))
-	    		}
-	    	}
-    	},
-    	None => {
-    		if program_ast_without_imports.imports.len() > 0 {
-    			return Err(imports::Error::new("Can't resolve import without a resolver").into())
-    		}
-    	}
-    }
-
-    #[cfg(feature = "libsnark")]
-    {
-    	use libsnark::{get_sha256_constraints};
-    	use standard::R1CS;
-    	use serde_json::from_str;
-
-	    if should_include_gadgets {
-	    	// inject globals
-		    let r1cs: R1CS = from_str(&get_sha256_constraints()).unwrap();
-
-		    compiled_imports.push((FlatProg::from(r1cs), "sha256libsnark".to_string()));
-	    }
-   	} 
-    	
-    let program_ast = Importer::new().apply_imports(compiled_imports, program_ast_without_imports);
+    
+    let program_ast = Importer::new().apply_imports(program_ast_without_imports, location.clone(), resolve_option, should_include_gadgets)?;
 
     // check semantics
     let typed_ast = Checker::new().check_program(program_ast)?;
@@ -138,7 +97,7 @@ mod test {
 	fn no_resolver_with_imports() {
 		let mut r = BufReader::new(r#"
 			import "./path/to/file" as foo
-			def main():
+			def main() -> (field):
 			   return foo()
 		"#.as_bytes());
 		let res: Result<FlatProg<FieldPrime>, CompileError<FieldPrime>> = compile(&mut r, Some(String::from("./path/to/file")), None::<fn(&Option<String>, &String) -> Result<(BufReader<Empty>, String, String), io::Error>>, false, false);
@@ -148,7 +107,7 @@ mod test {
 	#[test]
 	fn no_resolver_without_imports() {
 		let mut r = BufReader::new(r#"
-			def main():
+			def main() -> (field):
 			   return 1
 		"#.as_bytes());
 		let res: Result<FlatProg<FieldPrime>, CompileError<FieldPrime>> = compile(&mut r, Some(String::from("./path/to/file")), None::<fn(&Option<String>, &String) -> Result<(BufReader<Empty>, String, String), io::Error>>, false, false);

zokrates_core/src/flat_absy/mod.rs

@@ -10,6 +10,8 @@ pub mod flat_variable;
 
 pub use self::flat_parameter::FlatParameter;
 pub use self::flat_variable::FlatVariable;
+
+use types::Signature;
 use std::fmt;
 use std::collections::{BTreeMap};
 use field::Field;
@@ -80,8 +82,8 @@ pub struct FlatFunction<T: Field> {
     pub arguments: Vec<FlatParameter>,
     /// Vector of statements that are executed when running the function
     pub statements: Vec<FlatStatement<T>>,
-    /// number of returns
-    pub return_count: usize,
+    /// Typed signature
+    pub signature: Signature,
 }
 
 impl<T: Field> FlatFunction<T> {
@@ -158,14 +160,15 @@ impl<T: Field> fmt::Debug for FlatFunction<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "FlatFunction(id: {:?}, arguments: {:?}, ...):\n{}",
+            "FlatFunction(id: {:?}, arguments: {:?}, signature: {:?}):\n{}",
             self.id,
             self.arguments,
+            self.signature,
             self.statements
                 .iter()
                 .map(|x| format!("\t{:?}", x))
                 .collect::<Vec<_>>()
-                .join("\n")
+                .join("\n"),
         )
     }
 }
@@ -222,7 +225,7 @@ impl<T: Field> FlatStatement<T> {
     fn apply_substitution(self, substitution: &Substitution, should_fallback: bool) -> FlatStatement<T> {
         match self {
             FlatStatement::Definition(id, x) => FlatStatement::Definition(
-                substitution.get(&id).unwrap_or(id), 
+                id.apply_substitution(substitution, should_fallback), 
                 x.apply_substitution(substitution, should_fallback)
             ),
             FlatStatement::Return(x) => FlatStatement::Return(
@@ -237,6 +240,7 @@ impl<T: Field> FlatStatement<T> {
             FlatStatement::Directive(d) => {
                 let outputs = d.outputs.into_iter().map(|o| substitution.get(&o).unwrap_or(o)).collect();
                 let inputs = d.inputs.into_iter().map(|i| substitution.get(&i).unwrap()).collect();
+
                 FlatStatement::Directive(
                     DirectiveStatement {
                         outputs,
@@ -291,30 +295,6 @@ impl<T: Field> FlatExpression<T> {
         }
     }
 
-    pub fn apply(self, f: &Fn(FlatVariable) -> (FlatVariable)) -> Self {
-        match self {
-            e @ FlatExpression::Number(_) => e,
-            FlatExpression::Identifier(id) => FlatExpression::Identifier(f(id)),
-            FlatExpression::Add(e1, e2) => FlatExpression::Add(
-                box e1.apply(&f),
-                box e2.apply(&f),
-            ),
-            FlatExpression::Sub(e1, e2) => FlatExpression::Sub(
-                box e1.apply(&f),
-                box e2.apply(&f),
-            ),
-            FlatExpression::Mult(e1, e2) => FlatExpression::Mult(
-                box e1.apply(&f),
-                box e2.apply(&f),
-            ),
-            FlatExpression::Div(e1, e2) => FlatExpression::Div(
-                box e1.apply(&f),
-                box e2.apply(&f),
-            )
-        }
-    }
-
-
     fn solve(&self, inputs: &mut BTreeMap<FlatVariable, T>) -> T {
         match *self {
             FlatExpression::Number(ref x) => x.clone(),

zokrates_core/src/flatten/mod.rs

@@ -5,7 +5,7 @@
 //! @author Jacob Eberhardt <jacob.eberhardt@tu-berlin.de>
 //! @date 2017
 
-use std::collections::{HashSet, HashMap};
+use std::collections::{HashSet};
 use typed_absy::*;
 use field::Field;
 use flat_absy::*;
@@ -28,8 +28,6 @@ pub struct Flattener {
     variables: HashSet<FlatVariable>,
     /// Map of renamings for reassigned variables while processing the program.
     substitution: DirectSubstitution,
-    /// Map of function id to invocation counter
-    function_calls: HashMap<String, usize>,
     /// Index of the next introduced variable while processing the program.
     next_var_idx: usize,
     ///
@@ -46,7 +44,6 @@ impl Flattener {
             bits: bits,
             variables: HashSet::new(),
             substitution: DirectSubstitution::new(),
-            function_calls: HashMap::new(),
             next_var_idx: 0,
             bijection: BiMap::new(),
         }
@@ -88,12 +85,11 @@ impl Flattener {
             }],
             statements: vec![
                 TypedStatement::Definition(
-                    Variable::from("condition_as_field"),
+                    Variable::field_element("condition_as_field"),
                     FieldElementExpression::FunctionCall(
                         "_bool_to_field".to_string(), 
                         vec![
-                            TypedExpression::FieldElement(
-                                FieldElementExpression::Identifier("condition".to_string()))
+                                BooleanExpression::Identifier("condition".to_string()).into()
                         ]
                     ).into()
                 ),
@@ -115,10 +111,9 @@ impl Flattener {
                     ]
                 )
             ],
-            signature: Signature {
-                inputs: vec![Type::Boolean, Type::FieldElement, Type::FieldElement],
-                outputs: vec![Type::FieldElement]
-            }
+            signature: Signature::new()
+                .inputs(vec![Type::Boolean, Type::FieldElement, Type::FieldElement])
+                .outputs(vec![Type::FieldElement])
         };
 
         let ief = self.flatten_function(
@@ -128,26 +123,25 @@ impl Flattener {
         functions_flattened.push(ief);
     }
 
-    /// Returns (condition true, condition false) `Identifier`s for the given condition.
-    /// condition true = 1, if `condition` is true, 0 else
-    /// condition false = 1, if `condition` is false, 0 else
+    /// Flattens a boolean expression
     ///
     /// # Arguments
     ///
     /// * `statements_flattened` - Vector where new flattened statements can be added.
     /// * `condition` - `Condition` that will be flattened.
-    fn flatten_condition<T: Field>(
+    fn flatten_boolean_expression<T: Field>(
         &mut self,
         functions_flattened: &Vec<FlatFunction<T>>,
         arguments_flattened: &Vec<FlatParameter>,
         statements_flattened: &mut Vec<FlatStatement<T>>,
-        condition: BooleanExpression<T>,
-    ) -> BooleanExpression<T> { // those will be booleans in the future
-        match condition {
+        expression: BooleanExpression<T>,
+    ) -> FlatExpression<T> { // those will be booleans in the future
+        match expression {
+            BooleanExpression::Identifier(x) => FlatExpression::Identifier(self.bijection.get_by_left(&x).unwrap().clone()),
             BooleanExpression::Lt(box lhs, box rhs) => {
 
                 // We know from semantic checking that lhs and rhs have the same type
-                // What the condition will flatten to depends on that type
+                // What the expression will flatten to depends on that type
 
                 let lhs_flattened = self.flatten_field_expression(
                     functions_flattened,
@@ -314,13 +308,12 @@ impl Flattener {
                         )
                     );
 
-                // we need to return string-based variables for the rest of flattening, so we use the bijection
-                BooleanExpression::Identifier(self.bijection.get_by_right(&sub_bits[0]).unwrap().to_string())
+                FlatExpression::Identifier(sub_bits[0])
             }
             BooleanExpression::Eq(box lhs, box rhs) => {
 
                 // We know from semantic checking that lhs and rhs have the same type
-                // What the condition will flatten to depends on that type
+                // What the expression will flatten to depends on that type
 
                 // Wanted: (Y = (X != 0) ? 1 : 0)
                 // X = a - b
@@ -362,7 +355,13 @@ impl Flattener {
                     FlatExpression::Mult(box FlatExpression::Identifier(name_1_y), box FlatExpression::Identifier(name_x)),
                 ));
 
-                BooleanExpression::Identifier(self.bijection.get_by_right(&name_1_y).unwrap().to_string())
+                FlatExpression::Identifier(name_1_y)
+            },
+            BooleanExpression::Value(b) => {
+                FlatExpression::Number(match b {
+                    true => T::from(1),
+                    false => T::from(0)
+                })
             }
             _ => unimplemented!(),
         }
@@ -374,82 +373,43 @@ impl Flattener {
         arguments_flattened: &Vec<FlatParameter>,
         statements_flattened: &mut Vec<FlatStatement<T>>,
         id: &String,
-        return_count: usize,
+        return_types: Vec<Type>,
         param_expressions: &Vec<TypedExpression<T>>
     ) -> FlatExpressionList<T> {
-        for funct in functions_flattened {
-            if funct.id == *id && funct.arguments.len() == (*param_expressions).len() && funct.return_count == return_count {
-                // funct is now the called function
 
-                // Idea: variables are given a prefix.
-                // It consists of the function name followed by a call counter value
-                // e.g.: add_1_a_2
+        let passed_signature = Signature::new()
+            .inputs(param_expressions.into_iter().map(|e| e.get_type()).collect())
+            .outputs(return_types);
+
+        for funct in functions_flattened {
+            if funct.id == *id && funct.signature == passed_signature {
+                // funct is now the called function
 
                 // Stores prefixed variables
 
                 let mut replacement_map = DirectSubstitution::new();
 
-                // build prefix
-                match self.function_calls.clone().get(&funct.id) {
-                    Some(val) => {
-                        self.function_calls.insert(funct.id.clone(),val+1);
-                    }
-                    None => {
-                        self.function_calls.insert(funct.id.clone(),1);
-                    }
-                }
-
                 // Handle complex parameters and assign values:
                 // Rename Parameters, assign them to values in call. Resolve complex expressions with definitions
                 for (i, param_expr) in param_expressions.clone().into_iter().enumerate() {
-                    let new_var;
+                    let rhs = self.flatten_expression(
+                            functions_flattened,
+                            arguments_flattened,
+                            statements_flattened,
+                            param_expr,
+                        ).apply_recursive_substitution(&self.substitution);
 
-                    match param_expr {
-                        TypedExpression::FieldElement(e) => {
-
-                            // for field elements, flatten the input and assign it to a new variable
-                            let rhs = self.flatten_field_expression(
-                                functions_flattened,
-                                arguments_flattened,
-                                statements_flattened,
-                                e,
-                            ).apply_recursive_substitution(&self.substitution);
-
-                            new_var = self.issue_new_variable();
-                            statements_flattened
-                                .push(FlatStatement::Definition(new_var, rhs));
-                        },
-                        TypedExpression::Boolean(e) => {
-                            match e {
-                                BooleanExpression::Identifier(id) => {
-                                    new_var = self.issue_new_variable();
-                                    // a bit hacky for now, to be removed when flatten_condition returns a flatexpression
-                                    // basically extracted the bit of apply_substitution that handles identifiers
-
-                                    let mut id = id;
-                                    loop {
-                                        match self.substitution.get(&self.bijection.get_by_left(&id).unwrap()) {
-                                            Some(x) => id = x.to_string(),
-                                            None => break,
-                                        }
-                                    }
-
-                                    statements_flattened
-                                        .push(FlatStatement::Definition(new_var, FlatExpression::Identifier(self.bijection.get_by_left(&id).unwrap().clone())));
-                                },
-                                _ => panic!("a boolean argument to a function has to be a identifier")
-                            }
-                        }
-                    }
-
-                    replacement_map.insert(FlatVariable::new(funct.arguments.get(i).unwrap().id.id()), new_var);
+                    let new_var = self.issue_new_variable();
+                    statements_flattened
+                        .push(FlatStatement::Definition(new_var, rhs));
+                    replacement_map.insert(funct.arguments.get(i).unwrap().id.clone(), new_var);
                 }
 
                 // Ensure Renaming and correct returns:
                 // add all flattened statements, adapt return statement
                 for stat in funct.statements.clone() {
                     match stat {
-                        // set return statements right side as expression result
+                        // set return statements right sidreturne as expression result
                         FlatStatement::Return(list) => {
                             return FlatExpressionList {
                                 expressions: list.expressions.into_iter().map(|x| x.apply_direct_substitution(&replacement_map)).collect()
@@ -491,12 +451,37 @@ impl Flattener {
             }
         }
         panic!(
-            "TypedFunction definition for function {} with {:?} argument(s) not found.",
+            "TypedFunction definition for function {} with {:?} argument(s) not found. Should have been detected during semantic checking.",
             id,
             param_expressions
         );
     }
 
+    fn flatten_expression<T: Field>(
+        &mut self,
+        functions_flattened: &Vec<FlatFunction<T>>,
+        arguments_flattened: &Vec<FlatParameter>,
+        statements_flattened: &mut Vec<FlatStatement<T>>,
+        expr: TypedExpression<T>,
+    ) -> FlatExpression<T> {
+        match expr {
+            TypedExpression::FieldElement(e) => 
+                self.flatten_field_expression(
+                    functions_flattened,
+                    arguments_flattened,
+                    statements_flattened,
+                    e,
+                ),
+            TypedExpression::Boolean(e) => 
+                self.flatten_boolean_expression(
+                    functions_flattened,
+                    arguments_flattened,
+                    statements_flattened,
+                    e,
+                ),        
+        }
+    }
+
     fn flatten_field_expression<T: Field>(
         &mut self,
         functions_flattened: &Vec<FlatFunction<T>>,
@@ -642,55 +627,69 @@ impl Flattener {
                 FlatExpression::Div(box new_left, box new_right)
             },
             FieldElementExpression::Pow(box base, box exponent) => {
-                // TODO currently assuming that base is number or variable
                 match exponent {
-                    FieldElementExpression::Number(ref x) if x > &T::one() => match base {
-                        FieldElementExpression::Identifier(ref var) => {
-                            let id = if x > &T::from(2) {
+                    FieldElementExpression::Number(ref e) => {
+                        // flatten the base expression
+                        let base_flattened = self.flatten_field_expression(
+                                functions_flattened,
+                                arguments_flattened,
+                                statements_flattened,
+                                base.clone(),
+                            ).apply_recursive_substitution(&self.substitution);
+
+                        // we require from the base to be linear
+                        // TODO change that
+                        assert!(base_flattened.is_linear());
+
+                        match e {
+                            // flatten(base ** 1) == flatten(base)
+                            e if *e == T::one() => {
+                                base_flattened
+                            },
+                            // flatten(base ** 2) == flatten(base) * flatten(base)
+                            // in this case, no need to define an intermediate variable
+                            // as if a is linear, a ** 2 quadratic
+                            e if *e == T::from(2) => {
+                                FlatExpression::Mult(box base_flattened.clone(), box base_flattened)
+                            },
+                            // flatten(base ** n) = flatten(base) * flatten(base ** (n-1))
+                            e => {
+                                // flatten(base ** (n-1))
                                 let tmp_expression = self.flatten_field_expression(
                                     functions_flattened,
                                     arguments_flattened,
                                     statements_flattened,
                                     FieldElementExpression::Pow(
-                                        box FieldElementExpression::Identifier(var.to_string()),
-                                        box FieldElementExpression::Number(x.clone() - T::one()),
+                                        box base,
+                                        box FieldElementExpression::Number(e.clone() - T::one()),
                                     ),
-                                );
+                                ).apply_recursive_substitution(&self.substitution);
+
                                 let id = self.use_sym();
+
                                 statements_flattened.push(
-                                    FlatStatement::Definition(id, tmp_expression),
-                                );
-                                id
-                            } else {
-                                self.bijection.get_by_left(&var).unwrap().clone()
-                            };
-                            FlatExpression::Mult(
-                                box FlatExpression::Identifier(id),
-                                box FlatExpression::Identifier(self.bijection.get_by_left(&var).unwrap().clone()),
-                            )
+                                    FlatStatement::Definition(id, tmp_expression));
+                            
+                                FlatExpression::Mult(
+                                    box FlatExpression::Identifier(id),
+                                    box base_flattened,
+                                )
+                            }
                         }
-                        FieldElementExpression::Number(var) => FlatExpression::Mult(box FlatExpression::Number(var.clone()), box FlatExpression::Number(var)),
-                        _ => panic!("Only variables and numbers allowed in pow base"),
                     },
-                    _ => panic!("Expected number > 1 as pow exponent"),
+                    _ => panic!("Expected number as pow exponent"),
                 }
             },
             FieldElementExpression::IfElse(box condition, box consequent, box alternative) => {
-                let condition = self.flatten_condition(
-                    functions_flattened,
-                    arguments_flattened,
-                    statements_flattened,
-                    condition,
-                );
-
                 self.flatten_function_call(
                     functions_flattened,
                     arguments_flattened,
                     statements_flattened,
                     &"_if_else_field".to_string(),
-                    1,
+                    vec![Type::FieldElement],
                     &vec![condition.into(), consequent.into(), alternative.into()],
                 ).expressions[0].clone()
+
             },
             FieldElementExpression::FunctionCall(ref id, ref param_expressions) => {
                 let exprs_flattened = self.flatten_function_call(
@@ -698,7 +697,7 @@ impl Flattener {
                     arguments_flattened,
                     statements_flattened,
                     id,
-                    1,
+                    vec![Type::FieldElement],
                     param_expressions
                 );
                 assert!(exprs_flattened.expressions.len() == 1); // outside of MultipleDefinition, FunctionCalls must return a single value
@@ -716,20 +715,14 @@ impl Flattener {
     ) {
         match stat {
             TypedStatement::Return(exprs) => {
-
-                let flat_expressions = exprs.into_iter().map(|expr| {
-                    match expr {
-                        TypedExpression::FieldElement(e) => {
-                            self.flatten_field_expression(
-                                functions_flattened,
-                                arguments_flattened,
-                                statements_flattened,
-                                e,
-                            ).apply_recursive_substitution(&self.substitution)
-                        },
-                        _ => panic!("Functions can only return expressions of type FieldElement")
-                    }
-                }).collect();
+                let flat_expressions = exprs.into_iter().map(|expr| 
+                    self.flatten_expression(
+                        functions_flattened,
+                        arguments_flattened,
+                        statements_flattened,
+                        expr
+                    ).apply_recursive_substitution(&self.substitution)
+                ).collect();
 
                 statements_flattened.push(
                     FlatStatement::Return(
@@ -739,30 +732,30 @@ impl Flattener {
                     )
                 );
             }
+            TypedStatement::Declaration(_) => {
+                // declarations have already been checked
+                ()
+            }
             TypedStatement::Definition(v, expr) => {
 
                 // define n variables with n the number of primitive types for v_type
                 // assign them to the n primitive types for expr
 
-                match expr {
-                    TypedExpression::FieldElement(expr) => {
-                        let rhs = self.flatten_field_expression(
-                            functions_flattened,
-                            arguments_flattened,
-                            statements_flattened,
-                            expr,
-                        ).apply_recursive_substitution(&self.substitution);
-                        let var = self.use_variable(&v.id);
-                        // handle return of function call
-                        let var_to_replace = self.get_latest_var_substitution(&v.id);
-                        if !(var == var_to_replace) && self.variables.contains(&var_to_replace) && !self.substitution.contains_key(&var_to_replace){
-                            self.substitution.insert(var_to_replace.clone(),var.clone());
-                        }
+                let rhs = self.flatten_expression(
+                        functions_flattened,
+                        arguments_flattened,
+                        statements_flattened,
+                        expr
+                    ).apply_recursive_substitution(&self.substitution);
 
-                        statements_flattened.push(FlatStatement::Definition(var, rhs));
-                    },
-                    _ => panic!("Definitions must have type FieldElement")
+                let var = self.use_variable(&v.id);
+                // handle return of function call
+                let var_to_replace = self.get_latest_var_substitution(&v.id);
+                if !(var == var_to_replace) && self.variables.contains(&var_to_replace) && !self.substitution.contains_key(&var_to_replace){
+                    self.substitution.insert(var_to_replace.clone(),var.clone());
                 }
+
+                statements_flattened.push(FlatStatement::Definition(var, rhs));
             }
             TypedStatement::Condition(expr1, expr2) => {
 
@@ -771,8 +764,8 @@ impl Flattener {
 
                 match (expr1, expr2) {
                     (TypedExpression::FieldElement(e1), TypedExpression::FieldElement(e2)) => {
-                        
-                        let (lhs, rhs) = if e1.is_linear() {
+
+                        let (lhs, rhs) =
                             (
                                 self.flatten_field_expression(
                                     functions_flattened,
@@ -786,28 +779,46 @@ impl Flattener {
                                     statements_flattened,
                                     e2,
                                 ).apply_recursive_substitution(&self.substitution),
-                            )
-                        } else if e2.is_linear() {
+                            );
+
+                        if lhs.is_linear() {
+                            statements_flattened.push(FlatStatement::Condition(lhs, rhs));
+                        } else if rhs.is_linear() {
+                            // swap so that left side is linear
+                            statements_flattened.push(FlatStatement::Condition(rhs, lhs));
+                        } else {
+                            unimplemented!()
+                        }
+
+                    },
+                    (TypedExpression::Boolean(e1), TypedExpression::Boolean(e2)) => {
+                        
+                        let (lhs, rhs) =
                             (
-                                self.flatten_field_expression(
+                                self.flatten_boolean_expression(
+                                    functions_flattened,
+                                    arguments_flattened,
+                                    statements_flattened,
+                                    e1
+                                ).apply_recursive_substitution(&self.substitution),
+                                self.flatten_boolean_expression(
                                     functions_flattened,
                                     arguments_flattened,
                                     statements_flattened,
                                     e2,
                                 ).apply_recursive_substitution(&self.substitution),
-                                self.flatten_field_expression(
-                                    functions_flattened,
-                                    arguments_flattened,
-                                    statements_flattened,
-                                    e1,
-                                ).apply_recursive_substitution(&self.substitution),
-                            )
+                            );
+
+                        if lhs.is_linear() {
+                            statements_flattened.push(FlatStatement::Condition(lhs, rhs));
+                        } else if rhs.is_linear() {
+                            // swap so that left side is linear
+                            statements_flattened.push(FlatStatement::Condition(rhs, lhs));
                         } else {
                             unimplemented!()
-                        };
-                        statements_flattened.push(FlatStatement::Condition(lhs, rhs));
+                        }
                     },
-                    _ => panic!("Conditions (Assertions) must be applied to expressions of type FieldElement")
+                    _ => panic!("non matching types in condition should have been caught at semantic stage")
                 }
             }
             TypedStatement::For(var, start, end, statements) => {
@@ -832,34 +843,29 @@ impl Flattener {
 
                 // flatten the right side to p = sum(var_i.type.primitive_count) expressions
                 // define p new variables to the right side expressions 
+
+                let var_types = vars.iter().map(|v| v.get_type()).collect();
                 
                 match rhs {
-                    TypedExpressionList::FunctionCall(fun_id, exprs, types) => {
-
+                    TypedExpressionList::FunctionCall(fun_id, exprs, _) => {
                         let rhs_flattened = self.flatten_function_call(
                             functions_flattened,
                             arguments_flattened,
                             statements_flattened,
                             &fun_id,
-                            vars.len(),
+                            var_types,
                             &exprs,
                         ).apply_recursive_substitution(&self.substitution);
 
+                        // this will change for types that have multiple underlying fe
                         for (i, v) in vars.into_iter().enumerate() {
-                            let var_type = &types[i];
-
-                            match var_type {
-                                Type::FieldElement => {
-                                    let var = self.use_variable(&v.id);
-                                    // handle return of function call
-                                    let var_to_replace = self.get_latest_var_substitution(&v.id);
-                                    if !(var == var_to_replace) && self.variables.contains(&var_to_replace) && !self.substitution.contains_key(&var_to_replace){
-                                        self.substitution.insert(var_to_replace, var);
-                                    }
-                                    statements_flattened.push(FlatStatement::Definition(var, rhs_flattened.expressions[i].clone()));
-                                },
-                                _ => panic!("MultipleDefinition has to define expressions of type FieldElement")
+                            let var = self.use_variable(&v.id);
+                            // handle return of function call
+                            let var_to_replace = self.get_latest_var_substitution(&v.id);
+                            if !(var == var_to_replace) && self.variables.contains(&var_to_replace) && !self.substitution.contains_key(&var_to_replace){
+                                self.substitution.insert(var_to_replace.clone(),var.clone());
                             }
+                            statements_flattened.push(FlatStatement::Definition(var, rhs_flattened.expressions[i].clone()));
                         }
                     },
                 }
@@ -917,14 +923,11 @@ impl Flattener {
             );
         }
 
-        // the flattened return count is the sum of the primitive elements for each type returned
-        let return_count = funct.signature.outputs.iter().map(|output_type| output_type.get_primitive_count()).fold(0, |acc, x| acc + x);
-
         FlatFunction {
             id: funct.id.clone(),
             arguments: arguments_flattened,
             statements: statements_flattened,
-            return_count: return_count,
+            signature: funct.signature
         }
     }
 
@@ -1047,15 +1050,17 @@ mod tests {
                         ]
                     }
                 )],
-                return_count: 2
+                signature: Signature::new()
+                    .inputs(vec![])
+                    .outputs(vec![Type::FieldElement, Type::FieldElement])
             }
         ];
         let arguments_flattened = vec![];
         let mut statements_flattened = vec![];
         let statement = TypedStatement::MultipleDefinition(
             vec![
-                Variable::from("a".to_string()),
-                Variable::from("b".to_string())
+                Variable::field_element("a".to_string()),
+                Variable::field_element("b".to_string())
             ],
             TypedExpressionList::FunctionCall("foo".to_string(), vec![], vec![Type::FieldElement, Type::FieldElement])
         );
@@ -1099,13 +1104,15 @@ mod tests {
                         ]
                     }
                 )],
-                return_count: 2
+                signature: Signature::new()
+                    .inputs(vec![Type::FieldElement])
+                    .outputs(vec![Type::FieldElement, Type::FieldElement])
             }
         ];
         let statement = TypedStatement::MultipleDefinition(
             vec![
-                Variable::from("a".to_string()),
-                Variable::from("b".to_string())
+                Variable::field_element("a".to_string()),
+                Variable::field_element("b".to_string())
             ],
             TypedExpressionList::FunctionCall("dup".to_string(), vec![TypedExpression::FieldElement(FieldElementExpression::Number(FieldPrime::from(2)))], vec![Type::FieldElement, Type::FieldElement])
         );
@@ -1154,13 +1161,15 @@ mod tests {
                         ]
                     }
                 )],
-                return_count: 1         
+                signature: Signature::new()
+                    .inputs(vec![])
+                    .outputs(vec![Type::FieldElement])
             }
         ];
         let arguments_flattened = vec![];
         let mut statements_flattened = vec![];
         let statement = TypedStatement::Definition(
-            Variable::from("a".to_string()),
+            Variable::field_element("a".to_string()),
             TypedExpression::FieldElement(FieldElementExpression::FunctionCall("foo".to_string(), vec![]))
         );
 
@@ -1197,14 +1206,14 @@ mod tests {
 
         let funct = TypedFunction {
             id: "foo".to_string(),
-            signature: Signature {
-                inputs: vec![Type::FieldElement],
-                outputs: vec![Type::FieldElement]
-            },
-            arguments: vec![Parameter { id: Variable::from("a"), private: true }],
+            signature: Signature::new()
+                .inputs(vec![Type::FieldElement])
+                .outputs(vec![Type::FieldElement])
+            ,
+            arguments: vec![Parameter { id: Variable::field_element("a"), private: true }],
             statements: vec![
                 TypedStatement::Definition(
-                    Variable::from("a".to_string()), 
+                    Variable::field_element("a".to_string()), 
                     FieldElementExpression::Add(
                         box FieldElementExpression::Identifier("a".to_string()), 
                         box FieldElementExpression::Number(FieldPrime::from(1))
@@ -1243,7 +1252,7 @@ mod tests {
             id: String::from("foo"),
             arguments: vec![],
             statements: vec![
-                TypedStatement::Definition(Variable::from("a"), FieldElementExpression::Number(FieldPrime::from(3)).into()),
+                TypedStatement::Definition(Variable::field_element("a"), FieldElementExpression::Number(FieldPrime::from(3)).into()),
                 TypedStatement::Return(vec![
                     FieldElementExpression::Identifier(String::from("a")).into()
                     ]
@@ -1286,7 +1295,7 @@ mod tests {
                     expressions: vec![FlatExpression::Identifier(FlatVariable::new(0))]
                 })
             ],
-            return_count: 1
+            signature: Signature::new().outputs(vec![Type::FieldElement])
         };
 
 
@@ -1312,8 +1321,8 @@ mod tests {
             id: String::from("main"),
             arguments: vec![],
             statements: vec![
-                TypedStatement::Definition(Variable::from("a"), FieldElementExpression::Number(FieldPrime::from(7)).into()),
-                TypedStatement::Definition(Variable::from("b"), FieldElementExpression::Pow(box FieldElementExpression::Identifier(String::from("a")), box FieldElementExpression::Number(FieldPrime::from(4))).into()),
+                TypedStatement::Definition(Variable::field_element("a"), FieldElementExpression::Number(FieldPrime::from(7)).into()),
+                TypedStatement::Definition(Variable::field_element("b"), FieldElementExpression::Pow(box FieldElementExpression::Identifier(String::from("a")), box FieldElementExpression::Number(FieldPrime::from(4))).into()),
                 TypedStatement::Return(vec![
                     FieldElementExpression::Identifier(String::from("b")).into()
                     ]
@@ -1341,7 +1350,7 @@ mod tests {
                     ]
                 })                
             ],
-            return_count: 1
+            signature: Signature::new().outputs(vec![Type::FieldElement])
         };
 
         let flattened = flattener.flatten_function(
@@ -1377,10 +1386,10 @@ mod tests {
                             TypedExpression::FieldElement(FieldElementExpression::Number(FieldPrime::from(1)))
                         ]
                 )],
-                signature: Signature {
-                    inputs: vec![],
-                    outputs: vec![Type::FieldElement]
-                },
+                signature: Signature::new()
+                    .inputs(vec![])
+                    .outputs(vec![Type::FieldElement])
+                ,
             },
             TypedFunction {
                 id: "foo".to_string(),
@@ -1391,25 +1400,25 @@ mod tests {
                             TypedExpression::FieldElement(FieldElementExpression::Number(FieldPrime::from(2)))
                         ]
                 )],
-                signature: Signature {
-                    inputs: vec![],
-                    outputs: vec![Type::FieldElement, Type::FieldElement]
-                },
+                signature: Signature::new()
+                    .inputs(vec![])
+                    .outputs(vec![Type::FieldElement, Type::FieldElement])
+                ,
             },
             TypedFunction {
                 id: "main".to_string(),
                 arguments: vec![],
                 statements: vec![
-                    TypedStatement::Definition(Variable::from("a".to_string()), TypedExpression::FieldElement(FieldElementExpression::FunctionCall("foo".to_string(), vec![]))),
-                    TypedStatement::MultipleDefinition(vec![Variable::from("b".to_string()), Variable::from("c".to_string())], TypedExpressionList::FunctionCall("foo".to_string(), vec![], vec![Type::FieldElement, Type::FieldElement])),
+                    TypedStatement::Definition(Variable::field_element("a".to_string()), TypedExpression::FieldElement(FieldElementExpression::FunctionCall("foo".to_string(), vec![]))),
+                    TypedStatement::MultipleDefinition(vec![Variable::field_element("b".to_string()), Variable::field_element("c".to_string())], TypedExpressionList::FunctionCall("foo".to_string(), vec![], vec![Type::FieldElement, Type::FieldElement])),
                     TypedStatement::Return(
                         vec![TypedExpression::FieldElement(FieldElementExpression::Number(FieldPrime::from(1)))]
                     )
                 ],
-                signature: Signature {
-                    inputs: vec![],
-                    outputs: vec![Type::FieldElement]
-                },
+                signature: Signature::new()
+                    .inputs(vec![])
+                    .outputs(vec![Type::FieldElement])
+                ,
             }
         ];
 

zokrates_core/src/imports.rs

@@ -4,12 +4,35 @@
 //! @author Thibaut Schaeffer <thibaut@schaeff.fr>
 //! @date 2018
 
+use compile::CompileError;
+use std::io::BufRead;
+use compile::compile_aux;
 use std::fmt;
 use absy::*;
 use flat_absy::*;
 use field::Field;
 use std::io;
 
+pub struct CompiledImport<T: Field> {
+	pub flat_func: FlatFunction<T>,
+}
+
+impl<T: Field> CompiledImport<T> {
+	fn new(prog: FlatProg<T>, alias: String) -> CompiledImport<T> {
+		match prog.functions.iter().find(|fun| fun.id == "main") {
+        	Some(fun) => {
+				CompiledImport { flat_func: 
+					FlatFunction {
+						id: alias,
+						..fun.clone()
+					}
+				}
+        	},
+        	None => panic!("no main")
+        }
+	}
+}
+
 #[derive(PartialEq, Debug)]
 pub struct Error {
 	message: String
@@ -104,27 +127,56 @@ impl Importer {
 		}
 	}
 
-	pub	fn apply_imports<T: Field>(&self, origins: Vec<(FlatProg<T>, String)>, destination: Prog<T>) -> Prog<T> {
-		let imported_mains = origins.iter().map(|origin| {
-			match origin {
-				&(ref program, ref alias) => {
-					match program.functions.iter().find(|fun| fun.id == "main") {
-			        	Some(fun) => {
-			        		let mut f = fun.clone();
-			        		f.id = alias.to_string();
-			        		f
-			        	},
-			        	None => panic!("no main")
-			        }
-				}
-			}
-		}).collect();
+	pub	fn apply_imports<T: Field, S: BufRead, E: Into<Error>>(&self, destination: Prog<T>, location: Option<String>, resolve_option: Option<fn(&Option<String>, &String) -> Result<(S, String, String), E>>, should_include_gadgets: bool) -> Result<Prog<T>, CompileError<T>> {
 
-		Prog {
+		let mut origins: Vec<CompiledImport<T>> = vec![];
+
+	    // to resolve imports, we need a resolver
+	    match resolve_option {
+	    	Some(resolve) => {
+	    		// we have a resolver, pass each import through it
+		    	for import in destination.imports.iter() {
+		    		// find the absolute path for the import, based on the path of the file which imports it
+		    		match resolve(&location, &import.source) {
+		    			Ok((mut reader, location, auto_alias)) => {
+				    		let compiled = compile_aux(&mut reader, Some(location), resolve_option, should_include_gadgets)?;
+				    		let alias = match import.alias {
+				    			Some(ref alias) => alias.clone(),
+				    			None => auto_alias
+				    		};
+					    	origins.push(CompiledImport::new(compiled, alias));
+				    	},
+		    			Err(err) => return Err(CompileError::ImportError(err.into()))
+		    		}
+		    	}
+	    	},
+	    	None => {
+	    		if destination.imports.len() > 0 {
+	    			return Err(Error::new("Can't resolve import without a resolver").into())
+	    		}
+	    	}
+	    }
+
+	    #[cfg(feature = "libsnark")]
+	    {
+	    	use libsnark::{get_sha256_constraints};
+	    	use standard::R1CS;
+	    	use serde_json::from_str;
+
+		    if should_include_gadgets {
+		    	// inject globals
+			    let r1cs: R1CS = from_str(&get_sha256_constraints()).unwrap();
+
+			    origins.push(CompiledImport::new(FlatProg::from(r1cs), "sha256libsnark".to_string()));
+		    }
+	   	}
+
+
+		Ok(Prog {
 			imports: vec![],
 			functions: destination.clone().functions,
-			imported_functions: imported_mains
-		}
+			imported_functions: origins.into_iter().map(|o| o.flat_func).collect()
+		})
 	}
 }
 

zokrates_core/src/optimizer.rs

@@ -119,6 +119,7 @@ impl Optimizer {
 
 #[cfg(test)]
 mod tests {
+	use types::{Type, Signature};
 	use super::*;
 	use field::FieldPrime;
 	use flat_absy::flat_parameter::FlatParameter;
@@ -145,7 +146,10 @@ mod tests {
             		expressions: vec![FlatExpression::Identifier(z)]
             	})
             ],
-            return_count: 1
+            signature: Signature {
+            	inputs: vec![Type::FieldElement],
+            	outputs: vec![Type::FieldElement]
+            }
         };
 
         let optimized: FlatFunction<FieldPrime> = FlatFunction {
@@ -156,7 +160,10 @@ mod tests {
             		expressions: vec![FlatExpression::Identifier(x)]
             	})
         	],
-        	return_count: 1
+        	signature: Signature {
+            	inputs: vec![Type::FieldElement],
+            	outputs: vec![Type::FieldElement]
+            }
         };
 
         let mut optimizer = Optimizer::new();
@@ -192,7 +199,10 @@ mod tests {
             		expressions: vec![FlatExpression::Identifier(z), FlatExpression::Identifier(w)]
             	})
             ],
-            return_count: 2
+        	signature: Signature {
+            	inputs: vec![Type::FieldElement],
+            	outputs: vec![Type::FieldElement, Type::FieldElement]
+            }
         };
 
         let optimized: FlatFunction<FieldPrime> = FlatFunction {
@@ -204,7 +214,10 @@ mod tests {
             		expressions: vec![FlatExpression::Identifier(x), FlatExpression::Identifier(y)]
             	})
         	],
-        	return_count: 2
+        	signature: Signature {
+            	inputs: vec![Type::FieldElement],
+            	outputs: vec![Type::FieldElement, Type::FieldElement]
+            }
         };
 
         let mut optimizer = Optimizer::new();

zokrates_core/src/parser/parse/expression.rs

@@ -3,12 +3,12 @@ use field::Field;
 use parser::Error;
 use parser::tokenize::{Token, Position, next_token};
 
-use absy::{Condition, Expression};
+use absy::{Expression};
 
 use parser::tokenize::parse_num;
 
 fn parse_then_else<T: Field>(
-    cond: Condition<T>,
+    cond: Expression<T>,
     input: &String,
     pos: &Position,
 ) -> Result<(Expression<T>, String, Position), Error<T>> {
@@ -52,23 +52,23 @@ fn parse_if_then_else<T: Field>(
         (Token::If, s1, p1) => match parse_expr(&s1, &p1) {
             Ok((e2, s2, p2)) => match next_token(&s2, &p2) {
                 (Token::Lt, s3, p3) => match parse_expr(&s3, &p3) {
-                    Ok((e4, s4, p4)) => parse_then_else(Condition::Lt(e2, e4), &s4, &p4),
+                    Ok((e4, s4, p4)) => parse_then_else(Expression::Lt(box e2, box e4), &s4, &p4),
                     Err(err) => Err(err),
                 },
                 (Token::Le, s3, p3) => match parse_expr(&s3, &p3) {
-                    Ok((e4, s4, p4)) => parse_then_else(Condition::Le(e2, e4), &s4, &p4),
+                    Ok((e4, s4, p4)) => parse_then_else(Expression::Le(box e2, box e4), &s4, &p4),
                     Err(err) => Err(err),
                 },
                 (Token::Eqeq, s3, p3) => match parse_expr(&s3, &p3) {
-                    Ok((e4, s4, p4)) => parse_then_else(Condition::Eq(e2, e4), &s4, &p4),
+                    Ok((e4, s4, p4)) => parse_then_else(Expression::Eq(box e2, box e4), &s4, &p4),
                     Err(err) => Err(err),
                 },
                 (Token::Ge, s3, p3) => match parse_expr(&s3, &p3) {
-                    Ok((e4, s4, p4)) => parse_then_else(Condition::Ge(e2, e4), &s4, &p4),
+                    Ok((e4, s4, p4)) => parse_then_else(Expression::Ge(box e2, box e4), &s4, &p4),
                     Err(err) => Err(err),
                 },
                 (Token::Gt, s3, p3) => match parse_expr(&s3, &p3) {
-                    Ok((e4, s4, p4)) => parse_then_else(Condition::Gt(e2, e4), &s4, &p4),
+                    Ok((e4, s4, p4)) => parse_then_else(Expression::Gt(box e2, box e4), &s4, &p4),
                     Err(err) => Err(err),
                 },
                 (t3, _, p3) => Err(Error {
@@ -300,9 +300,9 @@ mod tests {
         let pos = Position { line: 45, col: 121 };
         let string = String::from("if a < b then c else d fi");
         let expr = Expression::IfElse::<FieldPrime>(
-            box Condition::Lt(
-                Expression::Identifier(String::from("a")),
-                Expression::Identifier(String::from("b")),
+            box Expression::Lt(
+                box Expression::Identifier(String::from("a")),
+                box Expression::Identifier(String::from("b")),
             ),
             box Expression::Identifier(String::from("c")),
             box Expression::Identifier(String::from("d")),
@@ -320,9 +320,9 @@ mod tests {
             let pos = Position { line: 45, col: 121 };
             let string = String::from("if a < b then c else d fi");
             let expr = Expression::IfElse::<FieldPrime>(
-                box Condition::Lt(
-                    Expression::Identifier(String::from("a")),
-                    Expression::Identifier(String::from("b")),
+                box Expression::Lt(
+                    box Expression::Identifier(String::from("a")),
+                    box Expression::Identifier(String::from("b")),
                 ),
                 box Expression::Identifier(String::from("c")),
                 box Expression::Identifier(String::from("d")),

zokrates_core/src/parser/parse/function.rs

@@ -11,163 +11,283 @@ use super::statement::parse_statement;
 use absy::{Function, Statement, Variable, Parameter};
 use types::{Type, Signature};
 
+fn parse_function_identifier<T: Field>(
+    input: &String,
+    pos: &Position
+) -> Result<(String, String, Position), Error<T>> {
+    match next_token::<T>(&input, &pos) {
+        (Token::Ide(x), s, p) => {
+            Ok((x, s, p))
+        },
+        (t, _, p) => {
+            Err(Error {
+                expected: vec![Token::Ide(String::from("name"))],
+                got: t,
+                pos: p,
+            })
+        }
+    }
+}
+
+
+
+fn parse_function_header<T: Field>(
+    input: &String,
+    pos: &Position
+) -> Result<(String, Vec<Parameter>, Signature), Error<T>> {
+    // parse function identifier
+    let (id, s, p) = parse_function_identifier(input, pos)?;
+
+    // parse function arguments, enclosed by parentheses
+    let (args, s, p) = match next_token(&s, &p) {
+        (Token::Open, s1, p1) => {
+            match parse_function_arguments(s1, p1) {
+                Ok((args, s2, p2)) => {
+                    match next_token::<T>(&s2, &p2) {
+                        (Token::Close, s3, p3) => {
+                            Ok((args, s3, p3))
+                        },
+                        (t3, _, p3) => {
+                            return Err(Error {
+                                expected: vec![Token::Close],
+                                got: t3,
+                                pos: p3
+                            })
+                        }
+                    }
+                },
+                Err(e) => return Err(e),
+            }
+        }
+        (t1, _, p1) => {
+            return Err(Error {
+                expected: vec![Token::Open],
+                got: t1,
+                pos: p1,
+            })
+        }
+    }?;
+
+    // parse function return types, enclosed by parentheses
+    let (return_types, s, p) = match next_token(&s, &p) {
+        (Token::Arrow, s0, p0) => {
+            match next_token(&s0, &p0) {
+                (Token::Open, s1, p1) => {
+                    match parse_function_return_types(s1, p1) {
+                        Ok((types, s2, p2)) => {
+                            match next_token::<T>(&s2, &p2) {
+                                (Token::Close, s3, p3) => {
+                                    Ok((types, s3, p3))
+                                },
+                                (t3, _, p3) => {
+                                    return Err(Error {
+                                        expected: vec![Token::Close],
+                                        got: t3,
+                                        pos: p3
+                                    })
+                                }
+                            }
+                        },
+                        Err(e) => return Err(e),
+                    }
+                }
+                (t1, _, p1) => {
+                    return Err(Error {
+                        expected: vec![Token::Open],
+                        got: t1,
+                        pos: p1,
+                    })
+                }
+            }
+        },
+        (t0, _, p0) => {
+            return Err(Error {
+                expected: vec![Token::Arrow],
+                got: t0,
+                pos: p0,
+            })
+        }
+    }?;
+
+    let sig = Signature {
+        inputs: args.iter().map(|a| a.id.get_type()).collect(),
+        outputs: return_types
+    };
+
+    match next_token(&s, &p) {
+        (Token::Colon, s5, p5) => match next_token(&s5, &p5) {
+            (Token::InlineComment(_), _, _) => return Ok((id, args, sig)),
+            (Token::Unknown(ref x6), ..) if x6 == "" => return Ok((id, args, sig)),
+            (t6, _, p6) => {
+                return Err(Error {
+                    expected: vec![Token::Unknown("".to_string())],
+                    got: t6,
+                    pos: p6,
+                })
+            }
+        },
+        (t5, _, p5) => {
+            return Err(Error {
+                expected: vec![Token::Colon],
+                got: t5,
+                pos: p5,
+            })
+        }
+    }
+}
+
+fn parse_function_argument_variable<T: Field>(
+    input: &String,
+    pos: &Position
+) -> Result<(Variable, String, Position), Error<T>> {
+    let s4 = input;
+    let p4 = pos;
+
+    match next_token::<T>(&s4, &p4) {
+        (Token::Type(t), s5, p5) => {
+            match next_token(&s5, &p5) {
+                (Token::Ide(x), s6, p6) => {
+                    Ok((Variable::new(x, t), s6, p6))
+                }
+                (t6, _, p6) => {
+                    Err(Error {
+                        expected: vec![Token::Ide(String::from("identifier"))],
+                        got: t6,
+                        pos: p6,
+                    })
+                }
+            }
+        },
+        (t5, _, p5) => {
+            Err(Error {
+                expected: vec![Token::Type(Type::FieldElement)],
+                got: t5,
+                pos: p5,
+            })
+        }
+    }
+}
+
+fn parse_function_arguments<T: Field>(
+    input: String,
+    pos: Position,
+) -> Result<(Vec<Parameter>, String, Position), Error<T>> {
+    let mut args = Vec::new();
+    let mut s = input;
+    let mut p = pos;
+
+    loop {
+        match next_token(&s, &p) {
+            (Token::Private, s1, p1) => {
+                let (var, s2, p2) = parse_function_argument_variable::<T>(&s1, &p1)?;
+                args.push(Parameter { id: var, private: true});
+                match next_token::<T>(&s2, &p2) {
+                    (Token::Comma, s3, p3) => {
+                        s = s3;
+                        p = p3;
+                    },
+                    (Token::Close, _, _) => {
+                        return Ok((args, s2, p2))
+                    },
+                    (t3, _, p3) => {
+                        return Err(Error {
+                            expected: vec![Token::Comma, Token::Close],
+                            got: t3,
+                            pos: p3
+                        })
+                    }
+                }
+            },
+            (Token::Type(_), _, _) => {
+                let (var, s2, p2) = parse_function_argument_variable::<T>(&s, &p)?;
+                args.push(Parameter { id: var, private: false});
+                match next_token::<T>(&s2, &p2) {
+                    (Token::Comma, s3, p3) => {
+                        s = s3;
+                        p = p3;
+                    },
+                    (Token::Close, _, _) => {
+                        return Ok((args, s2, p2))
+                    },
+                    (t3, _, p3) => {
+                        return Err(Error {
+                            expected: vec![Token::Comma, Token::Close],
+                            got: t3,
+                            pos: p3
+                        })
+                    }
+                }
+            },
+            (Token::Close, _, _) => {
+                return Ok((vec![], s, p))
+            },
+            (t4, _, p4) => {
+                return Err(Error {
+                    expected: vec![Token::Type(Type::FieldElement), Token::Private, Token::Close],
+                    got: t4,
+                    pos: p4,
+                })
+            }
+        }
+    }
+}
+
+fn parse_function_return_types<T: Field>(
+    input: String,
+    pos: Position,
+) -> Result<(Vec<Type>, String, Position), Error<T>> {
+    let mut types = Vec::new();
+    let mut s = input;
+    let mut p = pos;
+
+    loop {
+        match next_token(&s, &p) {
+            (Token::Type(t), s1, p1) => {
+                types.push(t);
+                match next_token::<T>(&s1, &p1) {
+                    (Token::Comma, s3, p3) => {
+                        s = s3;
+                        p = p3;
+                    },
+                    (Token::Close, _, _) => {
+                        return Ok((types, s1, p1))
+                    },
+                    (t3, _, p3) => {
+                        return Err(Error {
+                            expected: vec![Token::Comma, Token::Close],
+                            got: t3,
+                            pos: p3
+                        })
+                    }
+                }
+            },
+            (Token::Close, _, _) => {
+                return Ok((vec![], s, p))
+            },
+            (t4, _, p4) => {
+                return Err(Error {
+                    expected: vec![Token::Type(Type::FieldElement), Token::Private, Token::Close],
+                    got: t4,
+                    pos: p4,
+                })
+            }
+        }
+    }
+}
+
 pub fn parse_function<T: Field, R: BufRead>(
     mut lines: &mut Lines<R>,
     input: &String,
     pos: &Position,
 ) -> Result<(Function<T>, Position), Error<T>> {
     let mut current_line = pos.line;
-    let id;
-    let mut args = Vec::new();
 
-    // parse function signature
-    match next_token(input, pos) {
-        (Token::Ide(x2), s2, p2) => {
-            id = x2;
-            match next_token(&s2, &p2) {
-                (Token::Open, s3, p3) => {
-                    let mut s = s3;
-                    let mut p = p3;
-                    loop {
-                        match next_token(&s, &p) {
-                            (Token::Private, s4, p4) => {
-                                match next_token(&s4, &p4) {
-                                    (Token::Ide(x), s5, p5) => {
-                                        args.push(Parameter { id: Variable::from(x), private: true });
-                                        match next_token(&s5, &p5) {
-                                            (Token::Comma, s6, p6) => {
-                                                s = s6;
-                                                p = p6;
-                                            }
-                                            (Token::Close, s5, p5) => match next_token(&s5, &p5) {
-                                                (Token::Colon, s6, p6) => match next_token(&s6, &p6) {
-                                                    (Token::InlineComment(_), _, _) => break,
-                                                    (Token::Unknown(ref x6), ..) if x6 == "" => break,
-                                                    (t6, _, p6) => {
-                                                        return Err(Error {
-                                                            expected: vec![Token::Unknown("".to_string())],
-                                                            got: t6,
-                                                            pos: p6,
-                                                        })
-                                                    }
-                                                },
-                                                (t6, _, p6) => {
-                                                    return Err(Error {
-                                                        expected: vec![Token::Colon],
-                                                        got: t6,
-                                                        pos: p6,
-                                                    })
-                                                }
-                                            },
-                                            (t5, _, p5) => {
-                                                return Err(Error {
-                                                    expected: vec![Token::Comma, Token::Close],
-                                                    got: t5,
-                                                    pos: p5,
-                                                })
-                                            }
-                                        }
-                                    }
-                                    (t5, _, p5) => {
-                                        return Err(Error {
-                                            expected: vec![Token::Comma, Token::Close],
-                                            got: t5,
-                                            pos: p5,
-                                        })
-                                    }
-                                }
-                            }
-                            (Token::Ide(x), s4, p4) => {
-                                args.push(Parameter { id: Variable::from(x), private: false });
-                                match next_token(&s4, &p4) {
-                                    (Token::Comma, s5, p5) => {
-                                        s = s5;
-                                        p = p5;
-                                    }
-                                    (Token::Close, s4, p4) => match next_token(&s4, &p4) {
-                                        (Token::Colon, s5, p5) => match next_token(&s5, &p5) {
-                                            (Token::InlineComment(_), _, _) => break,
-                                            (Token::Unknown(ref x6), ..) if x6 == "" => break,
-                                            (t6, _, p6) => {
-                                                return Err(Error {
-                                                    expected: vec![Token::Unknown("".to_string())],
-                                                    got: t6,
-                                                    pos: p6,
-                                                })
-                                            }
-                                        },
-                                        (t5, _, p5) => {
-                                            return Err(Error {
-                                                expected: vec![Token::Colon],
-                                                got: t5,
-                                                pos: p5,
-                                            })
-                                        }
-                                    },
-                                    (t5, _, p5) => {
-                                        return Err(Error {
-                                            expected: vec![Token::Comma, Token::Close],
-                                            got: t5,
-                                            pos: p5,
-                                        })
-                                    }
-                                }
-                            }
-                            (Token::Close, s4, p4) => {
-                                // case of no parameters
-                                match next_token(&s4, &p4) {
-                                    (Token::Colon, s5, p5) => match next_token(&s5, &p5) {
-                                        (Token::InlineComment(_), _, _) => break,
-                                        (Token::Unknown(ref x6), ..) if x6 == "" => break,
-                                        (t6, _, p6) => {
-                                            return Err(Error {
-                                                expected: vec![Token::Unknown("".to_string())],
-                                                got: t6,
-                                                pos: p6,
-                                            })
-                                        }
-                                    },
-                                    (t5, _, p5) => {
-                                        return Err(Error {
-                                            expected: vec![Token::Colon],
-                                            got: t5,
-                                            pos: p5,
-                                        })
-                                    }
-                                }
-                            }
-                            (t4, _, p4) => {
-                                return Err(Error {
-                                    expected: vec![Token::Ide(String::from("ide")), Token::Close],
-                                    got: t4,
-                                    pos: p4,
-                                })
-                            }
-                        }
-                    }
-                }
-                (t3, _, p3) => {
-                    return Err(Error {
-                        expected: vec![Token::Open],
-                        got: t3,
-                        pos: p3,
-                    })
-                }
-            }
-        }
-        (t2, _, p2) => {
-            return Err(Error {
-                expected: vec![Token::Ide(String::from("name"))],
-                got: t2,
-                pos: p2,
-            })
-        }
-    }
+    let (id, args, sig) = parse_function_header(input, pos)?;
+
     current_line += 1;
 
     // parse function body
     let mut stats = Vec::new();
-    let return_count;
     loop {
         match lines.next() {
             Some(Ok(ref x)) if x.trim().starts_with("//") || x.trim() == "" => {} // skip
@@ -179,14 +299,18 @@ pub fn parse_function<T: Field, R: BufRead>(
                     col: 1,
                 },
             ) {
-                Ok((Statement::Return(list), ..)) => {
-                    return_count = list.expressions.len();
-                    stats.push(Statement::Return(list));
-                    break;
-                }
-                Ok((statement, _, pos)) => {
-                    stats.push(statement);
-                    current_line = pos.line // update the interal line counter to continue where statement ended.
+                Ok((ref statements, _, ref pos)) => {
+                    for stat in statements {
+                        stats.push(stat.clone());
+                    }
+                    match statements[0] {
+                        Statement::Return(_) => {
+                            break;
+                        },
+                        _ => {
+                            current_line = pos.line // update the interal line counter to continue where statement ended.
+                        }
+                    }
                 }
                 Err(err) => return Err(err),
             },
@@ -202,17 +326,12 @@ pub fn parse_function<T: Field, R: BufRead>(
         None => panic!("Error while checking last function statement"),
     }
 
-    let input_count = args.len();
-
     Ok((
         Function {
             id: id,
             arguments: args,
             statements: stats,
-            signature: Signature {
-                inputs: vec![Type::FieldElement; input_count],
-                outputs: vec![Type::FieldElement; return_count]
-            }
+            signature: sig
         },
         Position {
             line: current_line,

zokrates_core/src/parser/parse/import.rs

@@ -87,7 +87,7 @@ mod tests {
         let string = String::from("import \"./foo.code\"");
         let import: Token<FieldPrime> = Token::Import;
         assert_eq!(
-            (import, "\"./foo.code\"".to_string(), pos.col(7 as isize)),
+            (import, " \"./foo.code\"".to_string(), pos.col(6 as isize)),
             next_token(&string, &pos)
         )
     }

zokrates_core/src/parser/parse/statement.rs

@@ -1,24 +1,26 @@
 use field::Field;
 
 use std::io::prelude::*;
-use std::io::{Lines};
+use std::io::Lines;
 
+use parser::tokenize::{next_token, Position, Token};
 use parser::Error;
-use parser::tokenize::{Token, Position, next_token};
 
-use parser::tokenize::{parse_ide, skip_whitespaces};
+use parser::tokenize::skip_whitespaces;
 
+use super::expression::{parse_expr, parse_expr1, parse_function_call, parse_term1};
 use super::expression_list::parse_expression_list;
-use super::expression::{parse_function_call, parse_term1, parse_expr1, parse_expr};
 
-use absy::{Statement, Expression, Variable};
+use absy::{Expression, Statement, Variable};
+use types::Type;
 
 pub fn parse_statement<T: Field, R: BufRead>(
     lines: &mut Lines<R>,
     input: &String,
     pos: &Position,
-) -> Result<(Statement<T>, String, Position), Error<T>> {
+) -> Result<(Vec<Statement<T>>, String, Position), Error<T>> {
     match next_token::<T>(input, pos) {
+        (Token::Type(t), s1, p1) => parse_declaration_definition(t, s1, p1),
         (Token::Ide(x1), s1, p1) => parse_statement1(x1, s1, p1),
         (Token::If, ..) | (Token::Open, ..) | (Token::Num(_), ..) => match parse_expr(input, pos) {
             Ok((e2, s2, p2)) => match next_token(&s2, &p2) {
@@ -26,11 +28,11 @@ pub fn parse_statement<T: Field, R: BufRead>(
                     Ok((e4, s4, p4)) => match next_token(&s4, &p4) {
                         (Token::InlineComment(_), ref s5, _) => {
                             assert_eq!(s5, "");
-                            Ok((Statement::Condition(e2, e4), s4, p4))
+                            Ok((vec![Statement::Condition(e2, e4)], s4, p4))
                         }
                         (Token::Unknown(ref t5), ref s5, _) if t5 == "" => {
                             assert_eq!(s5, "");
-                            Ok((Statement::Condition(e2, e4), s4, p4))
+                            Ok((vec![Statement::Condition(e2, e4)], s4, p4))
                         }
                         (t5, _, p5) => Err(Error {
                             expected: vec![Token::Unknown("".to_string())],
@@ -49,120 +51,130 @@ pub fn parse_statement<T: Field, R: BufRead>(
             Err(err) => Err(err),
         },
         (Token::For, s1, p1) => {
-            match parse_ide(&s1, &p1) {
-                (Token::Ide(x2), s2, p2) => {
-                    match next_token(&s2, &p2) {
-                        (Token::In, s3, p3) => {
-                            match next_token(&s3, &p3) {
-                                (Token::Num(x4), s4, p4) => {
-                                    match next_token(&s4, &p4) {
-                                        (Token::Dotdot, s5, p5) => {
-                                            match next_token(&s5, &p5) {
-                                                (Token::Num(x6), s6, p6) => {
-                                                    match next_token(&s6, &p6) {
-                                                        (Token::Do, s7, p7) => {
-                                                            match next_token(&s7, &p7) {
-                                                                (
-                                                                    Token::InlineComment(_),
-                                                                    ref s8,
-                                                                    _,
-                                                                ) => {
-                                                                    assert_eq!(s8, "");
-                                                                }
-                                                                (
-                                                                    Token::Unknown(ref t8),
-                                                                    ref s8,
-                                                                    _,
-                                                                ) if t8 == "" =>
-                                                                {
-                                                                    assert_eq!(s8, "");
-                                                                }
-                                                                (t8, _, p8) => {
-                                                                    return Err(Error {
-                                                                        expected: vec![
-                                                                            Token::Unknown(
-                                                                                "".to_string(),
-                                                                            ),
-                                                                        ],
-                                                                        got: t8,
-                                                                        pos: p8,
-                                                                    })
-                                                                }
+            match next_token(&s1, &p1) {
+                (Token::Type(t), s0, p0) => {
+                    match next_token(&s0, &p0) {
+                        (Token::Ide(x2), s2, p2) => {
+                            match next_token(&s2, &p2) {
+                                (Token::In, s3, p3) => {
+                                    match next_token(&s3, &p3) {
+                                        (Token::Num(x4), s4, p4) => {
+                                            match next_token(&s4, &p4) {
+                                                (Token::Dotdot, s5, p5) => {
+                                                    match next_token(&s5, &p5) {
+                                                        (Token::Num(x6), s6, p6) => {
+                                                            match next_token(&s6, &p6) {
+                                                                (Token::Do, s7, p7) => {
+                                                                    match next_token(&s7, &p7) {
+                                                                        (
+                                                                            Token::InlineComment(_),
+                                                                            ref s8,
+                                                                            _,
+                                                                        ) => {
+                                                                            assert_eq!(s8, "");
+                                                                        }
+                                                                        (
+                                                                            Token::Unknown(ref t8),
+                                                                            ref s8,
+                                                                            _,
+                                                                        )
+                                                                            if t8 == "" =>
+                                                                        {
+                                                                            assert_eq!(s8, "");
+                                                                        }
+                                                                        (t8, _, p8) => {
+                                                                            return Err(Error {
+                                                                                expected: vec![
+                                                                                    Token::Unknown(
+                                                                                        "".to_string(),
+                                                                                    ),
+                                                                                ],
+                                                                                got: t8,
+                                                                                pos: p8,
+                                                                            })
+                                                                        }
+                                                                    }
+                                                                    let mut current_line = p7.line;
+                                                                    let mut statements = Vec::new();
+                                                                    loop {
+                                                                        current_line += 1;
+                                                                        match lines.next() {
+                                                    Some(Ok(ref x)) if x.trim().starts_with("//") || x.trim() == "" => {}, // skip
+                                                    Some(Ok(ref x)) if x.trim().starts_with("endfor") => {
+                                                        let offset = skip_whitespaces(x);
+                                                        let s8 = x[offset + 6..].to_string();
+                                                        let p8 = Position{ line: current_line, col: offset + 7 };
+                                                        match next_token(&s8, &p8) {
+                                                            (Token::InlineComment(_), ref s9, _) => {
+                                                                assert_eq!(s9, "");
+                                                                return Ok((vec![Statement::For(Variable::new(x2, t), x4, x6, statements)], s8, p8))
                                                             }
-                                                            let mut current_line = p7.line;
-                                                            let mut statements = Vec::new();
-                                                            loop {
-                                                                current_line += 1;
-                                                                match lines.next() {
-                                            Some(Ok(ref x)) if x.trim().starts_with("//") || x.trim() == "" => {}, // skip
-                                            Some(Ok(ref x)) if x.trim().starts_with("endfor") => {
-                                                let offset = skip_whitespaces(x);
-                                                let s8 = x[offset + 6..].to_string();
-                                                let p8 = Position{ line: current_line, col: offset + 7 };
-                                                match next_token(&s8, &p8) {
-                                                    (Token::InlineComment(_), ref s9, _) => {
-                                                        assert_eq!(s9, "");
-                                                        return Ok((Statement::For(Variable::from(x2), x4, x6, statements), s8, p8))
-                                                    }
-                                                    (Token::Unknown(ref t9), ref s9, _) if t9 == "" => {
-                                                        assert_eq!(s9, "");
-                                                        return Ok((Statement::For(Variable::from(x2), x4, x6, statements), s8, p8))
+                                                            (Token::Unknown(ref t9), ref s9, _) if t9 == "" => {
+                                                                assert_eq!(s9, "");
+                                                                return Ok((vec![Statement::For(Variable::new(x2, t), x4, x6, statements)], s8, p8))
+                                                            },
+                                                            (t9, _, p9) => return Err(Error { expected: vec![Token::Unknown("1432567iuhgvfc".to_string())], got: t9 , pos: p9 }),
+                                                        }
                                                     },
-                                                    (t9, _, p9) => return Err(Error { expected: vec![Token::Unknown("1432567iuhgvfc".to_string())], got: t9 , pos: p9 }),
+                                                    Some(Ok(ref x)) if !x.trim().starts_with("return") => match parse_statement(lines, x, &Position { line: current_line, col: 1 }) {
+                                                        Ok((statement, ..)) => statements.push(statement[0].clone()),
+                                                        Err(err) => return Err(err),
+                                                    },
+                                                    Some(Err(err)) => panic!("Error while reading Definitions: {}", err),
+                                                    Some(Ok(ref x)) => {
+                                                        let (t, ..) = next_token(x, &Position{ line: current_line, col: 1 });
+                                                        return Err(Error { expected: vec![Token::ErrIde, Token::ErrNum, Token::If, Token::Open, Token::Hash, Token::For, Token::Endfor], got: t , pos:  Position{ line: current_line, col: 1 } })
+                                                    },
+                                                    None => return Err(Error { expected: vec![Token::ErrIde, Token::ErrNum, Token::If, Token::Open, Token::Hash, Token::For], got: Token::Unknown("".to_string()) , pos:  Position{ line: current_line, col: 1 } }),
                                                 }
-                                            },
-                                            Some(Ok(ref x)) if !x.trim().starts_with("return") => match parse_statement(lines, x, &Position { line: current_line, col: 1 }) {
-                                                Ok((statement, ..)) => statements.push(statement),
-                                                Err(err) => return Err(err),
-                                            },
-                                            Some(Err(err)) => panic!("Error while reading Definitions: {}", err),
-                                            Some(Ok(ref x)) => {
-                                                let (t, ..) = next_token(x, &Position{ line: current_line, col: 1 });
-                                                return Err(Error { expected: vec![Token::ErrIde, Token::ErrNum, Token::If, Token::Open, Token::Hash, Token::For, Token::Endfor], got: t , pos:  Position{ line: current_line, col: 1 } })
-                                            },
-                                            None => return Err(Error { expected: vec![Token::ErrIde, Token::ErrNum, Token::If, Token::Open, Token::Hash, Token::For], got: Token::Unknown("".to_string()) , pos:  Position{ line: current_line, col: 1 } }),
-                                        }
+                                                                    }
+                                                                }
+                                                                (t7, _, p7) => Err(Error {
+                                                                    expected: vec![Token::Do],
+                                                                    got: t7,
+                                                                    pos: p7,
+                                                                }),
                                                             }
                                                         }
-                                                        (t7, _, p7) => Err(Error {
-                                                            expected: vec![Token::Do],
-                                                            got: t7,
-                                                            pos: p7,
+                                                        (t6, _, p6) => Err(Error {
+                                                            expected: vec![Token::ErrNum],
+                                                            got: t6,
+                                                            pos: p6,
                                                         }),
                                                     }
                                                 }
-                                                (t6, _, p6) => Err(Error {
-                                                    expected: vec![Token::ErrNum],
-                                                    got: t6,
-                                                    pos: p6,
+                                                (t5, _, p5) => Err(Error {
+                                                    expected: vec![Token::Dotdot],
+                                                    got: t5,
+                                                    pos: p5,
                                                 }),
                                             }
                                         }
-                                        (t5, _, p5) => Err(Error {
-                                            expected: vec![Token::Dotdot],
-                                            got: t5,
-                                            pos: p5,
+                                        (t4, _, p4) => Err(Error {
+                                            expected: vec![Token::ErrNum],
+                                            got: t4,
+                                            pos: p4,
                                         }),
                                     }
                                 }
-                                (t4, _, p4) => Err(Error {
-                                    expected: vec![Token::ErrNum],
-                                    got: t4,
-                                    pos: p4,
+                                (t3, _, p3) => Err(Error {
+                                    expected: vec![Token::In],
+                                    got: t3,
+                                    pos: p3,
                                 }),
                             }
                         }
-                        (t3, _, p3) => Err(Error {
-                            expected: vec![Token::In],
-                            got: t3,
-                            pos: p3,
+                        (t2, _, p2) => Err(Error {
+                            expected: vec![Token::ErrIde],
+                            got: t2,
+                            pos: p2,
                         }),
                     }
-                }
-                (t2, _, p2) => Err(Error {
-                    expected: vec![Token::ErrIde],
-                    got: t2,
-                    pos: p2,
+                },
+                (t0, _, p0) => Err(Error {
+                    expected: vec![Token::Type(Type::FieldElement)],
+                    got: t0,
+                    pos: p0,
                 }),
             }
         }
@@ -170,11 +182,11 @@ pub fn parse_statement<T: Field, R: BufRead>(
             Ok((e2, s2, p2)) => match next_token(&s2, &p2) {
                 (Token::InlineComment(_), ref s3, _) => {
                     assert_eq!(s3, "");
-                    Ok((Statement::Return(e2), s2, p2))
+                    Ok((vec![Statement::Return(e2)], s2, p2))
                 }
                 (Token::Unknown(ref t3), ref s3, _) if t3 == "" => {
                     assert_eq!(s3, "");
-                    Ok((Statement::Return(e2), s2, p2))
+                    Ok((vec![Statement::Return(e2)], s2, p2))
                 }
                 (t3, _, p3) => Err(Error {
                     expected: vec![Token::Unknown("".to_string())],
@@ -203,25 +215,79 @@ pub fn parse_statement<T: Field, R: BufRead>(
     }
 }
 
-// parse statement that starts with an identifier
-fn parse_statement1<T: Field>(
-    ide: String,
+fn parse_definition1<T: Field>(
+    x: String,
     input: String,
     pos: Position,
-) -> Result<(Statement<T>, String, Position), Error<T>> {
+) -> Result<(Vec<Statement<T>>, String, Position), Error<T>> {
+    match parse_expr(&input, &pos) {
+        Ok((e1, s1, p1)) => match next_token(&s1, &p1) {
+            (Token::InlineComment(_), ref s2, _) => {
+                assert_eq!(s2, "");
+                match e1 {
+                        e @ Expression::FunctionCall(..) => {
+                            Ok((vec![Statement::MultipleDefinition(vec![x], e)], s1, p1))
+                        },
+                        e => {
+                            Ok((vec![Statement::Definition(x, e)], s1, p1))
+                        }
+                    }            
+                }
+            (Token::Unknown(ref t2), ref s2, _) if t2 == "" => {
+                assert_eq!(s2, "");
+                match e1 {
+                    e @ Expression::FunctionCall(..) => {
+                        Ok((vec![Statement::MultipleDefinition(vec![x], e)], s1, p1))
+                    },
+                    e => {
+                        Ok((vec![Statement::Definition(x, e)], s1, p1))
+                    }
+                }            
+            }
+            (t2, _, p2) => Err(Error {
+                expected: vec![
+                    Token::Unknown("".to_string()),
+                ],
+                got: t2,
+                pos: p2,
+            }),
+        },
+        Err(err) => Err(err),
+    }
+}
+
+fn parse_declaration_definition<T: Field>(
+    t: Type,
+    input: String,
+    pos: Position,
+) -> Result<(Vec<Statement<T>>, String, Position), Error<T>> {
     match next_token::<T>(&input, &pos) {
-        (Token::Eq, s1, p1) => match parse_expr(&s1, &p1) {
-            Ok((e2, s2, p2)) => match next_token(&s2, &p2) {
-                (Token::InlineComment(_), ref s3, _) => {
-                    assert_eq!(s3, "");
-                    Ok((Statement::Definition(Variable::from(ide), e2), s2, p2))
-                }
-                (Token::Unknown(ref t3), ref s3, _) if t3 == "" => {
-                    assert_eq!(s3, "");
-                    Ok((Statement::Definition(Variable::from(ide), e2), s2, p2))
-                }
-                (t3, _, p3) => {
-                    Err(Error {
+        (Token::Ide(x), s0, p0) => match next_token(&s0, &p0) {
+            (Token::Eq, s1, p1) => match parse_expr(&s1, &p1) {
+                Ok((e2, s2, p2)) => match next_token(&s2, &p2) {
+                    (Token::InlineComment(_), ref s3, _) => {
+                        assert_eq!(s3, "");
+                        match e2 {
+                            e @ Expression::FunctionCall(..) => {
+                                Ok((vec![Statement::Declaration(Variable::new(x.clone(), t)), Statement::MultipleDefinition(vec![x], e)], s2, p2))
+                            },
+                            e => {
+                                Ok((vec![Statement::Declaration(Variable::new(x.clone(), t)), Statement::Definition(x, e)], s2, p2))
+                            }
+                        }
+                    }
+                    (Token::Unknown(ref t3), ref s3, _) if t3 == "" => {
+                        assert_eq!(s3, "");
+                        match e2 {
+                            e @ Expression::FunctionCall(..) => {
+                                Ok((vec![Statement::Declaration(Variable::new(x.clone(), t)), Statement::MultipleDefinition(vec![x], e)], s2, p2))
+                            },
+                            e => {
+                                Ok((vec![Statement::Declaration(Variable::new(x.clone(), t)), Statement::Definition(x, e)], s2, p2))
+                            }
+                        }
+                    }
+                    (t3, _, p3) => Err(Error {
                         expected: vec![
                             Token::Add,
                             Token::Sub,
@@ -232,28 +298,71 @@ fn parse_statement1<T: Field>(
                         ],
                         got: t3,
                         pos: p3,
-                    })
-                }
+                    }),
+                },
+                Err(err) => Err(err),
             },
-            Err(err) => Err(err),
+            (Token::Comma, s1, p1) => match parse_identifier_list1(x, Some(t.clone()), s1, p1) {
+                // if we find a comma, parse the rest of the destructure
+                Ok((e2, d2, s2, p2)) => match next_token(&s2, &p2) {
+                    // then we should have an equal sign
+                    (Token::Eq, s3, p3) => match parse_expr(&s3, &p3) {
+                        Ok((e4, s4, p4)) => {
+                            let mut statements: Vec<Statement<T>> = d2.into_iter().map(|v| Statement::Declaration(v)).collect();
+                            statements.push(Statement::MultipleDefinition(e2, e4));
+                            Ok((statements, s4, p4)) // output a multipledefinition with the destructure and the expression
+                        }
+                        Err(err) => Err(err),
+                    },
+                    (t3, _, p3) => Err(Error {
+                        expected: vec![Token::Eq],
+                        got: t3,
+                        pos: p3,
+                    }),
+                },
+                Err(err) => Err(err),
+            },
+            (t1, _, p1) => Err(Error {
+                expected: vec![Token::Eq, Token::Unknown("".to_string())],
+                got: t1,
+                pos: p1,
+            }),
         },
-        (Token::Comma, s1, p1) => match parse_identifier_list1(ide, s1, p1) { // if we find a comma, parse the rest of the destructure
-            Ok((e2, s2, p2)) => match next_token(&s2, &p2) { // then we should have an equal sign
+        (t0, _, p0) => Err(Error {
+            expected: vec![Token::Ide(String::from("identifier"))],
+            got: t0,
+            pos: p0,
+        }),
+    }
+}
+
+// parse statement that starts with an identifier
+fn parse_statement1<T: Field>(
+    ide: String,
+    input: String,
+    pos: Position,
+) -> Result<(Vec<Statement<T>>, String, Position), Error<T>> {
+    match next_token::<T>(&input, &pos) {
+        (Token::Eq, s1, p1) => parse_definition1(ide, s1, p1),
+        (Token::Comma, s1, p1) => match parse_identifier_list1(ide, None, s1, p1) {
+            // if we find a comma, parse the rest of the destructure
+            Ok((e2, d2, s2, p2)) => match next_token(&s2, &p2) {
+                // then we should have an equal sign
                 (Token::Eq, s3, p3) => match parse_expr(&s3, &p3) {
                     Ok((e4, s4, p4)) => {
-                        Ok((Statement::MultipleDefinition(e2, e4), s4, p4)) // output a multipledefinition with the destructure and the expression
-                    },
-                    Err(err) => Err(err)
+                        let mut statements: Vec<Statement<T>> = d2.into_iter().map(|v| Statement::Declaration(v)).collect();
+                        statements.push(Statement::MultipleDefinition(e2, e4));
+                        Ok((statements, s4, p4)) // output a multipledefinition with the destructure and the expression
+                    }
+                    Err(err) => Err(err),
                 },
                 (t3, _, p3) => Err(Error {
-                    expected: vec![
-                        Token::Eq
-                    ],
+                    expected: vec![Token::Eq],
                     got: t3,
                     pos: p3,
                 }),
             },
-            Err(err) => Err(err)
+            Err(err) => Err(err),
         },
         (Token::Open, s1, p1) => match parse_function_call(ide, s1, p1) {
             Ok((e3, s3, p3)) => match next_token(&s3, &p3) {
@@ -261,11 +370,11 @@ fn parse_statement1<T: Field>(
                     Ok((e5, s5, p5)) => match next_token(&s5, &p5) {
                         (Token::InlineComment(_), ref s6, _) => {
                             assert_eq!(s6, "");
-                            Ok((Statement::Condition(e3, e5), s5, p5))
+                            Ok((vec![Statement::Condition(e3, e5)], s5, p5))
                         }
                         (Token::Unknown(ref t6), ref s6, _) if t6 == "" => {
                             assert_eq!(s6, "");
-                            Ok((Statement::Condition(e3, e5), s5, p5))
+                            Ok((vec![Statement::Condition(e3, e5)], s5, p5))
                         }
                         (t6, _, p6) => Err(Error {
                             expected: vec![
@@ -288,7 +397,7 @@ fn parse_statement1<T: Field>(
                     pos: p4,
                 }),
             },
-            Err(err) => Err(err)
+            Err(err) => Err(err),
         },
         _ => match parse_term1(Expression::Identifier(ide), input, pos) {
             Ok((e2, s2, p2)) => match parse_expr1(e2, s2, p2) {
@@ -297,11 +406,11 @@ fn parse_statement1<T: Field>(
                         Ok((e5, s5, p5)) => match next_token(&s5, &p5) {
                             (Token::InlineComment(_), ref s6, _) => {
                                 assert_eq!(s6, "");
-                                Ok((Statement::Condition(e3, e5), s5, p5))
+                                Ok((vec![Statement::Condition(e3, e5)], s5, p5))
                             }
                             (Token::Unknown(ref t6), ref s6, _) if t6 == "" => {
                                 assert_eq!(s6, "");
-                                Ok((Statement::Condition(e3, e5), s5, p5))
+                                Ok((vec![Statement::Condition(e3, e5)], s5, p5))
                             }
                             (t6, _, p6) => Err(Error {
                                 expected: vec![
@@ -334,32 +443,62 @@ fn parse_statement1<T: Field>(
 // parse an expression list starting with an identifier
 pub fn parse_identifier_list1<T: Field>(
     head: String,
+    _type: Option<Type>,
     input: String,
     pos: Position,
-) -> Result<(Vec<Variable>, String, Position), Error<T>> {
+) -> Result<(Vec<String>, Vec<Variable>, String, Position), Error<T>> {
     let mut res = Vec::new();
-    res.push(Variable::from(head));
-    parse_comma_separated_identifier_list_rec(input, pos, &mut res)
+    let mut decl = Vec::new();
+    res.push(head.clone());
+    match _type {
+        Some(t) => {
+            decl.push(Variable::new(head, t));
+        },
+        _ => {}
+    };
+    parse_comma_separated_identifier_list_rec(input, pos, &mut res, &mut decl)
 }
 
 fn parse_comma_separated_identifier_list_rec<T: Field>(
-    input: String, 
+    input: String,
     pos: Position,
-    mut acc: &mut Vec<Variable>
-) -> Result<(Vec<Variable>, String, Position), Error<T>> {
+    mut acc: &mut Vec<String>,
+    mut decl: &mut Vec<Variable>,
+) -> Result<(Vec<String>, Vec<Variable>, String, Position), Error<T>> {
     match next_token(&input, &pos) {
-        (Token::Ide(id), s1, p1) => {
-            acc.push(Variable::from(id));
+        (Token::Type(t), s1, p1) => {
             match next_token::<T>(&s1, &p1) {
-                (Token::Comma, s2, p2) => parse_comma_separated_identifier_list_rec(s2, p2, &mut acc),
-                (..) => Ok((acc.to_vec(), s1, p1)),
+                (Token::Ide(id), s2, p2) => {
+                    acc.push(id.clone());
+                    decl.push(Variable::new(id, t));
+                    match next_token::<T>(&s2, &p2) {
+                        (Token::Comma, s3, p3) => {
+                            parse_comma_separated_identifier_list_rec(s3, p3, &mut acc, &mut decl)
+                        }
+                        (..) => Ok((acc.to_vec(), decl.to_vec(), s2, p2)),
+                    }
+                }
+                (t2, _, p2) => Err(Error {
+                    expected: vec![Token::Ide(String::from("ide"))],
+                    got: t2,
+                    pos: p2,
+                }),
+            }
+        },
+        (Token::Ide(id), s1, p1) => {
+            acc.push(id);
+            match next_token::<T>(&s1, &p1) {
+                (Token::Comma, s2, p2) => {
+                    parse_comma_separated_identifier_list_rec(s2, p2, &mut acc, &mut decl)
+                }
+                (..) => Ok((acc.to_vec(), decl.to_vec(), s1, p1)),
             }
         },
         (t1, _, p1) => Err(Error {
             expected: vec![Token::Ide(String::from("ide"))],
             got: t1,
             pos: p1,
-        })
+        }),
     }
 }
 
@@ -376,11 +515,12 @@ mod tests {
             let string = String::from("() == 1");
             let cond = Statement::Condition(
                 Expression::FunctionCall(String::from("foo"), vec![]),
-                Expression::Number(FieldPrime::from(1))
+                Expression::Number(FieldPrime::from(1)),
             );
-            assert_eq!(Ok((cond, String::from(""), pos.col(string.len() as isize))),
+            assert_eq!(
+                Ok((vec![cond], String::from(""), pos.col(string.len() as isize))),
                 parse_statement1(String::from("foo"), string, pos)
             );
         }
     }
-}
+}

zokrates_core/src/parser/tokenize/token.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 use field::{Field};
+use types::Type;
 
 #[derive(PartialEq)]
 pub enum Token<T: Field> {
@@ -42,6 +43,9 @@ pub enum Token<T: Field> {
     // following used for error messages
     ErrIde,
     ErrNum,
+    // types
+    Type(Type),
+    Arrow,
 }
 impl<T: Field> fmt::Display for Token<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -84,6 +88,8 @@ impl<T: Field> fmt::Display for Token<T> {
             Token::As => write!(f, "as"),
             Token::ErrIde => write!(f, "identifier"),
             Token::ErrNum => write!(f, "number"),
+            Token::Type(ref x) => write!(f, "{}", x),
+            Token::Arrow => write!(f, "->"),
         }
     }
 }