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
-               (pair (timestamp %beginning_time) (timestamp %finish_time))
-               (string %title))
-            (string %vote)) ;
+        (or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title))
+            (or %vote (unit %nay) (unit %yea))) ;
       storage
-        (pair (pair (pair (timestamp %beginning_time) (map %candidates string int))
-                    (pair (timestamp %finish_time) (string %title)))
-              (set %voters address)) ;
+        (pair (pair (pair (timestamp %finish_time) (nat %nay))
+                    (pair (timestamp %start_time) (string %title)))
+              (pair (set %voters address) (nat %yea))) ;
       code { DUP ;
+             DUP ;
              CAR ;
              IF_LEFT
                { DUP ;
-                 DIP { DIP { DUP } ; SWAP ; CDR } ;
-                 PAIR ;
                  DUP ;
                  CAR ;
                  CAR ;
-                 CAR ;
-                 DIP { PUSH int 0 ;
-                       SOME ;
-                       DIP { PUSH int 0 ;
-                             SOME ;
-                             EMPTY_MAP string int ;
+                 PUSH nat 0 ;
                  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 ;
-                 SWAP ;
+                 DIP { PUSH nat 0 ; EMPTY_SET address ; PAIR } ;
                  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 } ;
-                 GET ;
-                 IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                 IF_LEFT
+                   { DIP { DUP } ;
+                     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 ;
-                 CAR ;
-                 DIP { DIP { DUP } ;
-                       SWAP ;
-                       CAR ;
-                       DIP { DUP ;
-                             PUSH int 1 ;
-                             ADD ;
-                             SOME ;
-                             DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CAR ; CDR } } ;
-                       UPDATE } ;
+                 PUSH bool True ;
+                 SENDER ;
+                 UPDATE ;
+                 DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ;
                  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 } } } |}]
+                 DIP { DROP 4 } } ;
+             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
-  in Current.address c
+  let c : unit contract = Tezos.implicit_account p
+  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) ;
-  Current.address(c) ;
+  let c : contract (unit) = Tezos.implicit_account (p);
+  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 =>
-  if (Current.amount == 100tz) {
-    42;
-  }
-  else {
-    0;
-  };
+  if (Tezos.amount == 100tez) { 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 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;
-
-/* 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);
   ([]: 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/bad_address_format.religo

@@ -1,3 +1,2 @@
-let main = (parameter: int, storage: address) => {     
+let main = (parameter : int, storage : 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) =
-  ([] : operation list), balance
+let main (p, s : parameter * storage) : return =
+  ([] : 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]);

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

@@ -16,8 +16,6 @@ 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 => {
   let bar : foo = Big_map.update (42, Some (0), m);
   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 and_op (n : nat) : nat = Bitwise.land n 7n
-let xor_op (n : nat) : nat = Bitwise.lxor n 7n
+let or_op  (n : nat) : nat = Bitwise.or  n 4n
+let and_op (n : nat) : nat = Bitwise.and 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_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 => !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.slice 1n 2n s
-
+let slice_op  (s : bytes) : bytes = Bytes.sub 1n 2n s
 let hasherman (s : bytes) : bytes = Crypto.sha256 s

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

@@ -4,6 +4,6 @@ let test = (k: int): int => {
   let j : int = k + 5;
   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);
 };

src/test/contracts/condition-annot.religo

@@ -1,6 +1,2 @@
 let main = (i : int) =>
-  if (((i == 2): bool)) {
-    (42: int);
-  } else {
-    (0: int);
-  };
+  if (((i == 2) : bool)) { (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
-    let result = 42 in result
-  else
-    let result = 0 in result
+  if i = 2
+  then let result = 42 in result
+  else let result = 0 in result

src/test/contracts/condition.religo

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

src/test/contracts/counter.mligo

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

src/test/contracts/counter.religo

@@ -1,7 +1,4 @@
-
 type storage = int;
 
-let main2 = (p: int, storage): string => ([]: list(operation), p + storage);
-
-let main = (x: (int, storage)) : string => main2(x[0],x[1]);
-
+let main = ((p, s) : (int, storage)) : (list (operation), storage) =>
+  ([] : list (operation), p + 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/eq_bool.religo

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

src/test/contracts/failwith.religo

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

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 (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 bar    = (i : int) : int => i + 50;
-
 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

@@ -8,49 +8,60 @@ type commit_set = (address, commit) big_map
 type storage = {
   hashed  : bytes;
   unused  : bool;
-  commits: commit_set;
+  commits : commit_set
 }
 
 type reveal = {
   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 *)
-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)
+type return = operation list * storage
 
-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)
+  then
+    (failwith "This contract has already been used." : return)
   else
     let commit : commit =
-    match (Big_map.find_opt sender s.commits) with
+      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)
+    | None ->
+       (failwith "You have not 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) 
+    if Tezos.now < commit.date
     then
-    let s: storage = {hashed = s.hashed; unused = false; commits = s.commits} in
-    ((p.message ()), s)
-  else (failwith "Your commitment did not match the storage hash.":
-          operation list * storage)
+      (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)
   | 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) =
-    fun (i : int) -> i
-  in
-  let bar: ((int -> int) -> int) =
-    fun (f : int -> int) -> f i
-  in
-  bar foo
+  let foo: (int -> int) = fun (i : int) -> i in
+  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 ii: int = f i in ii
 
 let foobar2 (i : int) : int =
-  let foo2: (int -> int) =
-    fun (i : int) -> i
-  in
-  higher2 i foo2
+  let foo2 : (int -> int) = fun (i : int) -> i
+  in higher2 i foo2
 
 let a : int = 0
 
 let foobar3 (i : int) : int =
-  let foo2: (int -> int) =
-    fun (i : int) ->  a + i
-  in
-  higher2 i foo2
+  let foo2 : (int -> int) = fun (i : int) ->  a + i
+  in higher2 i foo2
 
 let f (i : int) : int = i
 
@@ -37,10 +31,6 @@ let higher3 (i: int) (f: int -> int) (g: int -> int) : int =
 
 let foobar5 (i : int) : int =
   let a : int = 0 in
-  let foo: (int -> int) =
-    fun (i : int) -> a + i
-  in
-  let goo: (int -> int) =
-    fun (i : int) -> foo i
-  in
-  higher3 i foo goo
+  let foo : (int -> int) = fun (i : int) -> a + i in
+  let goo : (int -> int) = fun (i : int) -> foo i
+  in higher3 i foo goo

src/test/contracts/high-order.religo

@@ -1,13 +1,13 @@
 /* Test a function which takes another function as an argument */
+
 let foobar = (i : int): int => {
   let foo: int => int = (i: int) => i;
-
   let bar: ((int => int) => int) = (f : (int => int)) => f (i);
-
   bar (foo);
 };
 
 /* higher order function with more than one argument */
+
 let higher2 = (i : int, f : (int => int)) : int => {
   let ii : int = f (i);
   ii;
@@ -15,7 +15,6 @@ let higher2 = (i: int, f: (int => int)): int => {
 
 let foobar2 = (i : int) : int => {
   let foo2 : int => int = (i : int) => i;
-
   higher2 (i, foo2);
 };
 
@@ -23,7 +22,6 @@ let a: int = 0;
 
 let foobar3 = (i : int) : int => {
   let foo2: int => int = (i : int) => a + i;
-
   higher2 (i, foo2);
 };
 
@@ -41,8 +39,6 @@ let higher3 = (i: int, f: (int => int), g: (int => int)): int => {
 let foobar5 = (i : int) : int => {
   let a : int = 0;
   let foo : int => int = (i : int) => a + i;
-
   let goo : int => int = (i : int) => foo (i);
-
   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/.
-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.
+(* Preliminary thoughts on ids:
 
-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.
-*)
+I very much like the simplicity of http://gurno.com/adam/mne/.  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 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 =
-    if amount = storage.2.0 
-    then () 
-    else (failwith "Incorrect amount paid.": unit)
-  in
+    if Tezos.amount <> storage.2.0
+    then (failwith "Incorrect amount paid.": unit) in
   let profile, initial_controller = parameter in
   let identities, new_id, prices = storage in
   let controller : address =
     match initial_controller with
     | Some addr -> addr
-    | None -> sender
-  in
+    | None -> sender in
   let new_id_details: id_details = {
     owner = sender;
     controller = controller;
-    profile = profile ;
-  }
-  in
+    profile = profile} in
   let updated_identities : (id, id_details) big_map =
     Big_map.update new_id (Some new_id_details) identities
-  in
-  ([]: operation list), (updated_identities, new_id + 1, prices)
+  in ([]: operation list), (updated_identities, new_id + 1, prices)
 
 let update_owner (parameter, storage : (id * address) * storage) =
-  if (amount <> 0mutez)
-  then (failwith "Updating owner doesn't cost anything.": (operation list) * storage)
+  if amount <> 0tez
+  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 =
       match Big_map.find_opt id identities with
       | Some id_details -> id_details
-    | None -> (failwith "This ID does not exist.": id_details)
-  in
+      | None -> (failwith "This ID does not exist." : id_details) in
     let is_allowed : bool =
-    if sender = current_id_details.owner
+      if Tezos.sender = current_id_details.owner
       then true
-    else (failwith "You are not the owner of this ID.": bool)
-  in
+      else (failwith "You are not the owner of this ID." : bool) in
   let updated_id_details : id_details = {
     owner = new_owner;
     controller = current_id_details.controller;
-    profile = current_id_details.profile;
-  }
-  in
-  let updated_identities = Big_map.update id (Some updated_id_details) identities in
-  ([]: operation list), (updated_identities, last_id, prices)
+    profile = current_id_details.profile} in
+  let updated_identities =
+    Big_map.update id (Some updated_id_details) identities
+  in ([]: operation list), (updated_identities, last_id, prices)
 
 let update_details (parameter, storage: (id * bytes option * address option) * storage) =
-  if (amount <> 0mutez)
-  then (failwith "Updating details doesn't cost anything.": (operation list) * storage)
+  if Tezos.amount <> 0tez
+  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)
-  in
+      | None -> (failwith "This ID does not exist.": id_details) in
     let is_allowed : bool =
-    if (sender = current_id_details.controller) || (sender = current_id_details.owner)
+      if Tezos.sender = current_id_details.controller
+         || Tezos.sender = current_id_details.owner
       then true
-    else (failwith ("You are not the owner or controller of this ID."): bool)
-  in
+      else
+        (failwith ("You are not the owner or controller of this ID.")
+         : bool) in
     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
-  in
+      | Some new_profile -> new_profile in
     let controller : address =
       match new_controller with
       | None -> (* Default *) current_id_details.controller
-    | Some new_controller -> new_controller
-  in
+      | Some new_controller -> new_controller in
     let updated_id_details: id_details = {
         owner = owner;
         controller = controller;
-    profile = profile;
-  }
-  in
+        profile = profile} in
   let updated_identities: (id, id_details) big_map  =
-    Big_map.update id (Some updated_id_details) identities in
-  ([]: operation list), (updated_identities, last_id, prices)
+    Big_map.update id (Some updated_id_details) identities
+  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 undesirable *)
 let skip (p, storage: unit * storage) =
   let void : unit =
-    if amount = storage.2.1
-    then ()
-    else (failwith "Incorrect amount paid.": unit)
-  in
+    if Tezos.amount <> storage.2.1
+    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 
-  (([] : operation list), unit)
+  let c : unit contract = Tezos.implicit_account p
+  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 action =
+type parameter =
   Increment of int
 | Decrement of int
 
+type return = operation list * storage
+
 let add (a : int) (b : int) : int = a + b
 let sub (a : int) (b : int) : int = a - b
 
-(* real entrypoint that re-routes the flow based on the action provided *)
-
-let main (p: action) storage =
-  let storage =
-    match p with
+let main (action, store : parameter * storage) : return =
+  let store =
+    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,14 +1,13 @@
 let lambda_call =
   let a = 3 in
-  let foo = fun (i : int) -> i * i in
-  foo (a + 1)
+  let foo = fun (i : int) -> i * i
+  in foo (a + 1)
 
 let higher_order1 =
   let a = 2 in
-  let foo = fun (i:int) (j:int) (k:int) ->
-    a + i + j + 0 in
-  let bar = (foo 1 2) in
-  bar 3
+  let foo = fun (i : int) (j : int) (k : int) -> a + i + j + 0 in
+  let bar = (foo 1 2)
+  in bar 3
 
 let higher_order2 =
   let a = 2 in
@@ -20,68 +19,69 @@ let higher_order2 =
 
 let higher_order3 =
   let foo = fun (i : int) -> i + 1 in
-  let bar = fun (f:int->int) (i:int) -> (f i) + 1 in
-  let baz : (int -> int ) = bar foo in
-  baz 3
+  let bar = fun (f : int -> int) (i : int) -> f i + 1 in
+  let baz : int -> int = bar foo
+  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
-  bar 2
+  let bar : int -> int = fun (i : int) -> foo i
+  in bar 2
 
-let concats =
-  0x70 ^ 0x70
+let concats = 0x70 ^ 0x70
 
 type foo_record = {
   a : string;
-     b : string ;
+  b : string
 }
+
 let record_concat =
-  let ab : foo_record = { a = "a" ; b = "b" } in
-  ab.a ^ ab.b
+  let ab : foo_record = {a="a"; b="b"}
+  in ab.a ^ ab.b
 
 let record_patch =
-  let ab : foo_record = { a = "a" ; b = "b" } in
-  {ab with b = "c"}
+  let ab : foo_record = {a="a"; b="b"}
+  in {ab with b = "c"}
 
 type bar_record = {
   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 farg : bar_record = { f = foo ; arg = 2 } in
-  farg.f farg.arg
+  let foo : int -> int = fun (i : int) -> a + i*2 in
+  let farg : bar_record = {f = foo; arg = 2}
+  in farg.f farg.arg
 
 type foo_variant =
 | Foo
 | Bar of int
 | Baz of string
 
-let variant_exp =
-  (Foo, Bar 1, Baz "b")
+let variant_exp = Foo, Bar 1, Baz "b"
 
 let variant_match =
   let a = Bar 1 in
   match a with
   | Foo   -> 1
-  | Bar(i) -> 2
-  | Baz(s) -> 3
+  | Bar i -> 2
+  | 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"
   | Biz (a,b,c) -> c
-*/
+ *)
 
 let bool_match =
   let b = true in
@@ -96,69 +96,64 @@ let list_match =
   | [] -> a
 
 let tuple_proj =
-  let (a,b) = (true,false) in
-  a or b
+  let a, b = true, false
+  in a or b
 
 let list_const =
-  let a = [1 ; 2 ; 3 ; 4] in
-  0 :: a
+  let a = [1; 2; 3; 4]
+  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
-  (Michelson.is_nat i, Michelson.is_nat j)
+  let j : int = -1
+  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 add_one: (int -> int) = fun (i : int) -> i + 1 in
-  List.map add_one a
+  let add_one : (int -> int) = fun (i : int) -> i + 1
+  in List.map add_one a
 
 let fail_alone = failwith "you failed"
 
 let iter_list_fail =
   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 acc : (int * int -> int) =
-    fun (prev, el : int * int) -> prev + el in
-  List.fold acc a 0
+  let acc : int * int -> int =
+    fun (prev, el : int * int) -> prev + el
+  in List.fold acc a 0
 
-let comparison_int =
-  (1 > 2, 2 > 1, 1 >=2 , 2 >= 1)
+let comparison_int = 1 > 2, 2 > 1, 1 >=2, 2 >= 1
 
-let comparison_string =
-  ("foo" = "bar", "baz" = "baz")
+let comparison_string = "foo"="bar", "baz"="baz"
 
-let divs : (int * nat * tez * nat) =
-  (1/2 , 1n/2n , 1tz/2n , 1tz/2tz)
+let divs : int * nat * tez * nat = 1/2, 1n/2n, 1tez/2n, 1tez/2tez
 
 let var_neg =
-  let a = 2 in
-  -a
+  let a = 2 in -a
 
 let sizes =
   let a = [1; 2; 3; 4; 5] in
@@ -166,30 +161,33 @@ let sizes =
   let c = Set.literal [1; 2; 3; 4; 5] 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) ->
-    if i < 10 then continue (i + 1) else stop i in
-  (Loop.fold_while aux 20, Loop.fold_while aux 0)
+  let aux : int -> bool * int =
+    fun (i : int) ->
+    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 =
-  assert (1=1)
+let assertion_pass = assert (1=1)
 
-let assertion_fail =
-  assert (1=2)
+let assertion_fail = assert (1=2)
 
 let lit_address = ("KT1ThEdxfUcWUwqsdergy3QnbCWGHSUHeHJq" : address)
 
 let map_finds =
-  let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
-  Map.find_opt "two" m
+  let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
+  in Map.find_opt "two" m
 
 let map_finds_fail =
-  let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
-  Map.find "four" m
+  let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
+  in Map.find "four" m
 
 let map_empty =
   ((Map.empty : (int, int) map), (Map.literal [] : (int, int) map))
@@ -197,42 +195,40 @@ let map_empty =
 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
-  Map.fold aux m (-2)
+  let aux = fun (i : int * (string * int)) -> i.0 + i.1.1
+  in Map.fold aux m (-2)
 
 let map_iter =
-  let aux = fun (i: string * int) -> if (i.1=12) then failwith "never" else () in
-  Map.iter aux m
+  let aux =
+    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
-  Map.map aux m
+  let aux = fun (i : string * int) -> i.1 + String.length i.0
+  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 = (
-  Map.update "one" (Some(1)) (Map.literal [ "one", 2 ]),
+let map_update =
+  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 []:(string,int) map),
-  Map.update "one" (Some(1)) (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)
 
 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
-  Set.iter aux (Set.literal [1 ; 2 ; 3])
+  let aux = fun (i : int) -> if i = 1 then failwith "set_iter_fail"
+  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 kh2 : key_hash = Crypto.hash_key k2 in
-  if kh1 = kh2 
-  then (true, kh2)
-  else (false, kh2)
+  let kh2 : key_hash = Crypto.hash_key k2
+  in kh1 = kh2, kh2

src/test/contracts/key_hash.religo

@@ -1,10 +1,5 @@
 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);
-  if (kh1 == kh2) {
-    (true, kh2);
-  }
-  else {
-    (false, kh2);
-  }
+  ((kh1 == kh2), kh2)
 };

src/test/contracts/lambda.mligo

@@ -1,8 +1,7 @@
 type storage = unit
 
 (* not supported yet
-let main (p:unit) storage =
-  (fun x -> ()) ()
+let main (p, s : unit * storage) = (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 = (x: (unit, storage)) => main2(x[0], x[1]);
+let main = ((p,s) : (unit, storage)) => (((useless : unit)) => ()) ();

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)

src/test/contracts/lambda2.religo

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

src/test/contracts/let_multiple.mligo

@@ -13,15 +13,13 @@ 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 =
-  foo, bar
+let correct_values_bound (p : unit) : int * int = foo, bar
 
-let non_tuple_rhs (p: unit) : int =
-  bar - foo
+let non_tuple_rhs (p : unit) : int = 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
 
@@ -30,7 +28,7 @@ let correct_values_big_tuple (p: unit) : int * int * int * int * int =
 
 (* 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
 

src/test/contracts/let_multiple.religo

@@ -9,6 +9,7 @@ let ((x: int), (y: int)) = (3, 3);
 let main_paren = (p : unit): int => x + y;
 
 let foobar : (int, int) = (23, 42);
+
 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 = 7;
-    (x + n, storage[0] + storage[1]);
+    (x + n[0], n[1][0] + n[1][1]);
   };
   ([]: list (operation), x);
 };
-
-let main = (x: (int, storage)) => main2(x[0],x[1]);

src/test/contracts/list.mligo

@@ -1,19 +1,21 @@
 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 aggregate = fun (t : int * int) -> t.0 + t.1

src/test/contracts/list.religo

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

src/test/contracts/loop.mligo

@@ -1,31 +1,35 @@
-(* Test loops in CameLIGO *)
+(* Test functional iterators in CameLIGO *)
 
 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 =
   Loop.fold_while aux_simple n
 
 type sum_aggregator = {
   counter : int;
-  sum : int ;
+  sum : int
 }
 
 let counter (n : int) : int =
   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 }) )
-   initial in out.sum
+      Loop.stop {counter = prev.counter; sum = prev.sum} in
+  let out : sum_aggregator =
+    Loop.fold_while aggregate initial
+  in out.sum
 
 let aux_nest (prev : sum_aggregator) : bool * sum_aggregator =
   if prev.counter < 100 then
-    continue ({ counter = prev.counter + 1 ;
-                sum = prev.sum + Loop.fold_while aux_simple prev.counter})
+    let sum : int =
+      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 initial : sum_aggregator = {counter=0; sum=0} in

src/test/contracts/loop.religo

@@ -1,11 +1,7 @@
 /* Test loops in ReasonLIGO */
 
 let aux_simple = (i : int) : (bool, int) =>
-  if (i < 100) {
-    continue(i + 1);
-  } else {
-    stop(i);
-  };
+  if (i < 100) { Loop.resume (i + 1); } else { Loop.stop (i); };
 
 let counter_simple = (n : int) : int => Loop.fold_while (aux_simple, n);
 
@@ -16,27 +12,26 @@ type sum_aggregator = {
 
 let counter = (n : int) : int => {
   let initial : sum_aggregator = {counter: 0, sum: 0};
-  let out: sum_aggregator =
-    Loop.fold_while(
-      (prev: sum_aggregator) =>
+  let aggregate = (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});
-        },
-      initial
-    );
+      Loop.stop ({counter: prev.counter, sum: prev.sum});
+    };
+  let out : sum_aggregator =
+    Loop.fold_while (aggregate, initial);
   out.sum;
 };
 
 let aux_nest = (prev : sum_aggregator) : (bool, sum_aggregator) =>
   if (prev.counter < 100) {
-    continue({
-      counter: prev.counter + 1,
-      sum: prev.sum + Loop.fold_while(aux_simple, prev.counter),
-    });
+    let sum : int =
+      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 => {

src/test/contracts/map.mligo

@@ -16,26 +16,27 @@ let add (n,m: int * foobar) : foobar = Map.add 23 n 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)]
 
 (* Second dummy test, see above *)
+
 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 =
   Map.literal [(0,0); (1,9); (2,2)], 10n
 
 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 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 =

src/test/contracts/map.religo

@@ -1,4 +1,3 @@
-
 type foobar = map (int, int);
 
 let empty_map: foobar = Map.empty;
@@ -15,13 +14,17 @@ let add = (n: int, m: foobar) : foobar => Map.add(23, n, 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)]);
 
 /* Third dummy test, see above */
+
 let patch_deep = (m : (foobar, nat)) : (foobar, nat) => (
   Map.literal([(0, 0), (1, 9), (2, 2)]),
   10n
@@ -29,8 +32,6 @@ let patch_deep = (m: (foobar, nat)): (foobar, nat) => (
 
 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);
 

src/test/contracts/match.mligo

@@ -1,16 +1,18 @@
 type storage = int
 
-type param =
+type parameter =
   Add of int
 | Sub of int
 
-let main (p, s: param * storage) =
-  let storage =
-    s +
-      (match p with
+type return = operation list * storage
+
+let main (action, store : parameter * storage) =
+  let store =
+    store +
+      (match action with
          Add n -> n
-       | Sub n -> 0-n)
-  in ([] : operation list), storage
+       | Sub n -> -n)
+  in ([] : operation list), store
 
 let match_bool (b : bool) : int =
   match b with

src/test/contracts/match.religo

@@ -1,19 +1,18 @@
 type storage = int;
 
-type param =
+type parameter =
 | Add (int)
 | Sub (int);
 
-let main2 = ((p: param), storage) => {
-  let storage =
-    storage
-    + (
-      switch (p) {
+type return = (list (operation), storage);
+
+let main = ((action, store): (parameter, storage)) => {
+  let store =
+    store +
+      (switch (action) {
       | Add (n) => n
-      | Sub(n) => 0 - 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 action =
+type parameter =
   Increment of int
 | Decrement of int
 
+type return = operation list * storage
+
 let add (a : int) (b : int) : int = a + b
 let sub (a : int) (b : int) : int = a - b
 
-(* real entrypoint that re-routes the flow based on the action provided *)
-
-let main (p, s: action * storage) =
-  let storage =
-    match p  with
-      Increment n -> add s n
-    | Decrement n -> sub s n
-  in ([] : operation list), storage
+let main (action, store : parameter * storage) : return =
+  let store =
+    match action  with
+      Increment n -> add store n
+    | Decrement n -> sub store n
+  in ([] : operation list), store

src/test/contracts/match_bis.religo

@@ -1,24 +1,17 @@
 type storage = int;
 
-/* variant defining pseudo multi-entrypoint actions */
-
-type action =
+type parameter =
   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;
-
-/* real entrypoint that re-routes the flow based on the action provided */
-
-let main2 = ((p: action), storage) => {
-  let storage =
-    switch (p) {
-    | Increment(n) => add(storage, n)
-    | Decrement(n) => subtract(storage, n)
+let main = ((action, store) : (parameter, storage)) => {
+  let store =
+    switch (action) {
+    | Increment (n) => add (store, n)
+    | Decrement (n) => sub (store, 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 = (x: (int , int , int , int , int)): int => abcde_curried(x[0], x[1], x[2], x[3], x[4]);
+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]);

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 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 message : message = param.message in
   let s =
-  if (param.counter <> s.counter) then
-    let coco = failwith ("Counters does not match") in s
-  else (
-    let packed_payload : bytes = Bytes.pack ((message, param.counter, s.id, chain_id)) in
+    if param.counter <> s.counter then
+      (failwith "Counters does not match" : storage)
+    else
+      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 (valid,keys) = vk in
-      match (keys) with
-      | [] -> (valid,keys)
-      | key::tl -> (
-          let keys = tl in
-          if (pkh_sig.0 = Crypto.hash_key (key)) then
+      let aux =
+        fun (vk, pkh_sig: (nat * authorized_keys)*(key_hash * signature)) ->
+          let valid, keys = vk in
+            match keys with
+            | [] -> vk
+            | key::keys ->
+               if pkh_sig.0 = Crypto.hash_key key
+               then
                  let valid =
-              if (Crypto.check key pkh_sig.1 packed_payload) then valid + 1n
-              else let coco = failwith ("Invalid signature") in valid
-            in
-            (valid,keys)
-          else (valid,keys)
-      )
-    in
-    let (valid,keys) = List.fold aux param.signatures (valid,keys) in
-    if (valid < s.threshold) then
-      let coco = failwith ("Not enough signatures passed the check") in 
-      s
-    else 
-      {s with counter = s.counter + 1n}
-  )
-  in
-  (message(unit),s)
+                   if Crypto.check key pkh_sig.1 packed_payload
+                   then valid + 1n
+                   else (failwith "Invalid signature" : nat)
+                 in valid, keys
+               else valid, keys in
+      let valid, keys  =
+        List.fold aux param.signatures (valid, keys) in
+      if valid < s.threshold then
+        (failwith ("Not enough signatures passed the check") : storage)
+      else {s with counter = s.counter + 1n}
+    in message unit, s
 
-let main (param, s: parameter * storage) : return =
-  match (param) with  
-   | CheckMessage (p) -> check_message (p,s)
+let main (action, store : parameter * storage) : return =
+  match action with
+    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,44 +30,39 @@ 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");
-    s;
-  }
-  else {
-    let packed_payload : bytes = Bytes.pack ((message, param.counter, s.id, chain_id));
+      (failwith ("Counters does not match") : storage);
+    } else {
+    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) :
+                 ((nat, authorized_keys), (key_hash, signature)))
+                 : (nat, authorized_keys) => {
         let (valid, keys) = vk;
         switch (keys) {
-      | [] => (valid,keys);
-      | [key, ...tl] => {
-          let keys = tl;
+        | [] => vk;
+        | [key, ...keys] =>
             if (pkh_sig[0] == Crypto.hash_key (key)) {
               let valid =
                 if (Crypto.check (key, pkh_sig[1], packed_payload)) {
                   valid + 1n;
                 }
-            else {
-              let coco = failwith ("Invalid signature");
-              valid;
-              };
+                else { (failwith ("Invalid signature") : nat) };
               (valid, keys);
             }
-          else {
-          (valid,keys);
+            else { (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"); 
-      s;
+      (failwith ("Not enough signatures passed the check") : storage);
     }
     else {
       {...s,counter : s.counter + 1n};
@@ -74,7 +71,7 @@ let check_message = ((param,s) : (check_message_pt, storage)) : return => {
   (message (unit),s)
 };
 
-let main = ((param, s) : (parameter,storage)) : return =>
-  switch(param) { 
-   | CheckMessage (p) => check_message ((p,s))
+let main = ((action, store) : (parameter,storage)) : return =>
+  switch (action) {
+   | 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/record.mligo

@@ -1,24 +1,10 @@
-type foobar = {
- foo : int ;
- bar : int ;
-}
+type foobar = {foo : int; bar : int}
 
-let fb : foobar = {
-  foo = 0 ;
-  bar = 0 ;
-}
+let fb : foobar = {foo=0; bar=0}
 
-type abc = {
-  a : int ;
-  b : int ;
-  c : int
-}
+type abc = {a : int; b : int; c : int}
 
-let abc : abc = {
-  a = 42 ;
-  b = 142 ;
-  c = 242
-}
+let abc : abc = {a=42; b=142; c=242}
 
 let a : int = abc.a
 let b : int = abc.b
@@ -35,7 +21,7 @@ type big_record = {
   b : int;
   c : int;
   d : int;
-     e : int ;
+  e : int
 }
 
 let br : big_record = {
@@ -43,11 +29,10 @@ let br : big_record = {
   b = 23;
   c = 23;
   d = 23;
-  e = 23 ;
+  e = 23
 }
 
-type double_record = {
-  inner : abc;
-}
+type double_record = {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,11 +1,11 @@
 type foobar = {
  foo : int,
- bar : int ,
+ bar : int
 };
 
 let fb : foobar = {
   foo : 0,
-  bar : 0 ,
+  bar : 0
 };
 
 type abc = {
@@ -35,7 +35,7 @@ type big_record = {
   b : int,
   c : int,
   d : int,
-     e : int ,
+  e : int
 };
 
 let br : big_record = {
@@ -43,11 +43,12 @@ let br : big_record = {
   b : 23,
   c : 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 =
-  Set.fold aggregate s 15
+let fold_op (s : int set) : int = 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 =
-   Set.mem "foobar" s
+let mem_op (s : string set) : bool = Set.mem "foobar" s
 
-let size_op (s: string set) : nat =
-  Set.size s
+let size_op (s: string set) : nat = Set.cardinal 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) =>
   Set.remove ("foobar", s[0]);
 
-/*
- let patch_op (s: string set) : string set =
-   begin patch s with set ["foobar"]; end with s
+let mem_op = (s: set (string)) : bool =>
+  Set.mem ("foobar", s);
 
- 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: set(string)): bool => Set.mem("foobar", s);
-
-let size_op = (s: set(string)): nat => Set.size(s);
+let size_op = (s: set (string)): nat =>
+  Set.cardinal (s);

src/test/contracts/set_delegate.mligo

@@ -1,3 +1,3 @@
 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 unused: operation = (Operation.set_delegate(Some(p)));
+  let unused : operation = (Tezos.set_delegate (Some (p)));
   ([] : 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 slice_op (s: string) : string = String.slice 1n 2n s
-
+let size_op (s : string) : nat = String.length s
+let slice_op (s : string) : string = String.sub 1n 2n s
 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 slice_op = (s: string): string => String.slice(1n, 2n, s);
-
+let size_op = (s: string) : nat => String.length (s);
+let slice_op = (s: string) : string => String.sub (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 =
-| Increment of int
+type parameter =
+  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 storage =
-    match ps.0 with
-    | Increment n -> ps.1 + n
-    | Decrement n -> ps.1 - n in
-  (([] : operation list) , storage)
+let main (action, store : parameter * storage) : return =
+  let store =
+    match action with
+    | Increment n -> store + n
+    | Decrement n -> store - n
+  in ([] : operation list), store

src/test/contracts/super-counter.religo

@@ -1,12 +1,16 @@
-type action =
-  | Increment(int)
+type parameter =
+  Increment (int)
 | Decrement (int);
 
-let main = (p: action, s: int): (list(operation), int) => {
-  let storage =
-    switch (p) {
-    | Increment(n) => s + n
-    | Decrement(n) => s - n
+type storage = int;
+
+type return = (list (operation), storage);
+
+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 sub_tez : tez = 0.000021tz - 0.000020tz
-let not_enough_tez : tez = 4611686018427.387903tz
+let add_tez : tez = 21mutez + 0.000_021tez
+let sub_tez : tez = 0.000021tez - 0.000_020tez
+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;
   interval : int;
-  execute: unit -> operation list;
+  execute  : unit -> operation list
 }
 
-let main (p,s: unit * storage) : operation list * storage =
-  (* Multiple calls to Current.time give different values *)
-  let now: timestamp = Current.time in
-  if now > s.next_use
+type return = operation list * storage
+
+let main (action, store : parameter * storage) : return =
+  (* 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 = {
-                      next_use = now + s.interval;
-                      interval = s.interval;
-                      execute = s.execute;
-                      }
-    in
-    (s.execute (), s)
+    let store : storage =
+      {store with next_use = my_now + store.interval}
+    in store.execute (), store
   else
     (* TODO: Add the time until next use to this message *)
-    (failwith "You have to wait before you can execute this contract again.":
-       operation list * storage)
+    (failwith "You have to wait before you can execute this contract again."
+     : return)

src/test/contracts/tuple_type.mligo

@@ -4,11 +4,10 @@ let f (b: int * int) : int -> int = g
 
 let a (b : int * int -> int -> int) : int = (b (5,3)) 5
 
-let test1 (_: int) =
-    a f
+let test1 (_: int) = a f
 
 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)

src/test/contracts/tuple_type.religo

@@ -11,9 +11,7 @@
 
 type fun_type = (int, int) => int;
 
-let arguments = (b: int, c: int) => {
-  b + c;
-}; 
+let arguments = (b: int, c: int) => { b + c; };
 
 let arguments_type_def = (b: fun_type) => b (5, 3);
 
@@ -21,9 +19,7 @@ let arguments_test = (ignore: int) => arguments_type_def(arguments);
 
 type tuple_type = ((int, int)) => int;
 
-let tuple = ((a, b): (int, int)) => {
-  a + b;
-};
+let tuple = ((a, b): (int, int)) => { a + b; };
 
 let tuple_type_def = (b: tuple_type) => b ((5, 3));
 
@@ -32,18 +28,16 @@ let tuple_test = (ignore: int) => tuple_type_def(tuple);
 
 /* inline */
 
-let arguments_inline = (b: int, c: int) => {
-  b + c;
-}; 
+let arguments_inline = (b: int, c: int) => { b + c; };
 
 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)) => {
-  a + b;
-};
+let tuple_inline = ((a, b): (int, int)) => { a + b; };
 
 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);

src/test/contracts/variant.mligo

@@ -4,7 +4,5 @@ type foobar =
 | Kee of nat
 
 let foo : foobar = Foo 42
-
 let bar : foobar = Bar true
-
 let kee : foobar = Kee 23n

src/test/contracts/variant.religo

@@ -1,10 +1,8 @@
 type foobar =
-  | Foo(int)
+  Foo (int)
 | Bar (bool)
 | Kee (nat);
 
 let foo: foobar = Foo (42);
-
 let bar: foobar = Bar (true);
-
 let kee: foobar = Kee (23n);

src/test/contracts/vote.mligo

@@ -1,56 +1,49 @@
 type storage = {
   title       : string;
-  candidates : (string , int) map ;
+  yea         : nat;
+  nay         : nat;
   voters      : address set;
-  beginning_time : timestamp ;
-  finish_time : timestamp ;
+  start_time  : timestamp;
+  finish_time : timestamp
 }
 
-type init_action = {
+type return = operation list * storage
+
+type vote = Yea | Nay
+
+type reset = {
   title       : string;
-  beginning_time : timestamp ;
-  finish_time : timestamp ;
+  start_time  : timestamp;
+  finish_time : timestamp
 }
 
-type action =
-  | Vote of string
-  | Init of init_action
+type parameter =
+| Vote  of vote
+| Reset of reset
 
-let init (init_params_s : init_action * storage) =
-  let candidates = Map.literal [
-      ("Yes" , 0) ;
-      ("No" , 0)
-    ] in
-  (
+let reset (reset, _ : reset * storage) : return =
   ([] : operation list),
-    {
-      title = init_params_s.0.title ;
-      candidates = candidates ;
+  {title       = reset.title;
+   yea         = 0n;
+   nay         = 0n;
    voters      = (Set.empty : address set);
-      beginning_time = init_params_s.0.beginning_time ;
-      finish_time = init_params_s.0.finish_time ;
-    }
-  )
+   start_time  = reset.start_time;
+   finish_time = reset.finish_time}
 
-let vote (ps : string * storage) =
-  let now = Current.time in
-  (* let _ = assert (now >= ps.1.beginning_time && ps.1.finish_time > now) in *)
-  let addr = Current.sender in
-  (* let _ = assert (not Set.mem addr ps.1.voters) in *)
-  let x = Map.find ps.0 ps.1.candidates in
-  (
-    ([] : operation list),
-    {
-      title = ps.1.title ;
-      candidates = Map.update ps.0 (Some (x + 1)) ps.1.candidates ;
-      voters = Set.add addr ps.1.voters ;
-      beginning_time = ps.1.beginning_time ;
-      finish_time = ps.1.finish_time ;
-    }
-  )
-
-let main (a_s : action * storage) =
-  match a_s.0 with
-  | Vote p -> vote (p, a_s.1)
-  | Init ps -> init (ps, a_s.1)
+let vote (vote, store : vote * storage) : return =
+  let now = Tezos.now in
+  (* let _ =
+     assert (now >= store.start_time && store.finish_time > now) in *)
+  let addr = Tezos.sender in
+  (* let _ = assert (not Set.mem addr store.voters) in *)
+  let store =
+    match vote with
+      Yea -> {store with yea = store.yea + 1n}
+    | Nay -> {store with nay = store.nay + 1n}
+  in ([] : operation list),
+     {store with voters = Set.add addr store.voters}
 
+let main (action, store : parameter * storage) : return =
+  match action with
+  | Vote v  -> vote (v, store)
+  | Reset r -> reset (r, store)

src/test/contracts/website2.mligo

@@ -4,16 +4,16 @@ type storage = int
 
 (* variant defining pseudo multi-entrypoint actions *)
 
-type action =
+type parameter =
 | Increment of int
 | Decrement of int
 
 let add (a,b: int * int) : int = a + b
 let sub (a,b: int * int) : int = a - b
 
-(* real entrypoint that re-routes the flow based on the action provided *)
+(* real entrypoint that re-routes the flow based on the parameter provided *)
 
-let main (p,s: action * storage) =
+let main (p,s: parameter * storage) =
  let storage =
    match p with
    | Increment n -> add (s, n)

src/test/contracts/website2.religo

@@ -4,16 +4,16 @@ type storage = int;
 
 /* variant defining pseudo multi-entrypoint actions */
 
-type action =
+type parameter =
 | Increment (int)
 | Decrement (int);
 
 let add = ((a,b): (int, int)): int => a + b;
 let sub = ((a,b): (int, int)): int => a - b;
 
-/* real entrypoint that re-routes the flow based on the action provided */
+/* real entrypoint that re-routes the flow based on the parameter provided */
 
-let main = ((p,storage): (action, storage)) => {
+let main = ((p,storage): (parameter, storage)) => {
   let storage =
     switch (p) {
     | Increment(n) => add ((storage, n))

src/test/hash_lock_tests.ml

@@ -99,7 +99,7 @@ let reveal_no_commit () =
   let init_storage = storage test_hash true pre_commits in
   expect_string_failwith program "reveal"
     (e_pair reveal init_storage)
-    "You haven't made a commitment to hash against yet."
+    "You have not made a commitment to hash against yet."
 
 (* Test that the contract fails if our commit isn't 24 hours old yet *)
 let reveal_young_commit () =
@@ -132,7 +132,7 @@ let reveal_young_commit () =
   in
   expect_string_failwith ~options program "reveal"
     (e_pair reveal init_storage)
-    "It hasn't been 24 hours since your commit yet."
+    "It has not been 24 hours since your commit yet."
 
 (* Test that the contract fails if our reveal doesn't meet our commitment *)
 let reveal_breaks_commit () =
@@ -164,7 +164,7 @@ let reveal_breaks_commit () =
   in
   expect_string_failwith ~options program "reveal"
     (e_pair reveal init_storage)
-    "This reveal doesn't match your commitment."
+    "This reveal does not match your commitment."
 
 (* Test that the contract fails if we reveal the wrong bytes for the stored hash *)
 let reveal_wrong_commit () =

src/test/time_lock_repeat_tests.ml

@@ -63,7 +63,7 @@ let interval_advance () =
   let%bind predecessor_timestamp = mk_time "2000-01-01T10:10:10Z" in
   let%bind lock_time = mk_time "2000-01-01T00:10:10Z" in
   let init_storage = storage lock_time 86400 empty_message in
-  (* It takes a second for Current.now to be called, awful hack *)
+  (* It takes a second for Tezos.now to be called, awful hack *)
   let%bind new_timestamp = mk_time "2000-01-02T10:10:11Z" in
   let new_storage_fake = storage new_timestamp 86400 fake_uncompiled_empty_message in
   let options =

src/test/vote_tests.ml

@@ -20,38 +20,33 @@ open Ast_simplified
 
 let init_storage name = e_record_ez [
     ("title" , e_string name) ;
-    ("candidates" , e_map [
-        (e_string "Yes" , e_int 0) ;
-        (e_string "No" , e_int 0) ;
-      ]) ;
+    ("yea", e_nat 0) ;
+    ("nay", e_nat 0) ;
     ("voters" , e_typed_set [] t_address) ;
-    ("beginning_time" , e_timestamp 0) ;
+    ("start_time" , e_timestamp 0) ;
     ("finish_time" , e_timestamp 1000000000) ;
   ]
 
-let init title beginning_time finish_time =
-  let init_action = e_record_ez [
+let reset title start_time finish_time =
+  let reset_action = e_record_ez [
       ("title" , e_string title) ;
-      ("beginning_time" , e_timestamp beginning_time) ;
-      ("finish_time" , e_timestamp finish_time) ;
-    ] in
-  e_constructor "Init" init_action
+      ("start_time" , e_timestamp start_time) ;
+      ("finish_time" , e_timestamp finish_time)]
+  in e_constructor "Reset" reset_action
 
-let vote str =
-  let vote = e_string str in
-  e_constructor "Vote" vote
+let yea = e_constructor "Vote" (e_constructor "Yea" (e_unit ()))
 
 let init_vote () =
   let%bind (program , _) = get_program () in
-  let%bind result = Test_helpers.run_typed_program_with_simplified_input program "main" (e_pair (vote "Yes") (init_storage "basic")) in
+  let%bind result =
+    Test_helpers.run_typed_program_with_simplified_input
+      program "main" (e_pair yea (init_storage "basic")) in
   let%bind (_, storage) = extract_pair result in
   let%bind storage' = extract_record storage in
-  let votes = List.assoc (Label "candidates") storage' in
-  let%bind votes' = extract_map votes in
-  let%bind (_ , yess) =
-    trace_option (simple_error "") @@
-    List.find_opt (fun (k , _) -> Ast_simplified.Misc.is_value_eq (k , e_string "Yes")) votes' in
-  let%bind () = Ast_simplified.Misc.assert_value_eq (yess , e_int 1) in
+(*  let votes = List.assoc (Label "voters") storage' in
+  let%bind votes' = extract_map votes in *)
+  let yea = List.assoc (Label "yea") storage' in
+  let%bind () = Ast_simplified.Misc.assert_value_eq (yea, e_nat 1) in
   ok ()
 
 let main = test_suite "Vote" [