Improve ReasonLIGO output.

src/passes/01-parser/reasonligo/Pretty.ml

@@ -174,13 +174,13 @@ and pp_clause {value; _} =
 and pp_cond_expr {value; _} =
   let {test; ifso; kwd_else; ifnot; _} = value in
   let if_then =
-    string "if" ^^ string "(" ^^ pp_expr test ^^ string ")" ^^ string " {" ^^ hardline 
+    string "if" ^^ string "(" ^^ pp_expr test ^^ string ")" ^^ string " {" ^^ break 0 
     ^^ group (nest 2 (break 2 ^^ pp_expr ifso)) ^^ hardline ^^ string "}" in
   if kwd_else#is_ghost then
     if_then
   else
     if_then
-    ^^ string " else" ^^ string " {" ^^ hardline ^^ group (nest 2 (break 2 ^^ pp_expr ifnot)) ^^ hardline ^^ string "}"
+    ^^ string " else" ^^ string " {" ^^ break 0 ^^ group (nest 2 (break 2 ^^ pp_expr ifnot)) ^^ hardline ^^ string "}"
 
 and pp_annot_expr {value; _} =
   let expr, _, type_expr = value.inside in
@@ -201,7 +201,7 @@ and pp_bool_expr = function
 and pp_bin_op op {value; _} =
   let {arg1; arg2; _} = value
   and length = String.length op + 1 in
-  pp_expr arg1 ^/^ string (op ^ " ") ^^ nest length (pp_expr arg2)
+  pp_expr arg1 ^^ string " " ^^ string (op ^ " ") ^^ nest length (pp_expr arg2)
 
 and pp_un_op op {value; _} =
   string (op ^ " ") ^^ pp_expr value.arg
@@ -372,8 +372,11 @@ and pp_fun {value; _} =
       None -> empty
     | Some (_,e) ->
         group (break 0 ^^ string ":" ^^ nest 2 (break 1 ^^ pp_type_expr e))
-  in prefix 2 0 (string "(" ^^ binders ^^ string ")" ^^ annot
+  in 
-     ^^ string " => ") (pp_expr body)
+  match body with 
+  | ESeq _ -> string "(" ^^ binders ^^ string ")" ^^ annot ^^ string " => " ^^ pp_expr body
+  | _ -> (prefix 2 0 (string "(" ^^ binders ^^ string ")" ^^ annot
+     ^^ string " => ") (pp_expr body))
 
 and pp_seq {value; _} =
   let {compound; elements; _} = value in

src/test/contracts/expected/address.religo.expected

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

src/test/contracts/expected/amount.religo.expected

@@ -1,7 +1,6 @@
 let check_ = 
   (p: unit): int => 
-    if(Tezos.amount
+    if(Tezos.amount == 100000000mutez) {
-    == 100000000mutez) {
       42
     } else {
       0

src/test/contracts/expected/bytes_unpack.religo.expected

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

src/test/contracts/expected/check_signature.religo.expected

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

src/test/contracts/expected/closure.religo.expected

@@ -1,8 +1,7 @@
 let test = 
-  (k: int): int => 
+  (k: int): int => {
-    {
+    let j: int = k + 5;
-      let j: int = k + 5;
+    let close: (int => int) = (i: int) => i + j;
-      let close: (int => int) = (i: int) => i + j;
+    let j: int = 20;
-      let j: int = 20;
+    close(20)
-      close(20)
+  };
-    };

src/test/contracts/expected/condition-shadowing.religo.expected

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

src/test/contracts/expected/condition.religo.expected

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

src/test/contracts/expected/eq_bool.religo.expected

@@ -1,7 +1,6 @@
 let main = 
   ((a, b): (bool, bool)) => 
-    if(a
+    if(a == b) {
-    == b) {
       999
     } else {
       1

src/test/contracts/expected/high-order.religo.expected

@@ -1,34 +1,30 @@
 let foobar = 
-  (i: int): int => 
+  (i: int): int => {
-    {
+    let foo: int => int = (i: int) => i;
-      let foo: int => int = (i: int) => i;
+    let bar: ((int => int) => int) = 
-      let bar: ((int => int) => int) = 
+      (f: (int => int)) => f(i);
-        (f: (int => int)) => f(i);
+    bar(foo)
-      bar(foo)
+  };
-    };
 
 let higher2 = 
-  (i: int, f: (int => int)): int => 
+  (i: int, f: (int => int)): int => {
-    {
+    let ii: int = f(i);
-      let ii: int = f(i);
+    ii
-      ii
+  };
-    };
 
 let foobar2 = 
-  (i: int): int => 
+  (i: int): int => {
-    {
+    let foo2: int => int = (i: int) => i;
-      let foo2: int => int = (i: int) => i;
+    higher2(i, foo2)
-      higher2(i, foo2)
+  };
-    };
 
 let a: int = 0;
 
 let foobar3 = 
-  (i: int): int => 
+  (i: int): int => {
-    {
+    let foo2: int => int = (i: int) => a + i;
-      let foo2: int => int = (i: int) => a + i;
+    higher2(i, foo2)
-      higher2(i, foo2)
+  };
-    };
 
 let f = (i: int): int => i;
 
@@ -37,17 +33,15 @@ let g = (i: int): int => f(i);
 let foobar4 = (i: int): int => g(g(i));
 
 let higher3 = 
-  (i: int, f: (int => int), g: (int => int)): int => 
+  (i: int, f: (int => int), g: (int => int)): int => {
-    {
+    let ii: int = f(g(i));
-      let ii: int = f(g(i));
+    ii
-      ii
+  };
-    };
 
 let foobar5 = 
-  (i: int): int => 
+  (i: int): int => {
-    {
+    let a: int = 0;
-      let a: int = 0;
+    let foo: int => int = (i: int) => a + i;
-      let foo: int => int = (i: int) => a + i;
+    let goo: int => int = (i: int) => foo(i);
-      let goo: int => int = (i: int) => foo(i);
+    higher3(i, foo, goo)
-      higher3(i, foo, goo)
+  };
-    };

src/test/contracts/expected/key_hash.religo.expected

@@ -1,8 +1,6 @@
 let check_hash_key = 
-  (kh1_k2: (key_hash, key)): (bool, key_hash) => 
+  (kh1_k2: (key_hash, key)): (bool, key_hash) => {
-    {
+    let (kh1, k2) = kh1_k2;
-      let (kh1, k2) = kh1_k2;
+    let kh2: key_hash = Crypto.hash_key(k2);
-      let kh2: key_hash = Crypto.hash_key(k2);
+    ((kh1 == kh2), kh2)
-      ((kh1
+  };
-       == kh2), kh2)
-    };

src/test/contracts/expected/letin.religo.expected

@@ -1,15 +1,14 @@
 type storage = (int, int);
 
 let main = 
-  (n: (int, storage)): (list(operation), storage) => 
+  (n: (int, storage)): (list(operation), storage) => {
-    {
+    let x: (int, int) = 
-      let x: (int, int) = 
+      {
-        {
+        let x: int = 7;
-          let x: int = 7;
+        (x + n[0], n[1][0] + n[1][1])
-          (x + n[0], n[1][0] + n[1][1])
+      };
-        };
+    ([] : list(operation), x)
-      ([] : list(operation), x)
+  };
-    };
 
 let f0 = (a: string) => true;
 
@@ -18,22 +17,20 @@ let f1 = (a: string) => true;
 let f2 = (a: string) => true;
 
 let letin_nesting = 
-  (_: unit) => 
+  (_: unit) => {
-    {
+    let s = "test";
-      let s = "test";
+    let p0 = f0(s);
-      let p0 = f0(s);
+    assert(p0);
-      assert(p0);
+    let p1 = f1(s);
-      let p1 = f1(s);
+    assert(p1);
-      assert(p1);
+    let p2 = f2(s);
-      let p2 = f2(s);
+    assert(p2);
-      assert(p2);
+    s
-      s
+  };
-    };
 
 let letin_nesting2 = 
-  (x: int) => 
+  (x: int) => {
-    {
+    let y = 2;
-      let y = 2;
+    let z = 3;
-      let z = 3;
+    x + y + z
-      x + y + z
+  };
-    };

src/test/contracts/expected/list.religo.expected

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

src/test/contracts/expected/loop.religo.expected

@@ -1,7 +1,6 @@
 let rec aux_simple = 
   (i: int): int => 
-    if(i
+    if(i < 100) {
-    < 100) {
       aux_simple(i + 1)
     } else {
       i
@@ -12,29 +11,26 @@ let counter_simple = (n: int): int => aux_simple(n);
 type sum_aggregator = {counter: int, sum: int };
 
 let counter = 
-  (n: int): int => 
+  (n: int): int => {
-    {
+    let initial: sum_aggregator = {counter: 0, sum: 0 };
-      let initial: sum_aggregator = {counter: 0, sum: 0 };
+    let rec aggregate = 
-      let rec aggregate = 
+      (prev: sum_aggregator): int => 
-        (prev: sum_aggregator): int => 
+        if(prev.counter <= n) {
-          if(prev.counter
-          <= n) {
         
           
-            aggregate({
+          aggregate({
-                counter: prev.counter + 1,
+              counter: prev.counter + 1,
-                sum: prev.counter + prev.sum
+              sum: prev.counter + prev.sum
-              })
+            })
-          } else {
+        } else {
-            prev.sum
+          prev.sum
-          };
+        };
-      aggregate(initial)
+    aggregate(initial)
-    };
+  };
 
 let rec aux_nest = 
   (prev: sum_aggregator): sum_aggregator => 
-    if(prev.counter
+    if(prev.counter < 100) {
-    < 100) {
     
       let sum: int = prev.sum + aux_simple(prev.counter);
       aux_nest({counter: prev.counter + 1, sum: sum })
@@ -43,9 +39,8 @@ let rec aux_nest =
     };
 
 let counter_nest = 
-  (n: int): int => 
+  (n: int): int => {
-    {
+    let initial: sum_aggregator = {counter: 0, sum: 0 };
-      let initial: sum_aggregator = {counter: 0, sum: 0 };
+    let out: sum_aggregator = aux_nest(initial);
-      let out: sum_aggregator = aux_nest(initial);
+    out.sum
-      out.sum
+  };
-    };

src/test/contracts/expected/map.religo.expected

@@ -40,32 +40,28 @@ let get_ = (m: foobar): option(int) => Map.find_opt(42, m);
 let mem = (km: (int, foobar)): bool => Map.mem(km[0], km[1]);
 
 let iter_op = 
-  (m: foobar): unit => 
+  (m: foobar): unit => {
-    {
+    let assert_eq = (i: int, j: int) => assert(i == j);
-      let assert_eq = (i: int, j: int) => assert(i == j);
+    Map.iter(assert_eq, m)
-      Map.iter(assert_eq, m)
+  };
-    };
 
 let map_op = 
-  (m: foobar): foobar => 
+  (m: foobar): foobar => {
-    {
+    let increment = (z: int, j: int) => j + 1;
-      let increment = (z: int, j: int) => j + 1;
+    Map.map(increment, m)
-      Map.map(increment, m)
+  };
-    };
 
 let fold_op = 
-  (m: foobar): foobar => 
+  (m: foobar): foobar => {
-    {
+    let aggregate = 
-      let aggregate = 
+      (i: int, j: (int, int)) => i + j[0] + j[1];
-        (i: int, j: (int, int)) => i + j[0] + j[1];
+    Map.fold(aggregate, m, 10)
-      Map.fold(aggregate, m, 10)
+  };
-    };
 
 let deep_op = 
-  (m: foobar): foobar => 
+  (m: foobar): foobar => {
-    {
+    let coco = (0, m);
-      let coco = (0, m);
+    let coco = (0, Map.remove(42, coco[1]));
-      let coco = (0, Map.remove(42, coco[1]));
+    let coco = (0, Map.update(32, Some (16), coco[1]));
-      let coco = (0, Map.update(32, Some (16), coco[1]));
+    coco[1]
-      coco[1]
+  };
-    };

src/test/contracts/expected/match.religo.expected

@@ -5,13 +5,11 @@ type parameter = Add(int) | Sub(int);
 type return = (list(operation), storage);
 
 let main = 
-  ((action, store): (parameter, storage)) => 
+  ((action, store): (parameter, storage)) => {
-    {
+    let store = 
-      let store = 
+      store + (switch(action) {
-        store
+         | Add(n) => n
-        + (switch(action) {
+         | Sub(n) => -n
-           | Add(n) => n
+         });
-           | Sub(n) => -n
+    (([] : list(operation)), store)
-           });
+  };
-      (([] : list(operation)), store)
-    };

src/test/contracts/expected/match_bis.religo.expected

@@ -7,12 +7,11 @@ let add = ((a: int), (b: int)) => a + b;
 let sub = ((a: int), (b: int)) => a - b;
 
 let main = 
-  ((action, store): (parameter, storage)) => 
+  ((action, store): (parameter, storage)) => {
-    {
+    let store = 
-      let store = 
+      switch(action) {
-        switch(action) {
+      | Increment(n) => add(store, n)
-        | Increment(n) => add(store, n)
+      | Decrement(n) => sub(store, n)
-        | Decrement(n) => sub(store, n)
+      };
-        };
+    (([] : list(operation)), store)
-      (([] : list(operation)), store)
+  };
-    };

src/test/contracts/expected/michelson_pair_tree.religo.expected

@@ -6,8 +6,7 @@ type storage = michelson_pair
 type return = (list(operation), storage);
 
 let main = 
-  ((action, store): (unit, storage)): return => 
+  ((action, store): (unit, storage)): return => {
-    {
+    let foo = (3, (1, 2n));
-      let foo = (3, (1, 2n));
+    (([] : list(operation)), (foo : storage))
-      (([] : list(operation)), (foo : storage))
+  };
-    };

src/test/contracts/expected/multisig.religo.expected

@@ -30,65 +30,57 @@ type return = (list(operation), storage);
 type parameter = CheckMessage(check_message_pt);
 
 let check_message = 
-  ((param, s): (check_message_pt, storage)): return => 
+  ((param, s): (check_message_pt, storage)): return => {
-    {
+    let message: message = param.message;
-      let message: message = param.message;
+    let s = 
-      let s = 
+      if(param.counter != s.counter) {
-        if(param.counter
+        (failwith("Counters does not match") : storage)
-        != s.counter) {
+      } else {
-          (failwith("Counters does not match") : storage)
-        } else {
       
-          let packed_payload: bytes = 
+        let packed_payload: bytes = 
           
-            Bytes.pack((message, param.counter, s.id,
+          Bytes.pack((message, param.counter, s.id, chain_id));
-              chain_id));
+        let valid: nat = 0n;
-          let valid: nat = 0n;
+        let keys: authorized_keys = s.auth;
-          let keys: authorized_keys = s.auth;
+        let aux = 
-          let aux = 
+          ((vk, pkh_sig):
-            ((vk, pkh_sig):
+           ((nat, authorized_keys), (key_hash, signature)))
-             ((nat, authorized_keys), (key_hash, signature)))
+          :
-            :
+            (nat, authorized_keys) => {
-              (nat, authorized_keys) => 
+            let (valid, keys) = vk;
-              {
+            switch(keys) {
-                let (valid, keys) = vk;
+            | [] => vk
-                switch(keys) {
+            | [key, ...keys] =>
-                | [] => vk
+                if(pkh_sig[0] == Crypto.hash_key(key)) {
-                | [key, ...keys] =>
-                    if(pkh_sig[0]
-                    == Crypto.hash_key(key)) {
                 
-                      let valid = 
+                  let valid = 
-                        if(
+                    if(
-                        Crypto.check(key,
+                    Crypto.check(key,
-                           pkh_sig[1],
+                       pkh_sig[1],
-                           packed_payload)) {
+                       packed_payload)) {
-                          valid + 1n
+                      valid + 1n
-                        } else {
-                        
-                          (failwith("Invalid signature")
-                            : nat)
-                        };
-                      (valid, keys)
                     } else {
-                      (valid, keys)
+                      (failwith("Invalid signature") : nat)
-                    }
+                    };
+                  (valid, keys)
+                } else {
+                  (valid, keys)
                 }
-              };
+            }
-          let (valid, keys) = 
+          };
-            List.fold(aux, param.signatures, (valid, keys));
+        let (valid, keys) = 
-          if(valid
+          List.fold(aux, param.signatures, (valid, keys));
-          < s.threshold) {
+        if(valid < s.threshold) {
         
-            (
+          (
-              failwith("Not enough signatures passed the check")
+            failwith("Not enough signatures passed the check")
-              : storage)
+            : storage)
-          } else {
+        } else {
-            {...s, counter: s.counter + 1n}
+          {...s, counter: s.counter + 1n}
-          }
+        }
-        };
+      };
-      (message(unit), s)
+    (message(unit), s)
-    };
+  };
 
 let main = 
   ((action, store): (parameter, storage)): return => 

src/test/contracts/expected/no_semicolon.religo.expected

@@ -1,18 +1,15 @@
 type f = int;
 
 let a = 
-  (b: f) => 
+  (b: f) => {
-    {
+    if(b == 2) {
-      if(b
+      3
-      == 2) {
+    } else {
-        3
+      4
-      } else {
+    }
-        4
+  };
-      }
-    };
 
 let c = 
-  (c: f) => 
+  (c: f) => {
-    {
+    3
-      3
+  };
-    };

src/test/contracts/expected/pledge.religo.expected

@@ -5,32 +5,28 @@ type parameter =
 | Distribute((unit => list(operation)));
 
 let donate = 
-  ((p, s): (unit, storage)): (list(operation), storage) => 
+  ((p, s): (unit, storage)): (list(operation), storage) => {
-    {
+    (([] : list(operation)), s)
-      (([] : list(operation)), s)
+  };
-    };
 
 let distribute = 
   ((p, s): ((unit => list(operation)), storage))
   :
-    (list(operation), storage) => 
+    (list(operation), storage) => {
-    {
+    if(Tezos.sender == s) {
-      if(Tezos.sender
+      (p(()), s)
-      == s) {
+    } else {
-        (p(()), s)
-      } else {
     
-        (
+      (
-          failwith("You're not the oracle for this distribution.")
+        failwith("You're not the oracle for this distribution.")
-          : (list(operation), storage))
+        : (list(operation), storage))
-      }
+    }
-    };
+  };
 
 let main = 
-  ((p, s): (parameter, storage)): (list(operation), storage) => 
+  ((p, s): (parameter, storage)): (list(operation), storage) => {
-    {
+    switch(p) {
-      switch(p) {
+    | Donate => donate(((), s))
-      | Donate => donate(((), s))
+    | Distribute msg => distribute((msg, s))
-      | Distribute msg => distribute((msg, s))
+    }
-      }
+  };
-    };

src/test/contracts/expected/recursion.religo.expected

@@ -1,7 +1,6 @@
 let rec sum = 
   ((n, acc): (int, int)): int => 
-    if(n
+    if(n < 1) {
-    < 1) {
       acc
     } else {
       sum((n - 1, acc + n))
@@ -9,8 +8,7 @@ let rec sum =
 
 let rec fibo = 
   ((n, n_1, n_0): (int, int, int)): int => 
-    if(n
+    if(n < 2) {
-    < 2) {
       n_1
     } else {
       fibo((n - 1, n_1 + n_0, n_1))

src/test/contracts/expected/set_delegate.religo.expected

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

src/test/contracts/expected/super-counter.religo.expected

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

src/test/contracts/expected/tuple_type.religo.expected

@@ -1,10 +1,9 @@
 type fun_type = (int, int) => int;
 
 let arguments = 
-  (b: int, c: int) => 
+  (b: int, c: int) => {
-    {
+    b + c
-      b + c
+  };
-    };
 
 let arguments_type_def = (b: fun_type) => b(5, 3);
 
@@ -14,20 +13,18 @@ let arguments_test =
 type tuple_type = ((int, int)) => int;
 
 let tuple = 
-  ((a, b): (int, int)) => 
+  ((a, b): (int, int)) => {
-    {
+    a + b
-      a + b
+  };
-    };
 
 let tuple_type_def = (b: tuple_type) => b((5, 3));
 
 let tuple_test = (_: int) => tuple_type_def(tuple);
 
 let arguments_inline = 
-  (b: int, c: int) => 
+  (b: int, c: int) => {
-    {
+    b + c
-      b + c
+  };
-    };
 
 let arguments_type_def_inline = 
   (b: (int, int) => int) => b(5, 3);
@@ -36,10 +33,9 @@ let arguments_test_inline =
   (_: int) => arguments_type_def_inline(arguments_inline);
 
 let tuple_inline = 
-  ((a, b): (int, int)) => 
+  ((a, b): (int, int)) => {
-    {
+    a + b
-      a + b
+  };
-    };
 
 let tuple_type_def_inline = 
   (b: ((int, int)) => int) => b((5, 3));

src/test/contracts/expected/tuples_no_annotation.religo.expected

@@ -3,7 +3,6 @@ type storage = (int, string, nat, bool);
 type parameter = int;
 
 let main = 
-  ((p, storage): (parameter, storage)) => 
+  ((p, storage): (parameter, storage)) => {
-    {
+    ([] : list(operation), (2, "2", 2n, false))
-      ([] : list(operation), (2, "2", 2n, false))
+  };
-    };

src/test/contracts/expected/website2.religo.expected

@@ -7,12 +7,11 @@ let add = ((a, b): (int, int)): int => a + b;
 let sub = ((a, b): (int, int)): int => a - b;
 
 let main = 
-  ((p, storage): (parameter, storage)) => 
+  ((p, storage): (parameter, storage)) => {
-    {
+    let storage = 
-      let storage = 
+      switch(p) {
-        switch(p) {
+      | Increment(n) => add((storage, n))
-        | Increment(n) => add((storage, n))
+      | Decrement(n) => sub((storage, n))
-        | Decrement(n) => sub((storage, n))
+      };
-        };
+    ([] : list(operation), storage)
-      ([] : list(operation), storage)
+  };
-    };