Improve ReasonLIGO pretty printer output.

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

@@ -48,6 +48,7 @@ and pp_let_binding let_ (binding : let_binding) =
   in
   let rhs = pp_expr let_rhs in 
   match let_rhs with 
+  | EFun _
   | ESeq _
   | ERecord _ -> lhs ^^ rhs
   | _ -> prefix 2 0 lhs rhs
@@ -130,7 +131,7 @@ and pp_field_pattern {value; _} =
 
 and pp_ptyped {value; _} =
   let {pattern; type_expr; _} = value in
-  group (pp_pattern pattern ^^ string ":" ^/^ pp_type_expr type_expr)
+  group (pp_pattern pattern ^^ string ": " ^^ pp_type_expr type_expr)
 
 and pp_type_decl decl =
   let {name; type_expr; _} = decl.value in
@@ -374,7 +375,7 @@ and pp_fun {value; _} =
     match lhs_type with
       None -> empty
     | Some (_,e) ->
-        group (break 0 ^^ string ":" ^^ nest 2 (break 1 ^^ pp_type_expr e))
+        group (break 0 ^^ string ": " ^^ nest 2 (pp_type_expr e))
   in 
   match body with 
   | ESeq _ -> string "(" ^^ binders ^^ string ")" ^^ annot ^^ string " => " ^^ pp_expr body

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

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

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

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

src/test/contracts/expected/bad_address_format.religo.expected

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

src/test/contracts/expected/balance_constant.religo.expected

@@ -1,7 +1,6 @@
 type storage = tez;
 
-let main2 = 
+let main2 = (p: unit, s: storage) => 
-  (p: unit, s: storage) => 
   ([] : list(operation), Tezos.balance);
 
 let main = (x: (unit, storage)) => main2(x[0], x[1]);

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

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

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

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

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

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

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

@@ -1,5 +1,4 @@
-let main = 
+let main = (i: int) => {
-  (i: int) => {
   let result = 0;
   if(i == 2) {
   
@@ -10,4 +9,4 @@ let main =
     let result = 0;
     result
   }
-  };
+};

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

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

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

@@ -1,5 +1,5 @@
 type storage = int;
 
-let main = 
+let main = ((p, s): (int, storage))
-  ((p, s): (int, storage)): (list(operation), storage) => 
+: (list(operation), storage) => 
   ([] : list(operation), p + s);

src/test/contracts/expected/empty_case.religo.expected

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

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

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

src/test/contracts/expected/failwith.religo.expected

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

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

@@ -1,30 +1,25 @@
-let foobar = 
+let foobar = (i: int): int => {
-  (i: int): int => {
   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)
-  };
+};
 
-let higher2 = 
+let higher2 = (i: int, f: (int => int)): int => {
-  (i: int, f: (int => int)): int => {
   let ii: int = f(i);
   ii
-  };
+};
 
-let foobar2 = 
+let foobar2 = (i: int): int => {
-  (i: int): int => {
   let foo2: int => int = (i: int) => i;
   higher2(i, foo2)
-  };
+};
 
 let a: int = 0;
 
-let foobar3 = 
+let foobar3 = (i: int): int => {
-  (i: int): int => {
   let foo2: int => int = (i: int) => a + i;
   higher2(i, foo2)
-  };
+};
 
 let f = (i: int): int => i;
 
@@ -32,16 +27,15 @@ let g = (i: int): int => f(i);
 
 let foobar4 = (i: int): int => g(g(i));
 
-let higher3 = 
+let higher3 = (i: int, f: (int => int), g: (int => int))
-  (i: int, f: (int => int), g: (int => int)): int => {
+: int => {
   let ii: int = f(g(i));
   ii
-  };
+};
 
-let foobar5 = 
+let foobar5 = (i: int): int => {
-  (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/expected/implicit_account.religo.expected

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

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

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

src/test/contracts/expected/lambda.religo.expected

@@ -1,5 +1,4 @@
 type storage = unit;
 
-let main = 
+let main = ((p, s): (unit, storage)): unit => 
-  ((p, s): (unit, storage)): unit => 
   (((useless: unit)) => ())(());

src/test/contracts/expected/lambda2.religo.expected

@@ -1,5 +1,4 @@
 type storage = unit;
 
-let main = 
+let main = ((a, s): (unit, storage)): unit => 
-  ((a, s): (unit, storage)): unit => 
   ((f: (unit => unit)) => f(()))((useless: unit) => unit);

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

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

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

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

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

@@ -1,5 +1,4 @@
-let rec aux_simple = 
+let rec aux_simple = (i: int): int => 
-  (i: int): int => 
   if(i < 100) {
     aux_simple(i + 1)
   } else {
@@ -10,14 +9,12 @@ let counter_simple = (n: int): int => aux_simple(n);
 
 type sum_aggregator = {counter: int, sum: int };
 
-let counter = 
+let counter = (n: int): int => {
-  (n: int): int => {
   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) {
     
       
@@ -29,10 +26,9 @@ let counter =
       prev.sum
     };
   aggregate(initial)
-  };
+};
 
-let rec aux_nest = 
+let rec aux_nest = (prev: sum_aggregator): sum_aggregator => 
-  (prev: sum_aggregator): sum_aggregator => 
   if(prev.counter < 100) {
   
     let sum: int = prev.sum + aux_simple(prev.counter);
@@ -41,12 +37,11 @@ let rec aux_nest =
     ({counter: prev.counter, sum: prev.sum })
   };
 
-let counter_nest = 
+let counter_nest = (n: int): int => {
-  (n: int): int => {
   let initial: sum_aggregator = {
     counter: 0,
     sum: 0
   };
   let out: sum_aggregator = aux_nest(initial);
   out.sum
-  };
+};

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

@@ -12,23 +12,20 @@ let map1: foobar =
 
 let map2: foobar = Map.literal([(23, 0), (42, 0)]);
 
-let set_ = 
+let set_ = (n: int, m: foobar): foobar => 
-  (n: int, m: foobar): foobar => Map.update(23, Some (n), m);
+  Map.update(23, Some (n), m);
 
 let add = (n: int, m: foobar): foobar => Map.add(23, n, m);
 
 let rm = (m: foobar): foobar => Map.remove(42, m);
 
-let patch_ = 
+let patch_ = (m: foobar): foobar => 
-  (m: foobar): foobar => 
   Map.literal([(0, 5), (1, 6), (2, 7)]);
 
-let patch_empty = 
+let patch_empty = (m: foobar): foobar => 
-  (m: foobar): foobar => 
   Map.literal([(0, 0), (1, 1), (2, 2)]);
 
-let patch_deep = 
+let patch_deep = (m: (foobar, nat)): (foobar, nat) => 
-  (m: (foobar, nat)): (foobar, nat) => 
   (Map.literal([(0, 0), (1, 9), (2, 2)]), 10n);
 
 let size_ = (m: foobar): nat => Map.size(m);
@@ -39,29 +36,24 @@ 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 = 
+let iter_op = (m: foobar): unit => {
-  (m: foobar): unit => {
   let assert_eq = (i: int, j: int) => assert(i == j);
   Map.iter(assert_eq, m)
-  };
+};
 
-let map_op = 
+let map_op = (m: foobar): foobar => {
-  (m: foobar): foobar => {
   let increment = (z: int, j: int) => j + 1;
   Map.map(increment, m)
-  };
+};
 
-let fold_op = 
+let fold_op = (m: foobar): foobar => {
-  (m: foobar): foobar => {
+  let aggregate = (i: int, j: (int, int)) => i + j[0] + j[1];
-    let aggregate = 
-      (i: int, j: (int, int)) => i + j[0] + j[1];
   Map.fold(aggregate, m, 10)
-  };
+};
 
-let deep_op = 
+let deep_op = (m: foobar): foobar => {
-  (m: foobar): foobar => {
   let coco = (0, m);
   let coco = (0, Map.remove(42, coco[1]));
   let coco = (0, Map.update(32, Some (16), coco[1]));
   coco[1]
-  };
+};

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

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

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

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

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

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

src/test/contracts/expected/multiple-parameters.religo.expected

@@ -1,6 +1,6 @@
-let abcde_curried = 
+let abcde_curried = (a: int, b: int, c: int, d: int, e: int)
-  (a: int, b: int, c: int, d: int, e: int): int => c + e + 3;
+: int => 
+  c + e + 3;
 
-let abcde = 
+let abcde = (x: (int, int, int, int, int)): int => 
-  (x: (int, int, int, int, int)): int => 
   abcde_curried(x[0], x[1], x[2], x[3], x[4]);

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

@@ -29,8 +29,8 @@ type return = (list(operation), storage);
 
 type parameter = CheckMessage(check_message_pt);
 
-let check_message = 
+let check_message = ((param, s): (check_message_pt, storage))
-  ((param, s): (check_message_pt, storage)): return => {
+: return => {
   let message: message = param.message;
   let s = 
     if(param.counter != s.counter) {
@@ -38,15 +38,11 @@ let check_message =
     } else {
     
       let packed_payload: bytes = 
-          
         Bytes.pack((message, param.counter, s.id, chain_id));
       let valid: nat = 0n;
       let keys: authorized_keys = s.auth;
-        let aux = 
+      let aux = ((vk, pkh_sig): ((nat, authorized_keys),
-          ((vk, pkh_sig):
+       (key_hash, signature))): (nat, authorized_keys) => {
-           ((nat, authorized_keys), (key_hash, signature)))
-          :
-            (nat, authorized_keys) => {
         let (valid, keys) = vk;
         switch(keys) {
         | [] => vk
@@ -55,9 +51,7 @@ let check_message =
             
               let valid = 
                 if(
-                    Crypto.check(key,
+                Crypto.check(key, pkh_sig[1], packed_payload)) {
-                       pkh_sig[1],
-                       packed_payload)) {
                   valid + 1n
                 } else {
                   (failwith("Invalid signature") : nat)
@@ -72,18 +66,16 @@ let check_message =
         List.fold(aux, param.signatures, (valid, keys));
       if(valid < s.threshold) {
       
-          (
+        (failwith("Not enough signatures passed the check")
-            failwith("Not enough signatures passed the check")
           : storage)
       } else {
         {...s, counter: s.counter + 1n}
       }
     };
   (message(unit), s)
-  };
+};
 
-let main = 
+let main = ((action, store): (parameter, storage)): return => 
-  ((action, store): (parameter, storage)): return => 
   switch(action) {
   | CheckMessage(p) => check_message((p, store))
   };

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

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

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

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

src/test/contracts/expected/record.religo.expected

@@ -24,5 +24,6 @@ let br: big_record = {a: 23, b: 23, c: 23, d: 23, e: 23 };
 
 type double_record = {inner: abc };
 
-let modify_inner = 
+let modify_inner = (r: double_record): double_record => 
-  (r: double_record): double_record => {...r, inner.b: 2048};
+  {...r,
+    inner.b: 2048};

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

@@ -1,13 +1,11 @@
-let rec sum = 
+let rec sum = ((n, acc): (int, int)): int => 
-  ((n, acc): (int, int)): int => 
   if(n < 1) {
     acc
   } else {
     sum((n - 1, acc + n))
   };
 
-let rec fibo = 
+let rec fibo = ((n, n_1, n_0): (int, int, int)): int => 
-  ((n, n_1, n_0): (int, int, int)): int => 
   if(n < 2) {
     n_1
   } else {

src/test/contracts/expected/set_arithmetic.religo.expected

@@ -1,15 +1,13 @@
-let literal_op = 
+let literal_op = (p: unit): set(string) => 
-  (p: unit): set(string) => 
   Set.literal(["foo", "bar", "foobar"]);
 
-let add_op = 
+let add_op = (s: set(string)): set(string) => 
-  (s: set(string)): set(string) => Set.add("foobar", s);
+  Set.add("foobar", s);
 
-let remove_op = 
+let remove_op = (s: set(string)): set(string) => 
-  (s: set(string)): set(string) => Set.remove("foobar", s);
+  Set.remove("foobar", s);
 
-let remove_deep = 
+let remove_deep = (s: (set(string), nat)): set(string) => 
-  (s: (set(string), nat)): set(string) => 
   Set.remove("foobar", s[0]);
 
 let mem_op = (s: set(string)): bool => Set.mem("foobar", s);

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

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

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

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

src/test/contracts/expected/tuple_param_destruct.religo.expected

@@ -1,4 +1,4 @@
 let sum = ((result, i): (int, int)): int => result - i;
 
-let parentheses = 
+let parentheses = (((((result, i)))): (((int, int)))): int => 
-  (((((result, i)))): (((int, int)))): int => result - i;
+  result - i;

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

@@ -1,44 +1,40 @@
 type fun_type = (int, int) => int;
 
-let arguments = 
+let arguments = (b: int, c: int) => {
-  (b: int, c: int) => {
   b + c
-  };
+};
 
 let arguments_type_def = (b: fun_type) => b(5, 3);
 
-let arguments_test = 
+let arguments_test = (_: int) => 
-  (_: int) => arguments_type_def(arguments);
+  arguments_type_def(arguments);
 
 type tuple_type = ((int, int)) => int;
 
-let tuple = 
+let tuple = ((a, b): (int, int)) => {
-  ((a, b): (int, int)) => {
   a + b
-  };
+};
 
 let tuple_type_def = (b: tuple_type) => b((5, 3));
 
 let tuple_test = (_: int) => tuple_type_def(tuple);
 
-let arguments_inline = 
+let arguments_inline = (b: int, c: int) => {
-  (b: int, c: int) => {
   b + c
-  };
+};
 
-let arguments_type_def_inline = 
+let arguments_type_def_inline = (b: (int, int) => int) => 
-  (b: (int, int) => int) => b(5, 3);
+  b(5, 3);
 
-let arguments_test_inline = 
+let arguments_test_inline = (_: int) => 
-  (_: int) => arguments_type_def_inline(arguments_inline);
+  arguments_type_def_inline(arguments_inline);
 
-let tuple_inline = 
+let tuple_inline = ((a, b): (int, int)) => {
-  ((a, b): (int, int)) => {
   a + b
-  };
+};
 
-let tuple_type_def_inline = 
+let tuple_type_def_inline = (b: ((int, int)) => int) => 
-  (b: ((int, int)) => int) => b((5, 3));
+  b((5, 3));
 
-let tuple_test_inline = 
+let tuple_test_inline = (_: int) => 
-  (_: int) => tuple_type_def_inline(tuple_inline);
+  tuple_type_def_inline(tuple_inline);

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

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

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

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