Refactoring of the test contracts.

src/bin/expect_tests/contract_tests.ml

@@ -16,7 +16,7 @@ let%expect_test _ =
   [%expect {| 3231 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ;
-  [%expect {| 642 bytes |}] ;
+  [%expect {| 589 bytes |}] ;
 
   run_ligo_good [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ;
   [%expect {| (Left (Left 1)) |}] ;
@@ -948,39 +948,26 @@ let%expect_test _ =
   run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ;
   [%expect {|
     { parameter
-        (or (pair %init
+        (or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title))
-               (pair (timestamp %beginning_time) (timestamp %finish_time))
+            (or %vote (unit %nay) (unit %yea))) ;
-               (string %title))
-            (string %vote)) ;
       storage
-        (pair (pair (pair (timestamp %beginning_time) (map %candidates string int))
+        (pair (pair (pair (timestamp %finish_time) (nat %nay))
-                    (pair (timestamp %finish_time) (string %title)))
+                    (pair (timestamp %start_time) (string %title)))
-              (set %voters address)) ;
+              (pair (set %voters address) (nat %yea))) ;
       code { DUP ;
+             DUP ;
              CAR ;
              IF_LEFT
                { DUP ;
-                 DIP { DIP { DUP } ; SWAP ; CDR } ;
-                 PAIR ;
                  DUP ;
                  CAR ;
                  CAR ;
-                 CAR ;
+                 PUSH nat 0 ;
-                 DIP { PUSH int 0 ;
-                       SOME ;
-                       DIP { PUSH int 0 ;
-                             SOME ;
-                             EMPTY_MAP string int ;
                  SWAP ;
-                             PUSH string "Yes" ;
-                             UPDATE } ;
-                       PUSH string "No" ;
-                       UPDATE } ;
                  PAIR ;
-                 DIP { DUP ; CAR ; CAR ; CDR ; DIP { DUP ; CAR ; CDR } ; PAIR } ;
+                 DIP { DUP ; CAR ; CDR ; DIP { DUP ; CDR } ; PAIR } ;
                  PAIR ;
-                 EMPTY_SET address ;
+                 DIP { PUSH nat 0 ; EMPTY_SET address ; PAIR } ;
-                 SWAP ;
                  PAIR ;
                  NIL operation ;
                  PAIR ;
@@ -989,41 +976,56 @@ let%expect_test _ =
                  DIP { DIP { DUP } ; SWAP ; CDR } ;
                  PAIR ;
                  DUP ;
+                 CDR ;
+                 DIP { DUP } ;
+                 SWAP ;
                  CAR ;
-                 DIP { DUP ; CDR ; CAR ; CAR ; CDR } ;
+                 IF_LEFT
-                 GET ;
+                   { DIP { DUP } ;
-                 IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                     SWAP ;
+                     DIP 2 { DUP } ;
+                     DIG 2 ;
+                     CAR ;
+                     CAR ;
+                     CDR ;
+                     PUSH nat 1 ;
+                     ADD ;
+                     DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
+                     SWAP ;
+                     PAIR ;
+                     PAIR ;
+                     PAIR ;
+                     DIP { DROP } }
+                   { DIP { DUP } ;
+                     SWAP ;
+                     DIP 2 { DUP } ;
+                     DIG 2 ;
+                     CDR ;
+                     CDR ;
+                     PUSH nat 1 ;
+                     ADD ;
+                     DIP { DUP ; CAR ; SWAP ; CDR ; CAR } ;
+                     SWAP ;
+                     PAIR ;
+                     SWAP ;
+                     PAIR ;
+                     DIP { DROP } } ;
+                 DUP ;
                  DIP { DUP } ;
                  SWAP ;
                  CDR ;
                  CAR ;
-                 CAR ;
+                 PUSH bool True ;
-                 CAR ;
+                 SENDER ;
-                 DIP { DIP { DUP } ;
+                 UPDATE ;
-                       SWAP ;
+                 DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ;
-                       CAR ;
-                       DIP { DUP ;
-                             PUSH int 1 ;
-                             ADD ;
-                             SOME ;
-                             DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CAR ; CDR } } ;
-                       UPDATE } ;
                  PAIR ;
-                 DIP { DIP { DUP } ;
                  SWAP ;
-                       CDR ;
-                       CAR ;
-                       CDR ;
-                       CAR ;
-                       DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CDR ; CDR } ;
-                       PAIR } ;
-                 PAIR ;
-                 DIP { DIP { DUP } ; SWAP ; CDR ; CDR ; PUSH bool True ; SENDER ; UPDATE } ;
                  PAIR ;
                  NIL operation ;
                  PAIR ;
-                 DIP { DROP 3 } } ;
+                 DIP { DROP 4 } } ;
-             DIP { DROP } } } |}]
+             DIP { DROP 2 } } } |}]
 
 let%expect_test _ =
     run_ligo_good [ "compile-contract" ; contract "implicit.mligo" ; "main" ] ;
@@ -1064,7 +1066,7 @@ let%expect_test _ =
 let%expect_test _ =
   run_ligo_bad [ "compile-contract" ; contract "bad_address_format.religo" ; "main" ] ;
   [%expect {|
-    ligo: in file "bad_address_format.religo", line 2, characters 25-47. Badly formatted literal: @"KT1badaddr" {"location":"in file \"bad_address_format.religo\", line 2, characters 25-47"}
+    ligo: in file "bad_address_format.religo", line 2, characters 26-48. Badly formatted literal: @"KT1badaddr" {"location":"in file \"bad_address_format.religo\", line 2, characters 26-48"}
 
 
      If you're not sure how to fix this error, you can

src/passes/operators/operators.ml

@@ -325,9 +325,9 @@ module Simplify = struct
     | "Bytes.pack"   -> ok C_BYTES_PACK
     | "Bytes.unpack" -> ok C_BYTES_UNPACK
     | "Bytes.length" -> ok C_SIZE
-    | "Bytes.size"   -> ok C_SIZE
+    | "Bytes.size"   -> ok C_SIZE       (* Deprecated *)
     | "Bytes.concat" -> ok C_CONCAT
-    | "Bytes.slice"  -> ok C_SLICE
+    | "Bytes.slice"  -> ok C_SLICE      (* Deprecated *)
     | "Bytes.sub"    -> ok C_SLICE
 
     (* List module *)

src/test/contracts/address.mligo

@@ -1,3 +1,3 @@
 let main (p : key_hash) =
-  let c : unit contract = Current.implicit_account p
+  let c : unit contract = Tezos.implicit_account p
-  in Current.address c
+  in Tezos.address c

src/test/contracts/address.religo

@@ -1,4 +1,4 @@
 let main = (p : key_hash) : address => {
-  let c : contract(unit) = Current.implicit_account(p) ;
+  let c : contract (unit) = Tezos.implicit_account (p);
-  Current.address(c) ;
+  Tezos.address(c);
 };

src/test/contracts/amount.ligo

@@ -1,5 +1,5 @@
 function check (const p : unit) : int is
   block {
     var result : int := 0;
-    if amount = 100tz then result := 42 else result := 0
+    if amount = 100tez then result := 42 else result := 0
   } with result

src/test/contracts/amount.mligo

@@ -1 +1 @@
-let check_ (p : unit) : int = if Tezos.amount = 100tz then 42 else 0
+let check_ (p : unit) : int = if Tezos.amount = 100tez then 42 else 0

src/test/contracts/amount.religo

@@ -1,7 +1,2 @@
-let check_ = (p: unit) : int =>
+let check_ = (p : unit) : int =>
-  if (Current.amount == 100tz) {
+  if (Tezos.amount == 100tez) { 42; } else { 0; };
-    42;
-  }
-  else {
-    0;
-  };

src/test/contracts/arithmetic.ligo

@@ -1,5 +1,3 @@
-// Test PascaLIGO arithmetic operators
-
 function mod_op   (const n : int) : nat is n mod 42
 function plus_op  (const n : int) : int is n + 42
 function minus_op (const n : int) : int is n - 42

src/test/contracts/arithmetic.mligo

@@ -1,17 +1,8 @@
-// Test CameLIGO arithmetic operators
-
 let mod_op   (n : int) : nat = n mod 42
-
 let plus_op  (n : int) : int = n + 42
-
 let minus_op (n : int) : int = n - 42
-
 let times_op (n : int) : int = n * 42
-
 let div_op   (n : int) : int = n / 2
-
 let neg_op   (n : int) : int = -n
-
 let foo      (n : int) : int = n + 10
-
 let neg_op_2 (b : int) : int = -(foo b)

src/test/contracts/arithmetic.religo

@@ -1,24 +1,10 @@
 /* Test ReasonLIGO arithmetic operators */
 
-let mod_op = (n: int): nat => n mod 42;
+let mod_op   = (n : int) : nat => n mod 42;
-
+let plus_op  = (n : int) : int => n + 42;
-let plus_op = (n: int): int => n + 42;
+let minus_op = (n : int) : int => n - 42;
-
+let times_op = (n : int) : int => n * 42;
-let minus_op = (n: int): int => n - 42;
+let div_op   = (n : int) : int => n / 2;
-
+let neg_op   = (n : int): int => - n;
-let times_op = (n: int): int => n * 42;
+let foo      = (n : int): int => n + 10;
-
+let neg_op_2 = (b : int): int => -foo(b);
-let div_op = (n: int): int => n / 2;
-
-/* TODO (?): Support conversion from nat to int and back
-
-   let int_op (n : nat) : int =
-     Int n
-
-   */
-
-let neg_op = (n: int): int => - n;
-
-let foo = (n: int): int => n + 10;
-
-let neg_op_2 = (b: int): int => - foo(b);

src/test/contracts/assert.religo

@@ -1,4 +1,4 @@
-let main = (p: bool, s: unit) => {
+let main = (p, s : bool, unit) => {
-  let u: unit = assert(p);
+  let u : unit = assert (p);
-  ([]: list(operation), s);
+  ([]: list (operation), s);
 };

src/test/contracts/attributes.mligo

@@ -1,10 +1,7 @@
 let x = 1 [@@inline]
-
 let foo (a : int): int =
   (let test = 2 + a [@@inline] in test) [@@inline]
-
 let y = 1 [@@inline][@@other]
-
 let bar (b : int): int =
   let test = fun (z : int) -> 2 + b + z [@@inline][@@foo][@@bar]
   in test b

src/test/contracts/attributes.religo

@@ -2,7 +2,7 @@
 let x = 1;
 
 [@inline]
-let foo = (a: int): int => {
+let foo = (a : int) : int => {
   [@inline]
   let test = 2 + a;
   test;
@@ -11,8 +11,8 @@ let foo = (a: int): int => {
 [@inline][@other]
 let y = 1;
 
-let bar = (b: int): int => {
+let bar = (b : int) : int => {
   [@inline][@foo][@bar]
-  let test = (z: int) => 2 + b + z;
+  let test = (z : int) => 2 + b + z;
-  test(b);
+  test (b);
 };

src/test/contracts/bad_address_format.religo

@@ -1,3 +1,2 @@
-let main = (parameter: int, storage: address) => {     
+let main = (parameter : int, storage : address) =>
-    ([]:list(operation), "KT1badaddr" : address);
+  ([] : list (operation), "KT1badaddr" : address);
-};

src/test/contracts/balance_constant.mligo

@@ -10,7 +10,9 @@ generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
 
 *)
 
+type parameter = unit
 type storage = tez
+type return = operation list * storage
 
-let main (p, s : unit * storage) =
+let main (p, s : parameter * storage) : return =
-  ([] : operation list), balance
+  ([] : operation list), Tezos.balance

src/test/contracts/balance_constant.religo

@@ -12,6 +12,7 @@ generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
 
 type storage = tez;
 
-let main2 = (p: unit, storage) => ([]: list(operation), balance);
+let main2 = (p : unit, storage) =>
+  ([]: list (operation), Tezos.balance);
 
-let main = (x: (unit, storage)) => main2(x[0],x[1]);
+let main = (x : (unit, storage)) => main2 (x[0], x[1]);

src/test/contracts/big_map.mligo

@@ -1,11 +1,9 @@
 type foo = (int, int) big_map
 
 let set_ (n, m: int * foo) : foo = Big_map.update 23 (Some n) m
-
 let add (n, m : int * foo) : foo = Big_map.add 23 n m
 
 let rm (m : foo) : foo = Big_map.remove 42 m
-
 let gf (m : foo) : int = Big_map.find 23 m
 
 let get (m : foo): int option = Big_map.find_opt 42 m
@@ -13,7 +11,6 @@ let get (m : foo): int option = Big_map.find_opt 42 m
 let empty_map : foo = Big_map.empty
 
 let map1 : foo = Big_map.literal [(23,0); (42,0)]
-
 let map1 : foo = Big_map.literal [(23,0); (42,0)]
 
 let mutimaps (m : foo) (n : foo) : foo =

src/test/contracts/big_map.religo

@@ -1,24 +1,22 @@
 type foo = big_map(int, int);
 
-let set2 = (n: int, m: foo): foo => Big_map.update(23, Some(n), m);
+let set2 = (n : int, m : foo) : foo => Big_map.update (23, Some (n), m);
 
-let set_ = (x: (int, foo)): foo => set2(x[0], x[1]);
+let set_ = (x : (int, foo)) : foo => set2 (x[0], x[1]);
 
-let add = ((n,m): (int, foo)): foo => Big_map.add(23, n, m);
+let add = ((n,m) : (int, foo)) : foo => Big_map.add (23, n, m);
 
-let rm = (m: foo): foo => Big_map.remove(42, m);
+let rm = (m : foo) : foo => Big_map.remove (42, m);
 
-let gf = (m: foo): int => Big_map.find(23, m);
+let gf = (m : foo) : int => Big_map.find (23, m);
 
-let get = (m: foo): option(int) => Big_map.find_opt(42, m);
+let get = (m : foo) : option (int) => Big_map.find_opt (42, m);
 
-let empty_map: foo = Big_map.empty;
+let empty_map : foo = Big_map.empty;
 
-let map1: foo = Big_map.literal([(23, 0), (42, 0)]);
+let map1 : foo = Big_map.literal ([(23,0), (42,0)]);
-
-let map1: foo = Big_map.literal([(23, 0), (42, 0)]);
 
 let mutimaps = (m: foo, n: foo): foo => {
-  let bar: foo = Big_map.update(42, Some(0), m);
+  let bar : foo = Big_map.update (42, Some (0), m);
-  Big_map.update(42, get(bar), n);
+  Big_map.update (42, get (bar), n);
 };

src/test/contracts/bitwise_arithmetic.mligo

@@ -1,7 +1,7 @@
 (* Test CameLIGO bitwise operators *)
 
-let or_op  (n : nat) : nat = Bitwise.lor  n 4n
+let or_op  (n : nat) : nat = Bitwise.or  n 4n
-let and_op (n : nat) : nat = Bitwise.land n 7n
+let and_op (n : nat) : nat = Bitwise.and n 7n
-let xor_op (n : nat) : nat = Bitwise.lxor n 7n
+let xor_op (n : nat) : nat = Bitwise.xor n 7n
 let lsl_op (n : nat) : nat = Bitwise.shift_left n 7n
 let lsr_op (n : nat) : nat = Bitwise.shift_right n 7n

src/test/contracts/boolean_operators.mligo

@@ -1,11 +1,7 @@
 // Test CameLIGO boolean operators
 
 let or_true   (b : bool) : bool = b || true
-
 let or_false  (b : bool) : bool = b || false
-
 let and_true  (b : bool) : bool = b && true
-
 let and_false (b : bool) : bool = b && false
-
 let not_bool  (b : bool) : bool = not b

src/test/contracts/boolean_operators.religo

@@ -1,11 +1,7 @@
 // Test ReasonLIGO boolean operators
 
-let or_true = (b: bool): bool => b || true;
+let or_true   = (b : bool) : bool => b || true;
-
+let or_false  = (b : bool) : bool => b || false;
-let or_false = (b: bool): bool => b || false;
+let and_true  = (b : bool) : bool => b && true;
-
+let and_false = (b : bool) : bool => b && false;
-let and_true = (b: bool): bool => b && true;
+let not_bool  = (b : bool) : bool => !b;
-
-let and_false = (b: bool): bool => b && false;
-
-let not_bool = (b: bool): bool => !b;

src/test/contracts/bytes_arithmetic.mligo

@@ -1,5 +1,3 @@
 let concat_op (s : bytes) : bytes = Bytes.concat s 0x7070
-
+let slice_op  (s : bytes) : bytes = Bytes.sub 1n 2n s
-let slice_op (s : bytes) : bytes = Bytes.slice 1n 2n s
-
 let hasherman (s : bytes) : bytes = Crypto.sha256 s

src/test/contracts/bytes_unpack.religo

@@ -1,14 +1,14 @@
-let id_string = (p: string) : option(string) => {
+let id_string = (p : string) : option(string) => {
-  let packed : bytes = Bytes.pack(p);
+  let packed : bytes = Bytes.pack (p);
-  ((Bytes.unpack(packed)): option(string));
+  ((Bytes.unpack (packed)) : option (string));
 };
 
-let id_int = (p: int) : option(int) => {
+let id_int = (p : int) : option (int) => {
-  let packed: bytes = Bytes.pack(p);
+  let packed : bytes = Bytes.pack (p);
-  ((Bytes.unpack(packed)): option(int));
+  ((Bytes.unpack (packed)) : option (int));
 };
 
-let id_address = (p: address) : option(address) => {
+let id_address = (p : address) : option (address) => {
-  let packed: bytes = Bytes.pack(p);
+  let packed : bytes = Bytes.pack (p);
-  ((Bytes.unpack(packed)): option(address));
+  ((Bytes.unpack (packed)) : option (address));
 };

src/test/contracts/check_signature.religo

@@ -1,4 +1,4 @@
-let check_signature = (param: (key, signature, bytes)) : bool => {
+let check_signature = (param : (key, signature, bytes)) : bool => {
   let pk, signed, msg = param;
-  Crypto.check(pk, signed, msg);
+  Crypto.check (pk, signed, msg);
 };

src/test/contracts/closure.mligo

@@ -1,4 +1,4 @@
-(* Test whether closures retain values in CameLIGO *)
+(* Test whether closures capture variables in CameLIGO *)
 
 let test (k : int) : int =
   let j : int = k + 5 in

src/test/contracts/closure.religo

@@ -1,9 +1,9 @@
 /* Test whether closures retain values in ReasonLIGO */
 
-let test = (k: int): int => {
+let test = (k : int) : int => {
-  let j: int = k + 5;
+  let j : int = k + 5;
-  let close: (int => int) = (i: int) => i + j;
+  let close : (int => int) = (i : int) => i + j;
 
-  let j: int = 20; /* Shadow original variable to see if value close'd */
+  let j : int = 20; /* Shadow original variable */
-  close(20);
+  close (20);
 };

src/test/contracts/condition-annot.religo

@@ -1,6 +1,2 @@
-let main = (i: int) =>
+let main = (i : int) =>
-  if (((i == 2): bool)) {
+  if (((i == 2) : bool)) { (42 : int); } else { (0 : int); };
-    (42: int);
-  } else {
-    (0: int);
-  };

src/test/contracts/condition-shadowing.mligo

@@ -1,6 +1,5 @@
 let main (i : int) =
   let result = 0 in
-  if i = 2 then
+  if i = 2
-    let result = 42 in result
+  then let result = 42 in result
-  else
+  else let result = 0 in result
-    let result = 0 in result

src/test/contracts/condition.religo

@@ -1,8 +1,3 @@
 /* Test conditional in ReasonLIGO */
 
-let main = (i: int) =>
+let main = (i : int) => if (i == 2) { 42; } else { 0; };
-  if (i == 2) {
-    42;
-  } else {
-    0;
-  };

src/test/contracts/counter.mligo

@@ -1,4 +1,3 @@
 type storage = int
 
-let main (ps : int * storage) =
+let main (p, s : int * storage) = ([] : operation list), p + s
-  ([] : operation list), ps.0 + ps.1

src/test/contracts/counter.religo

@@ -1,7 +1,4 @@
-
 type storage = int;
 
-let main2 = (p: int, storage): string => ([]: list(operation), p + storage);
+let main = ((p, s) : (int, storage)) : (list (operation), storage) =>
-
+  ([] : list (operation), p + s);
-let main = (x: (int, storage)) : string => main2(x[0],x[1]);
-

src/test/contracts/crypto.religo

@@ -1,2 +1,2 @@
-let hasherman512 = (s: bytes) => Crypto.sha512(s);
+let hasherman512    = (s : bytes) => Crypto.sha512 (s);
-let hasherman_blake = (s: bytes) => Crypto.blake2b(s);
+let hasherman_blake = (s : bytes) => Crypto.blake2b (s);

src/test/contracts/curry.mligo

@@ -1,9 +1,5 @@
 let conv_test (j : int) (k : int) = j + k
-
 let main (i : int) : int = conv_test i 10
-
 let partial (a : int) (b : int) : int = a + b
-
 let mk_partial (j : int) : int -> int = partial j
-
 let partial_apply (i : int) : int = mk_partial 10 i

src/test/contracts/empty_case.religo

@@ -1,9 +1,9 @@
 type foo =
-  | Bar(int)
+| Bar (int)
-  | Baz;
+| Baz;
 
-let main = (f: foo): int =>
+let main = (f : foo) : int =>
   switch (f) {
-  | Bar(i) => i
+  | Bar (i) => i
   | Baz     => (-1)
   };

src/test/contracts/eq_bool.religo

@@ -1,8 +1,4 @@
 /* Test boolean comparison in ReasonLIGO */
 
-let main = ((a , b) : (bool , bool)) =>
+let main = ((a, b) : (bool, bool)) =>
-  if (a == b) {
+  if (a == b) { 999; } else { 1; };
-    999;
-  } else {
-    1;
-  };

src/test/contracts/failwith.religo

@@ -1,8 +1,4 @@
 type storage = unit;
 
 let main = (p: unit, storage) =>
-  if (true) {
+  if (true) { failwith("This contract always fails"); };
-    failwith("This contract always fails");
-  } else {
-    ();
-  };

src/test/contracts/fibo.mligo

@@ -1,6 +1,6 @@
 type storage = unit
 
-let main (p : unit; store : storage) : operation list * storage =
+let main (p, store : unit * storage) : operation list * storage =
   let n =
     (fun (f : int * int -> int) (x : int) (y : int) -> f (y,x))
       (fun (x : int) (y : int) -> x + y)

src/test/contracts/fibo3.mligo

@@ -1,6 +1,6 @@
 type storage = unit
 
-let main (p : unit; store : storage) : operation list * storage =
+let main (p, s : unit * storage) : operation list * storage =
   let n =
     (fun (f : int -> int -> int) (x : int) (y : int) -> f y (x+y))
       (fun (x : int) (y : int) -> x + y)

src/test/contracts/fibo4.mligo

@@ -1,6 +1,6 @@
 type storage = unit
 
-let main (p: unit) storage =
+let main (p, s : unit * storage) =
-  (fun (f: int -> int) (x: int) -> f x)
+  (fun (f : int -> int) (x : int) -> f x)
-    (fun (x: int) -> x)
+    (fun (x : int) -> x)
     1

src/test/contracts/function-shared.mligo

@@ -1,7 +1,5 @@
 (* Test use of multiple subroutines in a CameLIGO function *)
 
 let foo (i : int) : int = i + 20
-
 let bar (i : int) : int = i + 50
-
 let foobar (i : int) : int = foo i + bar i

src/test/contracts/function-shared.religo

@@ -1,7 +1,5 @@
 /* Test use of multiple subroutines in a ReasonLIGO function */
 
-let foo = (i: int): int => i + 20;
+let foo    = (i : int) : int => i + 20;
-
+let bar    = (i : int) : int => i + 50;
-let bar = (i: int): int => i + 50;
+let foobar = (i : int) : int => foo (i) + bar (i);
-
-let foobar = (i: int): int => foo(i) + bar(i);

src/test/contracts/guess_string.mligo

@@ -9,10 +9,14 @@ type param = {
 
 type return = operation list * storage
 
-let attempt (p: param; store : storage) : return =
+let attempt (p, store : param * storage) : return =
   (* if p.attempt <> store.challenge then failwith "Failed challenge" else *)
-  let contract : unit contract = Operation.get_contract sender in
+  let contract : unit contract =
+    match (Tezos.get_contract_opt Tezos.sender : unit contract option) with
+      Some contract -> contract
+    | None ->  (failwith "No contract" : unit contract)
+  in
   let transfer : operation =
-    Operation.transaction (unit, contract, 10.00tez) in
+    Tezos.transaction (unit, contract, 10.00tez) in
   let store : storage = {challenge = p.new_challenge}
   in ([] : operation list), store

src/test/contracts/hashlock.mligo

@@ -1,56 +1,67 @@
 type commit = {
-  date: timestamp;
+  date        : timestamp;
-  salted_hash: bytes;
+  salted_hash : bytes;
 }
 
 type commit_set = (address, commit) big_map
 
 type storage = {
-  hashed: bytes;
+  hashed  : bytes;
-  unused: bool;
+  unused  : bool;
-  commits: commit_set;
+  commits : commit_set
 }
 
 type reveal = {
-  hashable: bytes;
+  hashable : bytes;
-  message: unit -> operation list;
+  message  : unit -> operation list
 }
 
 type parameter =
-| Commit of bytes
+  Commit of bytes
 | Reveal of reveal
 
-(* We use hash-commit so that a baker can't steal *)
+type return = operation list * storage
-let commit ((p,s): bytes * storage) : operation list * storage =
-  let commit: commit = {date = Current.time + 86400; salted_hash = p;} in
-  let updated_map: commit_set = Big_map.update sender (Some commit) s.commits in
-  let s = {hashed = s.hashed; unused = s.unused; commits = updated_map} in
-  (([]: operation list), s)
 
-let reveal ((p,s): reveal * storage) : operation list * storage =
+(* We use hash-commit so that a baker can not steal *)
+
+let commit (p, s : bytes * storage) : return =
+  let commit : commit =
+    {date = Tezos.now + 86_400; salted_hash = p} in
+  let updated_map: commit_set =
+    Big_map.update Tezos.sender (Some commit) s.commits in
+  let s = {s with commits = updated_map}
+  in ([] : operation list), s
+
+let reveal (p, s : reveal * storage) : return =
   if not s.unused
-  then (failwith "This contract has already been used.": operation list * storage)
-  else
-  let commit: commit =
-    match (Big_map.find_opt sender s.commits) with
-    | Some c -> c
-    | None -> (failwith "You haven't made a commitment to hash against yet.": commit)
-  in
-  if Current.time < commit.date
-  then (failwith "It hasn't been 24 hours since your commit yet.": operation list * storage)
-  else
-  let salted = Crypto.sha256 (Bytes.concat p.hashable (Bytes.pack sender)) in
-  if (salted <> commit.salted_hash)
-  then (failwith "This reveal doesn't match your commitment.": operation list * storage)
-  else
-  if (s.hashed = Crypto.sha256 p.hashable) 
   then
-    let s: storage = {hashed = s.hashed; unused = false; commits = s.commits} in
+    (failwith "This contract has already been used." : return)
-    ((p.message ()), s)
+  else
-  else (failwith "Your commitment did not match the storage hash.":
+    let commit : commit =
-          operation list * storage)
+      match Big_map.find_opt sender s.commits with
+    | Some c -> c
+    | None ->
+       (failwith "You have not made a commitment to hash against yet."
+        : commit)
+    in
+    if Tezos.now < commit.date
+    then
+      (failwith "It has not been 24 hours since your commit yet.": return)
+    else
+      let salted =
+        Crypto.sha256 (Bytes.concat p.hashable (Bytes.pack sender)) in
+      if salted <> commit.salted_hash
+      then
+        (failwith "This reveal does not match your commitment.": return)
+      else
+        if s.hashed = Crypto.sha256 p.hashable
+        then
+          let s : storage = {s with unused = false}
+          in p.message (), s
+        else (failwith "Your commitment did not match the storage hash."
+              : return)
 
-let main ((p,s): parameter * storage) : operation list * storage =
+let main (p, s : parameter * storage) : return =
   match p with
-  | Commit c -> commit (c, s)
+  | Commit c -> commit (c,s)
-  | Reveal r -> reveal (r, s)
+  | Reveal r -> reveal (r,s)

src/test/contracts/high-order.mligo

@@ -1,30 +1,24 @@
 (* Test a function which takes another function as an argument *)
+
 let foobar (i : int) : int =
-  let foo: (int -> int) =
+  let foo: (int -> int) = fun (i : int) -> i in
-    fun (i : int) -> i
+  let bar: ((int -> int) -> int) = fun (f : int -> int) -> f i
-  in
+  in bar foo
-  let bar: ((int -> int) -> int) =
-    fun (f : int -> int) -> f i
-  in
-  bar foo
 
 (* higher order function with more than one argument *)
-let higher2 (i: int) (f: int -> int): int =
+
+let higher2 (i : int) (f : int -> int): int =
   let ii: int = f i in ii
 
 let foobar2 (i : int) : int =
-  let foo2: (int -> int) =
+  let foo2 : (int -> int) = fun (i : int) -> i
-    fun (i : int) -> i
+  in higher2 i foo2
-  in
-  higher2 i foo2
 
 let a : int = 0
 
 let foobar3 (i : int) : int =
-  let foo2: (int -> int) =
+  let foo2 : (int -> int) = fun (i : int) ->  a + i
-    fun (i : int) ->  a + i
+  in higher2 i foo2
-  in
-  higher2 i foo2
 
 let f (i : int) : int = i
 
@@ -32,15 +26,11 @@ let g (i : int) : int = f i
 
 let foobar4 (i : int) : int = g (g i)
 
-let higher3 (i: int) (f: int -> int) (g: int -> int) : int =
+let higher3 (i : int) (f : int -> int) (g : int -> int) : int =
-  let ii: int = f (g i) in ii
+  let ii : int = f (g i) in ii
 
 let foobar5 (i : int) : int =
   let a : int = 0 in
-  let foo: (int -> int) =
+  let foo : (int -> int) = fun (i : int) -> a + i in
-    fun (i : int) -> a + i
+  let goo : (int -> int) = fun (i : int) -> foo i
-  in
+  in higher3 i foo goo
-  let goo: (int -> int) =
-    fun (i : int) -> foo i
-  in
-  higher3 i foo goo

src/test/contracts/high-order.religo

@@ -1,48 +1,44 @@
 /* Test a function which takes another function as an argument */
-let foobar = (i: int): int => {
+
+let foobar = (i : int): int => {
   let foo: int => int = (i: int) => i;
-
+  let bar: ((int => int) => int) = (f : (int => int)) => f (i);
-  let bar: ((int => int) => int) = (f: (int => int)) => f(i);
+  bar (foo);
-
-  bar(foo);
 };
 
 /* higher order function with more than one argument */
-let higher2 = (i: int, f: (int => int)): int => {
+
-  let ii: int = f(i);
+let higher2 = (i : int, f : (int => int)) : int => {
+  let ii : int = f (i);
   ii;
 };
 
-let foobar2 = (i: int): int => {
+let foobar2 = (i : int) : int => {
-  let foo2: int => int = (i: int) => i;
+  let foo2 : int => int = (i : int) => i;
-
+  higher2 (i, foo2);
-  higher2(i, foo2);
 };
 
-let a: int = 0;
+let a : int = 0;
 
-let foobar3 = (i: int): int => {
+let foobar3 = (i : int) : int => {
-  let foo2: int => int = (i: int) => a + i;
+  let foo2: int => int = (i : int) => a + i;
-
+  higher2 (i, foo2);
-  higher2(i, foo2);
 };
 
-let f = (i: int): int => i;
+let f = (i : int) : int => i;
 
-let g = (i: int): int => f(i);
+let g = (i : int) : int => f (i);
 
-let foobar4 = (i: int): int => g(g(i));
+let foobar4 = (i : int) : int => g (g (i));
 
-let higher3 = (i: int, f: (int => int), g: (int => int)): int => {
+let higher3 = (i : int, f : (int => int), g : (int => int)) : int => {
-  let ii: int = f(g(i));
+  let ii : int = f (g (i));
   ii;
 };
 
-let foobar5 = (i: int): int => {
+let foobar5 = (i : int) : int => {
-  let a: int = 0;
+  let a : int = 0;
-  let foo: int => int = (i: int) => a + i;
+  let foo : int => int = (i : int) => a + i;
-
+  let goo : int => int = (i : int) => foo (i);
-  let goo: int => int = (i: int) => foo(i);
+  higher3 (i, foo, goo);
-
-  higher3(i, foo, goo);
 };

src/test/contracts/id.mligo

@@ -3,7 +3,7 @@ type id = int
 type id_details = {
   owner: address;
   controller: address;
-  profile: bytes;
+  profile: bytes
 }
 
 type buy = bytes * address option
@@ -14,126 +14,118 @@ type action =
 | Buy of buy
 | Update_owner of update_owner
 | Update_details of update_details
-| Skip of unit
+| Skip
+
+(* The prices kept in storage can be changed by bakers, though they
+   should only be adjusted down over time, not up. *)
 
-(* The prices kept in storage can be changed by bakers, though they should only be
-   adjusted down over time, not up. *)
 type storage = (id, id_details) big_map * int * (tez * tez)
 
-(** Preliminary thoughts on ids:
+type return = operation list * storage
 
-I very much like the simplicity of http://gurno.com/adam/mne/.
+(* Preliminary thoughts on ids:
-5 three letter words means you have a 15 character identity, not actually more
-annoying than an IP address and a lot more memorable than the raw digits. This
-can be stored as a single integer which is then translated into the corresponding
-series of 5 words.
 
-I in general like the idea of having a 'skip' mechanism, but it does need to cost
+I very much like the simplicity of http://gurno.com/adam/mne/.  5 three
-something so people don't eat up the address space. 256 ^ 5 means you have a lot
+letter words means you have a 15 character identity, not actually more
-of address space, but if people troll by skipping a lot that could be eaten up.
+annoying than an IP address and a lot more memorable than the raw
-Should probably do some napkin calculations for how expensive skipping needs to
+digits. This can be stored as a single integer which is then
-be to deter people from doing it just to chew up address space.
+translated into the corresponding series of 5 words.
-*)
+
+I in general like the idea of having a 'skip' mechanism, but it does
+need to cost something so people don't eat up the address space. 256^5
+means you have a lot of address space, but if people troll by skipping
+a lot that could be eaten up.  Should probably do some napkin
+calculations for how expensive skipping needs to be to deter people
+from doing it just to chew up address space.  *)
 
 let buy (parameter, storage: (bytes * address option) * storage) =
-  let void: unit = 
+  let void : unit =
-    if amount = storage.2.0 
+    if Tezos.amount <> storage.2.0
-    then () 
+    then (failwith "Incorrect amount paid.": unit) in
-    else (failwith "Incorrect amount paid.": unit)
-  in
   let profile, initial_controller = parameter in
   let identities, new_id, prices = storage in
-  let controller: address =
+  let controller : address =
     match initial_controller with
     | Some addr -> addr
-    | None -> sender
+    | None -> sender in
-  in
   let new_id_details: id_details = {
-    owner = sender ;
+    owner = sender;
-    controller = controller ;
+    controller = controller;
-    profile = profile ;
+    profile = profile} in
-  }
+  let updated_identities : (id, id_details) big_map =
-  in
-  let updated_identities: (id, id_details) big_map =
     Big_map.update new_id (Some new_id_details) identities
-  in
+  in ([]: operation list), (updated_identities, new_id + 1, prices)
-  ([]: operation list), (updated_identities, new_id + 1, prices)
 
-let update_owner (parameter, storage: (id * address) * storage) =
+let update_owner (parameter, storage : (id * address) * storage) =
-  if (amount <> 0mutez)
+  if amount <> 0tez
-  then (failwith "Updating owner doesn't cost anything.": (operation list) * storage)
+  then (failwith "Updating owner doesn't cost anything.": return)
   else
     let id, new_owner = parameter in
     let identities, last_id, prices = storage in
-  let current_id_details: id_details =
+    let current_id_details : id_details =
       match Big_map.find_opt id identities with
       | Some id_details -> id_details
-    | None -> (failwith "This ID does not exist.": id_details)
+      | None -> (failwith "This ID does not exist." : id_details) in
-  in
+    let is_allowed : bool =
-  let is_allowed: bool =
+      if Tezos.sender = current_id_details.owner
-    if sender = current_id_details.owner
       then true
-    else (failwith "You are not the owner of this ID.": bool)
+      else (failwith "You are not the owner of this ID." : bool) in
-  in
+  let updated_id_details : id_details = {
-  let updated_id_details: id_details = {
     owner = new_owner;
     controller = current_id_details.controller;
-    profile = current_id_details.profile;
+    profile = current_id_details.profile} in
-  }
+  let updated_identities =
-  in
+    Big_map.update id (Some updated_id_details) identities
-  let updated_identities = Big_map.update id (Some updated_id_details) identities in
+  in ([]: operation list), (updated_identities, last_id, prices)
-  ([]: operation list), (updated_identities, last_id, prices)
 
 let update_details (parameter, storage: (id * bytes option * address option) * storage) =
-  if (amount <> 0mutez)
+  if Tezos.amount <> 0tez
-  then (failwith "Updating details doesn't cost anything.": (operation list) * storage)
+  then
+    (failwith "Updating details doesn't cost anything." : return)
   else
     let id, new_profile, new_controller = parameter in
     let identities, last_id, prices = storage in
     let current_id_details: id_details =
       match Big_map.find_opt id identities with
       | Some id_details -> id_details
-    | None -> (failwith "This ID does not exist.": id_details)
+      | None -> (failwith "This ID does not exist.": id_details) in
-  in
+    let is_allowed : bool =
-  let is_allowed: bool =
+      if Tezos.sender = current_id_details.controller
-    if (sender = current_id_details.controller) || (sender = current_id_details.owner)
+         || Tezos.sender = current_id_details.owner
       then true
-    else (failwith ("You are not the owner or controller of this ID."): bool)
+      else
-  in
+        (failwith ("You are not the owner or controller of this ID.")
-  let owner: address = current_id_details.owner in
+         : bool) in
-  let profile: bytes =
+    let owner : address = current_id_details.owner in
+    let profile : bytes =
       match new_profile with
       | None -> (* Default *) current_id_details.profile
-    | Some new_profile -> new_profile
+      | Some new_profile -> new_profile in
-  in
+    let controller : address =
-  let controller: address =
       match new_controller with
       | None -> (* Default *) current_id_details.controller
-    | Some new_controller -> new_controller
+      | Some new_controller -> new_controller in
-  in
     let updated_id_details: id_details = {
         owner = owner;
         controller = controller;
-    profile = profile;
+        profile = profile} in
-  }
-  in
   let updated_identities: (id, id_details) big_map  =
-    Big_map.update id (Some updated_id_details) identities in
+    Big_map.update id (Some updated_id_details) identities
-  ([]: operation list), (updated_identities, last_id, prices)
+  in ([]: operation list), (updated_identities, last_id, prices)
 
-(* Let someone skip the next identity so nobody has to take one that's undesirable *)
+(* Let someone skip the next identity so nobody has to take one that's
-let skip (p,storage: unit * storage) =
+undesirable *)
-  let void: unit =
+
-    if amount = storage.2.1
+let skip (p, storage: unit * storage) =
-    then ()
+  let void : unit =
-    else (failwith "Incorrect amount paid.": unit)
+    if Tezos.amount <> storage.2.1
-  in
+    then (failwith "Incorrect amount paid." : unit) in
   let identities, last_id, prices = storage in
   ([]: operation list), (identities, last_id + 1, prices)
 
-let main (action, storage: action * storage) : operation list * storage =
+let main (action, storage : action * storage) : return =
   match action with
   | Buy b -> buy (b, storage)
   | Update_owner uo -> update_owner (uo, storage)
   | Update_details ud -> update_details (ud, storage)
-  | Skip s -> skip ((), storage)
+  | Skip -> skip ((), storage)

src/test/contracts/implicit.mligo

@@ -1,5 +1,5 @@
 let main2 (p : key_hash) (s : unit) =
-  let c : unit contract = Current.implicit_account p in 
+  let c : unit contract = Tezos.implicit_account p
-  (([] : operation list), unit)
+  in ([] : operation list), unit
 
-let main (t: key_hash * unit) = main2 t.0 t.1
+let main (p,s : key_hash * unit) = main2 p s

src/test/contracts/implicit_account.mligo

@@ -1 +1 @@
-let main (kh: key_hash) : unit contract = Current.implicit_account kh
+let main (kh : key_hash) : unit contract = Tezos.implicit_account kh

src/test/contracts/implicit_account.religo

@@ -1 +1,2 @@
-let main = (kh: key_hash): contract(unit) => Current.implicit_account(kh);
+let main = (kh : key_hash) : contract (unit) =>
+  Tezos.implicit_account (kh);

src/test/contracts/incr_decr.mligo

@@ -1,19 +1,17 @@
 type storage = int
 
-(* variant defining pseudo multi-entrypoint actions *)
+type parameter =
-
-type action =
   Increment of int
 | Decrement of int
 
-let add (a: int) (b: int) : int = a + b
+type return = operation list * storage
-let sub (a: int) (b: int) : int = a - b
 
-(* real entrypoint that re-routes the flow based on the action provided *)
+let add (a : int) (b : int) : int = a + b
+let sub (a : int) (b : int) : int = a - b
 
-let main (p: action) storage =
+let main (action, store : parameter * storage) : return =
-  let storage =
+  let store =
-    match p with
+    match action with
       Increment n -> add s n
     | Decrement n -> sub s n
-  in ([] : operation list), storage
+  in ([] : operation list), store

src/test/contracts/interpret_test.mligo

@@ -1,87 +1,87 @@
 let lambda_call =
   let a = 3 in
-  let foo = fun (i : int) -> i * i in
+  let foo = fun (i : int) -> i * i
-  foo (a + 1)
+  in foo (a + 1)
 
 let higher_order1 =
   let a = 2 in
-  let foo = fun (i:int) (j:int) (k:int) ->
+  let foo = fun (i : int) (j : int) (k : int) -> a + i + j + 0 in
-    a + i + j + 0 in
+  let bar = (foo 1 2)
-  let bar = (foo 1 2) in
+  in bar 3
-  bar 3
 
 let higher_order2 =
   let a = 2 in
-  let foo = fun (i:int) ->
+  let foo = fun (i : int) ->
               let b = 2 in
-      let bar = fun (i:int) -> i + a + b
+              let bar = fun (i : int) -> i + a + b
               in bar i
   in foo 1
 
 let higher_order3 =
-  let foo = fun (i:int) -> i + 1 in
+  let foo = fun (i : int) -> i + 1 in
-  let bar = fun (f:int->int) (i:int) -> (f i) + 1 in
+  let bar = fun (f : int -> int) (i : int) -> f i + 1 in
-  let baz : (int -> int ) = bar foo in
+  let baz : int -> int = bar foo
-  baz 3
+  in baz 3
 
 let higher_order4 =
   let a = 3 in
   let foo = fun (i : int) -> a + i in
-  let bar: (int -> int) = fun (i : int) -> foo i in
+  let bar : int -> int = fun (i : int) -> foo i
-  bar 2
+  in bar 2
 
-let concats =
+let concats = 0x70 ^ 0x70
-  0x70 ^ 0x70
 
 type foo_record = {
-     a : string ;
+  a : string;
-     b : string ;
+  b : string
 }
+
 let record_concat =
-  let ab : foo_record = { a = "a" ; b = "b" } in
+  let ab : foo_record = {a="a"; b="b"}
-  ab.a ^ ab.b
+  in ab.a ^ ab.b
 
 let record_patch =
-  let ab : foo_record = { a = "a" ; b = "b" } in
+  let ab : foo_record = {a="a"; b="b"}
-  {ab with b = "c"}
+  in {ab with b = "c"}
 
 type bar_record = {
-     f : int -> int ;
+  f   : int -> int;
-     arg : int ;
+  arg : int
 }
+
 let record_lambda =
   let a = 1 in
-  let foo : (int -> int) = fun (i:int) -> a+(i*2) in
+  let foo : int -> int = fun (i : int) -> a + i*2 in
-  let farg : bar_record = { f = foo ; arg = 2 } in
+  let farg : bar_record = {f = foo; arg = 2}
-  farg.f farg.arg
+  in farg.f farg.arg
 
 type foo_variant =
 | Foo
 | Bar of int
 | Baz of string
 
-let variant_exp =
+let variant_exp = Foo, Bar 1, Baz "b"
-  (Foo, Bar 1, Baz "b")
 
 let variant_match =
   let a = Bar 1 in
   match a with
   | Foo   -> 1
-  | Bar(i) -> 2
+  | Bar i -> 2
-  | Baz(s) -> 3
+  | Baz s -> 3
 
-/* UNSUPPORTED
+(* UNSUPPORTED: No deep patterns yet.
 type bar_variant =
 | Baz
 | Buz of int * int
 | Biz of int * int * string
+
 let long_variant_match =
   let a = Biz (1,2,"Biz") in
   match a with
   | Baz -> "Baz"
-  | Buz(a,b) -> "Buz"
+  | Buz (a,b) -> "Buz"
-  | Biz(a,b,c) -> c
+  | Biz (a,b,c) -> c
-*/
+ *)
 
 let bool_match =
   let b = true in
@@ -90,149 +90,145 @@ let bool_match =
   | false -> 2
 
 let list_match =
-  let a = [ 1 ; 2 ; 3 ; 4 ] in
+  let a = [1; 2; 3; 4] in
   match a with
-  | hd :: tl -> hd::a
+  | hd::tl -> hd::a
   | [] -> a
 
 let tuple_proj =
-  let (a,b) = (true,false) in
+  let a, b = true, false
-  a or b
+  in a or b
 
 let list_const =
-  let a = [1 ; 2 ; 3 ; 4] in
+  let a = [1; 2; 3; 4]
-  0 :: a
+  in 0::a
 
 type foobar = int option
 
 let options_match_some =
   let a = Some 0 in
   match a with
-  | Some(i) -> i
+  | Some i -> i
   | None -> 1
 
 let options_match_none =
   let a : foobar = None in
   match a with
-  | Some(i) -> i
+  | Some i -> i
   | None -> 0
 
 let is_nat_nat =
   let i : int = 1 in
-  let j : int = -1 in
+  let j : int = -1
-  (Michelson.is_nat i, Michelson.is_nat j)
+  in is_nat i, is_nat j
 
 let abs_int = abs (-5)
 
-let nat_int = int (5n)
+let nat_int = int 5n
 
 let map_list =
-  let a = [1 ; 2 ; 3 ; 4] in
+  let a = [1; 2; 3; 4] in
-  let add_one: (int -> int) = fun (i : int) -> i + 1 in
+  let add_one : (int -> int) = fun (i : int) -> i + 1
-  List.map add_one a
+  in List.map add_one a
 
 let fail_alone = failwith "you failed"
 
 let iter_list_fail =
-  let a = [1 ; 2 ; 3 ; 4] in
+  let a = [1; 2; 3; 4] in
-  let check_something: (int -> unit) = fun (i : int) ->
+  let check_something : int -> unit =
+    fun (i : int) ->
       if i = 2 then failwith "you failed"
-    else ()
+  in List.iter check_something a
-  in
-  List.iter check_something a
 
 let fold_list =
-  let a = [1 ; 2 ; 3 ; 4] in
+  let a = [1; 2; 3; 4] in
-  let acc : (int * int -> int) =
+  let acc : int * int -> int =
-    fun (prev, el : int * int) -> prev + el in
+    fun (prev, el : int * int) -> prev + el
-  List.fold acc a 0
+  in List.fold acc a 0
 
-let comparison_int =
+let comparison_int = 1 > 2, 2 > 1, 1 >=2, 2 >= 1
-  (1 > 2, 2 > 1, 1 >=2 , 2 >= 1)
 
-let comparison_string =
+let comparison_string = "foo"="bar", "baz"="baz"
-  ("foo" = "bar", "baz" = "baz")
 
-let divs : (int * nat * tez * nat) =
+let divs : int * nat * tez * nat = 1/2, 1n/2n, 1tez/2n, 1tez/2tez
-  (1/2 , 1n/2n , 1tz/2n , 1tz/2tz)
 
 let var_neg =
-  let a = 2 in
+  let a = 2 in -a
-  -a
 
 let sizes =
-  let a = [ 1 ; 2 ; 3 ; 4 ; 5 ] in
+  let a = [1; 2; 3; 4; 5] in
   let b = "12345" in
-  let c = Set.literal [ 1 ; 2 ; 3 ; 4 ; 5 ] in
+  let c = Set.literal [1; 2; 3; 4; 5] in
-  let d = Map.literal [ (1,1) ; (2,2) ; (3,3) ] in
+  let d = Map.literal [(1,1); (2,2); (3,3)] in
   let e = 0xFFFF in
-  (List.size a, String.size b, Set.size c, Map.size d, Bytes.size e)
+  List.length a,
+  String.length b,
+  Set.cardinal c,
+  Map.size d,
+  Bytes.length e
 
 let modi = 3 mod 2
 
 let fold_while =
-  let aux : int -> bool * int = fun (i:int) ->
+  let aux : int -> bool * int =
-    if i < 10 then continue (i + 1) else stop i in
+    fun (i : int) ->
-  (Loop.fold_while aux 20, Loop.fold_while aux 0)
+    if i < 10 then Loop.resume (i + 1) else Loop.stop i
+  in (Loop.fold_while aux 20, Loop.fold_while aux 0)
 
-let assertion_pass =
+let assertion_pass = assert (1=1)
-  assert (1=1)
 
-let assertion_fail =
+let assertion_fail = assert (1=2)
-  assert (1=2)
 
 let lit_address = ("KT1ThEdxfUcWUwqsdergy3QnbCWGHSUHeHJq" : address)
 
 let map_finds =
-  let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
+  let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
-  Map.find_opt "two" m
+  in Map.find_opt "two" m
 
 let map_finds_fail =
-  let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
+  let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
-  Map.find "four" m
+  in Map.find "four" m
 
 let map_empty =
-  ((Map.empty : (int,int) map) , (Map.literal [] : (int,int) map))
+  ((Map.empty : (int, int) map), (Map.literal [] : (int, int) map))
 
-let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ]
+let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
 
 let map_fold =
-  let aux = fun (i: int * (string * int)) -> i.0 + i.1.1 in
+  let aux = fun (i : int * (string * int)) -> i.0 + i.1.1
-  Map.fold aux m (-2)
+  in Map.fold aux m (-2)
 
 let map_iter =
-  let aux = fun (i: string * int) -> if (i.1=12) then failwith "never" else () in
+  let aux =
-  Map.iter aux m
+    fun (i : string * int) -> if i.1 = 12 then failwith "never"
+  in Map.iter aux m
 
 let map_map =
-  let aux = fun (i: string * int) -> i.1 + (String.size i.0) in
+  let aux = fun (i : string * int) -> i.1 + String.length i.0
-  Map.map aux m
+  in Map.map aux m
 
-let map_mem = (Map.mem "one" m , Map.mem "four" m)
+let map_mem = Map.mem "one" m, Map.mem "four" m
 
-let map_remove = (Map.remove "one" m, Map.remove "four" m)
+let map_remove = Map.remove "one" m, Map.remove "four" m
 
-let map_update = (
+let map_update =
-  Map.update "one" (Some(1)) (Map.literal [ "one", 2 ]),
+  Map.update "one" (Some 1) (Map.literal ["one", 2]),
-  Map.update "one" (None : int option) (Map.literal [ "one", 1]),
+  Map.update "one" (None : int option) (Map.literal ["one", 1]),
-  Map.update "one" (None : int option) (Map.literal []:(string,int) map),
+  Map.update "one" (None : int option) (Map.empty : (string, int) map),
-  Map.update "one" (Some(1)) (Map.literal []:(string,int) map)
+  Map.update "one" (Some 1) (Map.literal [] : (string, int) map)
-)
 
-let s = Set.literal [ 1 ; 2 ; 3 ]
+let s = Set.literal [1; 2; 3]
 
-let set_add = (
+let set_add =
   Set.add 1 s,
   Set.add 4 s,
-  Set.add 1 (Set.literal [] : int set)
+  Set.add 1 (Set.empty : int set)
-)
 
 let set_iter_fail =
-  let aux = fun (i:int) -> if i = 1 then failwith "set_iter_fail" else () in
+  let aux = fun (i : int) -> if i = 1 then failwith "set_iter_fail"
-  Set.iter aux (Set.literal [1 ; 2 ; 3])
+  in Set.iter aux (Set.literal [1; 2; 3])
 
-let set_mem = (
+let set_mem =
   Set.mem 1 s,
   Set.mem 4 s,
-  Set.mem 1 (Set.literal [] : int set)
+  Set.mem 1 (Set.empty : int set)
-)

src/test/contracts/isnat.mligo

@@ -1 +1 @@
-let main (i: int) : nat option = Michelson.is_nat i
+let main (i : int) : nat option = is_nat i

src/test/contracts/isnat.religo

@@ -1 +1 @@
-let main = (i: int): option(nat) => Michelson.is_nat(i);
+let main = (i : int): option (nat) => is_nat (i);

src/test/contracts/key_hash.mligo

@@ -1,5 +1,3 @@
-let check_hash_key (kh1, k2: key_hash * key) : bool * key_hash =
+let check_hash_key (kh1, k2 : key_hash * key) : bool * key_hash =
-  let kh2 : key_hash = Crypto.hash_key k2 in
+  let kh2 : key_hash = Crypto.hash_key k2
-  if kh1 = kh2 
+  in kh1 = kh2, kh2
-  then (true, kh2)
-  else (false, kh2)

src/test/contracts/key_hash.religo

@@ -1,10 +1,5 @@
-let check_hash_key = (kh1_k2: (key_hash, key)) : (bool, key_hash) => {
+let check_hash_key = (kh1_k2 : (key_hash, key)) : (bool, key_hash) => {
   let kh1, k2 = kh1_k2;
-  let kh2 : key_hash = Crypto.hash_key(k2);
+  let kh2 : key_hash = Crypto.hash_key (k2);
-  if (kh1 == kh2) {
+  ((kh1 == kh2), kh2)
-    (true, kh2);
-  }
-  else {
-    (false, kh2);
-  }
 };

src/test/contracts/lambda.mligo

@@ -1,8 +1,7 @@
 type storage = unit
 
 (* not supported yet
-let main (p:unit) storage =
+let main (p, s : unit * storage) = (fun x -> ()) ()
-  (fun x -> ()) ()
 *)
 
-let main (ps: unit * storage) = (fun (_: unit) -> ()) ()
+let main (p, s : unit * storage) = (fun (_ : unit) -> ()) ()

src/test/contracts/lambda.religo

@@ -5,6 +5,4 @@ type storage = unit;
      (fun x -> ()) ()
    */
 
-let main2 = ((p: unit), storage) => (((xxx: unit)) => ())();
+let main = ((p,s) : (unit, storage)) => (((useless : unit)) => ()) ();
-
-let main = (x: (unit, storage)) => main2(x[0], x[1]);

src/test/contracts/lambda2.mligo

@@ -1,8 +1,8 @@
 type storage = unit
 
 (* Not supported yet:
-let main (p:unit) storage = (fun x -> ()) ()
+let main (a, s : unit * storage) = (fun x -> ()) ()
 *)
 
-let main (_: unit * storage) =
+let main (a, s : unit * storage) =
-  (fun (f: unit -> unit) -> f ()) (fun (_: unit) -> unit)
+  (fun (f : unit -> unit) -> f ()) (fun (_ : unit) -> unit)

src/test/contracts/lambda2.religo

@@ -4,7 +4,5 @@ type storage = unit;
    let main (p:unit) storage = (fun x -> ()) ()
    */
 
-let main2 = (z: unit, storage) =>
+let main = ((a, s) : (unit, storage)) : (operation (list), storage) =>
-  ((f: (unit => unit)) => f())((z: unit) => unit);
+  ((f : (unit => unit)) => f ()) ((useless : unit) => unit);
-
-let main = (x: (unit, storage)) => main2(x[0],x[1]);

src/test/contracts/let_in_multi_bind.mligo

@@ -1,5 +1,5 @@
-let sum (p: int * int) : int =
+let sum (p : int * int) : int =
   let i, result = p in i + result
 
-let sum2 (p: string * string * string * string) : int =
+let sum2 (p : string * string * string * string) : int =
   let a, b, c, d = p in a ^ b ^ c ^ d

src/test/contracts/let_multiple.mligo

@@ -1,38 +1,36 @@
 (* Simple test of binding multiple values *)
 
-let (x: int), (y: int) = 1,2
+let (x : int), (y : int) = 1,2
 
-let main (p: unit) : int = x + y
+let main (p : unit) : int = x + y
 
-let ((x : int) , (y :int)) = 3,3
+let ((x : int) , (y : int)) = 3,3
 
-let main_paren (p: unit) : int = x + y
+let main_paren (p : unit) : int = x + y
 
 let foobar : (int * int) = (23 , 42)
 let (foo : int) , (bar : int) = foobar
 
 (* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
 
-let correct_values_bound (p: unit) : int * int =
+let correct_values_bound (p : unit) : int * int = foo, bar
-  foo, bar
 
-let non_tuple_rhs (p: unit) : int =
+let non_tuple_rhs (p : unit) : int = bar - foo
-  bar - foo
 
 (* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
 
-let big_tuple : (int * int * int * int * int) = (10, 20, 30, 40, 50)
+let big_tuple : int * int * int * int * int = 10, 20, 30, 40, 50
 
 let (a: int), (b: int), (c: int), (d: int), (e: int) = big_tuple
 
-let correct_values_big_tuple (p: unit) : int * int * int * int * int =
+let correct_values_big_tuple (p : unit) : int * int * int * int * int =
   a, b, c, d, e
 
 (* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
 
-let different_types: (int * string) = 10, "hello"
+let different_types : int * string = 10, "hello"
 
-let (greet_num: int), (greeting: string) = different_types
+let (greet_num : int), (greeting : string) = different_types
 
-let correct_values_different_types (p: unit) : int * string =
+let correct_values_different_types (p : unit) : int * string =
   greet_num, greeting

src/test/contracts/let_multiple.religo

@@ -1,14 +1,15 @@
 /* Simple test of binding multiple values */
 
-let ((x: int), (y: int)) = (1, 2);
+let ((x : int), (y : int)) = (1,2);
 
-let main = (p: unit): int => x + y;
+let main = (p : unit): int => x + y;
 
-let ((x: int), (y: int)) = (3, 3);
+let ((x : int), (y : int)) = (3,3);
 
-let main_paren = (p: unit): int => x + y;
+let main_paren = (p : unit): int => x + y;
 
-let foobar: (int, int) = (23, 42);
+let foobar : (int, int) = (23, 42);
-let ((foo: int), (bar: int)) = foobar;
 
-let non_tuple_rhs = (p: unit): int => foo + bar;
+let ((foo : int), (bar : int)) = foobar;
+
+let non_tuple_rhs = (p : unit) : int => foo + bar;

src/test/contracts/letin.mligo

@@ -1,6 +1,6 @@
 type storage = int * int
 
-let main (n: int * storage) =
+let main (n : int * storage) : operation list * storage =
   let x : int * int =
     let x : int = 7
     in x + n.0, n.1.0 + n.1.1

src/test/contracts/letin.religo

@@ -1,11 +1,9 @@
 type storage = (int, int);
 
-let main2 = ((n : int), storage) => {
+let main = (n : (int, storage)) : (list (operation), storage) => {
-  let x: (int, int) = {
+  let x : (int, int) = {
-    let x: int = 7;
+    let x : int = 7;
-    (x + n, storage[0] + storage[1]);
+    (x + n[0], n[1][0] + n[1][1]);
   };
-  ([]: list(operation), x);
+  ([]: list (operation), x);
 };
-
-let main = (x: (int, storage)) => main2(x[0],x[1]);

src/test/contracts/list.mligo

@@ -1,27 +1,29 @@
 type storage = int * int list
 
-type param = int list
+type parameter = int list
+
+type return = operation list * storage
 
 let x : int list = []
 let y : int list = [3; 4; 5]
 let z : int list = 2::y
 
-let main (p, s: param * storage) =
+let main (p, s: parameter * storage) : return =
   let storage =
     match p with
           [] -> s
     | hd::tl -> s.0 + hd, tl
   in ([] : operation list), storage
 
-let size_ (s: int list) : nat = List.size s
+let size_ (s : int list) : nat = List.length s
 
-let fold_op (s: int list) : int =
+let fold_op (s : int list) : int =
-  let aggregate = fun (t: int * int) -> t.0 + t.1
+  let aggregate = fun (t : int * int) -> t.0 + t.1
   in List.fold aggregate s 10
 
-let map_op (s: int list) : int list =
+let map_op (s : int list) : int list =
-  List.map (fun (cur: int) -> cur + 1) s
+  List.map (fun (cur : int) -> cur + 1) s
 
 let iter_op (s : int list) : unit =
-  let do_nothing = fun (_: int) -> unit
+  let do_nothing = fun (_ : int) -> unit
   in List.iter do_nothing s

src/test/contracts/list.religo

@@ -1,33 +1,33 @@
-type storage = (int, list(int));
+type storage = (int, list (int));
 
-type param = list(int);
+type parameter = list (int);
 
-let x: list(int) = [];
+type return = (list (operation), storage);
-let y: list(int) = [3, 4, 5];
-let z: list(int) = [2, ...y];
 
-let main2 = (p: param, storage) => {
+let x : list (int) = [];
+let y : list (int) = [3, 4, 5];
+let z : list (int) = [2, ...y];
+
+let main = ((p,s) : (parameter, storage)) : return => {
   let storage =
     switch (p) {
-    | [] => storage
+    | [] => s
-    | [hd, ...tl] => (storage[0] + hd, tl)
+    | [hd, ...tl] => (s[0] + hd, tl)
     };
   ([]: list(operation), storage);
 };
 
-let main = (x: (param, storage)) => main2(x[0],x[1]);
+let size_ = (s : list (int)) : nat => List.length (s);
 
-let size_ = (s: list(int)): nat => List.size(s);
+let fold_op = (s : list (int)) : int => {
-
+  let aggregate = (t: (int, int)) => t[0] + t[1];
-let fold_op = (s: list(int)): int => {
+  List.fold (aggregate, s, 10);
-  let aggregate = (prec_cur: (int, int)) => prec_cur[0] + prec_cur[1];
-  List.fold(aggregate, s, 10);
 };
 
-let map_op = (s: list(int)): list(int) =>
+let map_op = (s : list (int)) : list (int) =>
-  List.map((cur: int) => cur + 1, s);
+  List.map ((cur : int) => cur + 1, s);
 
-let iter_op = (s: list(int)): unit => {
+let iter_op = (s : list (int)) : unit => {
-  let do_nothing = (z: int) => unit;
+  let do_nothing = (useless : int) => unit;
-  List.iter(do_nothing, s);
+  List.iter (do_nothing, s);
 };

src/test/contracts/loop.mligo

@@ -1,33 +1,37 @@
-(* Test loops in CameLIGO *)
+(* Test functional iterators in CameLIGO *)
 
-let aux_simple (i: int) : bool * int =
+let aux_simple (i : int) : bool * int =
-  if i < 100 then continue (i + 1) else stop i
+  if i < 100 then Loop.resume (i + 1) else Loop.stop i
 
-let counter_simple (n: int) : int =
+let counter_simple (n : int) : int =
   Loop.fold_while aux_simple n
 
 type sum_aggregator = {
-  counter : int ;
+  counter : int;
-  sum : int ;
+  sum : int
 }
 
 let counter (n : int) : int =
-  let initial : sum_aggregator = { counter = 0 ; sum = 0 } in
+  let initial : sum_aggregator = {counter=0; sum=0} in
-  let out : sum_aggregator = Loop.fold_while (fun (prev: sum_aggregator) ->
+  let aggregate = fun (prev : sum_aggregator) ->
     if prev.counter <= n then
-      continue ({ counter = prev.counter + 1 ; sum = prev.counter + prev.sum })
+      Loop.resume {counter = prev.counter + 1;
+                   sum = prev.counter + prev.sum}
     else
-      stop ({ counter = prev.counter ; sum = prev.sum }) )
+      Loop.stop {counter = prev.counter; sum = prev.sum} in
-   initial in out.sum
+  let out : sum_aggregator =
+    Loop.fold_while aggregate initial
+  in out.sum
 
-let aux_nest (prev: sum_aggregator) : bool * sum_aggregator =
+let aux_nest (prev : sum_aggregator) : bool * sum_aggregator =
   if prev.counter < 100 then
-    continue ({ counter = prev.counter + 1 ;
+    let sum : int =
-                sum = prev.sum + Loop.fold_while aux_simple prev.counter})
+      prev.sum + Loop.fold_while aux_simple prev.counter
+    in Loop.resume {counter = prev.counter + 1; sum = sum}
   else
-    stop ({ counter = prev.counter ; sum = prev.sum })
+    Loop.stop {counter = prev.counter; sum = prev.sum}
 
-let counter_nest (n: int) : int =
+let counter_nest (n : int) : int =
-  let initial : sum_aggregator = { counter = 0 ; sum = 0 } in
+  let initial : sum_aggregator = {counter=0; sum=0} in
   let out : sum_aggregator = Loop.fold_while aux_nest initial
   in out.sum

src/test/contracts/loop.religo

@@ -1,46 +1,41 @@
 /* Test loops in ReasonLIGO */
 
-let aux_simple = (i: int): (bool, int) =>
+let aux_simple = (i : int) : (bool, int) =>
-  if (i < 100) {
+  if (i < 100) { Loop.resume (i + 1); } else { Loop.stop (i); };
-    continue(i + 1);
-  } else {
-    stop(i);
-  };
 
-let counter_simple = (n: int): int => Loop.fold_while(aux_simple, n);
+let counter_simple = (n : int) : int => Loop.fold_while (aux_simple, n);
 
 type sum_aggregator = {
-  counter: int,
+  counter : int,
-  sum: int,
+  sum     : int,
 };
 
-let counter = (n: int): int => {
+let counter = (n : int) : int => {
-  let initial: sum_aggregator = {counter: 0, sum: 0};
+  let initial : sum_aggregator = {counter: 0, sum: 0};
-  let out: sum_aggregator =
+  let aggregate = (prev : sum_aggregator) =>
-    Loop.fold_while(
-      (prev: sum_aggregator) =>
     if (prev.counter <= n) {
-          continue({counter: prev.counter + 1, sum: prev.counter + prev.sum});
+      Loop.resume ({counter : prev.counter + 1,
+                    sum : prev.counter + prev.sum});
     } else {
-          stop({counter: prev.counter, sum: prev.sum});
+      Loop.stop ({counter: prev.counter, sum: prev.sum});
-        },
+    };
-      initial
+  let out : sum_aggregator =
-    );
+    Loop.fold_while (aggregate, initial);
   out.sum;
 };
 
-let aux_nest = (prev: sum_aggregator): (bool, sum_aggregator) =>
+let aux_nest = (prev : sum_aggregator) : (bool, sum_aggregator) =>
   if (prev.counter < 100) {
-    continue({
+    let sum : int =
-      counter: prev.counter + 1,
+      prev.sum + Loop.fold_while (aux_simple, prev.counter);
-      sum: prev.sum + Loop.fold_while(aux_simple, prev.counter),
+    Loop.resume ({counter: prev.counter + 1,
-    });
+                  sum: sum});
   } else {
-    stop({counter: prev.counter, sum: prev.sum});
+    Loop.stop ({counter: prev.counter, sum: prev.sum});
   };
 
-let counter_nest = (n: int): int => {
+let counter_nest = (n : int) : int => {
-  let initial: sum_aggregator = {counter: 0, sum: 0};
+  let initial : sum_aggregator = {counter: 0, sum: 0};
-  let out: sum_aggregator = Loop.fold_while(aux_nest, initial);
+  let out : sum_aggregator = Loop.fold_while (aux_nest, initial);
   out.sum;
 };

src/test/contracts/map.mligo

@@ -7,47 +7,48 @@ let map1 : foobar =
 
 let map2 : foobar = Map.literal [(23,0); (42,0)]
 
-let set_2 (n: int) (m: foobar) : foobar = Map.update 23 (Some n) m
+let set_2 (n : int) (m : foobar) : foobar = Map.update 23 (Some n) m
 
-let set_ (t: int * foobar) : foobar = set_2 t.0 t.1
+let set_ (t : int * foobar) : foobar = set_2 t.0 t.1
 
-let add (n,m: int * foobar) : foobar = Map.add 23 n m
+let add (n,m : int * foobar) : foobar = Map.add 23 n m
 
-let rm (m: foobar) : foobar = Map.remove 42 m
+let rm (m : foobar) : foobar = Map.remove 42 m
 
 (* Dummy test so that we can add the same test for PascaLIGO *)
-let patch_ (m: foobar) : foobar = Map.literal [(0,5); (1,6); (2,7)]
+
+let patch_ (m : foobar) : foobar = Map.literal [(0,5); (1,6); (2,7)]
 
 (* Second dummy test, see above *)
-let patch_empty (m: foobar) : foobar = Map.literal [(0,0); (1,1); (2,2)]
+
+let patch_empty (m : foobar) : foobar = Map.literal [(0,0); (1,1); (2,2)]
 
 (* Third dummy test, see above *)
-let patch_deep (m: foobar * nat) : foobar * nat =
+
+let patch_deep (m : foobar * nat) : foobar * nat =
   Map.literal [(0,0); (1,9); (2,2)], 10n
 
-let size_ (m: foobar) : nat = Map.size m
+let size_ (m : foobar) : nat = Map.size m
 
-let gf (m: foobar) : int = Map.find 23 m
+let get  (m : foobar) : int option = Map.find_opt 42 m
+let get_ (m : foobar) : int option = Map.find_opt 42 m
 
-let get (m: foobar) : int option = Map.find_opt 42 m
+let mem (k,m : int * foobar) : bool = Map.mem k m
-let get_ (m: foobar) : int option = Map.find_opt 42 m
-
-let mem (k,m: int * foobar) : bool = Map.mem k m
 
 let iter_op (m : foobar) : unit =
-  let assert_eq = fun (i: int * int) -> assert (i.0 = i.1)
+  let assert_eq = fun (a, b : int * int) -> assert (a = b)
   in Map.iter assert_eq m
 
 let map_op (m : foobar) : foobar =
-  let increment = fun (i: int * int) -> i.1 + 1
+  let increment = fun (i : int * int) -> i.1 + 1
   in Map.map increment m
 
 let fold_op (m : foobar) : foobar =
-  let aggregate = fun (i: int * (int * int)) -> i.0 + i.1.0 + i.1.1
+  let aggregate = fun (i : int * (int * int)) -> i.0 + i.1.0 + i.1.1
   in Map.fold aggregate m 10
 
 let deep_op (m: foobar) : foobar =
-  let coco = 0,m in
+  let coco = 0, m in
   let coco = 0, Map.remove 42 coco.1 in
   let coco = 0, Map.update 32 (Some 16) coco.1
   in coco.1

src/test/contracts/map.religo

@@ -1,59 +1,60 @@
-
+type foobar = map (int, int);
-type foobar = map(int, int);
 
 let empty_map: foobar = Map.empty;
 
-let map1: foobar =
+let map1 : foobar =
-  Map.literal([(144, 23), (51, 23), (42, 23), (120, 23), (421, 23)]);
+  Map.literal ([(144, 23), (51, 23), (42, 23), (120, 23), (421, 23)]);
 
-let map2: foobar = Map.literal([(23, 0), (42, 0)]);
+let map2 : foobar = Map.literal ([(23, 0), (42, 0)]);
 
-let set_ = (n: int, m: foobar): foobar => Map.update(23, Some(n), m);
+let set_ = (n: int, m: foobar) : foobar => Map.update (23, Some (n), m);
 
-let add = (n: int, m: foobar) : foobar => Map.add(23, n, m);
+let add = (n: int, m: foobar) : foobar => Map.add (23, n, m);
 
-let rm = (m: foobar): foobar => Map.remove(42, m);
+let rm = (m: foobar) : foobar => Map.remove (42, m);
 
 /* Dummy test so that we can add the same test for PascaLIGO */
-let patch_ = (m: foobar): foobar => Map.literal([(0, 5), (1, 6), (2, 7)]);
+
+let patch_ = (m : foobar) : foobar =>
+  Map.literal ([(0, 5), (1, 6), (2, 7)]);
 
 /* Second dummy test, see above */
-let patch_empty = (m: foobar): foobar =>
+
-  Map.literal([(0, 0), (1, 1), (2, 2)]);
+let patch_empty = (m : foobar) : foobar =>
+  Map.literal ([(0, 0), (1, 1), (2, 2)]);
 
 /* Third dummy test, see above */
-let patch_deep = (m: (foobar, nat)): (foobar, nat) => (
+
+let patch_deep = (m : (foobar, nat)) : (foobar, nat) => (
   Map.literal([(0, 0), (1, 9), (2, 2)]),
   10n
 );
 
-let size_ = (m: foobar): nat => Map.size(m);
+let size_ = (m : foobar) : nat => Map.size (m);
 
-let gf = (m: foobar): int => Map.find(23, m);
+let get = (m: foobar): option(int) => Map.find_opt (42, m);
-
-let get = (m: foobar): option(int) => Map.find_opt(42, m);
 let get_ = (m: foobar): option(int) => Map.find_opt(42, m);
 
-let mem = (km: (int, foobar)): bool => Map.mem(km[0], km[1]);
+let mem = (km: (int, foobar)): bool => Map.mem (km[0], km[1]);
 
 let iter_op = (m: foobar): unit => {
-  let assert_eq = (i: int, j: int) => assert(i == j);
+  let assert_eq = (i: int, j: int) => assert (i == j);
-  Map.iter(assert_eq, m);
+  Map.iter (assert_eq, m);
 };
 
-let map_op = (m: foobar): foobar => {
+let map_op = (m: foobar) : foobar => {
   let increment = (z: int, j: int) => j + 1;
-  Map.map(increment, m);
+  Map.map (increment, m);
 };
 
 let fold_op = (m: foobar): foobar => {
   let aggregate = (i: int, j: (int, int)) => i + j[0] + j[1];
-  Map.fold(aggregate, m, 10);
+  Map.fold (aggregate, m, 10);
 };
 
-let deep_op = (m: foobar): foobar => {
+let deep_op = (m: foobar) : foobar => {
   let coco = (0, m);
-  let coco = (0, Map.remove(42, coco[1]));
+  let coco = (0, Map.remove (42, coco[1]));
-  let coco = (0, Map.update(32, Some(16), coco[1]));
+  let coco = (0, Map.update (32, Some (16), coco[1]));
   coco[1];
 };

src/test/contracts/match.mligo

@@ -1,28 +1,30 @@
 type storage = int
 
-type param =
+type parameter =
   Add of int
 | Sub of int
 
-let main (p, s: param * storage) =
+type return = operation list * storage
-  let storage =
-    s +
-      (match p with
-         Add n -> n
-       | Sub n -> 0-n)
-  in ([] : operation list), storage
 
-let match_bool (b: bool) : int =
+let main (action, store : parameter * storage) =
+  let store =
+    store +
+      (match action with
+         Add n -> n
+       | Sub n -> -n)
+  in ([] : operation list), store
+
+let match_bool (b : bool) : int =
   match b with
     true -> 10
   | false -> 0
 
-let match_list (l: int list) : int =
+let match_list (l : int list) : int =
   match l with
-    hd :: tl -> hd
+    hd::tl -> hd
   | [] -> 10
 
-let match_option (i: int option) : int =
+let match_option (i : int option) : int =
   match i with
     Some n -> n
   | None -> 0

src/test/contracts/match.religo

@@ -1,19 +1,18 @@
 type storage = int;
 
-type param =
+type parameter =
-  | Add(int)
+| Add (int)
-  | Sub(int);
+| Sub (int);
 
-let main2 = ((p: param), storage) => {
+type return = (list (operation), storage);
-  let storage =
+
-    storage
+let main = ((action, store): (parameter, storage)) => {
-    + (
+  let store =
-      switch (p) {
+    store +
-      | Add(n) => n
+      (switch (action) {
-      | Sub(n) => 0 - n
+      | Add (n) => n
+      | Sub (n) => -n
       }
   );
-  (([]: list(operation)), storage);
+  (([]: list(operation)), store);
 };
-
-let main = (x: (param, storage)) => main2(x[0],x[1]);

src/test/contracts/match_bis.mligo

@@ -1,19 +1,17 @@
 type storage = int
 
-(* variant defining pseudo multi-entrypoint actions *)
+type parameter =
-
-type action =
   Increment of int
 | Decrement of int
 
-let add (a: int) (b: int) : int = a + b
+type return = operation list * storage
-let sub (a: int) (b: int) : int = a - b
 
-(* real entrypoint that re-routes the flow based on the action provided *)
+let add (a : int) (b : int) : int = a + b
+let sub (a : int) (b : int) : int = a - b
 
-let main (p, s: action * storage) =
+let main (action, store : parameter * storage) : return =
-  let storage =
+  let store =
-    match p  with
+    match action  with
-      Increment n -> add s n
+      Increment n -> add store n
-    | Decrement n -> sub s n
+    | Decrement n -> sub store n
-  in ([] : operation list), storage
+  in ([] : operation list), store

src/test/contracts/match_bis.religo

@@ -1,24 +1,17 @@
 type storage = int;
 
-/* variant defining pseudo multi-entrypoint actions */
+type parameter =
-
+  Increment (int)
-type action =
+| Decrement (int);
-    Increment(int)
-  | Decrement(int);
 
 let add = ((a: int), (b: int)) => a + b;
+let sub = ((a: int), (b: int)) => a - b;
 
-let subtract = ((a: int), (b: int)) => a - b;
+let main = ((action, store) : (parameter, storage)) => {
-
+  let store =
-/* real entrypoint that re-routes the flow based on the action provided */
+    switch (action) {
-
+    | Increment (n) => add (store, n)
-let main2 = ((p: action), storage) => {
+    | Decrement (n) => sub (store, n)
-  let storage =
-    switch (p) {
-    | Increment(n) => add(storage, n)
-    | Decrement(n) => subtract(storage, n)
     };
-  (([]: list(operation)), storage);
+  (([]: list (operation)), store);
 };
-
-let main = (x: (action, storage)) => main2(x[0],x[1]);

src/test/contracts/multiple-parameters.mligo

@@ -1,7 +1,7 @@
 (* Test function with several parameters *)
 
 let abcde_curried (a : int)  (b : int)  (c : int)  (d : int)  (e : int) : int =
-  (c + e + 3)
+  c + e + 3
 
 let abcde (x : int * int * int * int * int) : int =
   abcde_curried x.0 x.1 x.2 x.3 x.4

src/test/contracts/multiple-parameters.religo

@@ -1,6 +1,7 @@
 /* Test function with several parameters */
 
-let abcde_curried = (a: int, b: int, c: int, d: int, e: int): int => c + e + 3;
+let abcde_curried =
-
+  (a: int, b: int, c: int, d: int, e: int): int => c + e + 3;
-let abcde = (x: (int , int , int , int , int)): int => abcde_curried(x[0], x[1], x[2], x[3], x[4]);
 
+let abcde = (x: (int , int , int , int , int)) : int =>
+  abcde_curried (x[0], x[1], x[2], x[3], x[4]);

src/test/contracts/multisig.mligo

@@ -2,7 +2,7 @@
 
 type counter = nat
 type threshold = nat
-type authorized_keys = (key) list
+type authorized_keys = key list
 type id = string
 
 type storage = {
@@ -14,53 +14,51 @@ type storage = {
 
 // I/O types
 
-type message = unit -> (operation) list
+type message = unit -> operation list
+
+type signatures = (key_hash * signature) list
 
-type signatures = (key_hash*signature) list
 type check_message_pt = {
   counter    : counter;
   message    : message;
   signatures : signatures
 }
 
-type return = (operation) list * storage
+type return = operation list * storage
 
 type parameter = CheckMessage of check_message_pt
 
-let check_message (param,s : check_message_pt * storage) : return = 
+let check_message (param, s : check_message_pt * storage) : return =
   let message : message = param.message in
   let s =
-  if (param.counter <> s.counter) then
+    if param.counter <> s.counter then
-    let coco = failwith ("Counters does not match") in s
+      (failwith "Counters does not match" : storage)
-  else (
+    else
-    let packed_payload : bytes = Bytes.pack ((message, param.counter, s.id, chain_id)) in
+      let packed_payload : bytes =
+        Bytes.pack (message, param.counter, s.id, chain_id) in
       let valid : nat = 0n in
       let keys : authorized_keys = s.auth in
-    let aux = fun (vk, pkh_sig: (nat* authorized_keys) * (key_hash*signature)) ->
+      let aux =
-      let (valid,keys) = vk in
+        fun (vk, pkh_sig: (nat * authorized_keys)*(key_hash * signature)) ->
-      match (keys) with
+          let valid, keys = vk in
-      | [] -> (valid,keys)
+            match keys with
-      | key::tl -> (
+            | [] -> vk
-          let keys = tl in
+            | key::keys ->
-          if (pkh_sig.0 = Crypto.hash_key (key)) then
+               if pkh_sig.0 = Crypto.hash_key key
+               then
                  let valid =
-              if (Crypto.check key pkh_sig.1 packed_payload) then valid + 1n
+                   if Crypto.check key pkh_sig.1 packed_payload
-              else let coco = failwith ("Invalid signature") in valid
+                   then valid + 1n
-            in
+                   else (failwith "Invalid signature" : nat)
-            (valid,keys)
+                 in valid, keys
-          else (valid,keys)
+               else valid, keys in
-      )
+      let valid, keys  =
-    in
+        List.fold aux param.signatures (valid, keys) in
-    let (valid,keys) = List.fold aux param.signatures (valid,keys) in
+      if valid < s.threshold then
-    if (valid < s.threshold) then
+        (failwith ("Not enough signatures passed the check") : storage)
-      let coco = failwith ("Not enough signatures passed the check") in 
+      else {s with counter = s.counter + 1n}
-      s
+    in message unit, s
-    else 
-      {s with counter = s.counter + 1n}
-  )
-  in
-  (message(unit),s)
 
-let main (param, s: parameter * storage) : return =
+let main (action, store : parameter * storage) : return =
-  match (param) with  
+  match action with
-   | CheckMessage (p) -> check_message (p,s)
+    CheckMessage (p) -> check_message (p, store)

src/test/contracts/multisig.religo

@@ -15,8 +15,10 @@ type storage = {
 // I/O types
 
 type message = unit => list (operation);
+
 type dummy = (key_hash,signature);
-type signatures = list (dummy);
+
+type signatures = list (dummy); /* Waiting to be fixed */
 
 type check_message_pt = {
   counter    : counter,
@@ -28,53 +30,48 @@ type return =  (list (operation),storage);
 
 type parameter = CheckMessage (check_message_pt);
 
-let check_message = ((param,s) : (check_message_pt, storage)) : return => {
+let check_message = ((param, s): (check_message_pt, storage)) : return =>
+{
   let message : message = param.message;
   let s =
     if (param.counter != s.counter) {
-    let coco = failwith ("Counters does not match");
+      (failwith ("Counters does not match") : storage);
-    s;
+    } else {
-  }
+    let packed_payload : bytes =
-  else {
+      Bytes.pack ((message, param.counter, s.id, chain_id));
-    let packed_payload : bytes = Bytes.pack ((message, param.counter, s.id, chain_id));
       let valid : nat = 0n;
       let keys : authorized_keys = s.auth;
-    let aux = ((vk,pkh_sig) : ((nat, authorized_keys),(key_hash,signature))):(nat,authorized_keys) => { 
+      let aux = ((vk, pkh_sig) :
-      let (valid,keys) = vk;
+                 ((nat, authorized_keys), (key_hash, signature)))
-      switch(keys) {
+                 : (nat, authorized_keys) => {
-      | [] => (valid,keys);
+        let (valid, keys) = vk;
-      | [key, ...tl] => {
+        switch (keys) {
-          let keys = tl;
+        | [] => vk;
-          if (pkh_sig[0] == Crypto.hash_key (key)){
+        | [key, ...keys] =>
+            if (pkh_sig[0] == Crypto.hash_key (key)) {
               let valid =
-            if (Crypto.check (key, pkh_sig[1], packed_payload)){
+                if (Crypto.check (key, pkh_sig[1], packed_payload)) {
-               valid + 1n ;
+                  valid + 1n;
                 }
-            else {
+                else { (failwith ("Invalid signature") : nat) };
-              let coco = failwith ("Invalid signature");
+              (valid, keys);
-              valid;
-              };
-          (valid,keys);
             }
-          else {
+            else { (valid, keys); };
-          (valid,keys);
         };
       };
-      };
+    let (valid, keys) =
-    };
+      List.fold (aux, param.signatures, (valid, keys));
-    let (valid,keys) = List.fold (aux, param.signatures, (valid,keys));
     if (valid < s.threshold) {
-      let coco = failwith ("Not enough signatures passed the check"); 
+      (failwith ("Not enough signatures passed the check") : storage);
-      s;
     }
     else {
       {...s,counter : s.counter + 1n};
     };
   };
-  (message(unit),s)
+  (message (unit),s)
 };
 
-let main = ((param, s) : (parameter,storage)) : return =>
+let main = ((action, store) : (parameter,storage)) : return =>
-  switch(param) { 
+  switch (action) {
-   | CheckMessage (p) => check_message ((p,s))
+   | CheckMessage (p) => check_message ((p, store))
   }

src/test/contracts/negative/self_in_lambda.mligo

@@ -1,5 +1,5 @@
 let foo (u: unit) : address =
-  Current.self_address
+  Tezos.self_address
 
 let main (ps: unit * address): (operation list * address) =
   ( ([] : operation list) , foo)

src/test/contracts/option.religo

@@ -1,4 +1,4 @@
-type foobar = option(int);
+type foobar = option (int);
 
-let s: foobar = Some(42);
+let s : foobar = Some (42);
-let n: foobar = None;
+let n : foobar = None;

src/test/contracts/record.mligo

@@ -1,24 +1,10 @@
-type foobar = {
+type foobar = {foo : int; bar : int}
- foo : int ;
- bar : int ;
-}
 
-let fb : foobar = {
+let fb : foobar = {foo=0; bar=0}
-  foo = 0 ;
-  bar = 0 ;
-}
 
-type abc = {
+type abc = {a : int; b : int; c : int}
-  a : int ;
-  b : int ;
-  c : int
-}
 
-let abc : abc = {
+let abc : abc = {a=42; b=142; c=242}
-  a = 42 ;
-  b = 142 ;
-  c = 242
-}
 
 let a : int = abc.a
 let b : int = abc.b
@@ -28,26 +14,25 @@ let projection (r : foobar) : int = r.foo + r.bar
 
 let modify (r : foobar) : foobar = {foo = 256; bar = r.bar}
 
-let modify_abc (r : abc) : abc = let c = 42 in {r with b = 2048; c = c}
+let modify_abc (r : abc) : abc = let c = 42 in {r with b=2048; c=c}
 
 type big_record = {
-     a : int ;
+  a : int;
-     b : int ;
+  b : int;
-     c : int ;
+  c : int;
-     d : int ;
+  d : int;
-     e : int ;
+  e : int
 }
 
 let br : big_record = {
-  a = 23 ;
+  a = 23;
-  b = 23 ;
+  b = 23;
-  c = 23 ;
+  c = 23;
-  d = 23 ;
+  d = 23;
-  e = 23 ;
+  e = 23
 }
 
-type double_record = {
+type double_record = {inner : abc}
-  inner : abc;
-}
 
-let modify_inner (r : double_record) : double_record = {r with inner.b = 2048 }
+let modify_inner (r : double_record) : double_record =
+  {r with inner.b = 2048}

src/test/contracts/record.religo

@@ -1,22 +1,22 @@
 type foobar = {
- foo : int ,
+ foo : int,
- bar : int ,
+ bar : int
 };
 
 let fb : foobar = {
-  foo : 0 ,
+  foo : 0,
-  bar : 0 ,
+  bar : 0
 };
 
 type abc = {
-  a : int ,
+  a : int,
-  b : int ,
+  b : int,
   c : int
 };
 
 let abc : abc = {
-  a : 42 ,
+  a : 42,
-  b : 142 ,
+  b : 142,
   c : 242
 };
 
@@ -24,30 +24,31 @@ let a : int = abc.a;
 let b : int = abc.b;
 let c : int = abc.c;
 
-let projection = (r : foobar) : int => r.foo + r.bar;
+let projection = (r: foobar) : int => r.foo + r.bar;
 
-let modify = (r : foobar) : foobar => {foo : 256, bar : r.bar};
+let modify = (r: foobar) : foobar => {foo: 256, bar: r.bar};
 
-let modify_abc = (r : abc) : abc => {...r,b : 2048 , c:42};
+let modify_abc = (r: abc) : abc => {...r, b: 2048, c: 42};
 
 type big_record = {
-     a : int ,
+  a : int,
-     b : int ,
+  b : int,
-     c : int ,
+  c : int,
-     d : int ,
+  d : int,
-     e : int ,
+  e : int
 };
 
 let br : big_record = {
-  a : 23 ,
+  a : 23,
-  b : 23 ,
+  b : 23,
-  c : 23 ,
+  c : 23,
-  d : 23 ,
+  d : 23,
-  e : 23 ,
+  e : 23
 };
 
 type double_record = {
   inner : abc,
 };
 
-let modify_inner = (r : double_record) : double_record => {...r,inner.b : 2048 };
+let modify_inner =
+  (r: double_record) : double_record => {...r, inner.b : 2048};

src/test/contracts/self_address.ligo

@@ -1 +1 @@
-function main (const p : unit) : address is self_address
+function main (const p : unit) : address is Tezos.self_address

src/test/contracts/self_address.mligo

@@ -1 +1 @@
-let main (p: unit) : address = Current.self_address 
+let main (p : unit) : address = Tezos.self_address

src/test/contracts/self_address.religo

@@ -1 +1 @@
-let main = (p: unit): address => Current.self_address;
+let main = (p: unit) : address => Tezos.self_address;

src/test/contracts/set_arithmetic-1.mligo

@@ -2,5 +2,4 @@
 
 let aggregate (i : int) (j : int) : int = i + j
 
-let fold_op (s : int set) : int =
+let fold_op (s : int set) : int = Set.fold aggregate s 15
-  Set.fold aggregate s 15

src/test/contracts/set_arithmetic.mligo

@@ -20,8 +20,6 @@ let patch_op_deep (s: string set * nat) : string set * nat =
   begin patch s.0 with set ["foobar"]; end with s
 *)
 
-let mem_op (s : string set) : bool =
+let mem_op (s : string set) : bool = Set.mem "foobar" s
-   Set.mem "foobar" s
 
-let size_op (s: string set) : nat =
+let size_op (s: string set) : nat = Set.cardinal s
-  Set.size s

src/test/contracts/set_arithmetic.religo

@@ -1,22 +1,19 @@
 /* Test set operations in ReasonLIGO */
 
-let literal_op = (p: unit) : set(string) => Set.literal(["foo", "bar", "foobar"]);
+let literal_op = (p: unit) : set (string) =>
+  Set.literal (["foo", "bar", "foobar"]);
 
-let add_op = (s: set(string)): set(string) => Set.add("foobar", s);
+let add_op = (s: set (string)) : set (string) =>
+  Set.add ("foobar", s);
 
-let remove_op = (s: set(string)): set(string) => Set.remove("foobar", s);
+let remove_op = (s: set (string)) : set(string) =>
+  Set.remove ("foobar", s);
 
-let remove_deep = (s: (set(string), nat)): (set(string), nat) =>
+let remove_deep = (s: (set (string), nat)): (set (string), nat) =>
-  Set.remove("foobar", s[0]);
+  Set.remove ("foobar", s[0]);
 
-/*
+let mem_op = (s: set (string)) : bool =>
- let patch_op (s: string set) : string set =
+  Set.mem ("foobar", s);
-   begin patch s with set ["foobar"]; end with s
 
- let patch_op_deep (s: string set * nat) : string set * nat =
+let size_op = (s: set (string)): nat =>
-   begin patch s[0] with set ["foobar"]; end with s
+  Set.cardinal (s);
- */
-
-let mem_op = (s: set(string)): bool => Set.mem("foobar", s);
-
-let size_op = (s: set(string)): nat => Set.size(s);

src/test/contracts/set_delegate.mligo

@@ -1,3 +1,3 @@
-let main (p: key_hash) : operation list =
+let main (p : key_hash) : operation list =
-    let unused: operation = (Operation.set_delegate (Some p)) in ([]: operation list)
+  let useless : operation = Tezos.set_delegate (Some p)
-
+  in ([] : operation list)

src/test/contracts/set_delegate.religo

@@ -1,4 +1,4 @@
-let main = (p: key_hash) : list(operation) => {
+let main = (p: key_hash) : list (operation) => {
-  let unused: operation = (Operation.set_delegate(Some(p)));
+  let unused : operation = (Tezos.set_delegate (Some (p)));
-  ([]: list(operation));
+  ([] : list (operation));
 } ;

src/test/contracts/string_arithmetic.mligo

@@ -1,7 +1,5 @@
 (* Test that the string concatenation syntax in CameLIGO works *)
 
-let size_op (s: string) : nat = String.size s
+let size_op (s : string) : nat = String.length s
-
+let slice_op (s : string) : string = String.sub 1n 2n s
-let slice_op (s: string) : string = String.slice 1n 2n s
+let concat_syntax (s : string) = s ^ "test_literal"
-
-let concat_syntax (s: string) = s ^ "test_literal"

src/test/contracts/string_arithmetic.religo

@@ -1,7 +1,5 @@
 /* Test that the string concatenation syntax in ReasonLIGO works */
 
-let size_op = (s: string): nat => String.size(s);
+let size_op = (s: string) : nat => String.length (s);
-
+let slice_op = (s: string) : string => String.sub (1n, 2n, s);
-let slice_op = (s: string): string => String.slice(1n, 2n, s);
-
 let concat_syntax = (s: string) => s ++ "test_literal";

src/test/contracts/subtle_nontail_fail.mligo

@@ -1,4 +1,4 @@
-let main (ps : unit * unit) =
+let main (_ : unit * unit) =
   if true
   then failwith "This contract always fails"
   else failwith "This contract still always fails"

src/test/contracts/super-counter.mligo

@@ -1,13 +1,17 @@
-type action =
+type parameter =
-| Increment of int
+  Increment of int
 | Decrement of int
 
-let test_param = Increment(1)
+type storage = int
+
+type return = operation list * storage
+
+let test_param = Increment 1
 let test_storage = 2
 
-let main (ps : action * int) : (operation list * int) =
+let main (action, store : parameter * storage) : return =
-  let storage =
+  let store =
-    match ps.0 with
+    match action with
-    | Increment n -> ps.1 + n
+    | Increment n -> store + n
-    | Decrement n -> ps.1 - n in
+    | Decrement n -> store - n
-  (([] : operation list) , storage)
+  in ([] : operation list), store

src/test/contracts/super-counter.religo

@@ -1,12 +1,16 @@
-type action =
+type parameter =
-  | Increment(int)
+  Increment (int)
-  | Decrement(int);
+| Decrement (int);
 
-let main = (p: action, s: int): (list(operation), int) => {
+type storage = int;
-  let storage =
+
-    switch (p) {
+type return = (list (operation), storage);
-    | Increment(n) => s + n
+
-    | Decrement(n) => s - n
+let main = ((action, store): (parameter, storage) : return => {
+  let store =
+    switch (action) {
+    | Increment (n) => store + n
+    | Decrement (n) => store - n
     };
-  ([]: list(operation), storage);
+  ([] : list (operation), store);
 };

src/test/contracts/tez.mligo

@@ -1,5 +1,6 @@
-let add_tez : tez = 21mutez + 0.000021tz
+let add_tez : tez = 21mutez + 0.000_021tez
-let sub_tez : tez = 0.000021tz - 0.000020tz
+let sub_tez : tez = 0.000021tez - 0.000_020tez
-let not_enough_tez : tez = 4611686018427.387903tz
+let not_enough_tez : tez = 461_168_601_842_738_7903mutez
 
-let add_more_tez : tez = 100tz + 10tz + 1tz + 0.1tz + 0.01tz + 0.001tz
+let add_more_tez : tez =
+  100tez + 10tez + 1tez + 0.1tez + 0.01tez + 0.001tez

src/test/contracts/timelock_repeat.mligo

@@ -1,22 +1,22 @@
+type parameter = unit
+
 type storage = {
-  next_use: timestamp;
+  next_use : timestamp;
-  interval: int;
+  interval : int;
-  execute: unit -> operation list;
+  execute  : unit -> operation list
 }
 
-let main (p,s: unit * storage) : operation list * storage =
+type return = operation list * storage
-  (* Multiple calls to Current.time give different values *)
+
-  let now: timestamp = Current.time in
+let main (action, store : parameter * storage) : return =
-  if now > s.next_use
+  (* Multiple evaluations of Tezos.now give different values *)
+  let my_now : timestamp = Tezos.now in
+  if my_now > store.next_use
   then
-    let s: storage = {
+    let store : storage =
-                      next_use = now + s.interval;
+      {store with next_use = my_now + store.interval}
-                      interval = s.interval;
+    in store.execute (), store
-                      execute = s.execute;
-                      }
-    in
-    (s.execute (), s)
   else
     (* TODO: Add the time until next use to this message *)
-    (failwith "You have to wait before you can execute this contract again.":
+    (failwith "You have to wait before you can execute this contract again."
-       operation list * storage)
+     : return)

src/test/contracts/tuple.mligo

@@ -4,7 +4,7 @@ let projection_abc (tpl : abc) : int = tpl.1
 
 type foobar = int * int
 
-let fb : foobar = (0, 0)
+let fb : foobar = (0,0)
 
 let projection (tpl : foobar) : int = tpl.0 + tpl.1
 

src/test/contracts/tuple_type.mligo

@@ -1,14 +1,13 @@
-let g (b: int) = b + 3
+let g (b : int) = b + 3
 
-let f (b: int * int) : int -> int = g
+let f (b : int * int) : int -> int = g
 
-let a (b: int * int -> int -> int) : int = (b (5,3)) 5
+let a (b : int * int -> int -> int) : int = (b (5,3)) 5
 
-let test1 (_: int) =
+let test1 (_: int) = a f
-    a f
 
-let n (a, b: int * int): int = a + b
+let n (a, b : int * int) : int = a + b
 
-let o (p: int * int -> int): int = p((3, 9))
+let o (p : int * int -> int) : int = p (3, 9)
 
-let test2 (ignore: int) = o(n)
+let test2 (ignore : int) = o (n)

src/test/contracts/tuple_type.religo

@@ -11,39 +11,33 @@
 
 type fun_type = (int, int) => int;
 
-let arguments = (b: int, c: int) => {
+let arguments = (b: int, c: int) => { b + c; };
-  b + c;
-}; 
 
-let arguments_type_def = (b: fun_type) => b(5, 3); 
+let arguments_type_def = (b: fun_type) => b (5, 3);
 
-let arguments_test = (ignore: int) => arguments_type_def(arguments);
+let arguments_test = (ignore: int) => arguments_type_def (arguments);
 
 type tuple_type = ((int, int)) => int;
 
-let tuple = ((a, b): (int, int)) => {
+let tuple = ((a, b): (int, int)) => { a + b; };
-  a + b;
-};
 
-let tuple_type_def = (b: tuple_type) => b((5, 3));
+let tuple_type_def = (b: tuple_type) => b ((5, 3));
 
-let tuple_test = (ignore: int) => tuple_type_def(tuple); 
+let tuple_test = (ignore: int) => tuple_type_def (tuple);
 
 
 /* inline */
 
-let arguments_inline = (b: int, c: int) => {
+let arguments_inline = (b: int, c: int) => { b + c; };
-  b + c;
-}; 
 
-let arguments_type_def_inline = (b: (int, int) => int) => b(5, 3); 
+let arguments_type_def_inline = (b: (int, int) => int) => b (5, 3);
 
-let arguments_test_inline = (ignore: int) => arguments_type_def_inline(arguments_inline);
+let arguments_test_inline = (ignore: int) =>
+  arguments_type_def_inline (arguments_inline);
 
-let tuple_inline = ((a, b): (int, int)) => {
+let tuple_inline = ((a, b): (int, int)) => { a + b; };
-  a + b;
-};
 
-let tuple_type_def_inline = (b:  ((int, int)) => int) => b((5, 3));
+let tuple_type_def_inline = (b: ((int, int)) => int) => b ((5, 3));
 
-let tuple_test_inline = (ignore: int) => tuple_type_def_inline(tuple_inline); 
+let tuple_test_inline = (ignore: int) =>
+  tuple_type_def_inline(tuple_inline);