Merge branch 'rinderknecht@contracts' into 'dev'

Refactoring of the test contracts

See merge request ligolang/ligo!465

src/bin/expect_tests/contract_tests.ml

@@ -7,7 +7,7 @@ let bad_contract basename =
 
 let%expect_test _ =
   run_ligo_good [ "measure-contract" ; contract "coase.ligo" ; "main" ] ;
-  [%expect {| 1747 bytes |}] ;
+  [%expect {| 1870 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "multisig.ligo" ; "main" ] ;
   [%expect {| 1324 bytes |}] ;
@@ -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)) |}] ;
@@ -86,7 +86,9 @@ let%expect_test _ =
                      SWAP ;
                      DIP { DUP ; CAR ; CAR } ;
                      GET ;
-                     IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                     IF_NONE
+                       { PUSH string "buy_single: No card pattern." ; FAILWITH }
+                       { DUP ; DIP { DROP } } ;
                      DUP ;
                      CAR ;
                      DIP { DUP ; CDR ; PUSH nat 1 ; ADD } ;
@@ -159,7 +161,9 @@ let%expect_test _ =
                      SWAP ;
                      DIP { DUP ; CAR ; CDR } ;
                      GET ;
-                     IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                     IF_NONE
+                       { PUSH string "sell_single: No card." ; FAILWITH }
+                       { DUP ; DIP { DROP } } ;
                      DUP ;
                      CAR ;
                      SENDER ;
@@ -173,7 +177,9 @@ let%expect_test _ =
                      CDR ;
                      DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR } ;
                      GET ;
-                     IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                     IF_NONE
+                       { PUSH string "sell_single: No card pattern." ; FAILWITH }
+                       { DUP ; DIP { DROP } } ;
                      DUP ;
                      DIP { DUP } ;
                      SWAP ;
@@ -209,7 +215,9 @@ let%expect_test _ =
                      MUL ;
                      SENDER ;
                      CONTRACT unit ;
-                     IF_NONE { PUSH string "bad address for get_contract" ; FAILWITH } {} ;
+                     IF_NONE
+                       { PUSH string "sell_single: No contract." ; FAILWITH }
+                       { DUP ; DIP { DROP } } ;
                      DIP { DUP } ;
                      SWAP ;
                      DIP { DUP } ;
@@ -246,7 +254,9 @@ let%expect_test _ =
                  CAR ;
                  DIP { DUP } ;
                  GET ;
-                 IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                 IF_NONE
+                   { PUSH string "transfer_single: No card." ; FAILWITH }
+                   { DUP ; DIP { DROP } } ;
                  DUP ;
                  CAR ;
                  SENDER ;
@@ -938,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 ;
@@ -979,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" ] ;
@@ -1054,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
@@ -1149,7 +1161,7 @@ let%expect_test _ =
 let%expect_test _ =
   run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_toplevel.mligo" ; "main" ] ;
   [%expect {|
-    ligo: in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8. No free variable allowed in this lambda: variable 'store' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * string ):Some(( nat * string ))) : None return let rhs#756 = #P in let p = rhs#756.0 in let s = rhs#756.1 in ( list[] : (TO_list(operation)) , store ) , NONE() : (TO_option(key_hash)) , 300000000mutez , \"un\")","location":"in file \"create_contract_toplevel.mligo\", line 4, character 35 to line 8, character 8"}
+ligo: in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8. No free variable allowed in this lambda: variable 'store' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * string ):Some(( nat * string ))) : None return let rhs#808 = #P in let p = rhs#808.0 in let s = rhs#808.1 in ( list[] : (TO_list(operation)) , store ) , NONE() : (TO_option(key_hash)) , 300000000mutez , \"un\")","location":"in file \"create_contract_toplevel.mligo\", line 4, character 35 to line 8, character 8"}
 
 
  If you're not sure how to fix this error, you can
@@ -1162,7 +1174,7 @@ let%expect_test _ =
 
   run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_var.mligo" ; "main" ] ;
   [%expect {|
-    ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5. No free variable allowed in this lambda: variable 'a' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * int ):Some(( nat * int ))) : None return let rhs#759 = #P in let p = rhs#759.0 in let s = rhs#759.1 in ( list[] : (TO_list(operation)) , a ) , NONE() : (TO_option(key_hash)) , 300000000mutez , 1)","location":"in file \"create_contract_var.mligo\", line 6, character 35 to line 10, character 5"}
+ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5. No free variable allowed in this lambda: variable 'a' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * int ):Some(( nat * int ))) : None return let rhs#811 = #P in let p = rhs#811.0 in let s = rhs#811.1 in ( list[] : (TO_list(operation)) , a ) , NONE() : (TO_option(key_hash)) , 300000000mutez , 1)","location":"in file \"create_contract_var.mligo\", line 6, character 35 to line 10, character 5"}
 
 
  If you're not sure how to fix this error, you can

src/passes/operators/operators.ml

@@ -89,7 +89,6 @@ module Simplify = struct
     | "Tezos.failwith"         -> ok C_FAILWITH
     | "failwith"               -> ok C_FAILWITH
     | "Tezos.create_contract"  -> ok C_CREATE_CONTRACT
-
     | "Tezos.transaction"      -> ok C_CALL
     | "transaction"            -> ok C_CALL                    (* Deprecated *)
     | "Tezos.set_delegate"     -> ok C_SET_DELEGATE
@@ -145,7 +144,7 @@ module Simplify = struct
     | "Bytes.unpack" -> ok C_BYTES_UNPACK
     | "bytes_unpack" -> ok C_BYTES_UNPACK  (* Deprecated *)
     | "Bytes.length" -> ok C_SIZE
-    | "Bytes.size"   -> ok C_SIZE
+    | "Bytes.size"   -> ok C_SIZE          (* Deprecated *)
     | "bytes_concat" -> ok C_CONCAT        (* Deprecated *)
     | "Bytes.concat" -> ok C_CONCAT
     | "Bytes.slice"  -> ok C_SLICE
@@ -166,7 +165,8 @@ module Simplify = struct
 
     (* Set module *)
 
-    | "Set.size"    -> ok C_SIZE
+    | "Set.cardinal" -> ok C_SIZE
+    | "Set.size"    -> ok C_SIZE        (* Deprecated *)
     | "set_size"    -> ok C_SIZE        (* Deprecated *)
     | "set_empty"   -> ok C_SET_EMPTY   (* Deprecated *)
     | "Set.mem"     -> ok C_SET_MEM
@@ -326,9 +326,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 *)
@@ -348,7 +348,8 @@ module Simplify = struct
     | "Set.add"      -> ok C_SET_ADD
     | "Set.remove"   -> ok C_SET_REMOVE
     | "Set.fold"     -> ok C_SET_FOLD
-    | "Set.size"    -> ok C_SIZE
+    | "Set.size"     -> ok C_SIZE (* Deprecated *)
+    | "Set.cardinal" -> ok C_SIZE
 
     (* Map module *)
 

src/test/contracts/address.ligo

@@ -1,5 +1,3 @@
-// function main (const c : contract (unit)) : address is address (c)
-
 function main (const p : key_hash) : address is block {
-  const c : contract (unit) = implicit_account (p);
+  const c : contract (unit) = Tezos.implicit_account (p);
-} with address (c)
+} with Tezos.address (c)

src/test/contracts/address.mligo

@@ -1,3 +1,3 @@
 let main (p : key_hash) =
-  let c : unit contract = Current.implicit_account p in 
+  let c : unit contract = Tezos.implicit_account p
-  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,8 +1,5 @@
 function check (const p : unit) : int is
-  begin
+  block {
     var result : int := 0;
-    if amount = 100tz then
+    if amount = 100tez then result := 42 else result := 0
-      result := 42
+  } with result
-    else
-      result := 0
-  end with result

src/test/contracts/amount.mligo

@@ -1 +1 @@
-let check_ (p: unit) : int = if Current.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) {
+  if (Tezos.amount == 100tez) { 42; } else { 0; };
-    42;
-  }
-  else {
-    0;
-  };

src/test/contracts/arithmetic.ligo

@@ -1,15 +1,7 @@
-// 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
-
 function times_op (const n : int) : int is n * 42
-
 function div_op   (const n : int) : int is n / 2
-
 function int_op   (const n : nat) : int is int (n)
-
 function neg_op   (const n : int) : int is -n

src/test/contracts/arithmetic.mligo

@@ -1,30 +1,8 @@
-// Test CameLIGO arithmetic operators
+let mod_op   (n : int) : nat = n mod 42
-
+let plus_op  (n : int) : int = n + 42
-let mod_op (n : int) : nat =
+let minus_op (n : int) : int = n - 42
-  n mod 42
+let times_op (n : int) : int = n * 42
-
+let div_op   (n : int) : int = n / 2
-let plus_op (n : int) : int =
+let neg_op   (n : int) : int = -n
-  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/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/assign.ligo

@@ -1,4 +1 @@
-function main (const i : int) : int is
+function main (const i : int) : int is block {i := i + 1} with i
-  block {
-   i := i + 1
-  } with i

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.ligo

@@ -9,4 +9,4 @@ type storage is tez
 type return is list (operation) * storage
 
 function main (const param : parameter; const store: storage) : return is
-  ((nil : list (operation)), balance)
+  ((nil : list (operation)), Tezos.balance)

src/test/contracts/balance_constant.mligo

@@ -1,17 +1,18 @@
-(**
+(*
-
 This test makes sure that the balance is accessible in CameLIGO.
-It's there to detect a regression of: https://gitlab.com/ligolang/ligo/issues/61
 
-Which results in this error when you attempt to compile this contract:
+It is there to detect a regression of:
+https://gitlab.com/ligolang/ligo/issues/61
+
+which results in this error when you attempt to compile this contract:
 
 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, s: 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.ligo

@@ -22,8 +22,6 @@ function rm (var m : foo) : foo is block {
   remove 42 from map m
 } with m
 
-function gf (const m : foo) : int is get_force (23, m)
-
 function get (const m : foo) : option (int) is m[42]
 
 const empty_big_map : big_map (int,int) = big_map []

src/test/contracts/big_map.mligo

@@ -1,23 +1,18 @@
 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
 
 let empty_map : foo = Big_map.empty
 
-let map1 : foo = Big_map.literal
+let map1 : foo = Big_map.literal [(23,0); (42,0)]
-  [ (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 in
+  let bar : foo = Big_map.update 42 (Some 0) m
-  Big_map.update 42 (get bar) n
+  in Big_map.update 42 (get bar) n

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/boolean_operators.ligo

@@ -1,11 +1,5 @@
-// Test PascaLIGO boolean operators
-
 function or_true   (const b : bool) : bool is b or True
-
 function or_false  (const b : bool) : bool is b or False
-
 function and_true  (const b : bool) : bool is b and True
-
 function and_false (const b : bool) : bool is b and False
-
 function not_bool  (const b : bool) : bool is not b

src/test/contracts/boolean_operators.mligo

@@ -1,16 +1,7 @@
 // Test CameLIGO boolean operators
 
-let or_true (b : bool) : bool =
+let or_true   (b : bool) : bool = b || true
-   b || true
+let or_false  (b : bool) : bool = b || false
-
+let and_true  (b : bool) : bool = b && true
-let or_false (b : bool) : bool =
+let and_false (b : bool) : bool = b && false
-   b || false
+let not_bool  (b : bool) : bool = not b
-
-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.ligo

@@ -1,5 +1,3 @@
-function concat_op (const s : bytes) : bytes is bytes_concat (s, 0x7070)
+function concat_op (const s : bytes) : bytes is Bytes.concat (s, 0x7070)
-
+function slice_op  (const s : bytes) : bytes is Bytes.sub (1n, 2n, s)
-function slice_op (const s : bytes) : bytes is bytes_slice (1n, 2n, s)
+function hasherman (const s : bytes) : bytes is Crypto.sha256 (s)
-
-function hasherman (const s : bytes) : bytes is sha_256 (s)

src/test/contracts/bytes_arithmetic.mligo

@@ -1,8 +1,3 @@
-let concat_op (s : bytes) : bytes =
+let concat_op (s : bytes) : bytes = Bytes.concat s 0x7070
-   Bytes.concat s 0x7070
+let slice_op  (s : bytes) : bytes = Bytes.sub 1n 2n s
-
+let hasherman (s : bytes) : bytes = Crypto.sha256 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.ligo

@@ -1,11 +1,11 @@
 function id_string (const p : string) : option (string) is block {
-  const packed : bytes = bytes_pack (p)
+  const packed : bytes = Bytes.pack (p)
-} with (bytes_unpack (packed) : option (string))
+} with (Bytes.unpack (packed) : option (string))
 
 function id_int (const p : int) : option (int) is block {
-  const packed : bytes = bytes_pack (p)
+  const packed : bytes = Bytes.pack (p)
-} with (bytes_unpack (packed) : option (int))
+} with (Bytes.unpack (packed) : option (int))
 
 function id_address (const p : address) : option (address) is block {
-  const packed : bytes = bytes_pack (p)
+  const packed : bytes = Bytes.pack (p)
-} with (bytes_unpack (packed) : option (address))
+} with (Bytes.unpack (packed) : option (address))

src/test/contracts/bytes_unpack.mligo

@@ -1,11 +1,11 @@
 let id_string (p : string) : string option =
   let packed : bytes = Bytes.pack p in
-  ((Bytes.unpack packed): string option)
+  (Bytes.unpack packed : string option)
 
 let id_int (p : int) : int option =
   let packed : bytes = Bytes.pack p in
-  ((Bytes.unpack packed): int option)
+  (Bytes.unpack packed : int option)
 
 let id_address (p : address) : address option =
   let packed : bytes = Bytes.pack p in
-  ((Bytes.unpack packed): address option)
+  (Bytes.unpack packed : address option)

src/test/contracts/chain_id.ligo

@@ -1 +1 @@
-function chain_id (const tt : chain_id) : chain_id is get_chain_id
+function chain_id (const tt : chain_id) : chain_id is Tezos.chain_id

src/test/contracts/check_signature.ligo

@@ -1,4 +1,4 @@
 function check_signature (const pk     : key;
                           const signed : signature;
                           const msg    : bytes) : bool
-is crypto_check (pk, signed, msg)
+is Crypto.check (pk, signed, msg)

src/test/contracts/closure.mligo

@@ -1,9 +1,7 @@
-(* 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
-  let close: (int -> int) =
+  let close : int -> int = fun (i : int) -> i + j in
-    fun (i: int) -> i + j
+  let j : int = 20 (* Shadow original variable *)
-  in
+  in close 20
-  let j: int = 20 in (* Shadow original variable to see if value close'd *)
-  close 20

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/coase.ligo

@@ -45,27 +45,38 @@ type parameter is
 | Transfer_single of action_transfer_single
 
 function transfer_single (const action : action_transfer_single;
-                          const s : storage) : return is block {
+                          const s : storage) : return is
+  block {
     const cards : cards = s.cards;
-    const card : card = get_force (action.card_to_transfer, cards);
+    const card : card =
+      case cards[action.card_to_transfer] of
+        Some (card) -> card
+      | None -> (failwith ("transfer_single: No card.") : card)
+      end;
     if card.card_owner =/= sender then
       failwith ("This card doesn't belong to you")
     else skip;
     card.card_owner := action.destination;
     cards[action.card_to_transfer] := card;
-    s.cards := cards;
+    s.cards := cards
-    const operations : list (operation) = nil
+  } with ((nil : list (operation)), s)
-  } with (operations, s)
 
 function sell_single (const action : action_sell_single;
                       const s : storage) : return is
   block {
-    const card : card = get_force (action.card_to_sell, s.cards);
+    const card : card =
+      case s.cards[action.card_to_sell] of
+        Some (card) -> card
+      | None -> (failwith ("sell_single: No card.") : card)
+      end;
     if card.card_owner =/= sender
     then failwith ("This card doesn't belong to you")
     else skip;
     const card_pattern : card_pattern =
-      get_force (card.card_pattern, s.card_patterns);
+      case s.card_patterns[card.card_pattern] of
+        Some (pattern) -> pattern
+      | None -> (failwith ("sell_single: No card pattern.") : card_pattern)
+      end;
     card_pattern.quantity := abs (card_pattern.quantity - 1n);
     const card_patterns : card_patterns = s.card_patterns;
     card_patterns[card.card_pattern] := card_pattern;
@@ -74,8 +85,12 @@ function sell_single (const action : action_sell_single;
     remove action.card_to_sell from map cards;
     s.cards := cards;
     const price : tez = card_pattern.coefficient * card_pattern.quantity;
-    const receiver : contract (unit) = get_contract (sender);
+    const receiver : contract (unit) =
-    const op : operation = transaction (unit, price, receiver);
+      case (Tezos.get_contract_opt (Tezos.sender) : option (contract (unit))) of
+        Some (contract) -> contract
+      | None -> (failwith ("sell_single: No contract.") : contract (unit))
+      end;
+    const op : operation = Tezos.transaction (unit, price, receiver);
     const operations : list (operation) = list [op]
   } with (operations, s)
 
@@ -84,12 +99,13 @@ function buy_single (const action : action_buy_single;
   block {
     // Check funds
     const card_pattern : card_pattern =
-      get_force (action.card_to_buy, s.card_patterns);
+      case s.card_patterns[action.card_to_buy] of
+        Some (pattern) -> pattern
+      | None -> (failwith ("buy_single: No card pattern.") : card_pattern)
+      end;
     const price : tez =
       card_pattern.coefficient * (card_pattern.quantity + 1n);
     if price > amount then failwith ("Not enough money") else skip;
-    // Administrative procedure
-    const operations : list(operation) = nil;
     // Increase quantity
     card_pattern.quantity := card_pattern.quantity + 1n;
     const card_patterns : card_patterns = s.card_patterns;
@@ -103,7 +119,7 @@ function buy_single (const action : action_buy_single;
     ];
     s.cards := cards;
     s.next_id := s.next_id + 1n
-  } with (operations, s)
+  } with ((nil : list (operation)), s)
 
 function main (const action : parameter; const s : storage) : return is
   case action of

src/test/contracts/condition-annot.mligo

@@ -1,2 +1,4 @@
+type integer = int
+
 let main (i : int) =
-  if (i=2 : bool) then (42: int) else (0: int)
+  if (i = 2 : bool) then (42 : int) else (0 : integer)

src/test/contracts/condition-annot.religo

@@ -1,6 +1,2 @@
 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,8 +1,5 @@
-(* TODO : make a test using mutation, not shadowing *)
-
 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,6 +1,4 @@
-
 type storage = int;
 
-let main2 = (p: int, s: storage): string => ([]: list(operation), p + s);
+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.ligo

@@ -1,3 +1,2 @@
-function hasherman512 (const s: bytes) : bytes is sha_512 (s)
+function hasherman512    (const s : bytes) : bytes is Crypto.sha512 (s)
-
+function hasherman_blake (const s : bytes) : bytes is Crypto.blake2b (s)
-function hasherman_blake (const s: bytes) : bytes is 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 mk_partial (j: int) : (int -> int) = partial j
+let partial_apply (i : int) : int = mk_partial 10 i
-
-let partial_apply (i: int) : int = (mk_partial 10) i

src/test/contracts/declarations.ligo

@@ -1,5 +1,3 @@
-// Test PascaLIGO top-level declarations
-
 const foo : int = 42
 
 function main (const i : int) : int is i + foo

src/test/contracts/deep_access.ligo

@@ -26,4 +26,7 @@ type nested_record_t is
 function nested_record (var nee : nested_record_t) : string is
   block {
     nee.nesty.mymap[1] := "one"
-  } with get_force (1, nee.nesty.mymap)
+  } with case nee.nesty.mymap[1] of
+           Some (s) -> s
+         | None -> (failwith ("Should not happen.") : string)
+         end

src/test/contracts/dispatch-counter.ligo

@@ -7,7 +7,6 @@ type storage is int
 type return is list (operation) * storage
 
 function increment (const i : int; const n : int) : int is i+n
-
 function decrement (const i : int; const n : int) : int is i-n
 
 const nop : list (operation) = nil

src/test/contracts/empty_case.mligo

@@ -1,8 +1,8 @@
 type foo =
-  | Bar of int
+  Bar of int
 | Baz
 
 let main (f : foo) : int =
   match f with
-  | Bar i -> i
+    Bar i -> i
   | Baz -> -1

src/test/contracts/entrypoints.ligo

@@ -5,8 +5,7 @@ type return is list (operation) * storage
 function cb (const a : address; const s : storage) : return is
   block {
     const c : contract (unit) = get_entrypoint ("%cb", a)
-  }
+  } with (list [Tezos.transaction (unit, 0tez, c)], s)
-  with (list [transaction (unit, 0mutez, c)], s)
 
 
 function cbo (const a : address; const s : storage) : return is
@@ -14,6 +13,6 @@ function cbo (const a : address; const s : storage) : return is
     const c : contract (unit) =
       case (get_entrypoint_opt ("%cbo", a) : option (contract (unit))) of
         Some (c) -> c
-      | None -> (failwith ("entrypoint not found") : contract (unit))
+      | None -> (failwith ("cbo: Entrypoint not found.") : contract (unit))
       end
-  } with (list [transaction(unit, 0mutez, c)], s)
+  } with (list [Tezos.transaction (unit, 0tez, c)], s)

src/test/contracts/eq_bool.religo

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

src/test/contracts/failwith.mligo

@@ -1,4 +1,4 @@
 type storage = unit
 
-let main (p: unit) (s:storage) =
+let main (p, store : unit * storage) : operation list * storage =
-  if true then failwith "This contract always fails" else ()
+  (failwith "This contract always fails" : operation list * storage)

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,7 +1,9 @@
 type storage = unit
 
-let main (p: unit) storage =
+let main (p, store : unit * storage) : operation list * storage =
-  (fun (f: (int * int) -> int) (x: int) (y: int) -> f (y,x))
+  let n =
+    (fun (f : int * int -> int) (x : int) (y : int) -> f (y,x))
       (fun (x : int) (y : int) -> x + y)
       0
       1
+  in ([] : operation list), store

src/test/contracts/fibo2.mligo

@@ -1,7 +1,9 @@
 type storage = unit
 
-let main (p: unit) storage =
+let main (p : unit; store : storage) : operation list * storage =
-  (fun (f: int -> int) (_: int) (y: int) -> f y)
+  let n =
+    (fun (f : int -> int) (z : int) (y : int) -> f y)
       (fun (x : int) -> x)
       0
       1
+  in ([] : operation list), store

src/test/contracts/fibo3.mligo

@@ -1,7 +1,9 @@
 type storage = unit
 
-let main (p: unit) 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)
       0
       1
+  in ([] : operation list), store

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
-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/get_contract.ligo

@@ -1,19 +1,16 @@
 type storage is unit
 type return is list (operation) * storage
 
-function cb (const s : storage) : return is
+function cb (const s : storage) : return is block {
-  block {
+  const c : contract (unit) = get_contract (Tezos.sender)
-    const c : contract(unit) = get_contract(sender)
+} with (list [Tezos.transaction (unit, 0tez, c)], s)
-  }
-  with (list [transaction(unit, 0mutez, c)], s)
 
 
 function cbo (const s : unit) : return is
   block {
     const c : contract (unit) =
-      case (get_contract_opt(sender) : option(contract(unit))) of
+      case (Tezos.get_contract_opt (Tezos.sender) : option (contract (unit))) of
-        Some (c) -> c
+        Some (contract) -> contract
       | None -> (failwith ("contract not found") : contract (unit))
       end
-  }
+  } with (list [Tezos.transaction (unit, 0tez, c)], s)
-  with (list [transaction(unit, 0mutez, c)], s)

src/test/contracts/guess_string.mligo

@@ -1,20 +1,22 @@
 type storage = {
-  challenge : string;
+  challenge : string
 }
 
 type param = {
   new_challenge : string;
-  attempt       : string;
+  attempt       : string
 }
 
-let attempt (p: param) storage =
+type return = operation list * storage
-  (* if p.attempt <> storage.challenge then failwith "Failed challenge" else *)
+
+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
+    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.00tz) in
+    Tezos.transaction (unit, contract, 10.00tez) in
-  (* TODO: no syntax for functional updates yet *)
+  let store : storage = {challenge = p.new_challenge}
-  (* let storage : storage = { storage with challenge = p.new_challenge } in *)
+  in ([] : operation list), store
-  (* for now, rebuild the record by hand. *)
-  let storage : storage = { challenge = p.new_challenge }
-  in ([] : operation list), storage

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 *)
+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)
+  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
+    if Tezos.now < 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 "It has not been 24 hours since your commit yet.": return)
-    ((p.message ()), s)
+    else
-  else (failwith "Your commitment did not match the storage hash.":
+      let salted =
-          operation list * storage)
+        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/heap.ligo

@@ -10,8 +10,12 @@ function get_top (const h : heap) : heap_elt is get_force (1n, h)
 function pop_switch (const h : heap) : heap is
   block {
    const result : heap_elt = get_top (h);
-   const s : nat = size (h);
+   const s : nat = Map.size (h);
-   const last : heap_elt = get_force (s, h);
+   const last : heap_elt =
+     case h[s] of
+       Some (e) -> e
+     | None -> (failwith ("No element.") : heap_elt)
+     end;
    remove 1n from map h;
    h[1n] := last
   } with h
@@ -19,8 +23,12 @@ function pop_switch (const h : heap) : heap is
 function pop_ (const h : heap) : nat is
   block {
     const result : heap_elt = get_top (h);
-    const s : nat = size (h);
+    const s : nat = Map.size (h);
-    var current : heap_elt := get_force (s, h);
+    var current : heap_elt :=
+      case h[s] of
+        Some (e) -> e
+      | None -> (failwith ("No element.") : heap_elt)
+      end;
     const i : nat = 1n;
     const left : nat = 2n * i;
     const right : nat = left + 1n;

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 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
 
@@ -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) =
+  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,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/.
+(* 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 =
-    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 =
     match initial_controller with
     | Some addr -> addr
-    | None -> sender
+    | None -> sender in
-  in
   let new_id_details: id_details = {
     owner = sender;
     controller = controller;
-    profile = profile ;
+    profile = profile} in
-  }
-  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) =
-  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 =
       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 =
-    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)
+      else (failwith "You are not the owner of this ID." : bool) in
-  in
   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 =
-    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)
+      else
-  in
+        (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
+      | Some new_profile -> new_profile in
-  in
     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 undesirable *)
 let skip (p, storage: unit * storage) =
   let void : unit =
-    if amount = storage.2.1
+    if Tezos.amount <> storage.2.1
-    then ()
+    then (failwith "Incorrect amount paid." : unit) in
-    else (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.ligo

@@ -1 +1,2 @@
-function main (const kh: key_hash) : contract (unit) is implicit_account (kh)
+function main (const kh: key_hash) : contract (unit) is
+  Tezos.implicit_account (kh)

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
 
+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 (action, store : parameter * storage) : return =
-
+  let store =
-let main (p: action) storage =
+    match action with
-  let storage =
-    match p 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
+  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
@@ -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 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;
-     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;
-     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"
   | 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
+  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 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 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) =
+  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
@@ -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) ->
+  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))
@@ -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
+  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 []:(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 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.ligo

@@ -1,7 +1,5 @@
 function check_hash_key (const kh1 : key_hash;
                          const k2 : key) : bool * key_hash is
   block {
-    var ret : bool := False;
+    var kh2 : key_hash := Crypto.hash_key (k2);
-    var kh2 : key_hash := crypto_hash_key (k2);
+  } with ((kh1 = kh2), kh2)
-    if kh1 = kh2 then ret := True else skip
-  } with (ret, kh2)

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
+  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 kh1, k2 = kh1_k2;
   let kh2 : key_hash = Crypto.hash_key (k2);
-  if (kh1 == kh2) {
+  ((kh1 == kh2), kh2)
-    (true, kh2);
-  }
-  else {
-    (false, kh2);
-  }
 };

src/test/contracts/key_hash_comparable.ligo

@@ -1,8 +1,9 @@
-type storage is record
+type storage is record [
   one : map (key_hash, nat);
-  two: big_map(key_hash, bool);
+  two : big_map (key_hash, bool)
-end
+]
 
 type return is list (operation) * storage
 
-function main (const a : int; const store : storage) : return is ((nil: list(operation)), store)
+function main (const a : int; const store : storage) : return is
+  ((nil : list (operation)), store)

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,5 @@ type storage = unit;
      (fun x -> ()) ()
    */
 
-let main2 = ((p: unit), s: storage) => (((xxx: unit)) => ())();
+let main = ((p,s) : (unit, storage)) : unit =>
-
+  (((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)

src/test/contracts/lambda2.religo

@@ -4,7 +4,5 @@ type storage = unit;
    let main (p:unit) storage = (fun x -> ()) ()
    */
 
-let main2 = (z: unit, s: storage) =>
+let main = ((a, s) : (unit, storage)) : unit =>
-  ((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_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 =
+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
 
@@ -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), s: storage) => {
+let main = (n : (int, storage)) : (list (operation), storage) => {
   let x : (int, int) = {
     let x : int = 7;
-    (x + n, s[0] + s[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.ligo

@@ -17,17 +17,17 @@ const bl : foobar = list [144; 51; 42; 120; 421]
 function fold_op (const s : list (int)) : int is
   block {
     function aggregate (const prec: int; const cur: int) : int is prec+cur
-  } with list_fold (aggregate, s, 10)
+  } with List.fold (aggregate, s, 10)
 
 function iter_op (const s : list (int)) : int is
   block {
     var r : int := 0;
     function aggregate (const i : int) : unit is
       block { r := r + i } with unit;
-    list_iter (aggregate, s)
+    List.iter (aggregate, s)
   } with r
 
 function map_op (const s : list (int)) : list (int) is
   block {
     function increment (const i : int) : int is i+1
-  } with list_map (increment, s)
+  } with List.map (increment, s)

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 : storage) => {
+let main = ((action, s) : (parameter, storage)) : return => {
   let storage =
-    switch (p) {
+    switch (action) {
-    | [] => 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 = (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 }) )
+      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 =
   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 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) {
+  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);
 
@@ -16,27 +12,26 @@ type sum_aggregator = {
 
 let counter = (n : int) : int => {
   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) =>
   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 => {

src/test/contracts/loop_bugs.ligo

@@ -1,6 +1,6 @@
 function shadowing_in_body (var nee : unit) : string is block {
   var st : string := "";
-  var list1 : list(string) := list "to"; "to" end;
+  var list1 : list (string) := list ["to"; "to"];
   for x in list list1 block {
     const x : string = "ta";
     st := st ^ x;
@@ -10,7 +10,7 @@ function shadowing_in_body (var nee : unit) : string is block {
 
 function shadowing_assigned_in_body (var nee : unit) : string is block {
   var st : string := "";
-  var list1 : list(string) := list "to"; "to" end;
+  var list1 : list (string) := list ["to"; "to"];
   for x in list list1 block {
     st := st ^ x;
     var st : string := "ta";

src/test/contracts/map.ligo

@@ -30,32 +30,28 @@ function patch_ (var m : foobar) : foobar is block {
 function patch_deep (var m : foobar * nat) : foobar * nat is
   block { patch m.0 with map [1 -> 9] } with m
 
-function size_ (const m : foobar) : nat is size (m)
+function size_ (const m : foobar) : nat is Map.size (m)
-
-function gf (const m : foobar) : int is get_force (23, m)
 
 function get (const m : foobar) : option (int) is m[42]
 
-function get_ (const m : foobar) : option (int) is map_get (42, m)
+function mem (const k: int; const m: foobar) : bool is Map.mem (k, m)
-
-function mem (const k: int; const m: foobar) : bool is map_mem (k, m)
 
 function iter_op (const m : foobar) : unit is
   block {
     function aggregate (const i : int; const j : int) : unit is block
       { if i=j then skip else failwith ("fail") } with unit
-  } with map_iter (aggregate, m)
+  } with Map.iter (aggregate, m)
 
 function map_op (const m : foobar) : foobar is
   block {
     function increment (const i : int; const j : int) : int is j+1
-  } with map_map (increment, m)
+  } with Map.map (increment, m)
 
 function fold_op (const m : foobar) : int is
   block {
     function aggregate (const i : int; const j : int * int) : int is
       i + j.0 + j.1
-  } with map_fold(aggregate, m, 10)
+  } with Map.fold (aggregate, m, 10)
 
 function deep_op (var m : foobar) : foobar is
   block {

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) =
+type return = operation list * storage
-  let storage =
+
-    s +
+let main (action, store : parameter * storage) =
-      (match p with
+  let store =
+    store +
+      (match action with
          Add n -> n
-       | Sub n -> 0-n)
+       | Sub n -> -n)
-  in ([] : operation list), storage
+  in ([] : operation list), store
 
 let match_bool (b : bool) : int =
   match b with

src/test/contracts/match.religo

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

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
 
+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 (action, store : parameter * storage) : return =
-
+  let store =
-let main (p, s: action * storage) =
+    match action  with
-  let storage =
+      Increment n -> add store n
-    match p  with
+    | Decrement n -> sub store n
-      Increment n -> add s n
+  in ([] : operation list), store
-    | Decrement n -> sub s n
-  in ([] : operation list), storage

src/test/contracts/match_bis.religo

@@ -1,24 +1,17 @@
 type storage = int;
 
-/* variant defining pseudo multi-entrypoint actions */
+type parameter =
-
-type action =
   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 : 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-v2.ligo

@@ -37,22 +37,22 @@ function send (const param : send_pt; const s : storage) : return is
   block {
     // check sender against the authorized addresses
 
-    if not set_mem (sender, s.authorized_addresses)
+    if not Set.mem (Tezos.sender, s.authorized_addresses)
     then failwith("Unauthorized address")
     else skip;
 
     // check message size against the stored limit
 
     var message : message := param;
-    const packed_msg : bytes = bytes_pack (message);
+    const packed_msg : bytes = Bytes.pack (message);
-    if size (packed_msg) > s.max_message_size
+    if Bytes.length (packed_msg) > s.max_message_size
     then failwith ("Message size exceed maximum limit")
     else skip;
 
     (* compute the new set of addresses associated with the message and
        update counters *)
 
-    var new_store : addr_set := set_empty;
+    var new_store : addr_set := set [];
 
     case map_get (packed_msg, s.message_store) of
       Some (voters) ->
@@ -60,26 +60,25 @@ function send (const param : send_pt; const s : storage) : return is
           (* The message is already stored.
              Increment the counter only if the sender is not already
              associated with the message. *)
-          if set_mem (sender, voters)
+          if Set.mem (Tezos.sender, voters)
           then skip
-          else s.proposal_counters[sender] :=
+          else s.proposal_counters[Tezos.sender] :=
-                 get_force (sender, s.proposal_counters) + 1n;
+                 get_force (Tezos.sender, s.proposal_counters) + 1n;
-
+                 new_store := Set.add (Tezos.sender,voters)
-          new_store := set_add(sender,voters)
         }
     | None ->
         block {
           // the message has never been received before
           s.proposal_counters[sender] :=
-             get_force (sender, s.proposal_counters) + 1n;
+             get_force (Tezos.sender, s.proposal_counters) + 1n;
-             new_store := set [sender]
+             new_store := set [Tezos.sender]
         }
     end;
 
     // check sender counters against the maximum number of proposal
 
     var sender_proposal_counter : nat :=
-      get_force (sender, s.proposal_counters);
+      get_force (Tezos.sender, s.proposal_counters);
 
     if sender_proposal_counter > s.max_proposal
     then failwith ("Maximum number of proposal reached")
@@ -89,14 +88,14 @@ function send (const param : send_pt; const s : storage) : return is
 
     var ret_ops : list (operation) := nil;
 
-    if size (new_store) >= s.threshold then {
+    if Set.cardinal (new_store) >= s.threshold then {
       remove packed_msg from map s.message_store;
       ret_ops := message (s.state_hash);
       // update the state hash
-      s.state_hash := sha_256 (bytes_concat (s.state_hash, packed_msg));
+      s.state_hash := Crypto.sha256 (Bytes.concat (s.state_hash, packed_msg));
       // decrement the counters
       for addr -> ctr in map s.proposal_counters block {
-        if set_mem(addr,new_store) then
+        if Set.mem (addr, new_store) then
           s.proposal_counters[addr] := abs (ctr - 1n)
         else skip
       }
@@ -106,26 +105,26 @@ function send (const param : send_pt; const s : storage) : return is
 function withdraw (const param : withdraw_pt; const s : storage) : return is
   block {
     var message : message := param;
-    const packed_msg : bytes = bytes_pack (message);
+    const packed_msg : bytes = Bytes.pack (message);
 
-    case map_get(packed_msg, s.message_store) of
+    case s.message_store[packed_msg] of
       Some (voters) ->
         block {
           // The message is stored
-          const new_set : addr_set = set_remove (sender, voters);
+          const new_set : addr_set = Set.remove (Tezos.sender, voters);
 
           (* Decrement the counter only if the sender was already
              associated with the message *)
 
-          if size (voters) =/= size (new_set)
+          if Set.cardinal (voters) =/= Set.cardinal (new_set)
-          then s.proposal_counters[sender] :=
+          then s.proposal_counters[Tezos.sender] :=
-                 abs (get_force (sender, s.proposal_counters) - 1n)
+                 abs (get_force (Tezos.sender, s.proposal_counters) - 1n)
           else skip;
 
           (* If the message is left without any associated addresses,
              remove the corresponding message_store field *)
 
-          if size (new_set) = 0n
+          if Set.cardinal (new_set) = 0n
           then remove packed_msg from map s.message_store
           else s.message_store[packed_msg] := new_set
         }

src/test/contracts/multisig.ligo

@@ -38,7 +38,7 @@ function check_message (const param : check_message_pt;
     failwith ("Counters does not match")
   else {
     const packed_payload : bytes =
-      bytes_pack ((message, param.counter, s.id, get_chain_id));
+      Bytes.pack ((message, param.counter, s.id, Tezos.chain_id));
     var valid : nat := 0n;
 
     var keys : authorized_keys := s.auth;
@@ -47,8 +47,8 @@ function check_message (const param : check_message_pt;
         nil -> skip
       | key # tl -> block {
           keys := tl;
-          if pkh_sig.0 = crypto_hash_key (key) then
+          if pkh_sig.0 = Crypto.hash_key (key) then
-            if crypto_check (key, pkh_sig.1, packed_payload)
+            if Crypto.check (key, pkh_sig.1, packed_payload)
             then valid := valid + 1n
             else failwith ("Invalid signature")
           else skip

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
+    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)