From a0c58326c43a7a8026b3d4c158017bf126180e90 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Fri, 22 Dec 2023 23:23:30 +0100
Subject: Regenerate the test files and add the fstar-split tests

---
 tests/coq/array/Array.v      | 421 +++++++++++++++++++++----------------------
 tests/coq/array/Primitives.v | 137 +++++++-------
 2 files changed, 264 insertions(+), 294 deletions(-)

(limited to 'tests/coq/array')

diff --git a/tests/coq/array/Array.v b/tests/coq/array/Array.v
index 1f2cc0e0..faa0e92c 100644
--- a/tests/coq/array/Array.v
+++ b/tests/coq/array/Array.v
@@ -12,108 +12,98 @@ Module Array.
     Source: 'src/array.rs', lines 3:0-3:11 *)
 Inductive AB_t := | AB_A : AB_t | AB_B : AB_t.
 
-(** [array::incr]: merged forward/backward function
-    (there is a single backward function, and the forward function returns ())
+(** [array::incr]:
     Source: 'src/array.rs', lines 8:0-8:24 *)
 Definition incr (x : u32) : result u32 :=
   u32_add x 1%u32.
 
-(** [array::array_to_shared_slice_]: forward function
+(** [array::array_to_shared_slice_]:
     Source: 'src/array.rs', lines 16:0-16:53 *)
 Definition array_to_shared_slice_
   (T : Type) (s : array T 32%usize) : result (slice T) :=
   array_to_slice T 32%usize s
 .
 
-(** [array::array_to_mut_slice_]: forward function
+(** [array::array_to_mut_slice_]:
     Source: 'src/array.rs', lines 21:0-21:58 *)
 Definition array_to_mut_slice_
-  (T : Type) (s : array T 32%usize) : result (slice T) :=
-  array_to_slice T 32%usize s
-.
-
-(** [array::array_to_mut_slice_]: backward function 0
-    Source: 'src/array.rs', lines 21:0-21:58 *)
-Definition array_to_mut_slice__back
-  (T : Type) (s : array T 32%usize) (ret : slice T) :
-  result (array T 32%usize)
+  (T : Type) (s : array T 32%usize) :
+  result ((slice T) * (slice T -> result (array T 32%usize)))
   :=
-  array_from_slice T 32%usize s ret
+  p <- array_to_slice_mut T 32%usize s;
+  let (s1, to_slice_mut_back) := p in
+  let back := fun (ret : slice T) => to_slice_mut_back ret in
+  Return (s1, back)
 .
 
-(** [array::array_len]: forward function
+(** [array::array_len]:
     Source: 'src/array.rs', lines 25:0-25:40 *)
 Definition array_len (T : Type) (s : array T 32%usize) : result usize :=
-  s0 <- array_to_slice T 32%usize s; let i := slice_len T s0 in Return i
+  s1 <- array_to_slice T 32%usize s; let i := slice_len T s1 in Return i
 .
 
-(** [array::shared_array_len]: forward function
+(** [array::shared_array_len]:
     Source: 'src/array.rs', lines 29:0-29:48 *)
 Definition shared_array_len (T : Type) (s : array T 32%usize) : result usize :=
-  s0 <- array_to_slice T 32%usize s; let i := slice_len T s0 in Return i
+  s1 <- array_to_slice T 32%usize s; let i := slice_len T s1 in Return i
 .
 
-(** [array::shared_slice_len]: forward function
+(** [array::shared_slice_len]:
     Source: 'src/array.rs', lines 33:0-33:44 *)
 Definition shared_slice_len (T : Type) (s : slice T) : result usize :=
   let i := slice_len T s in Return i
 .
 
-(** [array::index_array_shared]: forward function
+(** [array::index_array_shared]:
     Source: 'src/array.rs', lines 37:0-37:57 *)
 Definition index_array_shared
   (T : Type) (s : array T 32%usize) (i : usize) : result T :=
   array_index_usize T 32%usize s i
 .
 
-(** [array::index_array_u32]: forward function
+(** [array::index_array_u32]:
     Source: 'src/array.rs', lines 44:0-44:53 *)
 Definition index_array_u32 (s : array u32 32%usize) (i : usize) : result u32 :=
   array_index_usize u32 32%usize s i
 .
 
-(** [array::index_array_copy]: forward function
+(** [array::index_array_copy]:
     Source: 'src/array.rs', lines 48:0-48:45 *)
 Definition index_array_copy (x : array u32 32%usize) : result u32 :=
   array_index_usize u32 32%usize x 0%usize
 .
 
-(** [array::index_mut_array]: forward function
+(** [array::index_mut_array]:
     Source: 'src/array.rs', lines 52:0-52:62 *)
 Definition index_mut_array
-  (T : Type) (s : array T 32%usize) (i : usize) : result T :=
-  array_index_usize T 32%usize s i
-.
-
-(** [array::index_mut_array]: backward function 0
-    Source: 'src/array.rs', lines 52:0-52:62 *)
-Definition index_mut_array_back
-  (T : Type) (s : array T 32%usize) (i : usize) (ret : T) :
-  result (array T 32%usize)
+  (T : Type) (s : array T 32%usize) (i : usize) :
+  result (T * (T -> result (array T 32%usize)))
   :=
-  array_update_usize T 32%usize s i ret
+  p <- array_index_mut_usize T 32%usize s i;
+  let (t, index_mut_back) := p in
+  let back := fun (ret : T) => index_mut_back ret in
+  Return (t, back)
 .
 
-(** [array::index_slice]: forward function
+(** [array::index_slice]:
     Source: 'src/array.rs', lines 56:0-56:46 *)
 Definition index_slice (T : Type) (s : slice T) (i : usize) : result T :=
   slice_index_usize T s i
 .
 
-(** [array::index_mut_slice]: forward function
+(** [array::index_mut_slice]:
     Source: 'src/array.rs', lines 60:0-60:58 *)
-Definition index_mut_slice (T : Type) (s : slice T) (i : usize) : result T :=
-  slice_index_usize T s i
-.
-
-(** [array::index_mut_slice]: backward function 0
-    Source: 'src/array.rs', lines 60:0-60:58 *)
-Definition index_mut_slice_back
-  (T : Type) (s : slice T) (i : usize) (ret : T) : result (slice T) :=
-  slice_update_usize T s i ret
+Definition index_mut_slice
+  (T : Type) (s : slice T) (i : usize) :
+  result (T * (T -> result (slice T)))
+  :=
+  p <- slice_index_mut_usize T s i;
+  let (t, index_mut_back) := p in
+  let back := fun (ret : T) => index_mut_back ret in
+  Return (t, back)
 .
 
-(** [array::slice_subslice_shared_]: forward function
+(** [array::slice_subslice_shared_]:
     Source: 'src/array.rs', lines 64:0-64:70 *)
 Definition slice_subslice_shared_
   (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
@@ -122,47 +112,41 @@ Definition slice_subslice_shared_
     {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
-(** [array::slice_subslice_mut_]: forward function
+(** [array::slice_subslice_mut_]:
     Source: 'src/array.rs', lines 68:0-68:75 *)
 Definition slice_subslice_mut_
-  (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
-  core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
-    (core_slice_index_SliceIndexRangeUsizeSliceTInst u32) x
-    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
-.
-
-(** [array::slice_subslice_mut_]: backward function 0
-    Source: 'src/array.rs', lines 68:0-68:75 *)
-Definition slice_subslice_mut__back
-  (x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
-  result (slice u32)
+  (x : slice u32) (y : usize) (z : usize) :
+  result ((slice u32) * (slice u32 -> result (slice u32)))
   :=
-  core_slice_index_Slice_index_mut_back u32 (core_ops_range_Range usize)
-    (core_slice_index_SliceIndexRangeUsizeSliceTInst u32) x
-    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |} ret
+  p <-
+    core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
+      (core_slice_index_SliceIndexRangeUsizeSliceTInst u32) x
+      {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |};
+  let (s, index_mut_back) := p in
+  let back := fun (ret : slice u32) => index_mut_back ret in
+  Return (s, back)
 .
 
-(** [array::array_to_slice_shared_]: forward function
+(** [array::array_to_slice_shared_]:
     Source: 'src/array.rs', lines 72:0-72:54 *)
 Definition array_to_slice_shared_
   (x : array u32 32%usize) : result (slice u32) :=
   array_to_slice u32 32%usize x
 .
 
-(** [array::array_to_slice_mut_]: forward function
+(** [array::array_to_slice_mut_]:
     Source: 'src/array.rs', lines 76:0-76:59 *)
-Definition array_to_slice_mut_ (x : array u32 32%usize) : result (slice u32) :=
-  array_to_slice u32 32%usize x
-.
-
-(** [array::array_to_slice_mut_]: backward function 0
-    Source: 'src/array.rs', lines 76:0-76:59 *)
-Definition array_to_slice_mut__back
-  (x : array u32 32%usize) (ret : slice u32) : result (array u32 32%usize) :=
-  array_from_slice u32 32%usize x ret
+Definition array_to_slice_mut_
+  (x : array u32 32%usize) :
+  result ((slice u32) * (slice u32 -> result (array u32 32%usize)))
+  :=
+  p <- array_to_slice_mut u32 32%usize x;
+  let (s, to_slice_mut_back) := p in
+  let back := fun (ret : slice u32) => to_slice_mut_back ret in
+  Return (s, back)
 .
 
-(** [array::array_subslice_shared_]: forward function
+(** [array::array_subslice_shared_]:
     Source: 'src/array.rs', lines 80:0-80:74 *)
 Definition array_subslice_shared_
   (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
@@ -172,41 +156,35 @@ Definition array_subslice_shared_
     {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
-(** [array::array_subslice_mut_]: forward function
+(** [array::array_subslice_mut_]:
     Source: 'src/array.rs', lines 84:0-84:79 *)
 Definition array_subslice_mut_
-  (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
-  core_array_Array_index_mut u32 (core_ops_range_Range usize) 32%usize
-    (core_ops_index_IndexMutSliceTIInst u32 (core_ops_range_Range usize)
-    (core_slice_index_SliceIndexRangeUsizeSliceTInst u32)) x
-    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
-.
-
-(** [array::array_subslice_mut_]: backward function 0
-    Source: 'src/array.rs', lines 84:0-84:79 *)
-Definition array_subslice_mut__back
-  (x : array u32 32%usize) (y : usize) (z : usize) (ret : slice u32) :
-  result (array u32 32%usize)
+  (x : array u32 32%usize) (y : usize) (z : usize) :
+  result ((slice u32) * (slice u32 -> result (array u32 32%usize)))
   :=
-  core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 32%usize
-    (core_ops_index_IndexMutSliceTIInst u32 (core_ops_range_Range usize)
-    (core_slice_index_SliceIndexRangeUsizeSliceTInst u32)) x
-    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |} ret
+  p <-
+    core_array_Array_index_mut u32 (core_ops_range_Range usize) 32%usize
+      (core_ops_index_IndexMutSliceTIInst u32 (core_ops_range_Range usize)
+      (core_slice_index_SliceIndexRangeUsizeSliceTInst u32)) x
+      {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |};
+  let (s, index_mut_back) := p in
+  let back := fun (ret : slice u32) => index_mut_back ret in
+  Return (s, back)
 .
 
-(** [array::index_slice_0]: forward function
+(** [array::index_slice_0]:
     Source: 'src/array.rs', lines 88:0-88:38 *)
 Definition index_slice_0 (T : Type) (s : slice T) : result T :=
   slice_index_usize T s 0%usize
 .
 
-(** [array::index_array_0]: forward function
+(** [array::index_array_0]:
     Source: 'src/array.rs', lines 92:0-92:42 *)
 Definition index_array_0 (T : Type) (s : array T 32%usize) : result T :=
   array_index_usize T 32%usize s 0%usize
 .
 
-(** [array::index_index_array]: forward function
+(** [array::index_index_array]:
     Source: 'src/array.rs', lines 103:0-103:71 *)
 Definition index_index_array
   (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
@@ -216,157 +194,164 @@ Definition index_index_array
   array_index_usize u32 32%usize a j
 .
 
-(** [array::update_update_array]: forward function
+(** [array::update_update_array]:
     Source: 'src/array.rs', lines 114:0-114:70 *)
 Definition update_update_array
   (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
   result unit
   :=
-  a <- array_index_usize (array u32 32%usize) 32%usize s i;
-  a0 <- array_update_usize u32 32%usize a j 0%u32;
-  _ <- array_update_usize (array u32 32%usize) 32%usize s i a0;
+  p <- array_index_mut_usize (array u32 32%usize) 32%usize s i;
+  let (a, index_mut_back) := p in
+  p1 <- array_index_mut_usize u32 32%usize a j;
+  let (_, index_mut_back1) := p1 in
+  a1 <- index_mut_back1 0%u32;
+  _ <- index_mut_back a1;
   Return tt
 .
 
-(** [array::array_local_deep_copy]: forward function
+(** [array::array_local_deep_copy]:
     Source: 'src/array.rs', lines 118:0-118:43 *)
 Definition array_local_deep_copy (x : array u32 32%usize) : result unit :=
   Return tt
 .
 
-(** [array::take_array]: forward function
+(** [array::take_array]:
     Source: 'src/array.rs', lines 122:0-122:30 *)
 Definition take_array (a : array u32 2%usize) : result unit :=
   Return tt.
 
-(** [array::take_array_borrow]: forward function
+(** [array::take_array_borrow]:
     Source: 'src/array.rs', lines 123:0-123:38 *)
 Definition take_array_borrow (a : array u32 2%usize) : result unit :=
   Return tt
 .
 
-(** [array::take_slice]: forward function
+(** [array::take_slice]:
     Source: 'src/array.rs', lines 124:0-124:28 *)
 Definition take_slice (s : slice u32) : result unit :=
   Return tt.
 
-(** [array::take_mut_slice]: merged forward/backward function
-    (there is a single backward function, and the forward function returns ())
+(** [array::take_mut_slice]:
     Source: 'src/array.rs', lines 125:0-125:36 *)
 Definition take_mut_slice (s : slice u32) : result (slice u32) :=
   Return s.
 
-(** [array::const_array]: forward function
+(** [array::const_array]:
     Source: 'src/array.rs', lines 127:0-127:32 *)
 Definition const_array : result (array u32 2%usize) :=
   Return (mk_array u32 2%usize [ 0%u32; 0%u32 ])
 .
 
-(** [array::const_slice]: forward function
+(** [array::const_slice]:
     Source: 'src/array.rs', lines 131:0-131:20 *)
 Definition const_slice : result unit :=
   _ <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   Return tt
 .
 
-(** [array::take_all]: forward function
+(** [array::take_all]:
     Source: 'src/array.rs', lines 141:0-141:17 *)
 Definition take_all : result unit :=
+  _ <- take_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   _ <- take_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   _ <- take_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   _ <- take_slice s;
-  s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s1 <- take_mut_slice s0;
-  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
+  p <- array_to_slice_mut u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  let (s1, to_slice_mut_back) := p in
+  s2 <- take_mut_slice s1;
+  _ <- to_slice_mut_back s2;
   Return tt
 .
 
-(** [array::index_array]: forward function
+(** [array::index_array]:
     Source: 'src/array.rs', lines 155:0-155:38 *)
 Definition index_array (x : array u32 2%usize) : result u32 :=
   array_index_usize u32 2%usize x 0%usize
 .
 
-(** [array::index_array_borrow]: forward function
+(** [array::index_array_borrow]:
     Source: 'src/array.rs', lines 158:0-158:46 *)
 Definition index_array_borrow (x : array u32 2%usize) : result u32 :=
   array_index_usize u32 2%usize x 0%usize
 .
 
-(** [array::index_slice_u32_0]: forward function
+(** [array::index_slice_u32_0]:
     Source: 'src/array.rs', lines 162:0-162:42 *)
 Definition index_slice_u32_0 (x : slice u32) : result u32 :=
   slice_index_usize u32 x 0%usize
 .
 
-(** [array::index_mut_slice_u32_0]: forward function
+(** [array::index_mut_slice_u32_0]:
     Source: 'src/array.rs', lines 166:0-166:50 *)
-Definition index_mut_slice_u32_0 (x : slice u32) : result u32 :=
-  slice_index_usize u32 x 0%usize
+Definition index_mut_slice_u32_0
+  (x : slice u32) : result (u32 * (slice u32)) :=
+  i <- slice_index_usize u32 x 0%usize; Return (i, x)
 .
 
-(** [array::index_mut_slice_u32_0]: backward function 0
-    Source: 'src/array.rs', lines 166:0-166:50 *)
-Definition index_mut_slice_u32_0_back (x : slice u32) : result (slice u32) :=
-  _ <- slice_index_usize u32 x 0%usize; Return x
-.
-
-(** [array::index_all]: forward function
+(** [array::index_all]:
     Source: 'src/array.rs', lines 170:0-170:25 *)
 Definition index_all : result u32 :=
   i <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i0 <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i1 <- u32_add i i0;
-  i2 <- index_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i3 <- u32_add i1 i2;
+  i1 <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  i2 <- u32_add i i1;
+  i3 <- index_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  i4 <- u32_add i2 i3;
   s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i4 <- index_slice_u32_0 s;
-  i5 <- u32_add i3 i4;
-  s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i6 <- index_mut_slice_u32_0 s0;
-  i7 <- u32_add i5 i6;
-  s1 <- index_mut_slice_u32_0_back s0;
-  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
-  Return i7
-.
-
-(** [array::update_array]: forward function
+  i5 <- index_slice_u32_0 s;
+  i6 <- u32_add i4 i5;
+  p <- array_to_slice_mut u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  let (s1, to_slice_mut_back) := p in
+  p1 <- index_mut_slice_u32_0 s1;
+  let (i7, s2) := p1 in
+  i8 <- u32_add i6 i7;
+  _ <- to_slice_mut_back s2;
+  Return i8
+.
+
+(** [array::update_array]:
     Source: 'src/array.rs', lines 184:0-184:36 *)
 Definition update_array (x : array u32 2%usize) : result unit :=
-  _ <- array_update_usize u32 2%usize x 0%usize 1%u32; Return tt
+  p <- array_index_mut_usize u32 2%usize x 0%usize;
+  let (_, index_mut_back) := p in
+  _ <- index_mut_back 1%u32;
+  Return tt
 .
 
-(** [array::update_array_mut_borrow]: merged forward/backward function
-    (there is a single backward function, and the forward function returns ())
+(** [array::update_array_mut_borrow]:
     Source: 'src/array.rs', lines 187:0-187:48 *)
 Definition update_array_mut_borrow
   (x : array u32 2%usize) : result (array u32 2%usize) :=
-  array_update_usize u32 2%usize x 0%usize 1%u32
+  p <- array_index_mut_usize u32 2%usize x 0%usize;
+  let (_, index_mut_back) := p in
+  index_mut_back 1%u32
 .
 
-(** [array::update_mut_slice]: merged forward/backward function
-    (there is a single backward function, and the forward function returns ())
+(** [array::update_mut_slice]:
     Source: 'src/array.rs', lines 190:0-190:38 *)
 Definition update_mut_slice (x : slice u32) : result (slice u32) :=
-  slice_update_usize u32 x 0%usize 1%u32
+  p <- slice_index_mut_usize u32 x 0%usize;
+  let (_, index_mut_back) := p in
+  index_mut_back 1%u32
 .
 
-(** [array::update_all]: forward function
+(** [array::update_all]:
     Source: 'src/array.rs', lines 194:0-194:19 *)
 Definition update_all : result unit :=
   _ <- update_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  x <- update_array_mut_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s <- array_to_slice u32 2%usize x;
-  s0 <- update_mut_slice s;
-  _ <- array_from_slice u32 2%usize x s0;
+  _ <- update_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  a <- update_array_mut_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  p <- array_to_slice_mut u32 2%usize a;
+  let (s, to_slice_mut_back) := p in
+  s1 <- update_mut_slice s;
+  _ <- to_slice_mut_back s1;
   Return tt
 .
 
-(** [array::range_all]: forward function
+(** [array::range_all]:
     Source: 'src/array.rs', lines 205:0-205:18 *)
 Definition range_all : result unit :=
-  s <-
+  p <-
     core_array_Array_index_mut u32 (core_ops_range_Range usize) 4%usize
       (core_ops_index_IndexMutSliceTIInst u32 (core_ops_range_Range usize)
       (core_slice_index_SliceIndexRangeUsizeSliceTInst u32))
@@ -375,127 +360,119 @@ Definition range_all : result unit :=
         core_ops_range_Range_start := 1%usize;
         core_ops_range_Range_end_ := 3%usize
       |};
-  s0 <- update_mut_slice s;
-  _ <-
-    core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 4%usize
-      (core_ops_index_IndexMutSliceTIInst u32 (core_ops_range_Range usize)
-      (core_slice_index_SliceIndexRangeUsizeSliceTInst u32))
-      (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ])
-      {|
-        core_ops_range_Range_start := 1%usize;
-        core_ops_range_Range_end_ := 3%usize
-      |} s0;
+  let (s, index_mut_back) := p in
+  s1 <- update_mut_slice s;
+  _ <- index_mut_back s1;
   Return tt
 .
 
-(** [array::deref_array_borrow]: forward function
+(** [array::deref_array_borrow]:
     Source: 'src/array.rs', lines 214:0-214:46 *)
 Definition deref_array_borrow (x : array u32 2%usize) : result u32 :=
   array_index_usize u32 2%usize x 0%usize
 .
 
-(** [array::deref_array_mut_borrow]: forward function
-    Source: 'src/array.rs', lines 219:0-219:54 *)
-Definition deref_array_mut_borrow (x : array u32 2%usize) : result u32 :=
-  array_index_usize u32 2%usize x 0%usize
-.
-
-(** [array::deref_array_mut_borrow]: backward function 0
+(** [array::deref_array_mut_borrow]:
     Source: 'src/array.rs', lines 219:0-219:54 *)
-Definition deref_array_mut_borrow_back
-  (x : array u32 2%usize) : result (array u32 2%usize) :=
-  _ <- array_index_usize u32 2%usize x 0%usize; Return x
+Definition deref_array_mut_borrow
+  (x : array u32 2%usize) : result (u32 * (array u32 2%usize)) :=
+  i <- array_index_usize u32 2%usize x 0%usize; Return (i, x)
 .
 
-(** [array::take_array_t]: forward function
+(** [array::take_array_t]:
     Source: 'src/array.rs', lines 227:0-227:31 *)
 Definition take_array_t (a : array AB_t 2%usize) : result unit :=
   Return tt.
 
-(** [array::non_copyable_array]: forward function
+(** [array::non_copyable_array]:
     Source: 'src/array.rs', lines 229:0-229:27 *)
 Definition non_copyable_array : result unit :=
   _ <- take_array_t (mk_array AB_t 2%usize [ AB_A; AB_B ]); Return tt
 .
 
-(** [array::sum]: loop 0: forward function
+(** [array::sum]: loop 0:
     Source: 'src/array.rs', lines 242:0-250:1 *)
 Fixpoint sum_loop
-  (n : nat) (s : slice u32) (sum0 : u32) (i : usize) : result u32 :=
+  (n : nat) (s : slice u32) (sum1 : u32) (i : usize) : result u32 :=
   match n with
   | O => Fail_ OutOfFuel
-  | S n0 =>
-    let i0 := slice_len u32 s in
-    if i s< i0
+  | S n1 =>
+    let i1 := slice_len u32 s in
+    if i s< i1
     then (
-      i1 <- slice_index_usize u32 s i;
-      sum1 <- u32_add sum0 i1;
-      i2 <- usize_add i 1%usize;
-      sum_loop n0 s sum1 i2)
-    else Return sum0
+      i2 <- slice_index_usize u32 s i;
+      sum3 <- u32_add sum1 i2;
+      i3 <- usize_add i 1%usize;
+      sum_loop n1 s sum3 i3)
+    else Return sum1
   end
 .
 
-(** [array::sum]: forward function
+(** [array::sum]:
     Source: 'src/array.rs', lines 242:0-242:28 *)
 Definition sum (n : nat) (s : slice u32) : result u32 :=
   sum_loop n s 0%u32 0%usize
 .
 
-(** [array::sum2]: loop 0: forward function
+(** [array::sum2]: loop 0:
     Source: 'src/array.rs', lines 252:0-261:1 *)
 Fixpoint sum2_loop
-  (n : nat) (s : slice u32) (s2 : slice u32) (sum0 : u32) (i : usize) :
+  (n : nat) (s : slice u32) (s2 : slice u32) (sum1 : u32) (i : usize) :
   result u32
   :=
   match n with
   | O => Fail_ OutOfFuel
-  | S n0 =>
-    let i0 := slice_len u32 s in
-    if i s< i0
+  | S n1 =>
+    let i1 := slice_len u32 s in
+    if i s< i1
     then (
-      i1 <- slice_index_usize u32 s i;
-      i2 <- slice_index_usize u32 s2 i;
-      i3 <- u32_add i1 i2;
-      sum1 <- u32_add sum0 i3;
-      i4 <- usize_add i 1%usize;
-      sum2_loop n0 s s2 sum1 i4)
-    else Return sum0
+      i2 <- slice_index_usize u32 s i;
+      i3 <- slice_index_usize u32 s2 i;
+      i4 <- u32_add i2 i3;
+      sum3 <- u32_add sum1 i4;
+      i5 <- usize_add i 1%usize;
+      sum2_loop n1 s s2 sum3 i5)
+    else Return sum1
   end
 .
 
-(** [array::sum2]: forward function
+(** [array::sum2]:
     Source: 'src/array.rs', lines 252:0-252:41 *)
 Definition sum2 (n : nat) (s : slice u32) (s2 : slice u32) : result u32 :=
   let i := slice_len u32 s in
-  let i0 := slice_len u32 s2 in
-  if negb (i s= i0) then Fail_ Failure else sum2_loop n s s2 0%u32 0%usize
+  let i1 := slice_len u32 s2 in
+  if negb (i s= i1) then Fail_ Failure else sum2_loop n s s2 0%u32 0%usize
 .
 
-(** [array::f0]: forward function
+(** [array::f0]:
     Source: 'src/array.rs', lines 263:0-263:11 *)
 Definition f0 : result unit :=
-  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
-  s0 <- slice_update_usize u32 s 0%usize 1%u32;
-  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]) s0;
+  p <- array_to_slice_mut u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
+  let (s, to_slice_mut_back) := p in
+  p1 <- slice_index_mut_usize u32 s 0%usize;
+  let (_, index_mut_back) := p1 in
+  s1 <- index_mut_back 1%u32;
+  _ <- to_slice_mut_back s1;
   Return tt
 .
 
-(** [array::f1]: forward function
+(** [array::f1]:
     Source: 'src/array.rs', lines 268:0-268:11 *)
 Definition f1 : result unit :=
-  _ <-
-    array_update_usize u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
-      0%usize 1%u32;
+  p <-
+    array_index_mut_usize u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
+      0%usize;
+  let (_, index_mut_back) := p in
+  _ <- index_mut_back 1%u32;
   Return tt
 .
 
-(** [array::f2]: forward function
+(** [array::f2]:
     Source: 'src/array.rs', lines 273:0-273:17 *)
 Definition f2 (i : u32) : result unit :=
   Return tt.
 
-(** [array::f4]: forward function
+(** [array::f4]:
     Source: 'src/array.rs', lines 282:0-282:54 *)
 Definition f4
   (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
@@ -505,7 +482,7 @@ Definition f4
     {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
-(** [array::f3]: forward function
+(** [array::f3]:
     Source: 'src/array.rs', lines 275:0-275:18 *)
 Definition f3 (n : nat) : result u32 :=
   i <-
@@ -514,8 +491,8 @@ Definition f3 (n : nat) : result u32 :=
   _ <- f2 i;
   let b := array_repeat u32 32%usize 0%u32 in
   s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
-  s0 <- f4 b 16%usize 18%usize;
-  sum2 n s s0
+  s1 <- f4 b 16%usize 18%usize;
+  sum2 n s s1
 .
 
 (** [array::SZ]
@@ -523,21 +500,25 @@ Definition f3 (n : nat) : result u32 :=
 Definition sz_body : result usize := Return 32%usize.
 Definition sz_c : usize := sz_body%global.
 
-(** [array::f5]: forward function
+(** [array::f5]:
     Source: 'src/array.rs', lines 289:0-289:31 *)
 Definition f5 (x : array u32 32%usize) : result u32 :=
   array_index_usize u32 32%usize x 0%usize
 .
 
-(** [array::ite]: forward function
+(** [array::ite]:
     Source: 'src/array.rs', lines 294:0-294:12 *)
 Definition ite : result unit :=
-  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s1 <- index_mut_slice_u32_0_back s0;
-  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
-  s2 <- index_mut_slice_u32_0_back s;
-  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s2;
+  p <- array_to_slice_mut u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  let (s, to_slice_mut_back) := p in
+  p1 <- index_mut_slice_u32_0 s;
+  let (_, s1) := p1 in
+  p2 <- array_to_slice_mut u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  let (s2, to_slice_mut_back1) := p2 in
+  p3 <- index_mut_slice_u32_0 s2;
+  let (_, s3) := p3 in
+  _ <- to_slice_mut_back1 s3;
+  _ <- to_slice_mut_back s1;
   Return tt
 .
 
diff --git a/tests/coq/array/Primitives.v b/tests/coq/array/Primitives.v
index 84280b96..990e27e4 100644
--- a/tests/coq/array/Primitives.v
+++ b/tests/coq/array/Primitives.v
@@ -67,8 +67,7 @@ Definition string := Coq.Strings.String.string.
 Definition char := Coq.Strings.Ascii.ascii.
 Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
 
-Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
-Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a * a := (x, x) .
 
 Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
 Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
@@ -504,13 +503,15 @@ Arguments core_ops_index_Index_index {_ _}.
 (* Trait declaration: [core::ops::index::IndexMut] *)
 Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
   core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
-  core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
-  core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+  core_ops_index_IndexMut_index_mut :
+    Self ->
+    Idx ->
+    result (core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) *
+            (core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self));
 }.
 Arguments mk_core_ops_index_IndexMut {_ _}.
 Arguments core_ops_index_IndexMut_indexInst {_ _}.
 Arguments core_ops_index_IndexMut_index_mut {_ _}.
-Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
 
 (* Trait declaration [core::ops::deref::Deref] *)
 Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
@@ -524,13 +525,14 @@ Arguments core_ops_deref_Deref_deref {_}.
 (* Trait declaration [core::ops::deref::DerefMut] *)
 Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
   core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
-  core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
-  core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
+  core_ops_deref_DerefMut_deref_mut :
+    Self ->
+    result (core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) *
+            (core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self));
 }.
 Arguments mk_core_ops_deref_DerefMut {_}.
 Arguments core_ops_deref_DerefMut_derefInst {_}.
 Arguments core_ops_deref_DerefMut_deref_mut {_}.
-Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
 
 Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
   core_ops_range_Range_start : T;
@@ -543,8 +545,8 @@ Arguments core_ops_range_Range_end_ {_}.
 (*** [alloc] *)
 
 Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
-Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
-Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result (T * (T -> result T)) :=
+  Return (x, fun x => Return x).
 
 (* Trait instance *)
 Definition alloc_boxed_Box_coreopsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
@@ -556,7 +558,6 @@ Definition alloc_boxed_Box_coreopsDerefInst (Self : Type) : core_ops_deref_Deref
 Definition alloc_boxed_Box_coreopsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
   core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreopsDerefInst Self;
   core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
-  core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
 |}.
 
 
@@ -584,6 +585,13 @@ Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
 Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
 Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
 
+Definition array_index_mut_usize (T : Type) (n : usize) (a : array T n) (i : usize) :
+  result (T * (T -> result (array T n))) :=
+  match array_index_usize T n a i with
+  | Fail_ e => Fail_ e
+  | Return x => Return (x, array_update_usize T n a i)
+  end.
+
 (*** Slice *)
 Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
 
@@ -591,11 +599,25 @@ Axiom slice_len : forall (T : Type) (s : slice T), usize.
 Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
 Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
 
+Definition slice_index_mut_usize (T : Type) (s : slice T) (i : usize) :
+  result (T * (T -> result (slice T))) :=
+  match slice_index_usize T s i with
+  | Fail_ e => Fail_ e
+  | Return x => Return (x, slice_update_usize T s i)
+  end.
+
 (*** Subslices *)
 
 Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
 Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
 
+Definition array_to_slice_mut (T : Type) (n : usize) (a : array T n) :
+  result (slice T * (slice T -> result (array T n))) :=
+  match array_to_slice T n a with
+  | Fail_ e => Fail_ e
+  | Return x => Return (x, array_from_slice T n a)
+  end.
+
 Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
 Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
 
@@ -639,16 +661,9 @@ Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (l
   | right _ => Fail_ Failure
   end.
 
-(* The **forward** function shouldn't be used *)
-Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
-
 Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
   alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
 
-(* The **forward** function shouldn't be used *)
-Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
-
 Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
   alloc_vec_Vec_bind v (fun l =>
     if to_Z i <? Z.of_nat (length l)
@@ -661,6 +676,14 @@ Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : u
 (* Helper *)
 Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
 
+Definition alloc_vec_Vec_index_mut_usize {T : Type} (v: alloc_vec_Vec T) (i: usize) :
+  result (T * (T -> result (alloc_vec_Vec T))) :=
+  match alloc_vec_Vec_index_usize v i with
+  | Return x =>
+    Return (x, alloc_vec_Vec_update_usize v i)
+  | Fail_ e => Fail_ e
+  end.
+
 (* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
 Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
 
@@ -669,25 +692,23 @@ Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceI
   core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
   core_slice_index_SliceIndex_Output : Type;
   core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
-  core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
-  core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_get_mut :
+    Self -> T -> result (option core_slice_index_SliceIndex_Output * (option core_slice_index_SliceIndex_Output -> result T));
   core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
   core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
   core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
-  core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
-  core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_index_mut :
+    Self -> T -> result (core_slice_index_SliceIndex_Output * (core_slice_index_SliceIndex_Output -> result T));
 }.
 Arguments mk_core_slice_index_SliceIndex {_ _}.
 Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
 Arguments core_slice_index_SliceIndex_Output {_ _}.
 Arguments core_slice_index_SliceIndex_get {_ _}.
 Arguments core_slice_index_SliceIndex_get_mut {_ _}.
-Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
 Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
 Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
 Arguments core_slice_index_SliceIndex_index {_ _}.
 Arguments core_slice_index_SliceIndex_index_mut {_ _}.
-Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
 
 (* [core::slice::index::[T]::index]: forward function *)
 Definition core_slice_index_Slice_index
@@ -704,11 +725,9 @@ Axiom core_slice_index_RangeUsize_get : forall (T : Type) (i : core_ops_range_Ra
 
 (* [core::slice::index::Range::get_mut]: forward function *)
 Axiom core_slice_index_RangeUsize_get_mut :
-  forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
-
-(* [core::slice::index::Range::get_mut]: backward function 0 *)
-Axiom core_slice_index_RangeUsize_get_mut_back :
-  forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+  forall (T : Type),
+    core_ops_range_Range usize -> slice T ->
+    result (option (slice T) * (option (slice T) -> result (slice T))).
 
 (* [core::slice::index::Range::get_unchecked]: forward function *)
 Definition core_slice_index_RangeUsize_get_unchecked
@@ -732,21 +751,14 @@ Axiom core_slice_index_RangeUsize_index :
 
 (* [core::slice::index::Range::index_mut]: forward function *)
 Axiom core_slice_index_RangeUsize_index_mut :
-  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
-
-(* [core::slice::index::Range::index_mut]: backward function 0 *)
-Axiom core_slice_index_RangeUsize_index_mut_back :
-  forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T * (slice T -> result (slice T))).
 
 (* [core::slice::index::[T]::index_mut]: forward function *)
 Axiom core_slice_index_Slice_index_mut :
   forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
-  slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
-
-(* [core::slice::index::[T]::index_mut]: backward function 0 *)
-Axiom core_slice_index_Slice_index_mut_back :
-  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
-  slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+  slice T -> Idx ->
+  result (inst.(core_slice_index_SliceIndex_Output) *
+          (inst.(core_slice_index_SliceIndex_Output) -> result (slice T))).
 
 (* [core::array::[T; N]::index]: forward function *)
 Axiom core_array_Array_index :
@@ -756,12 +768,9 @@ Axiom core_array_Array_index :
 (* [core::array::[T; N]::index_mut]: forward function *)
 Axiom core_array_Array_index_mut :
   forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
-  (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
-
-(* [core::array::[T; N]::index_mut]: backward function 0 *)
-Axiom core_array_Array_index_mut_back :
-  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
-  (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+  (a : array T N) (i : Idx),
+  result (inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output) *
+          (inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output) -> result (array T N))).
 
 (* Trait implementation: [core::slice::index::private_slice_index::Range] *)
 Definition core_slice_index_private_slice_index_SealedRangeUsizeInst
@@ -774,12 +783,10 @@ Definition core_slice_index_SliceIndexRangeUsizeSliceTInst (T : Type) :
   core_slice_index_SliceIndex_Output := slice T;
   core_slice_index_SliceIndex_get := core_slice_index_RangeUsize_get T;
   core_slice_index_SliceIndex_get_mut := core_slice_index_RangeUsize_get_mut T;
-  core_slice_index_SliceIndex_get_mut_back := core_slice_index_RangeUsize_get_mut_back T;
   core_slice_index_SliceIndex_get_unchecked := core_slice_index_RangeUsize_get_unchecked T;
   core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_RangeUsize_get_unchecked_mut T;
   core_slice_index_SliceIndex_index := core_slice_index_RangeUsize_index T;
   core_slice_index_SliceIndex_index_mut := core_slice_index_RangeUsize_index_mut T;
-  core_slice_index_SliceIndex_index_mut_back := core_slice_index_RangeUsize_index_mut_back T;
 |}.
 
 (* Trait implementation: [core::slice::index::[T]] *)
@@ -796,7 +803,6 @@ Definition core_ops_index_IndexMutSliceTIInst (T Idx : Type)
   core_ops_index_IndexMut (slice T) Idx := {|
   core_ops_index_IndexMut_indexInst := core_ops_index_IndexSliceTIInst T Idx inst;
   core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
-  core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
 |}.
 
 (* Trait implementation: [core::array::[T; N]] *)
@@ -813,18 +819,14 @@ Definition core_ops_index_IndexMutArrayInst (T Idx : Type) (N : usize)
   core_ops_index_IndexMut (array T N) Idx := {|
   core_ops_index_IndexMut_indexInst := core_ops_index_IndexArrayInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
   core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
-  core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
 |}.
 
 (* [core::slice::index::usize::get]: forward function *)
 Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
 
 (* [core::slice::index::usize::get_mut]: forward function *)
-Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
-
-(* [core::slice::index::usize::get_mut]: backward function 0 *)
-Axiom core_slice_index_usize_get_mut_back :
-  forall (T : Type), usize -> slice T -> option T -> result (slice T).
+Axiom core_slice_index_usize_get_mut :
+  forall (T : Type), usize -> slice T -> result (option T * (option T -> result (slice T))).
 
 (* [core::slice::index::usize::get_unchecked]: forward function *)
 Axiom core_slice_index_usize_get_unchecked :
@@ -838,11 +840,8 @@ Axiom core_slice_index_usize_get_unchecked_mut :
 Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
 
 (* [core::slice::index::usize::index_mut]: forward function *)
-Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
-
-(* [core::slice::index::usize::index_mut]: backward function 0 *)
-Axiom core_slice_index_usize_index_mut_back :
-  forall (T : Type), usize -> slice T -> T -> result (slice T).
+Axiom core_slice_index_usize_index_mut :
+  forall (T : Type), usize -> slice T -> result (T * (T -> result (slice T))).
 
 (* Trait implementation: [core::slice::index::private_slice_index::usize] *)
 Definition core_slice_index_private_slice_index_SealedUsizeInst
@@ -855,12 +854,10 @@ Definition core_slice_index_SliceIndexUsizeSliceTInst (T : Type) :
   core_slice_index_SliceIndex_Output := T;
   core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
   core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
-  core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
   core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
   core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
   core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
   core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
-  core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
 |}.
 
 (* [alloc::vec::Vec::index]: forward function *)
@@ -869,12 +866,9 @@ Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_Slice
 
 (* [alloc::vec::Vec::index_mut]: forward function *)
 Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
-  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
-
-(* [alloc::vec::Vec::index_mut]: backward function 0 *)
-Axiom alloc_vec_Vec_index_mut_back :
-  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
-  (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+  (Self : alloc_vec_Vec T) (i : Idx),
+  result (inst.(core_slice_index_SliceIndex_Output) *
+          (inst.(core_slice_index_SliceIndex_Output) -> result (alloc_vec_Vec T))).
 
 (* Trait implementation: [alloc::vec::Vec] *)
 Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
@@ -890,7 +884,6 @@ Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
   core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
   core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
   core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
-  core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
 |}.
 
 (*** Theorems *)
@@ -901,10 +894,6 @@ Axiom alloc_vec_Vec_index_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usiz
 
 Axiom alloc_vec_Vec_index_mut_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
   alloc_vec_Vec_index_mut a usize (core_slice_index_SliceIndexUsizeSliceTInst a) v i =
-    alloc_vec_Vec_index_usize v i.
-
-Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
-  alloc_vec_Vec_index_mut_back a usize (core_slice_index_SliceIndexUsizeSliceTInst a) v i x =
-    alloc_vec_Vec_update_usize v i x.
+    alloc_vec_Vec_index_mut_usize v i.
 
 End Primitives.
-- 
cgit v1.3.1


From a4decc7654bc6f3301c0174124d21fdbc2dbc708 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sat, 23 Dec 2023 00:59:55 +0100
Subject: Regenerate the files

---
 tests/coq/array/Array.v                            | 18 ++++------
 tests/coq/betree/BetreeMain_Funs.v                 | 40 ++++++----------------
 tests/coq/hashmap/Hashmap_Funs.v                   |  8 ++---
 tests/coq/hashmap_on_disk/HashmapMain_Funs.v       | 10 +++---
 tests/coq/misc/External_Funs.v                     |  4 +--
 tests/coq/misc/NoNestedBorrows.v                   | 37 ++++++++------------
 tests/coq/misc/Paper.v                             | 11 +++---
 tests/coq/misc/PoloniusList.v                      |  8 ++---
 tests/coq/traits/Traits.v                          |  2 +-
 tests/fstar-split/betree/BetreeMain.Funs.fst       | 17 ++++-----
 tests/fstar-split/hashmap/Hashmap.Funs.fst         |  6 ++--
 .../hashmap_on_disk/HashmapMain.Funs.fst           |  8 ++---
 tests/fstar-split/misc/External.Funs.fst           |  4 +--
 tests/fstar-split/misc/NoNestedBorrows.fst         | 26 ++++++--------
 tests/fstar-split/misc/Paper.fst                   | 11 +++---
 tests/fstar-split/traits/Traits.fst                |  2 +-
 tests/fstar/array/Array.Funs.fst                   | 18 ++++------
 tests/fstar/betree/BetreeMain.Funs.fst             | 33 ++++++------------
 .../fstar/betree_back_stateful/BetreeMain.Funs.fst | 33 ++++++------------
 tests/fstar/hashmap/Hashmap.Funs.fst               |  9 +++--
 tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst   | 10 +++---
 tests/fstar/misc/External.Funs.fst                 |  4 +--
 tests/fstar/misc/NoNestedBorrows.fst               | 37 ++++++++------------
 tests/fstar/misc/Paper.fst                         | 11 +++---
 tests/fstar/misc/PoloniusList.fst                  |  6 ++--
 tests/fstar/traits/Traits.fst                      |  2 +-
 tests/lean/Array.lean                              | 18 ++++------
 tests/lean/BetreeMain/Funs.lean                    | 36 ++++++-------------
 tests/lean/External/Funs.lean                      |  3 +-
 tests/lean/Hashmap/Funs.lean                       |  9 ++---
 tests/lean/HashmapMain/Funs.lean                   | 11 +++---
 tests/lean/NoNestedBorrows.lean                    | 36 ++++++++-----------
 tests/lean/Paper.lean                              | 11 +++---
 tests/lean/PoloniusList.lean                       |  8 ++---
 tests/lean/Traits.lean                             |  3 +-
 35 files changed, 183 insertions(+), 327 deletions(-)

(limited to 'tests/coq/array')

diff --git a/tests/coq/array/Array.v b/tests/coq/array/Array.v
index faa0e92c..3a30413a 100644
--- a/tests/coq/array/Array.v
+++ b/tests/coq/array/Array.v
@@ -32,8 +32,7 @@ Definition array_to_mut_slice_
   :=
   p <- array_to_slice_mut T 32%usize s;
   let (s1, to_slice_mut_back) := p in
-  let back := fun (ret : slice T) => to_slice_mut_back ret in
-  Return (s1, back)
+  Return (s1, to_slice_mut_back)
 .
 
 (** [array::array_len]:
@@ -81,8 +80,7 @@ Definition index_mut_array
   :=
   p <- array_index_mut_usize T 32%usize s i;
   let (t, index_mut_back) := p in
-  let back := fun (ret : T) => index_mut_back ret in
-  Return (t, back)
+  Return (t, index_mut_back)
 .
 
 (** [array::index_slice]:
@@ -99,8 +97,7 @@ Definition index_mut_slice
   :=
   p <- slice_index_mut_usize T s i;
   let (t, index_mut_back) := p in
-  let back := fun (ret : T) => index_mut_back ret in
-  Return (t, back)
+  Return (t, index_mut_back)
 .
 
 (** [array::slice_subslice_shared_]:
@@ -123,8 +120,7 @@ Definition slice_subslice_mut_
       (core_slice_index_SliceIndexRangeUsizeSliceTInst u32) x
       {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |};
   let (s, index_mut_back) := p in
-  let back := fun (ret : slice u32) => index_mut_back ret in
-  Return (s, back)
+  Return (s, index_mut_back)
 .
 
 (** [array::array_to_slice_shared_]:
@@ -142,8 +138,7 @@ Definition array_to_slice_mut_
   :=
   p <- array_to_slice_mut u32 32%usize x;
   let (s, to_slice_mut_back) := p in
-  let back := fun (ret : slice u32) => to_slice_mut_back ret in
-  Return (s, back)
+  Return (s, to_slice_mut_back)
 .
 
 (** [array::array_subslice_shared_]:
@@ -168,8 +163,7 @@ Definition array_subslice_mut_
       (core_slice_index_SliceIndexRangeUsizeSliceTInst u32)) x
       {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |};
   let (s, index_mut_back) := p in
-  let back := fun (ret : slice u32) => index_mut_back ret in
-  Return (s, back)
+  Return (s, index_mut_back)
 .
 
 (** [array::index_slice_0]:
diff --git a/tests/coq/betree/BetreeMain_Funs.v b/tests/coq/betree/BetreeMain_Funs.v
index 516bc7b7..cefab0f4 100644
--- a/tests/coq/betree/BetreeMain_Funs.v
+++ b/tests/coq/betree/BetreeMain_Funs.v
@@ -123,8 +123,7 @@ Fixpoint betree_List_split_at
         i <- u64_sub n1 1%u64;
         p <- betree_List_split_at T n2 tl i;
         let (ls0, ls1) := p in
-        let l := ls0 in
-        Return (Betree_List_Cons hd l, ls1)
+        Return (Betree_List_Cons hd ls0, ls1)
       | Betree_List_Nil => Fail_ Failure
       end
   end
@@ -135,8 +134,7 @@ Fixpoint betree_List_split_at
 Definition betree_List_push_front
   (T : Type) (self : betree_List_t T) (x : T) : result (betree_List_t T) :=
   let (tl, _) := core_mem_replace (betree_List_t T) self Betree_List_Nil in
-  let l := tl in
-  Return (Betree_List_Cons x l)
+  Return (Betree_List_Cons x tl)
 .
 
 (** [betree_main::betree::{betree_main::betree::List<T>#1}::pop_front]:
@@ -186,8 +184,7 @@ Fixpoint betree_ListTupleU64T_partition_at_pivot
       else (
         p <- betree_ListTupleU64T_partition_at_pivot T n1 tl pivot;
         let (ls0, ls1) := p in
-        let l := ls0 in
-        Return (Betree_List_Cons (i, t) l, ls1))
+        Return (Betree_List_Cons (i, t) ls0, ls1))
     | Betree_List_Nil => Return (Betree_List_Nil, Betree_List_Nil)
     end
   end
@@ -242,10 +239,7 @@ Fixpoint betree_Node_lookup_first_message_for_key
     | Betree_List_Cons x next_msgs =>
       let (i, m) := x in
       if i s>= key
-      then
-        let back_'a :=
-          fun (ret : betree_List_t (u64 * betree_Message_t)) => Return ret in
-        Return (Betree_List_Cons (i, m) next_msgs, back_'a)
+      then Return (Betree_List_Cons (i, m) next_msgs, Return)
       else (
         p <- betree_Node_lookup_first_message_for_key n1 key next_msgs;
         let (l, lookup_first_message_for_key_back) := p in
@@ -254,10 +248,7 @@ Fixpoint betree_Node_lookup_first_message_for_key
             next_msgs1 <- lookup_first_message_for_key_back ret;
             Return (Betree_List_Cons (i, m) next_msgs1) in
         Return (l, back_'a))
-    | Betree_List_Nil =>
-      let back_'a :=
-        fun (ret : betree_List_t (u64 * betree_Message_t)) => Return ret in
-      Return (Betree_List_Nil, back_'a)
+    | Betree_List_Nil => Return (Betree_List_Nil, Return)
     end
   end
 .
@@ -456,14 +447,8 @@ Fixpoint betree_Node_lookup_first_message_after_key
             next_msgs1 <- lookup_first_message_after_key_back ret;
             Return (Betree_List_Cons (k, m) next_msgs1) in
         Return (l, back_'a))
-      else
-        let back_'a :=
-          fun (ret : betree_List_t (u64 * betree_Message_t)) => Return ret in
-        Return (Betree_List_Cons (k, m) next_msgs, back_'a)
-    | Betree_List_Nil =>
-      let back_'a :=
-        fun (ret : betree_List_t (u64 * betree_Message_t)) => Return ret in
-      Return (Betree_List_Nil, back_'a)
+      else Return (Betree_List_Cons (k, m) next_msgs, Return)
+    | Betree_List_Nil => Return (Betree_List_Nil, Return)
     end
   end
 .
@@ -562,9 +547,7 @@ Fixpoint betree_Node_lookup_mut_in_bindings
     | Betree_List_Cons hd tl =>
       let (i, i1) := hd in
       if i s>= key
-      then
-        let back_'a := fun (ret : betree_List_t (u64 * u64)) => Return ret in
-        Return (Betree_List_Cons (i, i1) tl, back_'a)
+      then Return (Betree_List_Cons (i, i1) tl, Return)
       else (
         p <- betree_Node_lookup_mut_in_bindings n1 key tl;
         let (l, lookup_mut_in_bindings_back) := p in
@@ -573,9 +556,7 @@ Fixpoint betree_Node_lookup_mut_in_bindings
             tl1 <- lookup_mut_in_bindings_back ret;
             Return (Betree_List_Cons (i, i1) tl1) in
         Return (l, back_'a))
-    | Betree_List_Nil =>
-      let back_'a := fun (ret : betree_List_t (u64 * u64)) => Return ret in
-      Return (Betree_List_Nil, back_'a)
+    | Betree_List_Nil => Return (Betree_List_Nil, Return)
     end
   end
 .
@@ -751,10 +732,9 @@ Definition betree_Node_apply
   (new_msg : betree_Message_t) (st : state) :
   result (state * (betree_Node_t * betree_NodeIdCounter_t))
   :=
-  let l := Betree_List_Nil in
   p <-
     betree_Node_apply_messages n self params node_id_cnt (Betree_List_Cons
-      (key, new_msg) l) st;
+      (key, new_msg) Betree_List_Nil) st;
   let (st1, p1) := p in
   let (self1, node_id_cnt1) := p1 in
   Return (st1, (self1, node_id_cnt1))
diff --git a/tests/coq/hashmap/Hashmap_Funs.v b/tests/coq/hashmap/Hashmap_Funs.v
index 5cd9fe70..0478edbe 100644
--- a/tests/coq/hashmap/Hashmap_Funs.v
+++ b/tests/coq/hashmap/Hashmap_Funs.v
@@ -49,8 +49,7 @@ Definition hashMap_new_with_capacity
   (max_load_divisor : usize) :
   result (HashMap_t T)
   :=
-  let v := alloc_vec_Vec_new (List_t T) in
-  slots <- hashMap_allocate_slots T n v capacity;
+  slots <- hashMap_allocate_slots T n (alloc_vec_Vec_new (List_t T)) capacity;
   i <- usize_mul capacity max_load_dividend;
   i1 <- usize_div i max_load_divisor;
   Return
@@ -128,7 +127,7 @@ Fixpoint hashMap_insert_in_list_loop
         p <- hashMap_insert_in_list_loop T n1 key value tl;
         let (b, back) := p in
         Return (b, List_Cons ckey cvalue back))
-    | List_Nil => let l := List_Nil in Return (true, List_Cons key value l)
+    | List_Nil => Return (true, List_Cons key value List_Nil)
     end
   end
 .
@@ -401,8 +400,7 @@ Definition hashMap_get_mut_in_list
   :=
   p <- hashMap_get_mut_in_list_loop T n ls key;
   let (t, back_'a) := p in
-  let back_'a1 := fun (ret : T) => back_'a ret in
-  Return (t, back_'a1)
+  Return (t, back_'a)
 .
 
 (** [hashmap::{hashmap::HashMap<T>}::get_mut]:
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Funs.v b/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
index b74fa61a..6a7eeb2d 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
@@ -53,8 +53,9 @@ Definition hashmap_HashMap_new_with_capacity
   (max_load_divisor : usize) :
   result (hashmap_HashMap_t T)
   :=
-  let v := alloc_vec_Vec_new (hashmap_List_t T) in
-  slots <- hashmap_HashMap_allocate_slots T n v capacity;
+  slots <-
+    hashmap_HashMap_allocate_slots T n (alloc_vec_Vec_new (hashmap_List_t T))
+      capacity;
   i <- usize_mul capacity max_load_dividend;
   i1 <- usize_div i max_load_divisor;
   Return
@@ -138,7 +139,7 @@ Fixpoint hashmap_HashMap_insert_in_list_loop
         let (b, back) := p in
         Return (b, Hashmap_List_Cons ckey cvalue back))
     | Hashmap_List_Nil =>
-      let l := Hashmap_List_Nil in Return (true, Hashmap_List_Cons key value l)
+      Return (true, Hashmap_List_Cons key value Hashmap_List_Nil)
     end
   end
 .
@@ -424,8 +425,7 @@ Definition hashmap_HashMap_get_mut_in_list
   :=
   p <- hashmap_HashMap_get_mut_in_list_loop T n ls key;
   let (t, back_'a) := p in
-  let back_'a1 := fun (ret : T) => back_'a ret in
-  Return (t, back_'a1)
+  Return (t, back_'a)
 .
 
 (** [hashmap_main::hashmap::{hashmap_main::hashmap::HashMap<T>}::get_mut]:
diff --git a/tests/coq/misc/External_Funs.v b/tests/coq/misc/External_Funs.v
index 049f5d39..91ea88c9 100644
--- a/tests/coq/misc/External_Funs.v
+++ b/tests/coq/misc/External_Funs.v
@@ -31,9 +31,7 @@ Definition test_new_non_zero_u32
 (** [external::test_vec]:
     Source: 'src/external.rs', lines 17:0-17:17 *)
 Definition test_vec : result unit :=
-  let v := alloc_vec_Vec_new u32 in
-  _ <- alloc_vec_Vec_push u32 v 0%u32;
-  Return tt
+  _ <- alloc_vec_Vec_push u32 (alloc_vec_Vec_new u32) 0%u32; Return tt
 .
 
 (** Unit test for [external::test_vec] *)
diff --git a/tests/coq/misc/NoNestedBorrows.v b/tests/coq/misc/NoNestedBorrows.v
index 081c65c3..8857d4b6 100644
--- a/tests/coq/misc/NoNestedBorrows.v
+++ b/tests/coq/misc/NoNestedBorrows.v
@@ -244,11 +244,10 @@ Check (test_list1 )%return.
 (** [no_nested_borrows::test_box1]:
     Source: 'src/no_nested_borrows.rs', lines 208:0-208:18 *)
 Definition test_box1 : result unit :=
-  let b := 0%i32 in
-  p <- alloc_boxed_Box_deref_mut i32 b;
+  p <- alloc_boxed_Box_deref_mut i32 0%i32;
   let (_, deref_mut_back) := p in
-  b1 <- deref_mut_back 1%i32;
-  x <- alloc_boxed_Box_deref i32 b1;
+  b <- deref_mut_back 1%i32;
+  x <- alloc_boxed_Box_deref i32 b;
   if negb (x s= 1%i32) then Fail_ Failure else Return tt
 .
 
@@ -290,8 +289,7 @@ Definition is_cons (T : Type) (l : List_t T) : result bool :=
 (** [no_nested_borrows::test_is_cons]:
     Source: 'src/no_nested_borrows.rs', lines 253:0-253:21 *)
 Definition test_is_cons : result unit :=
-  let l := List_Nil in
-  b <- is_cons i32 (List_Cons 0%i32 l);
+  b <- is_cons i32 (List_Cons 0%i32 List_Nil);
   if negb b then Fail_ Failure else Return tt
 .
 
@@ -310,8 +308,7 @@ Definition split_list (T : Type) (l : List_t T) : result (T * (List_t T)) :=
 (** [no_nested_borrows::test_split_list]:
     Source: 'src/no_nested_borrows.rs', lines 267:0-267:24 *)
 Definition test_split_list : result unit :=
-  let l := List_Nil in
-  p <- split_list i32 (List_Cons 0%i32 l);
+  p <- split_list i32 (List_Cons 0%i32 List_Nil);
   let (hd, _) := p in
   if negb (hd s= 0%i32) then Fail_ Failure else Return tt
 .
@@ -436,26 +433,25 @@ Definition list_rev (T : Type) (l : List_t T) : result (List_t T) :=
 (** [no_nested_borrows::test_list_functions]:
     Source: 'src/no_nested_borrows.rs', lines 398:0-398:28 *)
 Definition test_list_functions : result unit :=
-  let l := List_Nil in
-  let l1 := List_Cons 2%i32 l in
-  let l2 := List_Cons 1%i32 l1 in
-  i <- list_length i32 (List_Cons 0%i32 l2);
+  let l := List_Cons 2%i32 List_Nil in
+  let l1 := List_Cons 1%i32 l in
+  i <- list_length i32 (List_Cons 0%i32 l1);
   if negb (i s= 3%u32)
   then Fail_ Failure
   else (
-    i1 <- list_nth_shared i32 (List_Cons 0%i32 l2) 0%u32;
+    i1 <- list_nth_shared i32 (List_Cons 0%i32 l1) 0%u32;
     if negb (i1 s= 0%i32)
     then Fail_ Failure
     else (
-      i2 <- list_nth_shared i32 (List_Cons 0%i32 l2) 1%u32;
+      i2 <- list_nth_shared i32 (List_Cons 0%i32 l1) 1%u32;
       if negb (i2 s= 1%i32)
       then Fail_ Failure
       else (
-        i3 <- list_nth_shared i32 (List_Cons 0%i32 l2) 2%u32;
+        i3 <- list_nth_shared i32 (List_Cons 0%i32 l1) 2%u32;
         if negb (i3 s= 2%i32)
         then Fail_ Failure
         else (
-          p <- list_nth_mut i32 (List_Cons 0%i32 l2) 1%u32;
+          p <- list_nth_mut i32 (List_Cons 0%i32 l1) 1%u32;
           let (_, list_nth_mut_back) := p in
           ls <- list_nth_mut_back 3%i32;
           i4 <- list_nth_shared i32 ls 0%u32;
@@ -502,9 +498,7 @@ Definition id_mut_pair3
   (T1 T2 : Type) (x : T1) (y : T2) :
   result ((T1 * T2) * (T1 -> result T1) * (T2 -> result T2))
   :=
-  let back_'a := fun (ret : T1) => Return ret in
-  let back_'b := fun (ret : T2) => Return ret in
-  Return ((x, y), back_'a, back_'b)
+  Return ((x, y), Return, Return)
 .
 
 (** [no_nested_borrows::id_mut_pair4]:
@@ -513,10 +507,7 @@ Definition id_mut_pair4
   (T1 T2 : Type) (p : (T1 * T2)) :
   result ((T1 * T2) * (T1 -> result T1) * (T2 -> result T2))
   :=
-  let (t, t1) := p in
-  let back_'a := fun (ret : T1) => Return ret in
-  let back_'b := fun (ret : T2) => Return ret in
-  Return ((t, t1), back_'a, back_'b)
+  let (t, t1) := p in Return ((t, t1), Return, Return)
 .
 
 (** [no_nested_borrows::StructWithTuple]
diff --git a/tests/coq/misc/Paper.v b/tests/coq/misc/Paper.v
index e46df0ce..769cf34c 100644
--- a/tests/coq/misc/Paper.v
+++ b/tests/coq/misc/Paper.v
@@ -96,14 +96,13 @@ Fixpoint sum (l : List_t i32) : result i32 :=
 (** [paper::test_nth]:
     Source: 'src/paper.rs', lines 68:0-68:17 *)
 Definition test_nth : result unit :=
-  let l := List_Nil in
-  let l1 := List_Cons 3%i32 l in
-  let l2 := List_Cons 2%i32 l1 in
-  p <- list_nth_mut i32 (List_Cons 1%i32 l2) 2%u32;
+  let l := List_Cons 3%i32 List_Nil in
+  let l1 := List_Cons 2%i32 l in
+  p <- list_nth_mut i32 (List_Cons 1%i32 l1) 2%u32;
   let (x, list_nth_mut_back) := p in
   x1 <- i32_add x 1%i32;
-  l3 <- list_nth_mut_back x1;
-  i <- sum l3;
+  l2 <- list_nth_mut_back x1;
+  i <- sum l2;
   if negb (i s= 7%i32) then Fail_ Failure else Return tt
 .
 
diff --git a/tests/coq/misc/PoloniusList.v b/tests/coq/misc/PoloniusList.v
index 7e967855..8f403a8e 100644
--- a/tests/coq/misc/PoloniusList.v
+++ b/tests/coq/misc/PoloniusList.v
@@ -27,9 +27,7 @@ Fixpoint get_list_at_x
   match ls with
   | List_Cons hd tl =>
     if hd s= x
-    then
-      let back_'a := fun (ret : List_t u32) => Return ret in
-      Return (List_Cons hd tl, back_'a)
+    then Return (List_Cons hd tl, Return)
     else (
       p <- get_list_at_x tl x;
       let (l, get_list_at_x_back) := p in
@@ -37,9 +35,7 @@ Fixpoint get_list_at_x
         fun (ret : List_t u32) =>
           tl1 <- get_list_at_x_back ret; Return (List_Cons hd tl1) in
       Return (l, back_'a))
-  | List_Nil =>
-    let back_'a := fun (ret : List_t u32) => Return ret in
-    Return (List_Nil, back_'a)
+  | List_Nil => Return (List_Nil, Return)
   end
 .
 
diff --git a/tests/coq/traits/Traits.v b/tests/coq/traits/Traits.v
index 7055e25d..7abf2021 100644
--- a/tests/coq/traits/Traits.v
+++ b/tests/coq/traits/Traits.v
@@ -334,7 +334,7 @@ Definition use_with_const_ty1
   (H : Type) (LEN : usize) (withConstTyHLENInst : WithConstTy_t H LEN) :
   result usize
   :=
-  let i := withConstTyHLENInst.(WithConstTy_tWithConstTy_t_LEN1) in Return i
+  Return withConstTyHLENInst.(WithConstTy_tWithConstTy_t_LEN1)
 .
 
 (** [traits::use_with_const_ty2]:
diff --git a/tests/fstar-split/betree/BetreeMain.Funs.fst b/tests/fstar-split/betree/BetreeMain.Funs.fst
index 6890488a..33133236 100644
--- a/tests/fstar-split/betree/BetreeMain.Funs.fst
+++ b/tests/fstar-split/betree/BetreeMain.Funs.fst
@@ -113,8 +113,7 @@ let rec betree_List_split_at
       let* i = u64_sub n 1 in
       let* p = betree_List_split_at t tl i in
       let (ls0, ls1) = p in
-      let l = ls0 in
-      Return (Betree_List_Cons hd l, ls1)
+      Return (Betree_List_Cons hd ls0, ls1)
     | Betree_List_Nil -> Fail Failure
     end
 
@@ -124,8 +123,7 @@ let rec betree_List_split_at
 let betree_List_push_front
   (t : Type0) (self : betree_List_t t) (x : t) : result (betree_List_t t) =
   let tl = core_mem_replace (betree_List_t t) self Betree_List_Nil in
-  let l = tl in
-  Return (Betree_List_Cons x l)
+  Return (Betree_List_Cons x tl)
 
 (** [betree_main::betree::{betree_main::betree::List<T>#1}::pop_front]: forward function
     Source: 'src/betree.rs', lines 306:4-306:32 *)
@@ -178,8 +176,7 @@ let rec betree_ListTupleU64T_partition_at_pivot
     else
       let* p = betree_ListTupleU64T_partition_at_pivot t tl pivot in
       let (ls0, ls1) = p in
-      let l = ls0 in
-      Return (Betree_List_Cons (i, x) l, ls1)
+      Return (Betree_List_Cons (i, x) ls0, ls1)
   | Betree_List_Nil -> Return (Betree_List_Nil, Betree_List_Nil)
   end
 
@@ -871,13 +868,12 @@ let betree_Node_apply
   (new_msg : betree_Message_t) (st : state) :
   result (state & unit)
   =
-  let l = Betree_List_Nil in
   let* (st1, _) =
     betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
-      new_msg) l) st in
+      new_msg) Betree_List_Nil) st in
   let* _ =
     betree_Node_apply_messages_back self params node_id_cnt (Betree_List_Cons
-      (key, new_msg) l) st in
+      (key, new_msg) Betree_List_Nil) st in
   Return (st1, ())
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::apply]: backward function 0
@@ -888,9 +884,8 @@ let betree_Node_apply_back
   (new_msg : betree_Message_t) (st : state) :
   result (betree_Node_t & betree_NodeIdCounter_t)
   =
-  let l = Betree_List_Nil in
   betree_Node_apply_messages_back self params node_id_cnt (Betree_List_Cons
-    (key, new_msg) l) st
+    (key, new_msg) Betree_List_Nil) st
 
 (** [betree_main::betree::{betree_main::betree::BeTree#6}::new]: forward function
     Source: 'src/betree.rs', lines 849:4-849:60 *)
diff --git a/tests/fstar-split/hashmap/Hashmap.Funs.fst b/tests/fstar-split/hashmap/Hashmap.Funs.fst
index 79327183..290d49ee 100644
--- a/tests/fstar-split/hashmap/Hashmap.Funs.fst
+++ b/tests/fstar-split/hashmap/Hashmap.Funs.fst
@@ -41,8 +41,8 @@ let hashMap_new_with_capacity
   (max_load_divisor : usize) :
   result (hashMap_t t)
   =
-  let v = alloc_vec_Vec_new (list_t t) in
-  let* slots = hashMap_allocate_slots t v capacity in
+  let* slots = hashMap_allocate_slots t (alloc_vec_Vec_new (list_t t)) capacity
+    in
   let* i = usize_mul capacity max_load_dividend in
   let* i1 = usize_div i max_load_divisor in
   Return
@@ -124,7 +124,7 @@ let rec hashMap_insert_in_list_loop_back
     else
       let* tl1 = hashMap_insert_in_list_loop_back t key value tl in
       Return (List_Cons ckey cvalue tl1)
-  | List_Nil -> let l = List_Nil in Return (List_Cons key value l)
+  | List_Nil -> Return (List_Cons key value List_Nil)
   end
 
 (** [hashmap::{hashmap::HashMap<T>}::insert_in_list]: backward function 0
diff --git a/tests/fstar-split/hashmap_on_disk/HashmapMain.Funs.fst b/tests/fstar-split/hashmap_on_disk/HashmapMain.Funs.fst
index b2800e1e..2e2d54b8 100644
--- a/tests/fstar-split/hashmap_on_disk/HashmapMain.Funs.fst
+++ b/tests/fstar-split/hashmap_on_disk/HashmapMain.Funs.fst
@@ -43,8 +43,9 @@ let hashmap_HashMap_new_with_capacity
   (max_load_divisor : usize) :
   result (hashmap_HashMap_t t)
   =
-  let v = alloc_vec_Vec_new (hashmap_List_t t) in
-  let* slots = hashmap_HashMap_allocate_slots t v capacity in
+  let* slots =
+    hashmap_HashMap_allocate_slots t (alloc_vec_Vec_new (hashmap_List_t t))
+      capacity in
   let* i = usize_mul capacity max_load_dividend in
   let* i1 = usize_div i max_load_divisor in
   Return
@@ -128,8 +129,7 @@ let rec hashmap_HashMap_insert_in_list_loop_back
     else
       let* tl1 = hashmap_HashMap_insert_in_list_loop_back t key value tl in
       Return (Hashmap_List_Cons ckey cvalue tl1)
-  | Hashmap_List_Nil ->
-    let l = Hashmap_List_Nil in Return (Hashmap_List_Cons key value l)
+  | Hashmap_List_Nil -> Return (Hashmap_List_Cons key value Hashmap_List_Nil)
   end
 
 (** [hashmap_main::hashmap::{hashmap_main::hashmap::HashMap<T>}::insert_in_list]: backward function 0
diff --git a/tests/fstar-split/misc/External.Funs.fst b/tests/fstar-split/misc/External.Funs.fst
index 3b84697e..65382549 100644
--- a/tests/fstar-split/misc/External.Funs.fst
+++ b/tests/fstar-split/misc/External.Funs.fst
@@ -36,9 +36,7 @@ let test_new_non_zero_u32
 (** [external::test_vec]: forward function
     Source: 'src/external.rs', lines 17:0-17:17 *)
 let test_vec : result unit =
-  let v = alloc_vec_Vec_new u32 in
-  let* _ = alloc_vec_Vec_push u32 v 0 in
-  Return ()
+  let* _ = alloc_vec_Vec_push u32 (alloc_vec_Vec_new u32) 0 in Return ()
 
 (** Unit test for [external::test_vec] *)
 let _ = assert_norm (test_vec = Return ())
diff --git a/tests/fstar-split/misc/NoNestedBorrows.fst b/tests/fstar-split/misc/NoNestedBorrows.fst
index 41bb7a06..53e1d300 100644
--- a/tests/fstar-split/misc/NoNestedBorrows.fst
+++ b/tests/fstar-split/misc/NoNestedBorrows.fst
@@ -220,9 +220,8 @@ let _ = assert_norm (test_list1 = Return ())
 (** [no_nested_borrows::test_box1]: forward function
     Source: 'src/no_nested_borrows.rs', lines 208:0-208:18 *)
 let test_box1 : result unit =
-  let b = 0 in
-  let* b1 = alloc_boxed_Box_deref_mut_back i32 b 1 in
-  let* x = alloc_boxed_Box_deref i32 b1 in
+  let* b = alloc_boxed_Box_deref_mut_back i32 0 1 in
+  let* x = alloc_boxed_Box_deref i32 b in
   if not (x = 1) then Fail Failure else Return ()
 
 (** Unit test for [no_nested_borrows::test_box1] *)
@@ -262,8 +261,7 @@ let is_cons (t : Type0) (l : list_t t) : result bool =
 (** [no_nested_borrows::test_is_cons]: forward function
     Source: 'src/no_nested_borrows.rs', lines 253:0-253:21 *)
 let test_is_cons : result unit =
-  let l = List_Nil in
-  let* b = is_cons i32 (List_Cons 0 l) in
+  let* b = is_cons i32 (List_Cons 0 List_Nil) in
   if not b then Fail Failure else Return ()
 
 (** Unit test for [no_nested_borrows::test_is_cons] *)
@@ -280,8 +278,7 @@ let split_list (t : Type0) (l : list_t t) : result (t & (list_t t)) =
 (** [no_nested_borrows::test_split_list]: forward function
     Source: 'src/no_nested_borrows.rs', lines 267:0-267:24 *)
 let test_split_list : result unit =
-  let l = List_Nil in
-  let* p = split_list i32 (List_Cons 0 l) in
+  let* p = split_list i32 (List_Cons 0 List_Nil) in
   let (hd, _) = p in
   if not (hd = 0) then Fail Failure else Return ()
 
@@ -393,26 +390,25 @@ let list_rev (t : Type0) (l : list_t t) : result (list_t t) =
 (** [no_nested_borrows::test_list_functions]: forward function
     Source: 'src/no_nested_borrows.rs', lines 398:0-398:28 *)
 let test_list_functions : result unit =
-  let l = List_Nil in
-  let l1 = List_Cons 2 l in
-  let l2 = List_Cons 1 l1 in
-  let* i = list_length i32 (List_Cons 0 l2) in
+  let l = List_Cons 2 List_Nil in
+  let l1 = List_Cons 1 l in
+  let* i = list_length i32 (List_Cons 0 l1) in
   if not (i = 3)
   then Fail Failure
   else
-    let* i1 = list_nth_shared i32 (List_Cons 0 l2) 0 in
+    let* i1 = list_nth_shared i32 (List_Cons 0 l1) 0 in
     if not (i1 = 0)
     then Fail Failure
     else
-      let* i2 = list_nth_shared i32 (List_Cons 0 l2) 1 in
+      let* i2 = list_nth_shared i32 (List_Cons 0 l1) 1 in
       if not (i2 = 1)
       then Fail Failure
       else
-        let* i3 = list_nth_shared i32 (List_Cons 0 l2) 2 in
+        let* i3 = list_nth_shared i32 (List_Cons 0 l1) 2 in
         if not (i3 = 2)
         then Fail Failure
         else
-          let* ls = list_nth_mut_back i32 (List_Cons 0 l2) 1 3 in
+          let* ls = list_nth_mut_back i32 (List_Cons 0 l1) 1 3 in
           let* i4 = list_nth_shared i32 ls 0 in
           if not (i4 = 0)
           then Fail Failure
diff --git a/tests/fstar-split/misc/Paper.fst b/tests/fstar-split/misc/Paper.fst
index 2dc804de..0c44d78b 100644
--- a/tests/fstar-split/misc/Paper.fst
+++ b/tests/fstar-split/misc/Paper.fst
@@ -87,13 +87,12 @@ let rec sum (l : list_t i32) : result i32 =
 (** [paper::test_nth]: forward function
     Source: 'src/paper.rs', lines 68:0-68:17 *)
 let test_nth : result unit =
-  let l = List_Nil in
-  let l1 = List_Cons 3 l in
-  let l2 = List_Cons 2 l1 in
-  let* x = list_nth_mut i32 (List_Cons 1 l2) 2 in
+  let l = List_Cons 3 List_Nil in
+  let l1 = List_Cons 2 l in
+  let* x = list_nth_mut i32 (List_Cons 1 l1) 2 in
   let* x1 = i32_add x 1 in
-  let* l3 = list_nth_mut_back i32 (List_Cons 1 l2) 2 x1 in
-  let* i = sum l3 in
+  let* l2 = list_nth_mut_back i32 (List_Cons 1 l1) 2 x1 in
+  let* i = sum l2 in
   if not (i = 7) then Fail Failure else Return ()
 
 (** Unit test for [paper::test_nth] *)
diff --git a/tests/fstar-split/traits/Traits.fst b/tests/fstar-split/traits/Traits.fst
index 29a001b2..d3847590 100644
--- a/tests/fstar-split/traits/Traits.fst
+++ b/tests/fstar-split/traits/Traits.fst
@@ -274,7 +274,7 @@ let use_with_const_ty1
   (h : Type0) (len : usize) (withConstTyHLENInst : withConstTy_t h len) :
   result usize
   =
-  let i = withConstTyHLENInst.cLEN1 in Return i
+  Return withConstTyHLENInst.cLEN1
 
 (** [traits::use_with_const_ty2]: forward function
     Source: 'src/traits.rs', lines 187:0-187:73 *)
diff --git a/tests/fstar/array/Array.Funs.fst b/tests/fstar/array/Array.Funs.fst
index da4164bc..4193ba7d 100644
--- a/tests/fstar/array/Array.Funs.fst
+++ b/tests/fstar/array/Array.Funs.fst
@@ -24,8 +24,7 @@ let array_to_mut_slice_
   result ((slice t) & (slice t -> result (array t 32)))
   =
   let* (s1, to_slice_mut_back) = array_to_slice_mut t 32 s in
-  let back = fun ret -> to_slice_mut_back ret in
-  Return (s1, back)
+  Return (s1, to_slice_mut_back)
 
 (** [array::array_len]:
     Source: 'src/array.rs', lines 25:0-25:40 *)
@@ -64,8 +63,7 @@ let index_mut_array
   result (t & (t -> result (array t 32)))
   =
   let* (x, index_mut_back) = array_index_mut_usize t 32 s i in
-  let back = fun ret -> index_mut_back ret in
-  Return (x, back)
+  Return (x, index_mut_back)
 
 (** [array::index_slice]:
     Source: 'src/array.rs', lines 56:0-56:46 *)
@@ -79,8 +77,7 @@ let index_mut_slice
   result (t & (t -> result (slice t)))
   =
   let* (x, index_mut_back) = slice_index_mut_usize t s i in
-  let back = fun ret -> index_mut_back ret in
-  Return (x, back)
+  Return (x, index_mut_back)
 
 (** [array::slice_subslice_shared_]:
     Source: 'src/array.rs', lines 64:0-64:70 *)
@@ -100,8 +97,7 @@ let slice_subslice_mut_
     core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
       (core_slice_index_SliceIndexRangeUsizeSliceTInst u32) x
       { start = y; end_ = z } in
-  let back = fun ret -> index_mut_back ret in
-  Return (s, back)
+  Return (s, index_mut_back)
 
 (** [array::array_to_slice_shared_]:
     Source: 'src/array.rs', lines 72:0-72:54 *)
@@ -115,8 +111,7 @@ let array_to_slice_mut_
   result ((slice u32) & (slice u32 -> result (array u32 32)))
   =
   let* (s, to_slice_mut_back) = array_to_slice_mut u32 32 x in
-  let back = fun ret -> to_slice_mut_back ret in
-  Return (s, back)
+  Return (s, to_slice_mut_back)
 
 (** [array::array_subslice_shared_]:
     Source: 'src/array.rs', lines 80:0-80:74 *)
@@ -138,8 +133,7 @@ let array_subslice_mut_
       (core_ops_index_IndexMutSliceTIInst u32 (core_ops_range_Range usize)
       (core_slice_index_SliceIndexRangeUsizeSliceTInst u32)) x
       { start = y; end_ = z } in
-  let back = fun ret -> index_mut_back ret in
-  Return (s, back)
+  Return (s, index_mut_back)
 
 (** [array::index_slice_0]:
     Source: 'src/array.rs', lines 88:0-88:38 *)
diff --git a/tests/fstar/betree/BetreeMain.Funs.fst b/tests/fstar/betree/BetreeMain.Funs.fst
index a3065f3d..196f120c 100644
--- a/tests/fstar/betree/BetreeMain.Funs.fst
+++ b/tests/fstar/betree/BetreeMain.Funs.fst
@@ -103,8 +103,7 @@ let rec betree_List_split_at
       let* i = u64_sub n 1 in
       let* p = betree_List_split_at t tl i in
       let (ls0, ls1) = p in
-      let l = ls0 in
-      Return (Betree_List_Cons hd l, ls1)
+      Return (Betree_List_Cons hd ls0, ls1)
     | Betree_List_Nil -> Fail Failure
     end
 
@@ -113,8 +112,7 @@ let rec betree_List_split_at
 let betree_List_push_front
   (t : Type0) (self : betree_List_t t) (x : t) : result (betree_List_t t) =
   let (tl, _) = core_mem_replace (betree_List_t t) self Betree_List_Nil in
-  let l = tl in
-  Return (Betree_List_Cons x l)
+  Return (Betree_List_Cons x tl)
 
 (** [betree_main::betree::{betree_main::betree::List<T>#1}::pop_front]:
     Source: 'src/betree.rs', lines 306:4-306:32 *)
@@ -158,8 +156,7 @@ let rec betree_ListTupleU64T_partition_at_pivot
     else
       let* p = betree_ListTupleU64T_partition_at_pivot t tl pivot in
       let (ls0, ls1) = p in
-      let l = ls0 in
-      Return (Betree_List_Cons (i, x) l, ls1)
+      Return (Betree_List_Cons (i, x) ls0, ls1)
   | Betree_List_Nil -> Return (Betree_List_Nil, Betree_List_Nil)
   end
 
@@ -195,9 +192,7 @@ let rec betree_Node_lookup_first_message_for_key
   | Betree_List_Cons x next_msgs ->
     let (i, m) = x in
     if i >= key
-    then
-      let back_'a = fun ret -> Return ret in
-      Return (Betree_List_Cons (i, m) next_msgs, back_'a)
+    then Return (Betree_List_Cons (i, m) next_msgs, Return)
     else
       let* (l, lookup_first_message_for_key_back) =
         betree_Node_lookup_first_message_for_key key next_msgs in
@@ -206,8 +201,7 @@ let rec betree_Node_lookup_first_message_for_key
           let* next_msgs1 = lookup_first_message_for_key_back ret in
           Return (Betree_List_Cons (i, m) next_msgs1) in
       Return (l, back_'a)
-  | Betree_List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (Betree_List_Nil, back_'a)
+  | Betree_List_Nil -> Return (Betree_List_Nil, Return)
   end
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::lookup_in_bindings]:
@@ -362,11 +356,8 @@ let rec betree_Node_lookup_first_message_after_key
           let* next_msgs1 = lookup_first_message_after_key_back ret in
           Return (Betree_List_Cons (k, m) next_msgs1) in
       Return (l, back_'a)
-    else
-      let back_'a = fun ret -> Return ret in
-      Return (Betree_List_Cons (k, m) next_msgs, back_'a)
-  | Betree_List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (Betree_List_Nil, back_'a)
+    else Return (Betree_List_Cons (k, m) next_msgs, Return)
+  | Betree_List_Nil -> Return (Betree_List_Nil, Return)
   end
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::apply_to_internal]:
@@ -455,9 +446,7 @@ let rec betree_Node_lookup_mut_in_bindings
   | Betree_List_Cons hd tl ->
     let (i, i1) = hd in
     if i >= key
-    then
-      let back_'a = fun ret -> Return ret in
-      Return (Betree_List_Cons (i, i1) tl, back_'a)
+    then Return (Betree_List_Cons (i, i1) tl, Return)
     else
       let* (l, lookup_mut_in_bindings_back) =
         betree_Node_lookup_mut_in_bindings key tl in
@@ -466,8 +455,7 @@ let rec betree_Node_lookup_mut_in_bindings
           let* tl1 = lookup_mut_in_bindings_back ret in
           Return (Betree_List_Cons (i, i1) tl1) in
       Return (l, back_'a)
-  | Betree_List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (Betree_List_Nil, back_'a)
+  | Betree_List_Nil -> Return (Betree_List_Nil, Return)
   end
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::apply_to_leaf]:
@@ -608,10 +596,9 @@ let betree_Node_apply
   (new_msg : betree_Message_t) (st : state) :
   result (state & (betree_Node_t & betree_NodeIdCounter_t))
   =
-  let l = Betree_List_Nil in
   let* (st1, p) =
     betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
-      new_msg) l) st in
+      new_msg) Betree_List_Nil) st in
   let (self1, node_id_cnt1) = p in
   Return (st1, (self1, node_id_cnt1))
 
diff --git a/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst b/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst
index a3065f3d..196f120c 100644
--- a/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst
+++ b/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst
@@ -103,8 +103,7 @@ let rec betree_List_split_at
       let* i = u64_sub n 1 in
       let* p = betree_List_split_at t tl i in
       let (ls0, ls1) = p in
-      let l = ls0 in
-      Return (Betree_List_Cons hd l, ls1)
+      Return (Betree_List_Cons hd ls0, ls1)
     | Betree_List_Nil -> Fail Failure
     end
 
@@ -113,8 +112,7 @@ let rec betree_List_split_at
 let betree_List_push_front
   (t : Type0) (self : betree_List_t t) (x : t) : result (betree_List_t t) =
   let (tl, _) = core_mem_replace (betree_List_t t) self Betree_List_Nil in
-  let l = tl in
-  Return (Betree_List_Cons x l)
+  Return (Betree_List_Cons x tl)
 
 (** [betree_main::betree::{betree_main::betree::List<T>#1}::pop_front]:
     Source: 'src/betree.rs', lines 306:4-306:32 *)
@@ -158,8 +156,7 @@ let rec betree_ListTupleU64T_partition_at_pivot
     else
       let* p = betree_ListTupleU64T_partition_at_pivot t tl pivot in
       let (ls0, ls1) = p in
-      let l = ls0 in
-      Return (Betree_List_Cons (i, x) l, ls1)
+      Return (Betree_List_Cons (i, x) ls0, ls1)
   | Betree_List_Nil -> Return (Betree_List_Nil, Betree_List_Nil)
   end
 
@@ -195,9 +192,7 @@ let rec betree_Node_lookup_first_message_for_key
   | Betree_List_Cons x next_msgs ->
     let (i, m) = x in
     if i >= key
-    then
-      let back_'a = fun ret -> Return ret in
-      Return (Betree_List_Cons (i, m) next_msgs, back_'a)
+    then Return (Betree_List_Cons (i, m) next_msgs, Return)
     else
       let* (l, lookup_first_message_for_key_back) =
         betree_Node_lookup_first_message_for_key key next_msgs in
@@ -206,8 +201,7 @@ let rec betree_Node_lookup_first_message_for_key
           let* next_msgs1 = lookup_first_message_for_key_back ret in
           Return (Betree_List_Cons (i, m) next_msgs1) in
       Return (l, back_'a)
-  | Betree_List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (Betree_List_Nil, back_'a)
+  | Betree_List_Nil -> Return (Betree_List_Nil, Return)
   end
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::lookup_in_bindings]:
@@ -362,11 +356,8 @@ let rec betree_Node_lookup_first_message_after_key
           let* next_msgs1 = lookup_first_message_after_key_back ret in
           Return (Betree_List_Cons (k, m) next_msgs1) in
       Return (l, back_'a)
-    else
-      let back_'a = fun ret -> Return ret in
-      Return (Betree_List_Cons (k, m) next_msgs, back_'a)
-  | Betree_List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (Betree_List_Nil, back_'a)
+    else Return (Betree_List_Cons (k, m) next_msgs, Return)
+  | Betree_List_Nil -> Return (Betree_List_Nil, Return)
   end
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::apply_to_internal]:
@@ -455,9 +446,7 @@ let rec betree_Node_lookup_mut_in_bindings
   | Betree_List_Cons hd tl ->
     let (i, i1) = hd in
     if i >= key
-    then
-      let back_'a = fun ret -> Return ret in
-      Return (Betree_List_Cons (i, i1) tl, back_'a)
+    then Return (Betree_List_Cons (i, i1) tl, Return)
     else
       let* (l, lookup_mut_in_bindings_back) =
         betree_Node_lookup_mut_in_bindings key tl in
@@ -466,8 +455,7 @@ let rec betree_Node_lookup_mut_in_bindings
           let* tl1 = lookup_mut_in_bindings_back ret in
           Return (Betree_List_Cons (i, i1) tl1) in
       Return (l, back_'a)
-  | Betree_List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (Betree_List_Nil, back_'a)
+  | Betree_List_Nil -> Return (Betree_List_Nil, Return)
   end
 
 (** [betree_main::betree::{betree_main::betree::Node#5}::apply_to_leaf]:
@@ -608,10 +596,9 @@ let betree_Node_apply
   (new_msg : betree_Message_t) (st : state) :
   result (state & (betree_Node_t & betree_NodeIdCounter_t))
   =
-  let l = Betree_List_Nil in
   let* (st1, p) =
     betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
-      new_msg) l) st in
+      new_msg) Betree_List_Nil) st in
   let (self1, node_id_cnt1) = p in
   Return (st1, (self1, node_id_cnt1))
 
diff --git a/tests/fstar/hashmap/Hashmap.Funs.fst b/tests/fstar/hashmap/Hashmap.Funs.fst
index 9fc5d8a0..447f9b49 100644
--- a/tests/fstar/hashmap/Hashmap.Funs.fst
+++ b/tests/fstar/hashmap/Hashmap.Funs.fst
@@ -41,8 +41,8 @@ let hashMap_new_with_capacity
   (max_load_divisor : usize) :
   result (hashMap_t t)
   =
-  let v = alloc_vec_Vec_new (list_t t) in
-  let* slots = hashMap_allocate_slots t v capacity in
+  let* slots = hashMap_allocate_slots t (alloc_vec_Vec_new (list_t t)) capacity
+    in
   let* i = usize_mul capacity max_load_dividend in
   let* i1 = usize_div i max_load_divisor in
   Return
@@ -101,7 +101,7 @@ let rec hashMap_insert_in_list_loop
     else
       let* (b, back) = hashMap_insert_in_list_loop t key value tl in
       Return (b, List_Cons ckey cvalue back)
-  | List_Nil -> let l = List_Nil in Return (true, List_Cons key value l)
+  | List_Nil -> Return (true, List_Cons key value List_Nil)
   end
 
 (** [hashmap::{hashmap::HashMap<T>}::insert_in_list]:
@@ -309,8 +309,7 @@ let hashMap_get_mut_in_list
   result (t & (t -> result (list_t t)))
   =
   let* (x, back_'a) = hashMap_get_mut_in_list_loop t ls key in
-  let back_'a1 = fun ret -> back_'a ret in
-  Return (x, back_'a1)
+  Return (x, back_'a)
 
 (** [hashmap::{hashmap::HashMap<T>}::get_mut]:
     Source: 'src/hashmap.rs', lines 257:4-257:67 *)
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst b/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst
index 3a042678..b16dcada 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst
@@ -42,8 +42,9 @@ let hashmap_HashMap_new_with_capacity
   (max_load_divisor : usize) :
   result (hashmap_HashMap_t t)
   =
-  let v = alloc_vec_Vec_new (hashmap_List_t t) in
-  let* slots = hashmap_HashMap_allocate_slots t v capacity in
+  let* slots =
+    hashmap_HashMap_allocate_slots t (alloc_vec_Vec_new (hashmap_List_t t))
+      capacity in
   let* i = usize_mul capacity max_load_dividend in
   let* i1 = usize_div i max_load_divisor in
   Return
@@ -106,7 +107,7 @@ let rec hashmap_HashMap_insert_in_list_loop
       let* (b, back) = hashmap_HashMap_insert_in_list_loop t key value tl in
       Return (b, Hashmap_List_Cons ckey cvalue back)
   | Hashmap_List_Nil ->
-    let l = Hashmap_List_Nil in Return (true, Hashmap_List_Cons key value l)
+    Return (true, Hashmap_List_Cons key value Hashmap_List_Nil)
   end
 
 (** [hashmap_main::hashmap::{hashmap_main::hashmap::HashMap<T>}::insert_in_list]:
@@ -324,8 +325,7 @@ let hashmap_HashMap_get_mut_in_list
   result (t & (t -> result (hashmap_List_t t)))
   =
   let* (x, back_'a) = hashmap_HashMap_get_mut_in_list_loop t ls key in
-  let back_'a1 = fun ret -> back_'a ret in
-  Return (x, back_'a1)
+  Return (x, back_'a)
 
 (** [hashmap_main::hashmap::{hashmap_main::hashmap::HashMap<T>}::get_mut]:
     Source: 'src/hashmap.rs', lines 257:4-257:67 *)
diff --git a/tests/fstar/misc/External.Funs.fst b/tests/fstar/misc/External.Funs.fst
index bb1b9a64..6672b523 100644
--- a/tests/fstar/misc/External.Funs.fst
+++ b/tests/fstar/misc/External.Funs.fst
@@ -22,9 +22,7 @@ let test_new_non_zero_u32
 (** [external::test_vec]:
     Source: 'src/external.rs', lines 17:0-17:17 *)
 let test_vec : result unit =
-  let v = alloc_vec_Vec_new u32 in
-  let* _ = alloc_vec_Vec_push u32 v 0 in
-  Return ()
+  let* _ = alloc_vec_Vec_push u32 (alloc_vec_Vec_new u32) 0 in Return ()
 
 (** Unit test for [external::test_vec] *)
 let _ = assert_norm (test_vec = Return ())
diff --git a/tests/fstar/misc/NoNestedBorrows.fst b/tests/fstar/misc/NoNestedBorrows.fst
index 0fd0c1dc..ffcc32f3 100644
--- a/tests/fstar/misc/NoNestedBorrows.fst
+++ b/tests/fstar/misc/NoNestedBorrows.fst
@@ -220,10 +220,9 @@ let _ = assert_norm (test_list1 = Return ())
 (** [no_nested_borrows::test_box1]:
     Source: 'src/no_nested_borrows.rs', lines 208:0-208:18 *)
 let test_box1 : result unit =
-  let b = 0 in
-  let* (_, deref_mut_back) = alloc_boxed_Box_deref_mut i32 b in
-  let* b1 = deref_mut_back 1 in
-  let* x = alloc_boxed_Box_deref i32 b1 in
+  let* (_, deref_mut_back) = alloc_boxed_Box_deref_mut i32 0 in
+  let* b = deref_mut_back 1 in
+  let* x = alloc_boxed_Box_deref i32 b in
   if not (x = 1) then Fail Failure else Return ()
 
 (** Unit test for [no_nested_borrows::test_box1] *)
@@ -263,8 +262,7 @@ let is_cons (t : Type0) (l : list_t t) : result bool =
 (** [no_nested_borrows::test_is_cons]:
     Source: 'src/no_nested_borrows.rs', lines 253:0-253:21 *)
 let test_is_cons : result unit =
-  let l = List_Nil in
-  let* b = is_cons i32 (List_Cons 0 l) in
+  let* b = is_cons i32 (List_Cons 0 List_Nil) in
   if not b then Fail Failure else Return ()
 
 (** Unit test for [no_nested_borrows::test_is_cons] *)
@@ -281,8 +279,7 @@ let split_list (t : Type0) (l : list_t t) : result (t & (list_t t)) =
 (** [no_nested_borrows::test_split_list]:
     Source: 'src/no_nested_borrows.rs', lines 267:0-267:24 *)
 let test_split_list : result unit =
-  let l = List_Nil in
-  let* p = split_list i32 (List_Cons 0 l) in
+  let* p = split_list i32 (List_Cons 0 List_Nil) in
   let (hd, _) = p in
   if not (hd = 0) then Fail Failure else Return ()
 
@@ -388,26 +385,25 @@ let list_rev (t : Type0) (l : list_t t) : result (list_t t) =
 (** [no_nested_borrows::test_list_functions]:
     Source: 'src/no_nested_borrows.rs', lines 398:0-398:28 *)
 let test_list_functions : result unit =
-  let l = List_Nil in
-  let l1 = List_Cons 2 l in
-  let l2 = List_Cons 1 l1 in
-  let* i = list_length i32 (List_Cons 0 l2) in
+  let l = List_Cons 2 List_Nil in
+  let l1 = List_Cons 1 l in
+  let* i = list_length i32 (List_Cons 0 l1) in
   if not (i = 3)
   then Fail Failure
   else
-    let* i1 = list_nth_shared i32 (List_Cons 0 l2) 0 in
+    let* i1 = list_nth_shared i32 (List_Cons 0 l1) 0 in
     if not (i1 = 0)
     then Fail Failure
     else
-      let* i2 = list_nth_shared i32 (List_Cons 0 l2) 1 in
+      let* i2 = list_nth_shared i32 (List_Cons 0 l1) 1 in
       if not (i2 = 1)
       then Fail Failure
       else
-        let* i3 = list_nth_shared i32 (List_Cons 0 l2) 2 in
+        let* i3 = list_nth_shared i32 (List_Cons 0 l1) 2 in
         if not (i3 = 2)
         then Fail Failure
         else
-          let* (_, list_nth_mut_back) = list_nth_mut i32 (List_Cons 0 l2) 1 in
+          let* (_, list_nth_mut_back) = list_nth_mut i32 (List_Cons 0 l1) 1 in
           let* ls = list_nth_mut_back 3 in
           let* i4 = list_nth_shared i32 ls 0 in
           if not (i4 = 0)
@@ -448,9 +444,7 @@ let id_mut_pair3
   (t1 t2 : Type0) (x : t1) (y : t2) :
   result ((t1 & t2) & (t1 -> result t1) & (t2 -> result t2))
   =
-  let back_'a = fun ret -> Return ret in
-  let back_'b = fun ret -> Return ret in
-  Return ((x, y), back_'a, back_'b)
+  Return ((x, y), Return, Return)
 
 (** [no_nested_borrows::id_mut_pair4]:
     Source: 'src/no_nested_borrows.rs', lines 426:0-426:92 *)
@@ -458,10 +452,7 @@ let id_mut_pair4
   (t1 t2 : Type0) (p : (t1 & t2)) :
   result ((t1 & t2) & (t1 -> result t1) & (t2 -> result t2))
   =
-  let (x, x1) = p in
-  let back_'a = fun ret -> Return ret in
-  let back_'b = fun ret -> Return ret in
-  Return ((x, x1), back_'a, back_'b)
+  let (x, x1) = p in Return ((x, x1), Return, Return)
 
 (** [no_nested_borrows::StructWithTuple]
     Source: 'src/no_nested_borrows.rs', lines 433:0-433:34 *)
diff --git a/tests/fstar/misc/Paper.fst b/tests/fstar/misc/Paper.fst
index c6082929..cf4dc454 100644
--- a/tests/fstar/misc/Paper.fst
+++ b/tests/fstar/misc/Paper.fst
@@ -80,13 +80,12 @@ let rec sum (l : list_t i32) : result i32 =
 (** [paper::test_nth]:
     Source: 'src/paper.rs', lines 68:0-68:17 *)
 let test_nth : result unit =
-  let l = List_Nil in
-  let l1 = List_Cons 3 l in
-  let l2 = List_Cons 2 l1 in
-  let* (x, list_nth_mut_back) = list_nth_mut i32 (List_Cons 1 l2) 2 in
+  let l = List_Cons 3 List_Nil in
+  let l1 = List_Cons 2 l in
+  let* (x, list_nth_mut_back) = list_nth_mut i32 (List_Cons 1 l1) 2 in
   let* x1 = i32_add x 1 in
-  let* l3 = list_nth_mut_back x1 in
-  let* i = sum l3 in
+  let* l2 = list_nth_mut_back x1 in
+  let* i = sum l2 in
   if not (i = 7) then Fail Failure else Return ()
 
 (** Unit test for [paper::test_nth] *)
diff --git a/tests/fstar/misc/PoloniusList.fst b/tests/fstar/misc/PoloniusList.fst
index cbe7d6b8..b477802b 100644
--- a/tests/fstar/misc/PoloniusList.fst
+++ b/tests/fstar/misc/PoloniusList.fst
@@ -20,15 +20,13 @@ let rec get_list_at_x
   begin match ls with
   | List_Cons hd tl ->
     if hd = x
-    then
-      let back_'a = fun ret -> Return ret in Return (List_Cons hd tl, back_'a)
+    then Return (List_Cons hd tl, Return)
     else
       let* (l, get_list_at_x_back) = get_list_at_x tl x in
       let back_'a =
         fun ret ->
           let* tl1 = get_list_at_x_back ret in Return (List_Cons hd tl1) in
       Return (l, back_'a)
-  | List_Nil ->
-    let back_'a = fun ret -> Return ret in Return (List_Nil, back_'a)
+  | List_Nil -> Return (List_Nil, Return)
   end
 
diff --git a/tests/fstar/traits/Traits.fst b/tests/fstar/traits/Traits.fst
index 3543bd73..cb9c1654 100644
--- a/tests/fstar/traits/Traits.fst
+++ b/tests/fstar/traits/Traits.fst
@@ -273,7 +273,7 @@ let use_with_const_ty1
   (h : Type0) (len : usize) (withConstTyHLENInst : withConstTy_t h len) :
   result usize
   =
-  let i = withConstTyHLENInst.cLEN1 in Return i
+  Return withConstTyHLENInst.cLEN1
 
 (** [traits::use_with_const_ty2]:
     Source: 'src/traits.rs', lines 187:0-187:73 *)
diff --git a/tests/lean/Array.lean b/tests/lean/Array.lean
index 20f3425e..7785a208 100644
--- a/tests/lean/Array.lean
+++ b/tests/lean/Array.lean
@@ -30,8 +30,7 @@ def array_to_mut_slice_
   :=
   do
   let (s1, to_slice_mut_back) ← Array.to_slice_mut T 32#usize s
-  let back := fun ret => to_slice_mut_back ret
-  Result.ret (s1, back)
+  Result.ret (s1, to_slice_mut_back)
 
 /- [array::array_len]:
    Source: 'src/array.rs', lines 25:0-25:40 -/
@@ -79,8 +78,7 @@ def index_mut_array
   :=
   do
   let (t, index_mut_back) ← Array.index_mut_usize T 32#usize s i
-  let back := fun ret => index_mut_back ret
-  Result.ret (t, back)
+  Result.ret (t, index_mut_back)
 
 /- [array::index_slice]:
    Source: 'src/array.rs', lines 56:0-56:46 -/
@@ -95,8 +93,7 @@ def index_mut_slice
   :=
   do
   let (t, index_mut_back) ← Slice.index_mut_usize T s i
-  let back := fun ret => index_mut_back ret
-  Result.ret (t, back)
+  Result.ret (t, index_mut_back)
 
 /- [array::slice_subslice_shared_]:
    Source: 'src/array.rs', lines 64:0-64:70 -/
@@ -117,8 +114,7 @@ def slice_subslice_mut_
     core.slice.index.Slice.index_mut U32 (core.ops.range.Range Usize)
       (core.slice.index.SliceIndexRangeUsizeSliceTInst U32) x
       { start := y, end_ := z }
-  let back := fun ret => index_mut_back ret
-  Result.ret (s, back)
+  Result.ret (s, index_mut_back)
 
 /- [array::array_to_slice_shared_]:
    Source: 'src/array.rs', lines 72:0-72:54 -/
@@ -133,8 +129,7 @@ def array_to_slice_mut_
   :=
   do
   let (s, to_slice_mut_back) ← Array.to_slice_mut U32 32#usize x
-  let back := fun ret => to_slice_mut_back ret
-  Result.ret (s, back)
+  Result.ret (s, to_slice_mut_back)
 
 /- [array::array_subslice_shared_]:
    Source: 'src/array.rs', lines 80:0-80:74 -/
@@ -157,8 +152,7 @@ def array_subslice_mut_
       (core.ops.index.IndexMutSliceTIInst U32 (core.ops.range.Range Usize)
       (core.slice.index.SliceIndexRangeUsizeSliceTInst U32)) x
       { start := y, end_ := z }
-  let back := fun ret => index_mut_back ret
-  Result.ret (s, back)
+  Result.ret (s, index_mut_back)
 
 /- [array::index_slice_0]:
    Source: 'src/array.rs', lines 88:0-88:38 -/
diff --git a/tests/lean/BetreeMain/Funs.lean b/tests/lean/BetreeMain/Funs.lean
index 4e64d217..96daa197 100644
--- a/tests/lean/BetreeMain/Funs.lean
+++ b/tests/lean/BetreeMain/Funs.lean
@@ -107,8 +107,7 @@ divergent def betree.List.split_at
       let i ← n - 1#u64
       let p ← betree.List.split_at T tl i
       let (ls0, ls1) := p
-      let l := ls0
-      Result.ret (betree.List.Cons hd l, ls1)
+      Result.ret (betree.List.Cons hd ls0, ls1)
     | betree.List.Nil => Result.fail .panic
 
 /- [betree_main::betree::{betree_main::betree::List<T>#1}::push_front]:
@@ -116,8 +115,7 @@ divergent def betree.List.split_at
 def betree.List.push_front
   (T : Type) (self : betree.List T) (x : T) : Result (betree.List T) :=
   let (tl, _) := core.mem.replace (betree.List T) self betree.List.Nil
-  let l := tl
-  Result.ret (betree.List.Cons x l)
+  Result.ret (betree.List.Cons x tl)
 
 /- [betree_main::betree::{betree_main::betree::List<T>#1}::pop_front]:
    Source: 'src/betree.rs', lines 306:4-306:32 -/
@@ -159,8 +157,7 @@ divergent def betree.ListTupleU64T.partition_at_pivot
       do
       let p ← betree.ListTupleU64T.partition_at_pivot T tl pivot
       let (ls0, ls1) := p
-      let l := ls0
-      Result.ret (betree.List.Cons (i, t) l, ls1)
+      Result.ret (betree.List.Cons (i, t) ls0, ls1)
   | betree.List.Nil => Result.ret (betree.List.Nil, betree.List.Nil)
 
 /- [betree_main::betree::{betree_main::betree::Leaf#3}::split]:
@@ -194,9 +191,7 @@ divergent def betree.Node.lookup_first_message_for_key
   | betree.List.Cons x next_msgs =>
     let (i, m) := x
     if i >= key
-    then
-      let back_'a := fun ret => Result.ret ret
-      Result.ret (betree.List.Cons (i, m) next_msgs, back_'a)
+    then Result.ret (betree.List.Cons (i, m) next_msgs, Result.ret)
     else
       do
       let (l, lookup_first_message_for_key_back) ←
@@ -207,9 +202,7 @@ divergent def betree.Node.lookup_first_message_for_key
           let next_msgs1 ← lookup_first_message_for_key_back ret
           Result.ret (betree.List.Cons (i, m) next_msgs1)
       Result.ret (l, back_'a)
-  | betree.List.Nil =>
-    let back_'a := fun ret => Result.ret ret
-    Result.ret (betree.List.Nil, back_'a)
+  | betree.List.Nil => Result.ret (betree.List.Nil, Result.ret)
 
 /- [betree_main::betree::{betree_main::betree::Node#5}::lookup_in_bindings]:
    Source: 'src/betree.rs', lines 636:4-636:80 -/
@@ -381,12 +374,8 @@ divergent def betree.Node.lookup_first_message_after_key
           let next_msgs1 ← lookup_first_message_after_key_back ret
           Result.ret (betree.List.Cons (k, m) next_msgs1)
       Result.ret (l, back_'a)
-    else
-      let back_'a := fun ret => Result.ret ret
-      Result.ret (betree.List.Cons (k, m) next_msgs, back_'a)
-  | betree.List.Nil =>
-    let back_'a := fun ret => Result.ret ret
-    Result.ret (betree.List.Nil, back_'a)
+    else Result.ret (betree.List.Cons (k, m) next_msgs, Result.ret)
+  | betree.List.Nil => Result.ret (betree.List.Nil, Result.ret)
 
 /- [betree_main::betree::{betree_main::betree::Node#5}::apply_to_internal]:
    Source: 'src/betree.rs', lines 521:4-521:89 -/
@@ -478,9 +467,7 @@ divergent def betree.Node.lookup_mut_in_bindings
   | betree.List.Cons hd tl =>
     let (i, i1) := hd
     if i >= key
-    then
-      let back_'a := fun ret => Result.ret ret
-      Result.ret (betree.List.Cons (i, i1) tl, back_'a)
+    then Result.ret (betree.List.Cons (i, i1) tl, Result.ret)
     else
       do
       let (l, lookup_mut_in_bindings_back) ←
@@ -491,9 +478,7 @@ divergent def betree.Node.lookup_mut_in_bindings
           let tl1 ← lookup_mut_in_bindings_back ret
           Result.ret (betree.List.Cons (i, i1) tl1)
       Result.ret (l, back_'a)
-  | betree.List.Nil =>
-    let back_'a := fun ret => Result.ret ret
-    Result.ret (betree.List.Nil, back_'a)
+  | betree.List.Nil => Result.ret (betree.List.Nil, Result.ret)
 
 /- [betree_main::betree::{betree_main::betree::Node#5}::apply_to_leaf]:
    Source: 'src/betree.rs', lines 460:4-460:87 -/
@@ -650,10 +635,9 @@ def betree.Node.apply
   Result (State × (betree.Node × betree.NodeIdCounter))
   :=
   do
-  let l := betree.List.Nil
   let (st1, p) ←
     betree.Node.apply_messages self params node_id_cnt (betree.List.Cons (key,
-      new_msg) l) st
+      new_msg) betree.List.Nil) st
   let (self1, node_id_cnt1) := p
   Result.ret (st1, (self1, node_id_cnt1))
 
diff --git a/tests/lean/External/Funs.lean b/tests/lean/External/Funs.lean
index 88ced82d..db15aacc 100644
--- a/tests/lean/External/Funs.lean
+++ b/tests/lean/External/Funs.lean
@@ -25,8 +25,7 @@ def test_new_non_zero_u32
    Source: 'src/external.rs', lines 17:0-17:17 -/
 def test_vec : Result Unit :=
   do
-  let v := alloc.vec.Vec.new U32
-  let _ ← alloc.vec.Vec.push U32 v 0#u32
+  let _ ← alloc.vec.Vec.push U32 (alloc.vec.Vec.new U32) 0#u32
   Result.ret ()
 
 /- Unit test for [external::test_vec] -/
diff --git a/tests/lean/Hashmap/Funs.lean b/tests/lean/Hashmap/Funs.lean
index 32ed2b33..3978bfc7 100644
--- a/tests/lean/Hashmap/Funs.lean
+++ b/tests/lean/Hashmap/Funs.lean
@@ -41,8 +41,7 @@ def HashMap.new_with_capacity
   Result (HashMap T)
   :=
   do
-  let v := alloc.vec.Vec.new (List T)
-  let slots ← HashMap.allocate_slots T v capacity
+  let slots ← HashMap.allocate_slots T (alloc.vec.Vec.new (List T)) capacity
   let i ← capacity * max_load_dividend
   let i1 ← i / max_load_divisor
   Result.ret
@@ -102,8 +101,7 @@ divergent def HashMap.insert_in_list_loop
       do
       let (b, back) ← HashMap.insert_in_list_loop T key value tl
       Result.ret (b, List.Cons ckey cvalue back)
-  | List.Nil => let l := List.Nil
-                Result.ret (true, List.Cons key value l)
+  | List.Nil => Result.ret (true, List.Cons key value List.Nil)
 
 /- [hashmap::{hashmap::HashMap<T>}::insert_in_list]:
    Source: 'src/hashmap.rs', lines 97:4-97:71 -/
@@ -315,8 +313,7 @@ def HashMap.get_mut_in_list
   :=
   do
   let (t, back_'a) ← HashMap.get_mut_in_list_loop T ls key
-  let back_'a1 := fun ret => back_'a ret
-  Result.ret (t, back_'a1)
+  Result.ret (t, back_'a)
 
 /- [hashmap::{hashmap::HashMap<T>}::get_mut]:
    Source: 'src/hashmap.rs', lines 257:4-257:67 -/
diff --git a/tests/lean/HashmapMain/Funs.lean b/tests/lean/HashmapMain/Funs.lean
index 9bfb5070..ebed2570 100644
--- a/tests/lean/HashmapMain/Funs.lean
+++ b/tests/lean/HashmapMain/Funs.lean
@@ -42,8 +42,9 @@ def hashmap.HashMap.new_with_capacity
   Result (hashmap.HashMap T)
   :=
   do
-  let v := alloc.vec.Vec.new (hashmap.List T)
-  let slots ← hashmap.HashMap.allocate_slots T v capacity
+  let slots ←
+    hashmap.HashMap.allocate_slots T (alloc.vec.Vec.new (hashmap.List T))
+      capacity
   let i ← capacity * max_load_dividend
   let i1 ← i / max_load_divisor
   Result.ret
@@ -105,8 +106,7 @@ divergent def hashmap.HashMap.insert_in_list_loop
       let (b, back) ← hashmap.HashMap.insert_in_list_loop T key value tl
       Result.ret (b, hashmap.List.Cons ckey cvalue back)
   | hashmap.List.Nil =>
-    let l := hashmap.List.Nil
-    Result.ret (true, hashmap.List.Cons key value l)
+    Result.ret (true, hashmap.List.Cons key value hashmap.List.Nil)
 
 /- [hashmap_main::hashmap::{hashmap_main::hashmap::HashMap<T>}::insert_in_list]:
    Source: 'src/hashmap.rs', lines 97:4-97:71 -/
@@ -328,8 +328,7 @@ def hashmap.HashMap.get_mut_in_list
   :=
   do
   let (t, back_'a) ← hashmap.HashMap.get_mut_in_list_loop T ls key
-  let back_'a1 := fun ret => back_'a ret
-  Result.ret (t, back_'a1)
+  Result.ret (t, back_'a)
 
 /- [hashmap_main::hashmap::{hashmap_main::hashmap::HashMap<T>}::get_mut]:
    Source: 'src/hashmap.rs', lines 257:4-257:67 -/
diff --git a/tests/lean/NoNestedBorrows.lean b/tests/lean/NoNestedBorrows.lean
index cb0aac10..0dd29429 100644
--- a/tests/lean/NoNestedBorrows.lean
+++ b/tests/lean/NoNestedBorrows.lean
@@ -244,10 +244,9 @@ def test_list1 : Result Unit :=
    Source: 'src/no_nested_borrows.rs', lines 208:0-208:18 -/
 def test_box1 : Result Unit :=
   do
-  let b := 0#i32
-  let (_, deref_mut_back) ← alloc.boxed.Box.deref_mut I32 b
-  let b1 ← deref_mut_back 1#i32
-  let x ← alloc.boxed.Box.deref I32 b1
+  let (_, deref_mut_back) ← alloc.boxed.Box.deref_mut I32 0#i32
+  let b ← deref_mut_back 1#i32
+  let x ← alloc.boxed.Box.deref I32 b
   if not (x = 1#i32)
   then Result.fail .panic
   else Result.ret ()
@@ -297,8 +296,7 @@ def is_cons (T : Type) (l : List T) : Result Bool :=
    Source: 'src/no_nested_borrows.rs', lines 253:0-253:21 -/
 def test_is_cons : Result Unit :=
   do
-  let l := List.Nil
-  let b ← is_cons I32 (List.Cons 0#i32 l)
+  let b ← is_cons I32 (List.Cons 0#i32 List.Nil)
   if not b
   then Result.fail .panic
   else Result.ret ()
@@ -317,8 +315,7 @@ def split_list (T : Type) (l : List T) : Result (T × (List T)) :=
    Source: 'src/no_nested_borrows.rs', lines 267:0-267:24 -/
 def test_split_list : Result Unit :=
   do
-  let l := List.Nil
-  let p ← split_list I32 (List.Cons 0#i32 l)
+  let p ← split_list I32 (List.Cons 0#i32 List.Nil)
   let (hd, _) := p
   if not (hd = 0#i32)
   then Result.fail .panic
@@ -441,31 +438,30 @@ def list_rev (T : Type) (l : List T) : Result (List T) :=
    Source: 'src/no_nested_borrows.rs', lines 398:0-398:28 -/
 def test_list_functions : Result Unit :=
   do
-  let l := List.Nil
-  let l1 := List.Cons 2#i32 l
-  let l2 := List.Cons 1#i32 l1
-  let i ← list_length I32 (List.Cons 0#i32 l2)
+  let l := List.Cons 2#i32 List.Nil
+  let l1 := List.Cons 1#i32 l
+  let i ← list_length I32 (List.Cons 0#i32 l1)
   if not (i = 3#u32)
   then Result.fail .panic
   else
     do
-    let i1 ← list_nth_shared I32 (List.Cons 0#i32 l2) 0#u32
+    let i1 ← list_nth_shared I32 (List.Cons 0#i32 l1) 0#u32
     if not (i1 = 0#i32)
     then Result.fail .panic
     else
       do
-      let i2 ← list_nth_shared I32 (List.Cons 0#i32 l2) 1#u32
+      let i2 ← list_nth_shared I32 (List.Cons 0#i32 l1) 1#u32
       if not (i2 = 1#i32)
       then Result.fail .panic
       else
         do
-        let i3 ← list_nth_shared I32 (List.Cons 0#i32 l2) 2#u32
+        let i3 ← list_nth_shared I32 (List.Cons 0#i32 l1) 2#u32
         if not (i3 = 2#i32)
         then Result.fail .panic
         else
           do
           let (_, list_nth_mut_back) ←
-            list_nth_mut I32 (List.Cons 0#i32 l2) 1#u32
+            list_nth_mut I32 (List.Cons 0#i32 l1) 1#u32
           let ls ← list_nth_mut_back 3#i32
           let i4 ← list_nth_shared I32 ls 0#u32
           if not (i4 = 0#i32)
@@ -512,9 +508,7 @@ def id_mut_pair3
   (T1 T2 : Type) (x : T1) (y : T2) :
   Result ((T1 × T2) × (T1 → Result T1) × (T2 → Result T2))
   :=
-  let back_'a := fun ret => Result.ret ret
-  let back_'b := fun ret => Result.ret ret
-  Result.ret ((x, y), back_'a, back_'b)
+  Result.ret ((x, y), Result.ret, Result.ret)
 
 /- [no_nested_borrows::id_mut_pair4]:
    Source: 'src/no_nested_borrows.rs', lines 426:0-426:92 -/
@@ -523,9 +517,7 @@ def id_mut_pair4
   Result ((T1 × T2) × (T1 → Result T1) × (T2 → Result T2))
   :=
   let (t, t1) := p
-  let back_'a := fun ret => Result.ret ret
-  let back_'b := fun ret => Result.ret ret
-  Result.ret ((t, t1), back_'a, back_'b)
+  Result.ret ((t, t1), Result.ret, Result.ret)
 
 /- [no_nested_borrows::StructWithTuple]
    Source: 'src/no_nested_borrows.rs', lines 433:0-433:34 -/
diff --git a/tests/lean/Paper.lean b/tests/lean/Paper.lean
index 015fec84..a35c8db0 100644
--- a/tests/lean/Paper.lean
+++ b/tests/lean/Paper.lean
@@ -95,13 +95,12 @@ divergent def sum (l : List I32) : Result I32 :=
    Source: 'src/paper.rs', lines 68:0-68:17 -/
 def test_nth : Result Unit :=
   do
-  let l := List.Nil
-  let l1 := List.Cons 3#i32 l
-  let l2 := List.Cons 2#i32 l1
-  let (x, list_nth_mut_back) ← list_nth_mut I32 (List.Cons 1#i32 l2) 2#u32
+  let l := List.Cons 3#i32 List.Nil
+  let l1 := List.Cons 2#i32 l
+  let (x, list_nth_mut_back) ← list_nth_mut I32 (List.Cons 1#i32 l1) 2#u32
   let x1 ← x + 1#i32
-  let l3 ← list_nth_mut_back x1
-  let i ← sum l3
+  let l2 ← list_nth_mut_back x1
+  let i ← sum l2
   if not (i = 7#i32)
   then Result.fail .panic
   else Result.ret ()
diff --git a/tests/lean/PoloniusList.lean b/tests/lean/PoloniusList.lean
index a485adbe..59c557a0 100644
--- a/tests/lean/PoloniusList.lean
+++ b/tests/lean/PoloniusList.lean
@@ -20,9 +20,7 @@ divergent def get_list_at_x
   match ls with
   | List.Cons hd tl =>
     if hd = x
-    then
-      let back_'a := fun ret => Result.ret ret
-      Result.ret (List.Cons hd tl, back_'a)
+    then Result.ret (List.Cons hd tl, Result.ret)
     else
       do
       let (l, get_list_at_x_back) ← get_list_at_x tl x
@@ -32,8 +30,6 @@ divergent def get_list_at_x
           let tl1 ← get_list_at_x_back ret
           Result.ret (List.Cons hd tl1)
       Result.ret (l, back_'a)
-  | List.Nil =>
-    let back_'a := fun ret => Result.ret ret
-    Result.ret (List.Nil, back_'a)
+  | List.Nil => Result.ret (List.Nil, Result.ret)
 
 end polonius_list
diff --git a/tests/lean/Traits.lean b/tests/lean/Traits.lean
index 63d07d85..35f9e5bf 100644
--- a/tests/lean/Traits.lean
+++ b/tests/lean/Traits.lean
@@ -288,8 +288,7 @@ def use_with_const_ty1
   (H : Type) (LEN : Usize) (WithConstTyHLENInst : WithConstTy H LEN) :
   Result Usize
   :=
-  let i := WithConstTyHLENInst.LEN1
-  Result.ret i
+  Result.ret WithConstTyHLENInst.LEN1
 
 /- [traits::use_with_const_ty2]:
    Source: 'src/traits.rs', lines 187:0-187:73 -/
-- 
cgit v1.3.1