summaryrefslogtreecommitdiff
path: root/tests/fstar
diff options
context:
space:
mode:
authorSon HO2023-11-10 18:21:06 +0100
committerGitHub2023-11-10 18:21:06 +0100
commit587f1ebc0178acb19029d3fc9a729c197082aba7 (patch)
treef29805e5426f9f3fabe12d3fdadda96a1e987880 /tests/fstar
parent7fc7c82aa61d782b335e7cf37231fd9998cd0d89 (diff)
parentd300be95c28ff3147bb6f6a65992df5b9b571bdf (diff)
Merge pull request #44 from AeneasVerif/son_traits_types
Add support for traits
Diffstat (limited to 'tests/fstar')
-rw-r--r--tests/fstar/array/Array.Clauses.Template.fst5
-rw-r--r--tests/fstar/array/Array.Funs.fst348
-rw-r--r--tests/fstar/array/Array.Types.fst4
-rw-r--r--tests/fstar/array/Primitives.fst464
-rw-r--r--tests/fstar/betree/BetreeMain.Clauses.Template.fst60
-rw-r--r--tests/fstar/betree/BetreeMain.Clauses.fst90
-rw-r--r--tests/fstar/betree/BetreeMain.Funs.fst1129
-rw-r--r--tests/fstar/betree/BetreeMain.Opaque.fsti18
-rw-r--r--tests/fstar/betree/BetreeMain.Types.fsti50
-rw-r--r--tests/fstar/betree/Primitives.fst464
-rw-r--r--tests/fstar/betree_back_stateful/BetreeMain.Clauses.Template.fst60
-rw-r--r--tests/fstar/betree_back_stateful/BetreeMain.Clauses.fst90
-rw-r--r--tests/fstar/betree_back_stateful/BetreeMain.Funs.fst1377
-rw-r--r--tests/fstar/betree_back_stateful/BetreeMain.Opaque.fsti18
-rw-r--r--tests/fstar/betree_back_stateful/BetreeMain.Types.fsti50
-rw-r--r--tests/fstar/betree_back_stateful/Primitives.fst464
-rw-r--r--tests/fstar/hashmap/Hashmap.Clauses.Template.fst26
-rw-r--r--tests/fstar/hashmap/Hashmap.Clauses.fst24
-rw-r--r--tests/fstar/hashmap/Hashmap.Funs.fst498
-rw-r--r--tests/fstar/hashmap/Hashmap.Properties.fst1648
-rw-r--r--tests/fstar/hashmap/Hashmap.Properties.fsti100
-rw-r--r--tests/fstar/hashmap/Hashmap.Types.fst14
-rw-r--r--tests/fstar/hashmap/Primitives.fst464
-rw-r--r--tests/fstar/hashmap_on_disk/HashmapMain.Clauses.Template.fst38
-rw-r--r--tests/fstar/hashmap_on_disk/HashmapMain.Clauses.fst32
-rw-r--r--tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst575
-rw-r--r--tests/fstar/hashmap_on_disk/HashmapMain.Opaque.fsti8
-rw-r--r--tests/fstar/hashmap_on_disk/HashmapMain.Properties.fst20
-rw-r--r--tests/fstar/hashmap_on_disk/HashmapMain.Types.fsti16
-rw-r--r--tests/fstar/hashmap_on_disk/Primitives.fst464
-rw-r--r--tests/fstar/misc/Constants.fst52
-rw-r--r--tests/fstar/misc/External.Funs.fst38
-rw-r--r--tests/fstar/misc/External.Opaque.fsti8
-rw-r--r--tests/fstar/misc/External.Types.fsti2
-rw-r--r--tests/fstar/misc/Loops.Clauses.Template.fst3
-rw-r--r--tests/fstar/misc/Loops.Clauses.fst2
-rw-r--r--tests/fstar/misc/Loops.Funs.fst392
-rw-r--r--tests/fstar/misc/Loops.Types.fst4
-rw-r--r--tests/fstar/misc/NoNestedBorrows.fst278
-rw-r--r--tests/fstar/misc/Paper.fst65
-rw-r--r--tests/fstar/misc/PoloniusList.fst18
-rw-r--r--tests/fstar/misc/Primitives.fst464
-rw-r--r--tests/fstar/traits/Makefile49
-rw-r--r--tests/fstar/traits/Primitives.fst729
-rw-r--r--tests/fstar/traits/Traits.fst371
45 files changed, 7128 insertions, 3965 deletions
diff --git a/tests/fstar/array/Array.Clauses.Template.fst b/tests/fstar/array/Array.Clauses.Template.fst
index 8a15e230..06056d61 100644
--- a/tests/fstar/array/Array.Clauses.Template.fst
+++ b/tests/fstar/array/Array.Clauses.Template.fst
@@ -8,11 +8,12 @@ open Array.Types
(** [array::sum]: decreases clause *)
unfold
-let sum_loop_decreases (s : slice u32) (sum : u32) (i : usize) : nat = admit ()
+let sum_loop_decreases (s : slice u32) (sum0 : u32) (i : usize) : nat =
+ admit ()
(** [array::sum2]: decreases clause *)
unfold
-let sum2_loop_decreases (s : slice u32) (s2 : slice u32) (sum : u32)
+let sum2_loop_decreases (s : slice u32) (s2 : slice u32) (sum0 : u32)
(i : usize) : nat =
admit ()
diff --git a/tests/fstar/array/Array.Funs.fst b/tests/fstar/array/Array.Funs.fst
index 7c1d0b09..8f0bfbbd 100644
--- a/tests/fstar/array/Array.Funs.fst
+++ b/tests/fstar/array/Array.Funs.fst
@@ -7,349 +7,369 @@ include Array.Clauses
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
+(** [array::incr]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+let incr (x : u32) : result u32 =
+ u32_add x 1
+
(** [array::array_to_shared_slice_]: forward function *)
-let array_to_shared_slice__fwd
- (t : Type0) (s : array t 32) : result (slice t) =
- array_to_slice_shared t 32 s
+let array_to_shared_slice_ (t : Type0) (s : array t 32) : result (slice t) =
+ array_to_slice t 32 s
(** [array::array_to_mut_slice_]: forward function *)
-let array_to_mut_slice__fwd (t : Type0) (s : array t 32) : result (slice t) =
- array_to_slice_mut_fwd t 32 s
+let array_to_mut_slice_ (t : Type0) (s : array t 32) : result (slice t) =
+ array_to_slice t 32 s
(** [array::array_to_mut_slice_]: backward function 0 *)
let array_to_mut_slice__back
(t : Type0) (s : array t 32) (ret : slice t) : result (array t 32) =
- array_to_slice_mut_back t 32 s ret
+ array_from_slice t 32 s ret
(** [array::array_len]: forward function *)
-let array_len_fwd (t : Type0) (s : array t 32) : result usize =
- let* s0 = array_to_slice_shared t 32 s in let i = slice_len t s0 in Return i
+let array_len (t : Type0) (s : array t 32) : result usize =
+ let* s0 = array_to_slice t 32 s in let i = slice_len t s0 in Return i
(** [array::shared_array_len]: forward function *)
-let shared_array_len_fwd (t : Type0) (s : array t 32) : result usize =
- let* s0 = array_to_slice_shared t 32 s in let i = slice_len t s0 in Return i
+let shared_array_len (t : Type0) (s : array t 32) : result usize =
+ let* s0 = array_to_slice t 32 s in let i = slice_len t s0 in Return i
(** [array::shared_slice_len]: forward function *)
-let shared_slice_len_fwd (t : Type0) (s : slice t) : result usize =
+let shared_slice_len (t : Type0) (s : slice t) : result usize =
let i = slice_len t s in Return i
(** [array::index_array_shared]: forward function *)
-let index_array_shared_fwd
- (t : Type0) (s : array t 32) (i : usize) : result t =
- array_index_shared t 32 s i
+let index_array_shared (t : Type0) (s : array t 32) (i : usize) : result t =
+ array_index_usize t 32 s i
(** [array::index_array_u32]: forward function *)
-let index_array_u32_fwd (s : array u32 32) (i : usize) : result u32 =
- array_index_shared u32 32 s i
-
-(** [array::index_array_generic]: forward function *)
-let index_array_generic_fwd
- (n : usize) (s : array u32 n) (i : usize) : result u32 =
- array_index_shared u32 n s i
-
-(** [array::index_array_generic_call]: forward function *)
-let index_array_generic_call_fwd
- (n : usize) (s : array u32 n) (i : usize) : result u32 =
- index_array_generic_fwd n s i
+let index_array_u32 (s : array u32 32) (i : usize) : result u32 =
+ array_index_usize u32 32 s i
(** [array::index_array_copy]: forward function *)
-let index_array_copy_fwd (x : array u32 32) : result u32 =
- array_index_shared u32 32 x 0
+let index_array_copy (x : array u32 32) : result u32 =
+ array_index_usize u32 32 x 0
(** [array::index_mut_array]: forward function *)
-let index_mut_array_fwd (t : Type0) (s : array t 32) (i : usize) : result t =
- array_index_mut_fwd t 32 s i
+let index_mut_array (t : Type0) (s : array t 32) (i : usize) : result t =
+ array_index_usize t 32 s i
(** [array::index_mut_array]: backward function 0 *)
let index_mut_array_back
(t : Type0) (s : array t 32) (i : usize) (ret : t) : result (array t 32) =
- array_index_mut_back t 32 s i ret
+ array_update_usize t 32 s i ret
(** [array::index_slice]: forward function *)
-let index_slice_fwd (t : Type0) (s : slice t) (i : usize) : result t =
- slice_index_shared t s i
+let index_slice (t : Type0) (s : slice t) (i : usize) : result t =
+ slice_index_usize t s i
(** [array::index_mut_slice]: forward function *)
-let index_mut_slice_fwd (t : Type0) (s : slice t) (i : usize) : result t =
- slice_index_mut_fwd t s i
+let index_mut_slice (t : Type0) (s : slice t) (i : usize) : result t =
+ slice_index_usize t s i
(** [array::index_mut_slice]: backward function 0 *)
let index_mut_slice_back
(t : Type0) (s : slice t) (i : usize) (ret : t) : result (slice t) =
- slice_index_mut_back t s i ret
+ slice_update_usize t s i ret
(** [array::slice_subslice_shared_]: forward function *)
-let slice_subslice_shared__fwd
+let slice_subslice_shared_
(x : slice u32) (y : usize) (z : usize) : result (slice u32) =
- slice_subslice_shared u32 x (Mkrange y z)
+ core_slice_index_Slice_index u32 (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+ { start = y; end_ = z }
(** [array::slice_subslice_mut_]: forward function *)
-let slice_subslice_mut__fwd
+let slice_subslice_mut_
(x : slice u32) (y : usize) (z : usize) : result (slice u32) =
- slice_subslice_mut_fwd u32 x (Mkrange y z)
+ core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+ { start = y; end_ = z }
(** [array::slice_subslice_mut_]: backward function 0 *)
let slice_subslice_mut__back
(x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
result (slice u32)
=
- slice_subslice_mut_back u32 x (Mkrange y z) ret
+ core_slice_index_Slice_index_mut_back u32 (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+ { start = y; end_ = z } ret
(** [array::array_to_slice_shared_]: forward function *)
-let array_to_slice_shared__fwd (x : array u32 32) : result (slice u32) =
- array_to_slice_shared u32 32 x
+let array_to_slice_shared_ (x : array u32 32) : result (slice u32) =
+ array_to_slice u32 32 x
(** [array::array_to_slice_mut_]: forward function *)
-let array_to_slice_mut__fwd (x : array u32 32) : result (slice u32) =
- array_to_slice_mut_fwd u32 32 x
+let array_to_slice_mut_ (x : array u32 32) : result (slice u32) =
+ array_to_slice u32 32 x
(** [array::array_to_slice_mut_]: backward function 0 *)
let array_to_slice_mut__back
(x : array u32 32) (ret : slice u32) : result (array u32 32) =
- array_to_slice_mut_back u32 32 x ret
+ array_from_slice u32 32 x ret
(** [array::array_subslice_shared_]: forward function *)
-let array_subslice_shared__fwd
+let array_subslice_shared_
(x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
- array_subslice_shared u32 32 x (Mkrange y z)
+ core_array_Array_index u32 (core_ops_range_Range usize) 32
+ (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ { start = y; end_ = z }
(** [array::array_subslice_mut_]: forward function *)
-let array_subslice_mut__fwd
+let array_subslice_mut_
(x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
- array_subslice_mut_fwd u32 32 x (Mkrange y z)
+ core_array_Array_index_mut u32 (core_ops_range_Range usize) 32
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ { start = y; end_ = z }
(** [array::array_subslice_mut_]: backward function 0 *)
let array_subslice_mut__back
(x : array u32 32) (y : usize) (z : usize) (ret : slice u32) :
result (array u32 32)
=
- array_subslice_mut_back u32 32 x (Mkrange y z) ret
+ core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 32
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ { start = y; end_ = z } ret
(** [array::index_slice_0]: forward function *)
-let index_slice_0_fwd (t : Type0) (s : slice t) : result t =
- slice_index_shared t s 0
+let index_slice_0 (t : Type0) (s : slice t) : result t =
+ slice_index_usize t s 0
(** [array::index_array_0]: forward function *)
-let index_array_0_fwd (t : Type0) (s : array t 32) : result t =
- array_index_shared t 32 s 0
+let index_array_0 (t : Type0) (s : array t 32) : result t =
+ array_index_usize t 32 s 0
(** [array::index_index_array]: forward function *)
-let index_index_array_fwd
+let index_index_array
(s : array (array u32 32) 32) (i : usize) (j : usize) : result u32 =
- let* a = array_index_shared (array u32 32) 32 s i in
- array_index_shared u32 32 a j
+ let* a = array_index_usize (array u32 32) 32 s i in
+ array_index_usize u32 32 a j
(** [array::update_update_array]: forward function *)
-let update_update_array_fwd
+let update_update_array
(s : array (array u32 32) 32) (i : usize) (j : usize) : result unit =
- let* a = array_index_mut_fwd (array u32 32) 32 s i in
- let* a0 = array_index_mut_back u32 32 a j 0 in
- let* _ = array_index_mut_back (array u32 32) 32 s i a0 in
+ let* a = array_index_usize (array u32 32) 32 s i in
+ let* a0 = array_update_usize u32 32 a j 0 in
+ let* _ = array_update_usize (array u32 32) 32 s i a0 in
Return ()
(** [array::array_local_deep_copy]: forward function *)
-let array_local_deep_copy_fwd (x : array u32 32) : result unit =
+let array_local_deep_copy (x : array u32 32) : result unit =
Return ()
(** [array::take_array]: forward function *)
-let take_array_fwd (a : array u32 2) : result unit =
+let take_array (a : array u32 2) : result unit =
Return ()
(** [array::take_array_borrow]: forward function *)
-let take_array_borrow_fwd (a : array u32 2) : result unit =
+let take_array_borrow (a : array u32 2) : result unit =
Return ()
(** [array::take_slice]: forward function *)
-let take_slice_fwd (s : slice u32) : result unit =
+let take_slice (s : slice u32) : result unit =
Return ()
(** [array::take_mut_slice]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let take_mut_slice_fwd_back (s : slice u32) : result (slice u32) =
+let take_mut_slice (s : slice u32) : result (slice u32) =
Return s
(** [array::take_all]: forward function *)
-let take_all_fwd : result unit =
- let* _ = take_array_fwd (mk_array u32 2 [ 0; 0 ]) in
- let* _ = take_array_borrow_fwd (mk_array u32 2 [ 0; 0 ]) in
- let* s = array_to_slice_shared u32 2 (mk_array u32 2 [ 0; 0 ]) in
- let* _ = take_slice_fwd s in
- let* s0 = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
- let* s1 = take_mut_slice_fwd_back s0 in
- let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
+let take_all : result unit =
+ let* _ = take_array (mk_array u32 2 [ 0; 0 ]) in
+ let* _ = take_array_borrow (mk_array u32 2 [ 0; 0 ]) in
+ let* s = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+ let* _ = take_slice s in
+ let* s0 = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+ let* s1 = take_mut_slice s0 in
+ let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
Return ()
(** [array::index_array]: forward function *)
-let index_array_fwd (x : array u32 2) : result u32 =
- array_index_shared u32 2 x 0
+let index_array (x : array u32 2) : result u32 =
+ array_index_usize u32 2 x 0
(** [array::index_array_borrow]: forward function *)
-let index_array_borrow_fwd (x : array u32 2) : result u32 =
- array_index_shared u32 2 x 0
+let index_array_borrow (x : array u32 2) : result u32 =
+ array_index_usize u32 2 x 0
(** [array::index_slice_u32_0]: forward function *)
-let index_slice_u32_0_fwd (x : slice u32) : result u32 =
- slice_index_shared u32 x 0
+let index_slice_u32_0 (x : slice u32) : result u32 =
+ slice_index_usize u32 x 0
(** [array::index_mut_slice_u32_0]: forward function *)
-let index_mut_slice_u32_0_fwd (x : slice u32) : result u32 =
- slice_index_shared u32 x 0
+let index_mut_slice_u32_0 (x : slice u32) : result u32 =
+ slice_index_usize u32 x 0
(** [array::index_mut_slice_u32_0]: backward function 0 *)
let index_mut_slice_u32_0_back (x : slice u32) : result (slice u32) =
- let* _ = slice_index_shared u32 x 0 in Return x
+ let* _ = slice_index_usize u32 x 0 in Return x
(** [array::index_all]: forward function *)
-let index_all_fwd : result u32 =
- let* i = index_array_fwd (mk_array u32 2 [ 0; 0 ]) in
- let* i0 = index_array_fwd (mk_array u32 2 [ 0; 0 ]) in
+let index_all : result u32 =
+ let* i = index_array (mk_array u32 2 [ 0; 0 ]) in
+ let* i0 = index_array (mk_array u32 2 [ 0; 0 ]) in
let* i1 = u32_add i i0 in
- let* i2 = index_array_borrow_fwd (mk_array u32 2 [ 0; 0 ]) in
+ let* i2 = index_array_borrow (mk_array u32 2 [ 0; 0 ]) in
let* i3 = u32_add i1 i2 in
- let* s = array_to_slice_shared u32 2 (mk_array u32 2 [ 0; 0 ]) in
- let* i4 = index_slice_u32_0_fwd s in
+ let* s = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+ let* i4 = index_slice_u32_0 s in
let* i5 = u32_add i3 i4 in
- let* s0 = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
- let* i6 = index_mut_slice_u32_0_fwd s0 in
+ let* s0 = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+ let* i6 = index_mut_slice_u32_0 s0 in
let* i7 = u32_add i5 i6 in
let* s1 = index_mut_slice_u32_0_back s0 in
- let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
+ let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
Return i7
(** [array::update_array]: forward function *)
-let update_array_fwd (x : array u32 2) : result unit =
- let* _ = array_index_mut_back u32 2 x 0 1 in Return ()
+let update_array (x : array u32 2) : result unit =
+ let* _ = array_update_usize u32 2 x 0 1 in Return ()
(** [array::update_array_mut_borrow]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let update_array_mut_borrow_fwd_back (x : array u32 2) : result (array u32 2) =
- array_index_mut_back u32 2 x 0 1
+let update_array_mut_borrow (x : array u32 2) : result (array u32 2) =
+ array_update_usize u32 2 x 0 1
(** [array::update_mut_slice]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let update_mut_slice_fwd_back (x : slice u32) : result (slice u32) =
- slice_index_mut_back u32 x 0 1
+let update_mut_slice (x : slice u32) : result (slice u32) =
+ slice_update_usize u32 x 0 1
(** [array::update_all]: forward function *)
-let update_all_fwd : result unit =
- let* _ = update_array_fwd (mk_array u32 2 [ 0; 0 ]) in
- let* x = update_array_mut_borrow_fwd_back (mk_array u32 2 [ 0; 0 ]) in
- let* s = array_to_slice_mut_fwd u32 2 x in
- let* s0 = update_mut_slice_fwd_back s in
- let* _ = array_to_slice_mut_back u32 2 x s0 in
+let update_all : result unit =
+ let* _ = update_array (mk_array u32 2 [ 0; 0 ]) in
+ let* x = update_array_mut_borrow (mk_array u32 2 [ 0; 0 ]) in
+ let* s = array_to_slice u32 2 x in
+ let* s0 = update_mut_slice s in
+ let* _ = array_from_slice u32 2 x s0 in
Return ()
(** [array::range_all]: forward function *)
-let range_all_fwd : result unit =
+let range_all : result unit =
let* s =
- array_subslice_mut_fwd u32 4 (mk_array u32 4 [ 0; 0; 0; 0 ]) (Mkrange 1 3)
- in
- let* s0 = update_mut_slice_fwd_back s in
+ core_array_Array_index_mut u32 (core_ops_range_Range usize) 4
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32
+ (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+ (mk_array u32 4 [ 0; 0; 0; 0 ]) { start = 1; end_ = 3 } in
+ let* s0 = update_mut_slice s in
let* _ =
- array_subslice_mut_back u32 4 (mk_array u32 4 [ 0; 0; 0; 0 ]) (Mkrange 1 3)
- s0 in
+ core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 4
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32
+ (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+ (mk_array u32 4 [ 0; 0; 0; 0 ]) { start = 1; end_ = 3 } s0 in
Return ()
(** [array::deref_array_borrow]: forward function *)
-let deref_array_borrow_fwd (x : array u32 2) : result u32 =
- array_index_shared u32 2 x 0
+let deref_array_borrow (x : array u32 2) : result u32 =
+ array_index_usize u32 2 x 0
(** [array::deref_array_mut_borrow]: forward function *)
-let deref_array_mut_borrow_fwd (x : array u32 2) : result u32 =
- array_index_shared u32 2 x 0
+let deref_array_mut_borrow (x : array u32 2) : result u32 =
+ array_index_usize u32 2 x 0
(** [array::deref_array_mut_borrow]: backward function 0 *)
let deref_array_mut_borrow_back (x : array u32 2) : result (array u32 2) =
- let* _ = array_index_shared u32 2 x 0 in Return x
+ let* _ = array_index_usize u32 2 x 0 in Return x
(** [array::take_array_t]: forward function *)
-let take_array_t_fwd (a : array t_t 2) : result unit =
+let take_array_t (a : array aB_t 2) : result unit =
Return ()
(** [array::non_copyable_array]: forward function *)
-let non_copyable_array_fwd : result unit =
- let* _ = take_array_t_fwd (mk_array t_t 2 [ TA; TB ]) in Return ()
+let non_copyable_array : result unit =
+ let* _ = take_array_t (mk_array aB_t 2 [ AB_A; AB_B ]) in Return ()
(** [array::sum]: loop 0: forward function *)
-let rec sum_loop_fwd
- (s : slice u32) (sum : u32) (i : usize) :
- Tot (result u32) (decreases (sum_loop_decreases s sum i))
+let rec sum_loop
+ (s : slice u32) (sum0 : u32) (i : usize) :
+ Tot (result u32) (decreases (sum_loop_decreases s sum0 i))
=
let i0 = slice_len u32 s in
if i < i0
then
- let* i1 = slice_index_shared u32 s i in
- let* sum0 = u32_add sum i1 in
+ let* i1 = slice_index_usize u32 s i in
+ let* sum1 = u32_add sum0 i1 in
let* i2 = usize_add i 1 in
- sum_loop_fwd s sum0 i2
- else Return sum
+ sum_loop s sum1 i2
+ else Return sum0
(** [array::sum]: forward function *)
-let sum_fwd (s : slice u32) : result u32 =
- sum_loop_fwd s 0 0
+let sum (s : slice u32) : result u32 =
+ sum_loop s 0 0
(** [array::sum2]: loop 0: forward function *)
-let rec sum2_loop_fwd
- (s : slice u32) (s2 : slice u32) (sum : u32) (i : usize) :
- Tot (result u32) (decreases (sum2_loop_decreases s s2 sum i))
+let rec sum2_loop
+ (s : slice u32) (s2 : slice u32) (sum0 : u32) (i : usize) :
+ Tot (result u32) (decreases (sum2_loop_decreases s s2 sum0 i))
=
let i0 = slice_len u32 s in
if i < i0
then
- let* i1 = slice_index_shared u32 s i in
- let* i2 = slice_index_shared u32 s2 i in
+ let* i1 = slice_index_usize u32 s i in
+ let* i2 = slice_index_usize u32 s2 i in
let* i3 = u32_add i1 i2 in
- let* sum0 = u32_add sum i3 in
+ let* sum1 = u32_add sum0 i3 in
let* i4 = usize_add i 1 in
- sum2_loop_fwd s s2 sum0 i4
- else Return sum
+ sum2_loop s s2 sum1 i4
+ else Return sum0
(** [array::sum2]: forward function *)
-let sum2_fwd (s : slice u32) (s2 : slice u32) : result u32 =
+let sum2 (s : slice u32) (s2 : slice u32) : result u32 =
let i = slice_len u32 s in
let i0 = slice_len u32 s2 in
- if not (i = i0) then Fail Failure else sum2_loop_fwd s s2 0 0
+ if not (i = i0) then Fail Failure else sum2_loop s s2 0 0
(** [array::f0]: forward function *)
-let f0_fwd : result unit =
- let* s = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 1; 2 ]) in
- let* s0 = slice_index_mut_back u32 s 0 1 in
- let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 1; 2 ]) s0 in
+let f0 : result unit =
+ let* s = array_to_slice u32 2 (mk_array u32 2 [ 1; 2 ]) in
+ let* s0 = slice_update_usize u32 s 0 1 in
+ let* _ = array_from_slice u32 2 (mk_array u32 2 [ 1; 2 ]) s0 in
Return ()
(** [array::f1]: forward function *)
-let f1_fwd : result unit =
- let* _ = array_index_mut_back u32 2 (mk_array u32 2 [ 1; 2 ]) 0 1 in
- Return ()
+let f1 : result unit =
+ let* _ = array_update_usize u32 2 (mk_array u32 2 [ 1; 2 ]) 0 1 in Return ()
(** [array::f2]: forward function *)
-let f2_fwd (i : u32) : result unit =
+let f2 (i : u32) : result unit =
Return ()
(** [array::f4]: forward function *)
-let f4_fwd (x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
- array_subslice_shared u32 32 x (Mkrange y z)
+let f4 (x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
+ core_array_Array_index u32 (core_ops_range_Range usize) 32
+ (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ { start = y; end_ = z }
(** [array::f3]: forward function *)
-let f3_fwd : result u32 =
- let* i = array_index_shared u32 2 (mk_array u32 2 [ 1; 2 ]) 0 in
- let* _ = f2_fwd i in
- let* s = array_to_slice_shared u32 2 (mk_array u32 2 [ 1; 2 ]) in
- let* s0 =
- f4_fwd
- (mk_array u32 32 [
- 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0;
- 0; 0; 0; 0; 0; 0; 0; 0
- ]) 16 18 in
- sum2_fwd s s0
+let f3 : result u32 =
+ let* i = array_index_usize u32 2 (mk_array u32 2 [ 1; 2 ]) 0 in
+ let* _ = f2 i in
+ let b = array_repeat u32 32 0 in
+ let* s = array_to_slice u32 2 (mk_array u32 2 [ 1; 2 ]) in
+ let* s0 = f4 b 16 18 in
+ sum2 s s0
+
+(** [array::SZ] *)
+let sz_body : result usize = Return 32
+let sz_c : usize = eval_global sz_body
+
+(** [array::f5]: forward function *)
+let f5 (x : array u32 32) : result u32 =
+ array_index_usize u32 32 x 0
(** [array::ite]: forward function *)
-let ite_fwd : result unit =
- let* s = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
- let* s0 = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
+let ite : result unit =
+ let* s = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+ let* s0 = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
let* s1 = index_mut_slice_u32_0_back s0 in
- let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
+ let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
let* s2 = index_mut_slice_u32_0_back s in
- let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s2 in
+ let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s2 in
Return ()
diff --git a/tests/fstar/array/Array.Types.fst b/tests/fstar/array/Array.Types.fst
index 5e8e81d8..4e8d5566 100644
--- a/tests/fstar/array/Array.Types.fst
+++ b/tests/fstar/array/Array.Types.fst
@@ -5,6 +5,6 @@ open Primitives
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
-(** [array::T] *)
-type t_t = | TA : t_t | TB : t_t
+(** [array::AB] *)
+type aB_t = | AB_A : aB_t | AB_B : aB_t
diff --git a/tests/fstar/array/Primitives.fst b/tests/fstar/array/Primitives.fst
index 9db82069..3297803c 100644
--- a/tests/fstar/array/Primitives.fst
+++ b/tests/fstar/array/Primitives.fst
@@ -55,8 +55,12 @@ type string = string
let is_zero (n: nat) : bool = n = 0
let decrease (n: nat{n > 0}) : nat = n - 1
-let mem_replace_fwd (a : Type0) (x : a) (y : a) : a = x
-let mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
(*** Scalars *)
/// Rem.: most of the following code was partially generated
@@ -100,6 +104,11 @@ type scalar_ty =
| U64
| U128
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
let scalar_min (ty : scalar_ty) : int =
match ty with
| Isize -> isize_min
@@ -162,6 +171,15 @@ let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scala
let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
mk_scalar ty (x * y)
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
(** Cast an integer from a [src_ty] to a [tgt_ty] *)
// TODO: check the semantics of casts in Rust
let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
@@ -169,17 +187,44 @@ let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) :
/// The scalar types
type isize : eqtype = scalar Isize
-type i8 : eqtype = scalar I8
-type i16 : eqtype = scalar I16
-type i32 : eqtype = scalar I32
-type i64 : eqtype = scalar I64
-type i128 : eqtype = scalar I128
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
type usize : eqtype = scalar Usize
-type u8 : eqtype = scalar U8
-type u16 : eqtype = scalar U16
-type u32 : eqtype = scalar U32
-type u64 : eqtype = scalar U64
-type u128 : eqtype = scalar U128
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
/// Negation
let isize_neg = scalar_neg #Isize
@@ -231,7 +276,7 @@ let u32_add = scalar_add #U32
let u64_add = scalar_add #U64
let u128_add = scalar_add #U128
-/// Substraction
+/// Subtraction
let isize_sub = scalar_sub #Isize
let i8_sub = scalar_sub #I8
let i16_sub = scalar_sub #I16
@@ -259,12 +304,65 @@ let u32_mul = scalar_mul #U32
let u64_mul = scalar_mul #U64
let u128_mul = scalar_mul #U128
-(*** Range *)
-type range (a : Type0) = {
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
start : a;
end_ : a;
}
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
(*** Array *)
type array (a : Type0) (n : usize) = s:list a{length s = n}
@@ -278,15 +376,11 @@ let mk_array (a : Type0) (n : usize)
normalize_term_spec (FStar.List.Tot.length l);
l
-let array_index_shared (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let array_index_mut_fwd (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let array_index_mut_back (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
if i < length x then Return (list_update x i nx)
else Fail Failure
@@ -295,55 +389,54 @@ type slice (a : Type0) = s:list a{length s <= usize_max}
let slice_len (a : Type0) (s : slice a) : usize = length s
-let slice_index_shared (a : Type0) (x : slice a) (i : usize) : result a =
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let slice_index_mut_fwd (a : Type0) (x : slice a) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let slice_index_mut_back (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
if i < length x then Return (list_update x i nx)
else Fail Failure
(*** Subslices *)
-let array_to_slice_shared (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_fwd (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_back (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
if length s = n then Return s
else Fail Failure
// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
-let array_subslice_shared (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
- admit()
-
-let array_subslice_mut_fwd (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let array_subslice_mut_back (a : Type0) (n : usize) (x : array a n) (r : range usize) (ns : slice a) : result (array a n) =
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
admit()
-let slice_subslice_shared (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
admit()
-let slice_subslice_mut_fwd (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let slice_subslice_mut_back (a : Type0) (x : slice a) (r : range usize) (ns : slice a) : result (slice a) =
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
admit()
(*** Vector *)
-type vec (a : Type0) = v:list a{length v <= usize_max}
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
-let vec_new (a : Type0) : vec a = assert_norm(length #a [] == 0); []
-let vec_len (a : Type0) (v : vec a) : usize = length v
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
// The **forward** function shouldn't be used
-let vec_push_fwd (a : Type0) (v : vec a) (x : a) : unit = ()
-let vec_push_back (a : Type0) (v : vec a) (x : a) :
- Pure (result (vec a))
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
(requires True)
(ensures (fun res ->
match res with
@@ -358,18 +451,279 @@ let vec_push_back (a : Type0) (v : vec a) (x : a) :
else Fail Failure
// The **forward** function shouldn't be used
-let vec_insert_fwd (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
if i < length v then Return () else Fail Failure
-let vec_insert_back (a : Type0) (v : vec a) (i : usize) (x : a) : result (vec a) =
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
if i < length v then Return (list_update v i x) else Fail Failure
-// The **backward** function shouldn't be used
-let vec_index_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_back (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
- if i < length v then Return () else Fail Failure
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
-let vec_index_mut_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_mut_back (a : Type0) (v : vec a) (i : usize) (nx : a) : result (vec a) =
- if i < length v then Return (list_update v i nx) else Fail Failure
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/betree/BetreeMain.Clauses.Template.fst b/tests/fstar/betree/BetreeMain.Clauses.Template.fst
index 823df03a..8722f0bf 100644
--- a/tests/fstar/betree/BetreeMain.Clauses.Template.fst
+++ b/tests/fstar/betree/BetreeMain.Clauses.Template.fst
@@ -8,95 +8,95 @@ open BetreeMain.Types
(** [betree_main::betree::List::{1}::len]: decreases clause *)
unfold
-let betree_list_len_decreases (t : Type0) (self : betree_list_t t) : nat =
+let betree_List_len_decreases (t : Type0) (self : betree_List_t t) : nat =
admit ()
(** [betree_main::betree::List::{1}::split_at]: decreases clause *)
unfold
-let betree_list_split_at_decreases (t : Type0) (self : betree_list_t t)
+let betree_List_split_at_decreases (t : Type0) (self : betree_List_t t)
(n : u64) : nat =
admit ()
(** [betree_main::betree::List::{2}::partition_at_pivot]: decreases clause *)
unfold
-let betree_list_partition_at_pivot_decreases (t : Type0)
- (self : betree_list_t (u64 & t)) (pivot : u64) : nat =
+let betree_List_partition_at_pivot_decreases (t : Type0)
+ (self : betree_List_t (u64 & t)) (pivot : u64) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_lookup_first_message_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_upserts]: decreases clause *)
unfold
-let betree_node_apply_upserts_decreases
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
+let betree_Node_apply_upserts_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
(key : u64) (st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : nat =
+let betree_Node_lookup_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : nat =
admit ()
(** [betree_main::betree::Internal::{4}::lookup_in_children]: decreases clause *)
unfold
-let betree_internal_lookup_in_children_decreases (self : betree_internal_t)
+let betree_Internal_lookup_in_children_decreases (self : betree_Internal_t)
(key : u64) (st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup]: decreases clause *)
unfold
-let betree_node_lookup_decreases (self : betree_node_t) (key : u64)
+let betree_Node_lookup_decreases (self : betree_Node_t) (key : u64)
(st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::filter_messages_for_key]: decreases clause *)
unfold
-let betree_node_filter_messages_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_filter_messages_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_after_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_lookup_first_message_after_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_messages_to_internal]: decreases clause *)
unfold
-let betree_node_apply_messages_to_internal_decreases
- (msgs : betree_list_t (u64 & betree_message_t))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_apply_messages_to_internal_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_mut_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : nat =
+let betree_Node_lookup_mut_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_messages_to_leaf]: decreases clause *)
unfold
-let betree_node_apply_messages_to_leaf_decreases
- (bindings : betree_list_t (u64 & u64))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_apply_messages_to_leaf_decreases
+ (bindings : betree_List_t (u64 & u64))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Internal::{4}::flush]: decreases clause *)
unfold
-let betree_internal_flush_decreases (self : betree_internal_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) : nat =
+let betree_Internal_flush_decreases (self : betree_Internal_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_messages]: decreases clause *)
unfold
-let betree_node_apply_messages_decreases (self : betree_node_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) : nat =
+let betree_Node_apply_messages_decreases (self : betree_Node_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) : nat =
admit ()
diff --git a/tests/fstar/betree/BetreeMain.Clauses.fst b/tests/fstar/betree/BetreeMain.Clauses.fst
index 07484711..cda7b920 100644
--- a/tests/fstar/betree/BetreeMain.Clauses.fst
+++ b/tests/fstar/betree/BetreeMain.Clauses.fst
@@ -8,8 +8,8 @@ open BetreeMain.Types
(*** Well-founded relations *)
(* We had a few issues when proving termination of the mutually recursive functions:
- * - betree_internal_flush
- * - betree_node_apply_messages
+ * - betree_Internal_flush
+ * - betree_Node_apply_messages
*
* The quantity which effectively decreases is:
* (betree_size, messages_length)
@@ -103,108 +103,108 @@ let wf_nat_pair_lem (p0 p1 : nat_pair) :
(** [betree_main::betree::List::{1}::len]: decreases clause *)
unfold
-let betree_list_len_decreases (t : Type0) (self : betree_list_t t) : betree_list_t t =
+let betree_List_len_decreases (t : Type0) (self : betree_List_t t) : betree_List_t t =
self
(** [betree_main::betree::List::{1}::split_at]: decreases clause *)
unfold
-let betree_list_split_at_decreases (t : Type0) (self : betree_list_t t)
+let betree_List_split_at_decreases (t : Type0) (self : betree_List_t t)
(n : u64) : nat =
n
(** [betree_main::betree::List::{2}::partition_at_pivot]: decreases clause *)
unfold
-let betree_list_partition_at_pivot_decreases (t : Type0)
- (self : betree_list_t (u64 & t)) (pivot : u64) : betree_list_t (u64 & t) =
+let betree_List_partition_at_pivot_decreases (t : Type0)
+ (self : betree_List_t (u64 & t)) (pivot : u64) : betree_List_t (u64 & t) =
self
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : betree_list_t (u64 & u64) =
+let betree_Node_lookup_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : betree_List_t (u64 & u64) =
bindings
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_lookup_first_message_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
msgs
(** [betree_main::betree::Node::{5}::apply_upserts]: decreases clause *)
unfold
-let betree_node_apply_upserts_decreases
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
- (key : u64) (st : state) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_apply_upserts_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
+ (key : u64) (st : state) : betree_List_t (u64 & betree_Message_t) =
msgs
(** [betree_main::betree::Internal::{4}::lookup_in_children]: decreases clause *)
unfold
-let betree_internal_lookup_in_children_decreases (self : betree_internal_t)
- (key : u64) (st : state) : betree_internal_t =
+let betree_Internal_lookup_in_children_decreases (self : betree_Internal_t)
+ (key : u64) (st : state) : betree_Internal_t =
self
(** [betree_main::betree::Node::{5}::lookup]: decreases clause *)
unfold
-let betree_node_lookup_decreases (self : betree_node_t) (key : u64)
- (st : state) : betree_node_t =
+let betree_Node_lookup_decreases (self : betree_Node_t) (key : u64)
+ (st : state) : betree_Node_t =
self
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_mut_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : betree_list_t (u64 & u64) =
+let betree_Node_lookup_mut_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : betree_List_t (u64 & u64) =
bindings
unfold
-let betree_node_apply_messages_to_leaf_decreases
- (bindings : betree_list_t (u64 & u64))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_apply_messages_to_leaf_decreases
+ (bindings : betree_List_t (u64 & u64))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
new_msgs
(** [betree_main::betree::Node::{5}::filter_messages_for_key]: decreases clause *)
unfold
-let betree_node_filter_messages_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_filter_messages_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
msgs
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_after_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_lookup_first_message_after_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
msgs
-let betree_node_apply_messages_to_internal_decreases
- (msgs : betree_list_t (u64 & betree_message_t))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_apply_messages_to_internal_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
new_msgs
(*** Decrease clauses - nat_pair *)
/// The following decrease clauses use the [nat_pair] definition and the well-founded
/// relation proven above.
-let rec betree_size (bt : betree_node_t) : nat =
+let rec betree_size (bt : betree_Node_t) : nat =
match bt with
- | BetreeNodeInternal node -> 1 + betree_internal_size node
- | BetreeNodeLeaf _ -> 1
+ | Betree_Node_Internal node -> 1 + betree_Internal_size node
+ | Betree_Node_Leaf _ -> 1
-and betree_internal_size (node : betree_internal_t) : nat =
- 1 + betree_size node.betree_internal_left + betree_size node.betree_internal_right
+and betree_Internal_size (node : betree_Internal_t) : nat =
+ 1 + betree_size node.left + betree_size node.right
-let rec betree_list_len (#a : Type0) (ls : betree_list_t a) : nat =
+let rec betree_List_len (#a : Type0) (ls : betree_List_t a) : nat =
match ls with
- | BetreeListCons _ tl -> 1 + betree_list_len tl
- | BetreeListNil -> 0
+ | Betree_List_Cons _ tl -> 1 + betree_List_len tl
+ | Betree_List_Nil -> 0
(** [betree_main::betree::Internal::{4}::flush]: decreases clause *)
unfold
-let betree_internal_flush_decreases (self : betree_internal_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) : nat_pair =
- (|betree_internal_size self, 0|)
+let betree_Internal_flush_decreases (self : betree_Internal_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) : nat_pair =
+ (|betree_Internal_size self, 0|)
(** [betree_main::betree::Node::{5}::apply_messages]: decreases clause *)
unfold
-let betree_node_apply_messages_decreases (self : betree_node_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) : nat_pair =
- (|betree_size self, betree_list_len msgs|)
+let betree_Node_apply_messages_decreases (self : betree_Node_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) : nat_pair =
+ (|betree_size self, betree_List_len msgs|)
diff --git a/tests/fstar/betree/BetreeMain.Funs.fst b/tests/fstar/betree/BetreeMain.Funs.fst
index 847dc865..d2bf5c7c 100644
--- a/tests/fstar/betree/BetreeMain.Funs.fst
+++ b/tests/fstar/betree/BetreeMain.Funs.fst
@@ -9,35 +9,35 @@ include BetreeMain.Clauses
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [betree_main::betree::load_internal_node]: forward function *)
-let betree_load_internal_node_fwd
+let betree_load_internal_node
(id : u64) (st : state) :
- result (state & (betree_list_t (u64 & betree_message_t)))
+ result (state & (betree_List_t (u64 & betree_Message_t)))
=
- betree_utils_load_internal_node_fwd id st
+ betree_utils_load_internal_node id st
(** [betree_main::betree::store_internal_node]: forward function *)
-let betree_store_internal_node_fwd
- (id : u64) (content : betree_list_t (u64 & betree_message_t)) (st : state) :
+let betree_store_internal_node
+ (id : u64) (content : betree_List_t (u64 & betree_Message_t)) (st : state) :
result (state & unit)
=
- let* (st0, _) = betree_utils_store_internal_node_fwd id content st in
+ let* (st0, _) = betree_utils_store_internal_node id content st in
Return (st0, ())
(** [betree_main::betree::load_leaf_node]: forward function *)
-let betree_load_leaf_node_fwd
- (id : u64) (st : state) : result (state & (betree_list_t (u64 & u64))) =
- betree_utils_load_leaf_node_fwd id st
+let betree_load_leaf_node
+ (id : u64) (st : state) : result (state & (betree_List_t (u64 & u64))) =
+ betree_utils_load_leaf_node id st
(** [betree_main::betree::store_leaf_node]: forward function *)
-let betree_store_leaf_node_fwd
- (id : u64) (content : betree_list_t (u64 & u64)) (st : state) :
+let betree_store_leaf_node
+ (id : u64) (content : betree_List_t (u64 & u64)) (st : state) :
result (state & unit)
=
- let* (st0, _) = betree_utils_store_leaf_node_fwd id content st in
+ let* (st0, _) = betree_utils_store_leaf_node id content st in
Return (st0, ())
(** [betree_main::betree::fresh_node_id]: forward function *)
-let betree_fresh_node_id_fwd (counter : u64) : result u64 =
+let betree_fresh_node_id (counter : u64) : result u64 =
let* _ = u64_add counter 1 in Return counter
(** [betree_main::betree::fresh_node_id]: backward function 0 *)
@@ -45,976 +45,909 @@ let betree_fresh_node_id_back (counter : u64) : result u64 =
u64_add counter 1
(** [betree_main::betree::NodeIdCounter::{0}::new]: forward function *)
-let betree_node_id_counter_new_fwd : result betree_node_id_counter_t =
- Return { betree_node_id_counter_next_node_id = 0 }
+let betree_NodeIdCounter_new : result betree_NodeIdCounter_t =
+ Return { next_node_id = 0 }
(** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: forward function *)
-let betree_node_id_counter_fresh_id_fwd
- (self : betree_node_id_counter_t) : result u64 =
- let* _ = u64_add self.betree_node_id_counter_next_node_id 1 in
- Return self.betree_node_id_counter_next_node_id
+let betree_NodeIdCounter_fresh_id
+ (self : betree_NodeIdCounter_t) : result u64 =
+ let* _ = u64_add self.next_node_id 1 in Return self.next_node_id
(** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: backward function 0 *)
-let betree_node_id_counter_fresh_id_back
- (self : betree_node_id_counter_t) : result betree_node_id_counter_t =
- let* i = u64_add self.betree_node_id_counter_next_node_id 1 in
- Return { betree_node_id_counter_next_node_id = i }
-
-(** [core::num::u64::{9}::MAX] *)
-let core_num_u64_max_body : result u64 = Return 18446744073709551615
-let core_num_u64_max_c : u64 = eval_global core_num_u64_max_body
+let betree_NodeIdCounter_fresh_id_back
+ (self : betree_NodeIdCounter_t) : result betree_NodeIdCounter_t =
+ let* i = u64_add self.next_node_id 1 in Return { next_node_id = i }
(** [betree_main::betree::upsert_update]: forward function *)
-let betree_upsert_update_fwd
- (prev : option u64) (st : betree_upsert_fun_state_t) : result u64 =
+let betree_upsert_update
+ (prev : option u64) (st : betree_UpsertFunState_t) : result u64 =
begin match prev with
| None ->
begin match st with
- | BetreeUpsertFunStateAdd v -> Return v
- | BetreeUpsertFunStateSub i -> Return 0
+ | Betree_UpsertFunState_Add v -> Return v
+ | Betree_UpsertFunState_Sub i -> Return 0
end
| Some prev0 ->
begin match st with
- | BetreeUpsertFunStateAdd v ->
- let* margin = u64_sub core_num_u64_max_c prev0 in
- if margin >= v then u64_add prev0 v else Return core_num_u64_max_c
- | BetreeUpsertFunStateSub v ->
+ | Betree_UpsertFunState_Add v ->
+ let* margin = u64_sub core_u64_max prev0 in
+ if margin >= v then u64_add prev0 v else Return core_u64_max
+ | Betree_UpsertFunState_Sub v ->
if prev0 >= v then u64_sub prev0 v else Return 0
end
end
(** [betree_main::betree::List::{1}::len]: forward function *)
-let rec betree_list_len_fwd
- (t : Type0) (self : betree_list_t t) :
- Tot (result u64) (decreases (betree_list_len_decreases t self))
+let rec betree_List_len
+ (t : Type0) (self : betree_List_t t) :
+ Tot (result u64) (decreases (betree_List_len_decreases t self))
=
begin match self with
- | BetreeListCons x tl -> let* i = betree_list_len_fwd t tl in u64_add 1 i
- | BetreeListNil -> Return 0
+ | Betree_List_Cons x tl -> let* i = betree_List_len t tl in u64_add 1 i
+ | Betree_List_Nil -> Return 0
end
(** [betree_main::betree::List::{1}::split_at]: forward function *)
-let rec betree_list_split_at_fwd
- (t : Type0) (self : betree_list_t t) (n : u64) :
- Tot (result ((betree_list_t t) & (betree_list_t t)))
- (decreases (betree_list_split_at_decreases t self n))
+let rec betree_List_split_at
+ (t : Type0) (self : betree_List_t t) (n : u64) :
+ Tot (result ((betree_List_t t) & (betree_List_t t)))
+ (decreases (betree_List_split_at_decreases t self n))
=
if n = 0
- then Return (BetreeListNil, self)
+ then Return (Betree_List_Nil, self)
else
begin match self with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let* i = u64_sub n 1 in
- let* p = betree_list_split_at_fwd t tl i in
+ let* p = betree_List_split_at t tl i in
let (ls0, ls1) = p in
let l = ls0 in
- Return (BetreeListCons hd l, ls1)
- | BetreeListNil -> Fail Failure
+ Return (Betree_List_Cons hd l, ls1)
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{1}::push_front]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let betree_list_push_front_fwd_back
- (t : Type0) (self : betree_list_t t) (x : t) : result (betree_list_t t) =
- let tl = mem_replace_fwd (betree_list_t t) self BetreeListNil in
+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 (BetreeListCons x l)
+ Return (Betree_List_Cons x l)
(** [betree_main::betree::List::{1}::pop_front]: forward function *)
-let betree_list_pop_front_fwd (t : Type0) (self : betree_list_t t) : result t =
- let ls = mem_replace_fwd (betree_list_t t) self BetreeListNil in
+let betree_List_pop_front (t : Type0) (self : betree_List_t t) : result t =
+ let ls = core_mem_replace (betree_List_t t) self Betree_List_Nil in
begin match ls with
- | BetreeListCons x tl -> Return x
- | BetreeListNil -> Fail Failure
+ | Betree_List_Cons x tl -> Return x
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{1}::pop_front]: backward function 0 *)
-let betree_list_pop_front_back
- (t : Type0) (self : betree_list_t t) : result (betree_list_t t) =
- let ls = mem_replace_fwd (betree_list_t t) self BetreeListNil in
+let betree_List_pop_front_back
+ (t : Type0) (self : betree_List_t t) : result (betree_List_t t) =
+ let ls = core_mem_replace (betree_List_t t) self Betree_List_Nil in
begin match ls with
- | BetreeListCons x tl -> Return tl
- | BetreeListNil -> Fail Failure
+ | Betree_List_Cons x tl -> Return tl
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{1}::hd]: forward function *)
-let betree_list_hd_fwd (t : Type0) (self : betree_list_t t) : result t =
+let betree_List_hd (t : Type0) (self : betree_List_t t) : result t =
begin match self with
- | BetreeListCons hd l -> Return hd
- | BetreeListNil -> Fail Failure
+ | Betree_List_Cons hd l -> Return hd
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{2}::head_has_key]: forward function *)
-let betree_list_head_has_key_fwd
- (t : Type0) (self : betree_list_t (u64 & t)) (key : u64) : result bool =
+let betree_List_head_has_key
+ (t : Type0) (self : betree_List_t (u64 & t)) (key : u64) : result bool =
begin match self with
- | BetreeListCons hd l -> let (i, _) = hd in Return (i = key)
- | BetreeListNil -> Return false
+ | Betree_List_Cons hd l -> let (i, _) = hd in Return (i = key)
+ | Betree_List_Nil -> Return false
end
(** [betree_main::betree::List::{2}::partition_at_pivot]: forward function *)
-let rec betree_list_partition_at_pivot_fwd
- (t : Type0) (self : betree_list_t (u64 & t)) (pivot : u64) :
- Tot (result ((betree_list_t (u64 & t)) & (betree_list_t (u64 & t))))
- (decreases (betree_list_partition_at_pivot_decreases t self pivot))
+let rec betree_List_partition_at_pivot
+ (t : Type0) (self : betree_List_t (u64 & t)) (pivot : u64) :
+ Tot (result ((betree_List_t (u64 & t)) & (betree_List_t (u64 & t))))
+ (decreases (betree_List_partition_at_pivot_decreases t self pivot))
=
begin match self with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, x) = hd in
if i >= pivot
- then Return (BetreeListNil, BetreeListCons (i, x) tl)
+ then Return (Betree_List_Nil, Betree_List_Cons (i, x) tl)
else
- let* p = betree_list_partition_at_pivot_fwd t tl pivot in
+ let* p = betree_List_partition_at_pivot t tl pivot in
let (ls0, ls1) = p in
let l = ls0 in
- Return (BetreeListCons (i, x) l, ls1)
- | BetreeListNil -> Return (BetreeListNil, BetreeListNil)
+ Return (Betree_List_Cons (i, x) l, ls1)
+ | Betree_List_Nil -> Return (Betree_List_Nil, Betree_List_Nil)
end
(** [betree_main::betree::Leaf::{3}::split]: forward function *)
-let betree_leaf_split_fwd
- (self : betree_leaf_t) (content : betree_list_t (u64 & u64))
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
+let betree_Leaf_split
+ (self : betree_Leaf_t) (content : betree_List_t (u64 & u64))
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
(st : state) :
- result (state & betree_internal_t)
+ result (state & betree_Internal_t)
=
- let* p =
- betree_list_split_at_fwd (u64 & u64) content
- params.betree_params_split_size in
+ let* p = betree_List_split_at (u64 & u64) content params.split_size in
let (content0, content1) = p in
- let* p0 = betree_list_hd_fwd (u64 & u64) content1 in
+ let* p0 = betree_List_hd (u64 & u64) content1 in
let (pivot, _) = p0 in
- let* id0 = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
- let* id1 = betree_node_id_counter_fresh_id_fwd node_id_cnt0 in
- let* (st0, _) = betree_store_leaf_node_fwd id0 content0 st in
- let* (st1, _) = betree_store_leaf_node_fwd id1 content1 st0 in
- let n = BetreeNodeLeaf
- { betree_leaf_id = id0; betree_leaf_size = params.betree_params_split_size
- } in
- let n0 = BetreeNodeLeaf
- { betree_leaf_id = id1; betree_leaf_size = params.betree_params_split_size
- } in
- Return (st1,
- {
- betree_internal_id = self.betree_leaf_id;
- betree_internal_pivot = pivot;
- betree_internal_left = n;
- betree_internal_right = n0
- })
+ let* id0 = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
+ let* id1 = betree_NodeIdCounter_fresh_id node_id_cnt0 in
+ let* (st0, _) = betree_store_leaf_node id0 content0 st in
+ let* (st1, _) = betree_store_leaf_node id1 content1 st0 in
+ let n = Betree_Node_Leaf { id = id0; size = params.split_size } in
+ let n0 = Betree_Node_Leaf { id = id1; size = params.split_size } in
+ Return (st1, { id = self.id; pivot = pivot; left = n; right = n0 })
(** [betree_main::betree::Leaf::{3}::split]: backward function 2 *)
-let betree_leaf_split_back
- (self : betree_leaf_t) (content : betree_list_t (u64 & u64))
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
+let betree_Leaf_split_back
+ (self : betree_Leaf_t) (content : betree_List_t (u64 & u64))
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
(st : state) :
- result betree_node_id_counter_t
+ result betree_NodeIdCounter_t
=
- let* p =
- betree_list_split_at_fwd (u64 & u64) content
- params.betree_params_split_size in
+ let* p = betree_List_split_at (u64 & u64) content params.split_size in
let (content0, content1) = p in
- let* _ = betree_list_hd_fwd (u64 & u64) content1 in
- let* id0 = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
- let* id1 = betree_node_id_counter_fresh_id_fwd node_id_cnt0 in
- let* (st0, _) = betree_store_leaf_node_fwd id0 content0 st in
- let* _ = betree_store_leaf_node_fwd id1 content1 st0 in
- betree_node_id_counter_fresh_id_back node_id_cnt0
+ let* _ = betree_List_hd (u64 & u64) content1 in
+ let* id0 = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
+ let* id1 = betree_NodeIdCounter_fresh_id node_id_cnt0 in
+ let* (st0, _) = betree_store_leaf_node id0 content0 st in
+ let* _ = betree_store_leaf_node id1 content1 st0 in
+ betree_NodeIdCounter_fresh_id_back node_id_cnt0
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: forward function *)
-let rec betree_node_lookup_first_message_for_key_fwd
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_for_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_for_key
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_for_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons x next_msgs ->
+ | Betree_List_Cons x next_msgs ->
let (i, m) = x in
if i >= key
- then Return (BetreeListCons (i, m) next_msgs)
- else betree_node_lookup_first_message_for_key_fwd key next_msgs
- | BetreeListNil -> Return BetreeListNil
+ then Return (Betree_List_Cons (i, m) next_msgs)
+ else betree_Node_lookup_first_message_for_key key next_msgs
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: backward function 0 *)
-let rec betree_node_lookup_first_message_for_key_back
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t))
- (ret : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_for_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_for_key_back
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t))
+ (ret : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_for_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons x next_msgs ->
+ | Betree_List_Cons x next_msgs ->
let (i, m) = x in
if i >= key
then Return ret
else
let* next_msgs0 =
- betree_node_lookup_first_message_for_key_back key next_msgs ret in
- Return (BetreeListCons (i, m) next_msgs0)
- | BetreeListNil -> Return ret
+ betree_Node_lookup_first_message_for_key_back key next_msgs ret in
+ Return (Betree_List_Cons (i, m) next_msgs0)
+ | Betree_List_Nil -> Return ret
end
(** [betree_main::betree::Node::{5}::apply_upserts]: forward function *)
-let rec betree_node_apply_upserts_fwd
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
+let rec betree_Node_apply_upserts
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
(key : u64) (st : state) :
Tot (result (state & u64))
- (decreases (betree_node_apply_upserts_decreases msgs prev key st))
+ (decreases (betree_Node_apply_upserts_decreases msgs prev key st))
=
- let* b = betree_list_head_has_key_fwd betree_message_t msgs key in
+ let* b = betree_List_head_has_key betree_Message_t msgs key in
if b
then
- let* msg = betree_list_pop_front_fwd (u64 & betree_message_t) msgs in
+ let* msg = betree_List_pop_front (u64 & betree_Message_t) msgs in
let (_, m) = msg in
begin match m with
- | BetreeMessageInsert i -> Fail Failure
- | BetreeMessageDelete -> Fail Failure
- | BetreeMessageUpsert s ->
- let* v = betree_upsert_update_fwd prev s in
- let* msgs0 = betree_list_pop_front_back (u64 & betree_message_t) msgs in
- betree_node_apply_upserts_fwd msgs0 (Some v) key st
+ | Betree_Message_Insert i -> Fail Failure
+ | Betree_Message_Delete -> Fail Failure
+ | Betree_Message_Upsert s ->
+ let* v = betree_upsert_update prev s in
+ let* msgs0 = betree_List_pop_front_back (u64 & betree_Message_t) msgs in
+ betree_Node_apply_upserts msgs0 (Some v) key st
end
else
- let* (st0, v) = core_option_option_unwrap_fwd u64 prev st in
+ let* (st0, v) = core_option_Option_unwrap u64 prev st in
let* _ =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs (key,
- BetreeMessageInsert v) in
+ betree_List_push_front (u64 & betree_Message_t) msgs (key,
+ Betree_Message_Insert v) in
Return (st0, v)
(** [betree_main::betree::Node::{5}::apply_upserts]: backward function 0 *)
-let rec betree_node_apply_upserts_back
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
+let rec betree_Node_apply_upserts_back
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
(key : u64) (st : state) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_apply_upserts_decreases msgs prev key st))
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_apply_upserts_decreases msgs prev key st))
=
- let* b = betree_list_head_has_key_fwd betree_message_t msgs key in
+ let* b = betree_List_head_has_key betree_Message_t msgs key in
if b
then
- let* msg = betree_list_pop_front_fwd (u64 & betree_message_t) msgs in
+ let* msg = betree_List_pop_front (u64 & betree_Message_t) msgs in
let (_, m) = msg in
begin match m with
- | BetreeMessageInsert i -> Fail Failure
- | BetreeMessageDelete -> Fail Failure
- | BetreeMessageUpsert s ->
- let* v = betree_upsert_update_fwd prev s in
- let* msgs0 = betree_list_pop_front_back (u64 & betree_message_t) msgs in
- betree_node_apply_upserts_back msgs0 (Some v) key st
+ | Betree_Message_Insert i -> Fail Failure
+ | Betree_Message_Delete -> Fail Failure
+ | Betree_Message_Upsert s ->
+ let* v = betree_upsert_update prev s in
+ let* msgs0 = betree_List_pop_front_back (u64 & betree_Message_t) msgs in
+ betree_Node_apply_upserts_back msgs0 (Some v) key st
end
else
- let* (_, v) = core_option_option_unwrap_fwd u64 prev st in
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs (key,
- BetreeMessageInsert v)
+ let* (_, v) = core_option_Option_unwrap u64 prev st in
+ betree_List_push_front (u64 & betree_Message_t) msgs (key,
+ Betree_Message_Insert v)
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: forward function *)
-let rec betree_node_lookup_in_bindings_fwd
- (key : u64) (bindings : betree_list_t (u64 & u64)) :
+let rec betree_Node_lookup_in_bindings
+ (key : u64) (bindings : betree_List_t (u64 & u64)) :
Tot (result (option u64))
- (decreases (betree_node_lookup_in_bindings_decreases key bindings))
+ (decreases (betree_Node_lookup_in_bindings_decreases key bindings))
=
begin match bindings with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, i0) = hd in
if i = key
then Return (Some i0)
- else
- if i > key
- then Return None
- else betree_node_lookup_in_bindings_fwd key tl
- | BetreeListNil -> Return None
+ else if i > key then Return None else betree_Node_lookup_in_bindings key tl
+ | Betree_List_Nil -> Return None
end
(** [betree_main::betree::Internal::{4}::lookup_in_children]: forward function *)
-let rec betree_internal_lookup_in_children_fwd
- (self : betree_internal_t) (key : u64) (st : state) :
+let rec betree_Internal_lookup_in_children
+ (self : betree_Internal_t) (key : u64) (st : state) :
Tot (result (state & (option u64)))
- (decreases (betree_internal_lookup_in_children_decreases self key st))
+ (decreases (betree_Internal_lookup_in_children_decreases self key st))
=
- if key < self.betree_internal_pivot
- then betree_node_lookup_fwd self.betree_internal_left key st
- else betree_node_lookup_fwd self.betree_internal_right key st
+ if key < self.pivot
+ then betree_Node_lookup self.left key st
+ else betree_Node_lookup self.right key st
(** [betree_main::betree::Internal::{4}::lookup_in_children]: backward function 0 *)
-and betree_internal_lookup_in_children_back
- (self : betree_internal_t) (key : u64) (st : state) :
- Tot (result betree_internal_t)
- (decreases (betree_internal_lookup_in_children_decreases self key st))
+and betree_Internal_lookup_in_children_back
+ (self : betree_Internal_t) (key : u64) (st : state) :
+ Tot (result betree_Internal_t)
+ (decreases (betree_Internal_lookup_in_children_decreases self key st))
=
- if key < self.betree_internal_pivot
+ if key < self.pivot
then
- let* n = betree_node_lookup_back self.betree_internal_left key st in
- Return { self with betree_internal_left = n }
+ let* n = betree_Node_lookup_back self.left key st in
+ Return { self with left = n }
else
- let* n = betree_node_lookup_back self.betree_internal_right key st in
- Return { self with betree_internal_right = n }
+ let* n = betree_Node_lookup_back self.right key st in
+ Return { self with right = n }
(** [betree_main::betree::Node::{5}::lookup]: forward function *)
-and betree_node_lookup_fwd
- (self : betree_node_t) (key : u64) (st : state) :
+and betree_Node_lookup
+ (self : betree_Node_t) (key : u64) (st : state) :
Tot (result (state & (option u64)))
- (decreases (betree_node_lookup_decreases self key st))
+ (decreases (betree_Node_lookup_decreases self key st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st0, msgs) = betree_load_internal_node_fwd node.betree_internal_id st
- in
- let* pending = betree_node_lookup_first_message_for_key_fwd key msgs in
+ | Betree_Node_Internal node ->
+ let* (st0, msgs) = betree_load_internal_node node.id st in
+ let* pending = betree_Node_lookup_first_message_for_key key msgs in
begin match pending with
- | BetreeListCons p l ->
+ | Betree_List_Cons p l ->
let (k, msg) = p in
if k <> key
then
- let* (st1, opt) = betree_internal_lookup_in_children_fwd node key st0
- in
+ let* (st1, o) = betree_Internal_lookup_in_children node key st0 in
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, msg) l) in
- Return (st1, opt)
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, msg) l) in
+ Return (st1, o)
else
begin match msg with
- | BetreeMessageInsert v ->
+ | Betree_Message_Insert v ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageInsert v) l) in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Insert v) l) in
Return (st0, Some v)
- | BetreeMessageDelete ->
+ | Betree_Message_Delete ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageDelete) l) in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Delete) l) in
Return (st0, None)
- | BetreeMessageUpsert ufs ->
- let* (st1, v) = betree_internal_lookup_in_children_fwd node key st0
- in
+ | Betree_Message_Upsert ufs ->
+ let* (st1, v) = betree_Internal_lookup_in_children node key st0 in
let* (st2, v0) =
- betree_node_apply_upserts_fwd (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1 in
- let* node0 = betree_internal_lookup_in_children_back node key st0 in
+ betree_Node_apply_upserts (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1 in
+ let* node0 = betree_Internal_lookup_in_children_back node key st0 in
let* pending0 =
- betree_node_apply_upserts_back (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1 in
+ betree_Node_apply_upserts_back (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1 in
let* msgs0 =
- betree_node_lookup_first_message_for_key_back key msgs pending0 in
- let* (st3, _) =
- betree_store_internal_node_fwd node0.betree_internal_id msgs0 st2
- in
+ betree_Node_lookup_first_message_for_key_back key msgs pending0 in
+ let* (st3, _) = betree_store_internal_node node0.id msgs0 st2 in
Return (st3, Some v0)
end
- | BetreeListNil ->
- let* (st1, opt) = betree_internal_lookup_in_children_fwd node key st0 in
+ | Betree_List_Nil ->
+ let* (st1, o) = betree_Internal_lookup_in_children node key st0 in
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs BetreeListNil in
- Return (st1, opt)
+ betree_Node_lookup_first_message_for_key_back key msgs Betree_List_Nil
+ in
+ Return (st1, o)
end
- | BetreeNodeLeaf node ->
- let* (st0, bindings) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* opt = betree_node_lookup_in_bindings_fwd key bindings in
- Return (st0, opt)
+ | Betree_Node_Leaf node ->
+ let* (st0, bindings) = betree_load_leaf_node node.id st in
+ let* o = betree_Node_lookup_in_bindings key bindings in
+ Return (st0, o)
end
(** [betree_main::betree::Node::{5}::lookup]: backward function 0 *)
-and betree_node_lookup_back
- (self : betree_node_t) (key : u64) (st : state) :
- Tot (result betree_node_t)
- (decreases (betree_node_lookup_decreases self key st))
+and betree_Node_lookup_back
+ (self : betree_Node_t) (key : u64) (st : state) :
+ Tot (result betree_Node_t)
+ (decreases (betree_Node_lookup_decreases self key st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st0, msgs) = betree_load_internal_node_fwd node.betree_internal_id st
- in
- let* pending = betree_node_lookup_first_message_for_key_fwd key msgs in
+ | Betree_Node_Internal node ->
+ let* (st0, msgs) = betree_load_internal_node node.id st in
+ let* pending = betree_Node_lookup_first_message_for_key key msgs in
begin match pending with
- | BetreeListCons p l ->
+ | Betree_List_Cons p l ->
let (k, msg) = p in
if k <> key
then
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, msg) l) in
- let* node0 = betree_internal_lookup_in_children_back node key st0 in
- Return (BetreeNodeInternal node0)
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, msg) l) in
+ let* node0 = betree_Internal_lookup_in_children_back node key st0 in
+ Return (Betree_Node_Internal node0)
else
begin match msg with
- | BetreeMessageInsert v ->
+ | Betree_Message_Insert v ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageInsert v) l) in
- Return (BetreeNodeInternal node)
- | BetreeMessageDelete ->
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Insert v) l) in
+ Return (Betree_Node_Internal node)
+ | Betree_Message_Delete ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageDelete) l) in
- Return (BetreeNodeInternal node)
- | BetreeMessageUpsert ufs ->
- let* (st1, v) = betree_internal_lookup_in_children_fwd node key st0
- in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Delete) l) in
+ Return (Betree_Node_Internal node)
+ | Betree_Message_Upsert ufs ->
+ let* (st1, v) = betree_Internal_lookup_in_children node key st0 in
let* (st2, _) =
- betree_node_apply_upserts_fwd (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1 in
- let* node0 = betree_internal_lookup_in_children_back node key st0 in
+ betree_Node_apply_upserts (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1 in
+ let* node0 = betree_Internal_lookup_in_children_back node key st0 in
let* pending0 =
- betree_node_apply_upserts_back (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1 in
+ betree_Node_apply_upserts_back (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1 in
let* msgs0 =
- betree_node_lookup_first_message_for_key_back key msgs pending0 in
- let* _ =
- betree_store_internal_node_fwd node0.betree_internal_id msgs0 st2
- in
- Return (BetreeNodeInternal node0)
+ betree_Node_lookup_first_message_for_key_back key msgs pending0 in
+ let* _ = betree_store_internal_node node0.id msgs0 st2 in
+ Return (Betree_Node_Internal node0)
end
- | BetreeListNil ->
+ | Betree_List_Nil ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs BetreeListNil in
- let* node0 = betree_internal_lookup_in_children_back node key st0 in
- Return (BetreeNodeInternal node0)
+ betree_Node_lookup_first_message_for_key_back key msgs Betree_List_Nil
+ in
+ let* node0 = betree_Internal_lookup_in_children_back node key st0 in
+ Return (Betree_Node_Internal node0)
end
- | BetreeNodeLeaf node ->
- let* (_, bindings) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* _ = betree_node_lookup_in_bindings_fwd key bindings in
- Return (BetreeNodeLeaf node)
+ | Betree_Node_Leaf node ->
+ let* (_, bindings) = betree_load_leaf_node node.id st in
+ let* _ = betree_Node_lookup_in_bindings key bindings in
+ Return (Betree_Node_Leaf node)
end
(** [betree_main::betree::Node::{5}::filter_messages_for_key]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec betree_node_filter_messages_for_key_fwd_back
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_filter_messages_for_key_decreases key msgs))
+let rec betree_Node_filter_messages_for_key
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_filter_messages_for_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons p l ->
+ | Betree_List_Cons p l ->
let (k, m) = p in
if k = key
then
let* msgs0 =
- betree_list_pop_front_back (u64 & betree_message_t) (BetreeListCons (k,
- m) l) in
- betree_node_filter_messages_for_key_fwd_back key msgs0
- else Return (BetreeListCons (k, m) l)
- | BetreeListNil -> Return BetreeListNil
+ betree_List_pop_front_back (u64 & betree_Message_t) (Betree_List_Cons
+ (k, m) l) in
+ betree_Node_filter_messages_for_key key msgs0
+ else Return (Betree_List_Cons (k, m) l)
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: forward function *)
-let rec betree_node_lookup_first_message_after_key_fwd
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_after_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_after_key
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_after_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons p next_msgs ->
+ | Betree_List_Cons p next_msgs ->
let (k, m) = p in
if k = key
- then betree_node_lookup_first_message_after_key_fwd key next_msgs
- else Return (BetreeListCons (k, m) next_msgs)
- | BetreeListNil -> Return BetreeListNil
+ then betree_Node_lookup_first_message_after_key key next_msgs
+ else Return (Betree_List_Cons (k, m) next_msgs)
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: backward function 0 *)
-let rec betree_node_lookup_first_message_after_key_back
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t))
- (ret : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_after_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_after_key_back
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t))
+ (ret : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_after_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons p next_msgs ->
+ | Betree_List_Cons p next_msgs ->
let (k, m) = p in
if k = key
then
let* next_msgs0 =
- betree_node_lookup_first_message_after_key_back key next_msgs ret in
- Return (BetreeListCons (k, m) next_msgs0)
+ betree_Node_lookup_first_message_after_key_back key next_msgs ret in
+ Return (Betree_List_Cons (k, m) next_msgs0)
else Return ret
- | BetreeListNil -> Return ret
+ | Betree_List_Nil -> Return ret
end
(** [betree_main::betree::Node::{5}::apply_to_internal]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let betree_node_apply_to_internal_fwd_back
- (msgs : betree_list_t (u64 & betree_message_t)) (key : u64)
- (new_msg : betree_message_t) :
- result (betree_list_t (u64 & betree_message_t))
+let betree_Node_apply_to_internal
+ (msgs : betree_List_t (u64 & betree_Message_t)) (key : u64)
+ (new_msg : betree_Message_t) :
+ result (betree_List_t (u64 & betree_Message_t))
=
- let* msgs0 = betree_node_lookup_first_message_for_key_fwd key msgs in
- let* b = betree_list_head_has_key_fwd betree_message_t msgs0 key in
+ let* msgs0 = betree_Node_lookup_first_message_for_key key msgs in
+ let* b = betree_List_head_has_key betree_Message_t msgs0 key in
if b
then
begin match new_msg with
- | BetreeMessageInsert i ->
- let* msgs1 = betree_node_filter_messages_for_key_fwd_back key msgs0 in
+ | Betree_Message_Insert i ->
+ let* msgs1 = betree_Node_filter_messages_for_key key msgs0 in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageInsert i) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageDelete ->
- let* msgs1 = betree_node_filter_messages_for_key_fwd_back key msgs0 in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Insert i) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Delete ->
+ let* msgs1 = betree_Node_filter_messages_for_key key msgs0 in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageDelete) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageUpsert s ->
- let* p = betree_list_hd_fwd (u64 & betree_message_t) msgs0 in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Delete) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Upsert s ->
+ let* p = betree_List_hd (u64 & betree_Message_t) msgs0 in
let (_, m) = p in
begin match m with
- | BetreeMessageInsert prev ->
- let* v = betree_upsert_update_fwd (Some prev) s in
- let* msgs1 = betree_list_pop_front_back (u64 & betree_message_t) msgs0
+ | Betree_Message_Insert prev ->
+ let* v = betree_upsert_update (Some prev) s in
+ let* msgs1 = betree_List_pop_front_back (u64 & betree_Message_t) msgs0
in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageInsert v) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageDelete ->
- let* v = betree_upsert_update_fwd None s in
- let* msgs1 = betree_list_pop_front_back (u64 & betree_message_t) msgs0
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Insert v) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Delete ->
+ let* v = betree_upsert_update None s in
+ let* msgs1 = betree_List_pop_front_back (u64 & betree_Message_t) msgs0
in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageInsert v) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageUpsert ufs ->
- let* msgs1 = betree_node_lookup_first_message_after_key_fwd key msgs0
- in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Insert v) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Upsert ufs ->
+ let* msgs1 = betree_Node_lookup_first_message_after_key key msgs0 in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageUpsert s) in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Upsert s) in
let* msgs3 =
- betree_node_lookup_first_message_after_key_back key msgs0 msgs2 in
- betree_node_lookup_first_message_for_key_back key msgs msgs3
+ betree_Node_lookup_first_message_after_key_back key msgs0 msgs2 in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs3
end
end
else
let* msgs1 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs0 (key,
- new_msg) in
- betree_node_lookup_first_message_for_key_back key msgs msgs1
+ betree_List_push_front (u64 & betree_Message_t) msgs0 (key, new_msg) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs1
(** [betree_main::betree::Node::{5}::apply_messages_to_internal]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec betree_node_apply_messages_to_internal_fwd_back
- (msgs : betree_list_t (u64 & betree_message_t))
- (new_msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_apply_messages_to_internal_decreases msgs new_msgs))
+let rec betree_Node_apply_messages_to_internal
+ (msgs : betree_List_t (u64 & betree_Message_t))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_apply_messages_to_internal_decreases msgs new_msgs))
=
begin match new_msgs with
- | BetreeListCons new_msg new_msgs_tl ->
+ | Betree_List_Cons new_msg new_msgs_tl ->
let (i, m) = new_msg in
- let* msgs0 = betree_node_apply_to_internal_fwd_back msgs i m in
- betree_node_apply_messages_to_internal_fwd_back msgs0 new_msgs_tl
- | BetreeListNil -> Return msgs
+ let* msgs0 = betree_Node_apply_to_internal msgs i m in
+ betree_Node_apply_messages_to_internal msgs0 new_msgs_tl
+ | Betree_List_Nil -> Return msgs
end
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: forward function *)
-let rec betree_node_lookup_mut_in_bindings_fwd
- (key : u64) (bindings : betree_list_t (u64 & u64)) :
- Tot (result (betree_list_t (u64 & u64)))
- (decreases (betree_node_lookup_mut_in_bindings_decreases key bindings))
+let rec betree_Node_lookup_mut_in_bindings
+ (key : u64) (bindings : betree_List_t (u64 & u64)) :
+ Tot (result (betree_List_t (u64 & u64)))
+ (decreases (betree_Node_lookup_mut_in_bindings_decreases key bindings))
=
begin match bindings with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, i0) = hd in
if i >= key
- then Return (BetreeListCons (i, i0) tl)
- else betree_node_lookup_mut_in_bindings_fwd key tl
- | BetreeListNil -> Return BetreeListNil
+ then Return (Betree_List_Cons (i, i0) tl)
+ else betree_Node_lookup_mut_in_bindings key tl
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: backward function 0 *)
-let rec betree_node_lookup_mut_in_bindings_back
- (key : u64) (bindings : betree_list_t (u64 & u64))
- (ret : betree_list_t (u64 & u64)) :
- Tot (result (betree_list_t (u64 & u64)))
- (decreases (betree_node_lookup_mut_in_bindings_decreases key bindings))
+let rec betree_Node_lookup_mut_in_bindings_back
+ (key : u64) (bindings : betree_List_t (u64 & u64))
+ (ret : betree_List_t (u64 & u64)) :
+ Tot (result (betree_List_t (u64 & u64)))
+ (decreases (betree_Node_lookup_mut_in_bindings_decreases key bindings))
=
begin match bindings with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, i0) = hd in
if i >= key
then Return ret
else
- let* tl0 = betree_node_lookup_mut_in_bindings_back key tl ret in
- Return (BetreeListCons (i, i0) tl0)
- | BetreeListNil -> Return ret
+ let* tl0 = betree_Node_lookup_mut_in_bindings_back key tl ret in
+ Return (Betree_List_Cons (i, i0) tl0)
+ | Betree_List_Nil -> Return ret
end
(** [betree_main::betree::Node::{5}::apply_to_leaf]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let betree_node_apply_to_leaf_fwd_back
- (bindings : betree_list_t (u64 & u64)) (key : u64)
- (new_msg : betree_message_t) :
- result (betree_list_t (u64 & u64))
+let betree_Node_apply_to_leaf
+ (bindings : betree_List_t (u64 & u64)) (key : u64)
+ (new_msg : betree_Message_t) :
+ result (betree_List_t (u64 & u64))
=
- let* bindings0 = betree_node_lookup_mut_in_bindings_fwd key bindings in
- let* b = betree_list_head_has_key_fwd u64 bindings0 key in
+ let* bindings0 = betree_Node_lookup_mut_in_bindings key bindings in
+ let* b = betree_List_head_has_key u64 bindings0 key in
if b
then
- let* hd = betree_list_pop_front_fwd (u64 & u64) bindings0 in
+ let* hd = betree_List_pop_front (u64 & u64) bindings0 in
begin match new_msg with
- | BetreeMessageInsert v ->
- let* bindings1 = betree_list_pop_front_back (u64 & u64) bindings0 in
- let* bindings2 =
- betree_list_push_front_fwd_back (u64 & u64) bindings1 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings2
- | BetreeMessageDelete ->
- let* bindings1 = betree_list_pop_front_back (u64 & u64) bindings0 in
- betree_node_lookup_mut_in_bindings_back key bindings bindings1
- | BetreeMessageUpsert s ->
+ | Betree_Message_Insert v ->
+ let* bindings1 = betree_List_pop_front_back (u64 & u64) bindings0 in
+ let* bindings2 = betree_List_push_front (u64 & u64) bindings1 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings2
+ | Betree_Message_Delete ->
+ let* bindings1 = betree_List_pop_front_back (u64 & u64) bindings0 in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings1
+ | Betree_Message_Upsert s ->
let (_, i) = hd in
- let* v = betree_upsert_update_fwd (Some i) s in
- let* bindings1 = betree_list_pop_front_back (u64 & u64) bindings0 in
- let* bindings2 =
- betree_list_push_front_fwd_back (u64 & u64) bindings1 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings2
+ let* v = betree_upsert_update (Some i) s in
+ let* bindings1 = betree_List_pop_front_back (u64 & u64) bindings0 in
+ let* bindings2 = betree_List_push_front (u64 & u64) bindings1 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings2
end
else
begin match new_msg with
- | BetreeMessageInsert v ->
- let* bindings1 =
- betree_list_push_front_fwd_back (u64 & u64) bindings0 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings1
- | BetreeMessageDelete ->
- betree_node_lookup_mut_in_bindings_back key bindings bindings0
- | BetreeMessageUpsert s ->
- let* v = betree_upsert_update_fwd None s in
- let* bindings1 =
- betree_list_push_front_fwd_back (u64 & u64) bindings0 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings1
+ | Betree_Message_Insert v ->
+ let* bindings1 = betree_List_push_front (u64 & u64) bindings0 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings1
+ | Betree_Message_Delete ->
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings0
+ | Betree_Message_Upsert s ->
+ let* v = betree_upsert_update None s in
+ let* bindings1 = betree_List_push_front (u64 & u64) bindings0 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings1
end
(** [betree_main::betree::Node::{5}::apply_messages_to_leaf]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec betree_node_apply_messages_to_leaf_fwd_back
- (bindings : betree_list_t (u64 & u64))
- (new_msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & u64)))
- (decreases (betree_node_apply_messages_to_leaf_decreases bindings new_msgs))
+let rec betree_Node_apply_messages_to_leaf
+ (bindings : betree_List_t (u64 & u64))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & u64)))
+ (decreases (betree_Node_apply_messages_to_leaf_decreases bindings new_msgs))
=
begin match new_msgs with
- | BetreeListCons new_msg new_msgs_tl ->
+ | Betree_List_Cons new_msg new_msgs_tl ->
let (i, m) = new_msg in
- let* bindings0 = betree_node_apply_to_leaf_fwd_back bindings i m in
- betree_node_apply_messages_to_leaf_fwd_back bindings0 new_msgs_tl
- | BetreeListNil -> Return bindings
+ let* bindings0 = betree_Node_apply_to_leaf bindings i m in
+ betree_Node_apply_messages_to_leaf bindings0 new_msgs_tl
+ | Betree_List_Nil -> Return bindings
end
(** [betree_main::betree::Internal::{4}::flush]: forward function *)
-let rec betree_internal_flush_fwd
- (self : betree_internal_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) :
- Tot (result (state & (betree_list_t (u64 & betree_message_t))))
+let rec betree_Internal_flush
+ (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) :
+ Tot (result (state & (betree_List_t (u64 & betree_Message_t))))
(decreases (
- betree_internal_flush_decreases self params node_id_cnt content st))
+ betree_Internal_flush_decreases self params node_id_cnt content st))
=
- let* p =
- betree_list_partition_at_pivot_fwd betree_message_t content
- self.betree_internal_pivot in
+ let* p = betree_List_partition_at_pivot betree_Message_t content self.pivot
+ in
let (msgs_left, msgs_right) = p in
- let* len_left = betree_list_len_fwd (u64 & betree_message_t) msgs_left in
- if len_left >= params.betree_params_min_flush_size
+ let* len_left = betree_List_len (u64 & betree_Message_t) msgs_left in
+ if len_left >= params.min_flush_size
then
let* (st0, _) =
- betree_node_apply_messages_fwd self.betree_internal_left params
- node_id_cnt msgs_left st in
+ betree_Node_apply_messages self.left params node_id_cnt msgs_left st in
let* (_, node_id_cnt0) =
- betree_node_apply_messages_back self.betree_internal_left params
- node_id_cnt msgs_left st in
- let* len_right = betree_list_len_fwd (u64 & betree_message_t) msgs_right in
- if len_right >= params.betree_params_min_flush_size
+ betree_Node_apply_messages_back self.left params node_id_cnt msgs_left st
+ in
+ let* len_right = betree_List_len (u64 & betree_Message_t) msgs_right in
+ if len_right >= params.min_flush_size
then
let* (st1, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt0 msgs_right st0 in
+ betree_Node_apply_messages self.right params node_id_cnt0 msgs_right
+ st0 in
let* _ =
- betree_node_apply_messages_back self.betree_internal_right params
- node_id_cnt0 msgs_right st0 in
- Return (st1, BetreeListNil)
+ betree_Node_apply_messages_back self.right params node_id_cnt0
+ msgs_right st0 in
+ Return (st1, Betree_List_Nil)
else Return (st0, msgs_right)
else
let* (st0, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt msgs_right st in
+ betree_Node_apply_messages self.right params node_id_cnt msgs_right st in
let* _ =
- betree_node_apply_messages_back self.betree_internal_right params
- node_id_cnt msgs_right st in
+ betree_Node_apply_messages_back self.right params node_id_cnt msgs_right
+ st in
Return (st0, msgs_left)
(** [betree_main::betree::Internal::{4}::flush]: backward function 0 *)
-and betree_internal_flush_back
- (self : betree_internal_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) :
- Tot (result (betree_internal_t & betree_node_id_counter_t))
+and betree_Internal_flush_back
+ (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) :
+ Tot (result (betree_Internal_t & betree_NodeIdCounter_t))
(decreases (
- betree_internal_flush_decreases self params node_id_cnt content st))
+ betree_Internal_flush_decreases self params node_id_cnt content st))
=
- let* p =
- betree_list_partition_at_pivot_fwd betree_message_t content
- self.betree_internal_pivot in
+ let* p = betree_List_partition_at_pivot betree_Message_t content self.pivot
+ in
let (msgs_left, msgs_right) = p in
- let* len_left = betree_list_len_fwd (u64 & betree_message_t) msgs_left in
- if len_left >= params.betree_params_min_flush_size
+ let* len_left = betree_List_len (u64 & betree_Message_t) msgs_left in
+ if len_left >= params.min_flush_size
then
let* (st0, _) =
- betree_node_apply_messages_fwd self.betree_internal_left params
- node_id_cnt msgs_left st in
+ betree_Node_apply_messages self.left params node_id_cnt msgs_left st in
let* (n, node_id_cnt0) =
- betree_node_apply_messages_back self.betree_internal_left params
- node_id_cnt msgs_left st in
- let* len_right = betree_list_len_fwd (u64 & betree_message_t) msgs_right in
- if len_right >= params.betree_params_min_flush_size
+ betree_Node_apply_messages_back self.left params node_id_cnt msgs_left st
+ in
+ let* len_right = betree_List_len (u64 & betree_Message_t) msgs_right in
+ if len_right >= params.min_flush_size
then
let* (n0, node_id_cnt1) =
- betree_node_apply_messages_back self.betree_internal_right params
- node_id_cnt0 msgs_right st0 in
- Return
- ({ self with betree_internal_left = n; betree_internal_right = n0 },
- node_id_cnt1)
- else Return ({ self with betree_internal_left = n }, node_id_cnt0)
+ betree_Node_apply_messages_back self.right params node_id_cnt0
+ msgs_right st0 in
+ Return ({ self with left = n; right = n0 }, node_id_cnt1)
+ else Return ({ self with left = n }, node_id_cnt0)
else
let* (n, node_id_cnt0) =
- betree_node_apply_messages_back self.betree_internal_right params
- node_id_cnt msgs_right st in
- Return ({ self with betree_internal_right = n }, node_id_cnt0)
+ betree_Node_apply_messages_back self.right params node_id_cnt msgs_right
+ st in
+ Return ({ self with right = n }, node_id_cnt0)
(** [betree_main::betree::Node::{5}::apply_messages]: forward function *)
-and betree_node_apply_messages_fwd
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) :
+and betree_Node_apply_messages
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) :
Tot (result (state & unit))
(decreases (
- betree_node_apply_messages_decreases self params node_id_cnt msgs st))
+ betree_Node_apply_messages_decreases self params node_id_cnt msgs st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st0, content) =
- betree_load_internal_node_fwd node.betree_internal_id st in
- let* content0 =
- betree_node_apply_messages_to_internal_fwd_back content msgs in
- let* num_msgs = betree_list_len_fwd (u64 & betree_message_t) content0 in
- if num_msgs >= params.betree_params_min_flush_size
+ | Betree_Node_Internal node ->
+ let* (st0, content) = betree_load_internal_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_internal content msgs in
+ let* num_msgs = betree_List_len (u64 & betree_Message_t) content0 in
+ if num_msgs >= params.min_flush_size
then
let* (st1, content1) =
- betree_internal_flush_fwd node params node_id_cnt content0 st0 in
+ betree_Internal_flush node params node_id_cnt content0 st0 in
let* (node0, _) =
- betree_internal_flush_back node params node_id_cnt content0 st0 in
- let* (st2, _) =
- betree_store_internal_node_fwd node0.betree_internal_id content1 st1 in
+ betree_Internal_flush_back node params node_id_cnt content0 st0 in
+ let* (st2, _) = betree_store_internal_node node0.id content1 st1 in
Return (st2, ())
else
- let* (st1, _) =
- betree_store_internal_node_fwd node.betree_internal_id content0 st0 in
+ let* (st1, _) = betree_store_internal_node node.id content0 st0 in
Return (st1, ())
- | BetreeNodeLeaf node ->
- let* (st0, content) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* content0 = betree_node_apply_messages_to_leaf_fwd_back content msgs in
- let* len = betree_list_len_fwd (u64 & u64) content0 in
- let* i = u64_mul 2 params.betree_params_split_size in
+ | Betree_Node_Leaf node ->
+ let* (st0, content) = betree_load_leaf_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_leaf content msgs in
+ let* len = betree_List_len (u64 & u64) content0 in
+ let* i = u64_mul 2 params.split_size in
if len >= i
then
- let* (st1, _) =
- betree_leaf_split_fwd node content0 params node_id_cnt st0 in
- let* (st2, _) =
- betree_store_leaf_node_fwd node.betree_leaf_id BetreeListNil st1 in
+ let* (st1, _) = betree_Leaf_split node content0 params node_id_cnt st0 in
+ let* (st2, _) = betree_store_leaf_node node.id Betree_List_Nil st1 in
Return (st2, ())
else
- let* (st1, _) =
- betree_store_leaf_node_fwd node.betree_leaf_id content0 st0 in
+ let* (st1, _) = betree_store_leaf_node node.id content0 st0 in
Return (st1, ())
end
(** [betree_main::betree::Node::{5}::apply_messages]: backward function 0 *)
-and betree_node_apply_messages_back
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) :
- Tot (result (betree_node_t & betree_node_id_counter_t))
+and betree_Node_apply_messages_back
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) :
+ Tot (result (betree_Node_t & betree_NodeIdCounter_t))
(decreases (
- betree_node_apply_messages_decreases self params node_id_cnt msgs st))
+ betree_Node_apply_messages_decreases self params node_id_cnt msgs st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st0, content) =
- betree_load_internal_node_fwd node.betree_internal_id st in
- let* content0 =
- betree_node_apply_messages_to_internal_fwd_back content msgs in
- let* num_msgs = betree_list_len_fwd (u64 & betree_message_t) content0 in
- if num_msgs >= params.betree_params_min_flush_size
+ | Betree_Node_Internal node ->
+ let* (st0, content) = betree_load_internal_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_internal content msgs in
+ let* num_msgs = betree_List_len (u64 & betree_Message_t) content0 in
+ if num_msgs >= params.min_flush_size
then
let* (st1, content1) =
- betree_internal_flush_fwd node params node_id_cnt content0 st0 in
+ betree_Internal_flush node params node_id_cnt content0 st0 in
let* (node0, node_id_cnt0) =
- betree_internal_flush_back node params node_id_cnt content0 st0 in
- let* _ =
- betree_store_internal_node_fwd node0.betree_internal_id content1 st1 in
- Return (BetreeNodeInternal node0, node_id_cnt0)
+ betree_Internal_flush_back node params node_id_cnt content0 st0 in
+ let* _ = betree_store_internal_node node0.id content1 st1 in
+ Return (Betree_Node_Internal node0, node_id_cnt0)
else
- let* _ =
- betree_store_internal_node_fwd node.betree_internal_id content0 st0 in
- Return (BetreeNodeInternal node, node_id_cnt)
- | BetreeNodeLeaf node ->
- let* (st0, content) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* content0 = betree_node_apply_messages_to_leaf_fwd_back content msgs in
- let* len = betree_list_len_fwd (u64 & u64) content0 in
- let* i = u64_mul 2 params.betree_params_split_size in
+ let* _ = betree_store_internal_node node.id content0 st0 in
+ Return (Betree_Node_Internal node, node_id_cnt)
+ | Betree_Node_Leaf node ->
+ let* (st0, content) = betree_load_leaf_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_leaf content msgs in
+ let* len = betree_List_len (u64 & u64) content0 in
+ let* i = u64_mul 2 params.split_size in
if len >= i
then
let* (st1, new_node) =
- betree_leaf_split_fwd node content0 params node_id_cnt st0 in
- let* _ = betree_store_leaf_node_fwd node.betree_leaf_id BetreeListNil st1
- in
+ betree_Leaf_split node content0 params node_id_cnt st0 in
+ let* _ = betree_store_leaf_node node.id Betree_List_Nil st1 in
let* node_id_cnt0 =
- betree_leaf_split_back node content0 params node_id_cnt st0 in
- Return (BetreeNodeInternal new_node, node_id_cnt0)
+ betree_Leaf_split_back node content0 params node_id_cnt st0 in
+ Return (Betree_Node_Internal new_node, node_id_cnt0)
else
- let* _ = betree_store_leaf_node_fwd node.betree_leaf_id content0 st0 in
- Return (BetreeNodeLeaf { node with betree_leaf_size = len }, node_id_cnt)
+ let* _ = betree_store_leaf_node node.id content0 st0 in
+ Return (Betree_Node_Leaf { node with size = len }, node_id_cnt)
end
(** [betree_main::betree::Node::{5}::apply]: forward function *)
-let betree_node_apply_fwd
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t) (key : u64)
- (new_msg : betree_message_t) (st : state) :
+let betree_Node_apply
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+ (new_msg : betree_Message_t) (st : state) :
result (state & unit)
=
- let l = BetreeListNil in
+ let l = Betree_List_Nil in
let* (st0, _) =
- betree_node_apply_messages_fwd self params node_id_cnt (BetreeListCons
- (key, new_msg) l) st in
+ betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
+ new_msg) l) st in
let* _ =
- betree_node_apply_messages_back self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st in
Return (st0, ())
(** [betree_main::betree::Node::{5}::apply]: backward function 0 *)
-let betree_node_apply_back
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t) (key : u64)
- (new_msg : betree_message_t) (st : state) :
- result (betree_node_t & betree_node_id_counter_t)
+let betree_Node_apply_back
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+ (new_msg : betree_Message_t) (st : state) :
+ result (betree_Node_t & betree_NodeIdCounter_t)
=
- let l = BetreeListNil in
- betree_node_apply_messages_back self params node_id_cnt (BetreeListCons (key,
- new_msg) l) st
+ let l = Betree_List_Nil in
+ betree_Node_apply_messages_back self params node_id_cnt (Betree_List_Cons
+ (key, new_msg) l) st
(** [betree_main::betree::BeTree::{6}::new]: forward function *)
-let betree_be_tree_new_fwd
+let betree_BeTree_new
(min_flush_size : u64) (split_size : u64) (st : state) :
- result (state & betree_be_tree_t)
+ result (state & betree_BeTree_t)
=
- let* node_id_cnt = betree_node_id_counter_new_fwd in
- let* id = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* (st0, _) = betree_store_leaf_node_fwd id BetreeListNil st in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
+ let* node_id_cnt = betree_NodeIdCounter_new in
+ let* id = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* (st0, _) = betree_store_leaf_node id Betree_List_Nil st in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
Return (st0,
{
- betree_be_tree_params =
- {
- betree_params_min_flush_size = min_flush_size;
- betree_params_split_size = split_size
- };
- betree_be_tree_node_id_cnt = node_id_cnt0;
- betree_be_tree_root =
- (BetreeNodeLeaf { betree_leaf_id = id; betree_leaf_size = 0 })
+ params = { min_flush_size = min_flush_size; split_size = split_size };
+ node_id_cnt = node_id_cnt0;
+ root = (Betree_Node_Leaf { id = id; size = 0 })
})
(** [betree_main::betree::BeTree::{6}::apply]: forward function *)
-let betree_be_tree_apply_fwd
- (self : betree_be_tree_t) (key : u64) (msg : betree_message_t) (st : state) :
+let betree_BeTree_apply
+ (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t) (st : state) :
result (state & unit)
=
let* (st0, _) =
- betree_node_apply_fwd self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st in
+ betree_Node_apply self.root self.params self.node_id_cnt key msg st in
let* _ =
- betree_node_apply_back self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st in
+ betree_Node_apply_back self.root self.params self.node_id_cnt key msg st in
Return (st0, ())
(** [betree_main::betree::BeTree::{6}::apply]: backward function 0 *)
-let betree_be_tree_apply_back
- (self : betree_be_tree_t) (key : u64) (msg : betree_message_t) (st : state) :
- result betree_be_tree_t
+let betree_BeTree_apply_back
+ (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t) (st : state) :
+ result betree_BeTree_t
=
let* (n, nic) =
- betree_node_apply_back self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st in
- Return
- { self with betree_be_tree_node_id_cnt = nic; betree_be_tree_root = n }
+ betree_Node_apply_back self.root self.params self.node_id_cnt key msg st in
+ Return { self with node_id_cnt = nic; root = n }
(** [betree_main::betree::BeTree::{6}::insert]: forward function *)
-let betree_be_tree_insert_fwd
- (self : betree_be_tree_t) (key : u64) (value : u64) (st : state) :
+let betree_BeTree_insert
+ (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
result (state & unit)
=
- let* (st0, _) =
- betree_be_tree_apply_fwd self key (BetreeMessageInsert value) st in
- let* _ = betree_be_tree_apply_back self key (BetreeMessageInsert value) st in
+ let* (st0, _) = betree_BeTree_apply self key (Betree_Message_Insert value) st
+ in
+ let* _ = betree_BeTree_apply_back self key (Betree_Message_Insert value) st
+ in
Return (st0, ())
(** [betree_main::betree::BeTree::{6}::insert]: backward function 0 *)
-let betree_be_tree_insert_back
- (self : betree_be_tree_t) (key : u64) (value : u64) (st : state) :
- result betree_be_tree_t
+let betree_BeTree_insert_back
+ (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
+ result betree_BeTree_t
=
- betree_be_tree_apply_back self key (BetreeMessageInsert value) st
+ betree_BeTree_apply_back self key (Betree_Message_Insert value) st
(** [betree_main::betree::BeTree::{6}::delete]: forward function *)
-let betree_be_tree_delete_fwd
- (self : betree_be_tree_t) (key : u64) (st : state) : result (state & unit) =
- let* (st0, _) = betree_be_tree_apply_fwd self key BetreeMessageDelete st in
- let* _ = betree_be_tree_apply_back self key BetreeMessageDelete st in
+let betree_BeTree_delete
+ (self : betree_BeTree_t) (key : u64) (st : state) : result (state & unit) =
+ let* (st0, _) = betree_BeTree_apply self key Betree_Message_Delete st in
+ let* _ = betree_BeTree_apply_back self key Betree_Message_Delete st in
Return (st0, ())
(** [betree_main::betree::BeTree::{6}::delete]: backward function 0 *)
-let betree_be_tree_delete_back
- (self : betree_be_tree_t) (key : u64) (st : state) :
- result betree_be_tree_t
- =
- betree_be_tree_apply_back self key BetreeMessageDelete st
+let betree_BeTree_delete_back
+ (self : betree_BeTree_t) (key : u64) (st : state) : result betree_BeTree_t =
+ betree_BeTree_apply_back self key Betree_Message_Delete st
(** [betree_main::betree::BeTree::{6}::upsert]: forward function *)
-let betree_be_tree_upsert_fwd
- (self : betree_be_tree_t) (key : u64) (upd : betree_upsert_fun_state_t)
+let betree_BeTree_upsert
+ (self : betree_BeTree_t) (key : u64) (upd : betree_UpsertFunState_t)
(st : state) :
result (state & unit)
=
- let* (st0, _) =
- betree_be_tree_apply_fwd self key (BetreeMessageUpsert upd) st in
- let* _ = betree_be_tree_apply_back self key (BetreeMessageUpsert upd) st in
+ let* (st0, _) = betree_BeTree_apply self key (Betree_Message_Upsert upd) st
+ in
+ let* _ = betree_BeTree_apply_back self key (Betree_Message_Upsert upd) st in
Return (st0, ())
(** [betree_main::betree::BeTree::{6}::upsert]: backward function 0 *)
-let betree_be_tree_upsert_back
- (self : betree_be_tree_t) (key : u64) (upd : betree_upsert_fun_state_t)
+let betree_BeTree_upsert_back
+ (self : betree_BeTree_t) (key : u64) (upd : betree_UpsertFunState_t)
(st : state) :
- result betree_be_tree_t
+ result betree_BeTree_t
=
- betree_be_tree_apply_back self key (BetreeMessageUpsert upd) st
+ betree_BeTree_apply_back self key (Betree_Message_Upsert upd) st
(** [betree_main::betree::BeTree::{6}::lookup]: forward function *)
-let betree_be_tree_lookup_fwd
- (self : betree_be_tree_t) (key : u64) (st : state) :
+let betree_BeTree_lookup
+ (self : betree_BeTree_t) (key : u64) (st : state) :
result (state & (option u64))
=
- betree_node_lookup_fwd self.betree_be_tree_root key st
+ betree_Node_lookup self.root key st
(** [betree_main::betree::BeTree::{6}::lookup]: backward function 0 *)
-let betree_be_tree_lookup_back
- (self : betree_be_tree_t) (key : u64) (st : state) :
- result betree_be_tree_t
- =
- let* n = betree_node_lookup_back self.betree_be_tree_root key st in
- Return { self with betree_be_tree_root = n }
+let betree_BeTree_lookup_back
+ (self : betree_BeTree_t) (key : u64) (st : state) : result betree_BeTree_t =
+ let* n = betree_Node_lookup_back self.root key st in
+ Return { self with root = n }
(** [betree_main::main]: forward function *)
-let main_fwd : result unit =
+let main : result unit =
Return ()
(** Unit test for [betree_main::main] *)
-let _ = assert_norm (main_fwd = Return ())
+let _ = assert_norm (main = Return ())
diff --git a/tests/fstar/betree/BetreeMain.Opaque.fsti b/tests/fstar/betree/BetreeMain.Opaque.fsti
index c33cf225..c5d0a814 100644
--- a/tests/fstar/betree/BetreeMain.Opaque.fsti
+++ b/tests/fstar/betree/BetreeMain.Opaque.fsti
@@ -7,24 +7,24 @@ include BetreeMain.Types
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [betree_main::betree_utils::load_internal_node]: forward function *)
-val betree_utils_load_internal_node_fwd
- : u64 -> state -> result (state & (betree_list_t (u64 & betree_message_t)))
+val betree_utils_load_internal_node
+ : u64 -> state -> result (state & (betree_List_t (u64 & betree_Message_t)))
(** [betree_main::betree_utils::store_internal_node]: forward function *)
-val betree_utils_store_internal_node_fwd
+val betree_utils_store_internal_node
:
- u64 -> betree_list_t (u64 & betree_message_t) -> state -> result (state &
+ u64 -> betree_List_t (u64 & betree_Message_t) -> state -> result (state &
unit)
(** [betree_main::betree_utils::load_leaf_node]: forward function *)
-val betree_utils_load_leaf_node_fwd
- : u64 -> state -> result (state & (betree_list_t (u64 & u64)))
+val betree_utils_load_leaf_node
+ : u64 -> state -> result (state & (betree_List_t (u64 & u64)))
(** [betree_main::betree_utils::store_leaf_node]: forward function *)
-val betree_utils_store_leaf_node_fwd
- : u64 -> betree_list_t (u64 & u64) -> state -> result (state & unit)
+val betree_utils_store_leaf_node
+ : u64 -> betree_List_t (u64 & u64) -> state -> result (state & unit)
(** [core::option::Option::{0}::unwrap]: forward function *)
-val core_option_option_unwrap_fwd
+val core_option_Option_unwrap
(t : Type0) : option t -> state -> result (state & t)
diff --git a/tests/fstar/betree/BetreeMain.Types.fsti b/tests/fstar/betree/BetreeMain.Types.fsti
index a937c726..9320f6b7 100644
--- a/tests/fstar/betree/BetreeMain.Types.fsti
+++ b/tests/fstar/betree/BetreeMain.Types.fsti
@@ -6,53 +6,47 @@ open Primitives
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [betree_main::betree::List] *)
-type betree_list_t (t : Type0) =
-| BetreeListCons : t -> betree_list_t t -> betree_list_t t
-| BetreeListNil : betree_list_t t
+type betree_List_t (t : Type0) =
+| Betree_List_Cons : t -> betree_List_t t -> betree_List_t t
+| Betree_List_Nil : betree_List_t t
(** [betree_main::betree::UpsertFunState] *)
-type betree_upsert_fun_state_t =
-| BetreeUpsertFunStateAdd : u64 -> betree_upsert_fun_state_t
-| BetreeUpsertFunStateSub : u64 -> betree_upsert_fun_state_t
+type betree_UpsertFunState_t =
+| Betree_UpsertFunState_Add : u64 -> betree_UpsertFunState_t
+| Betree_UpsertFunState_Sub : u64 -> betree_UpsertFunState_t
(** [betree_main::betree::Message] *)
-type betree_message_t =
-| BetreeMessageInsert : u64 -> betree_message_t
-| BetreeMessageDelete : betree_message_t
-| BetreeMessageUpsert : betree_upsert_fun_state_t -> betree_message_t
+type betree_Message_t =
+| Betree_Message_Insert : u64 -> betree_Message_t
+| Betree_Message_Delete : betree_Message_t
+| Betree_Message_Upsert : betree_UpsertFunState_t -> betree_Message_t
(** [betree_main::betree::Leaf] *)
-type betree_leaf_t = { betree_leaf_id : u64; betree_leaf_size : u64; }
+type betree_Leaf_t = { id : u64; size : u64; }
(** [betree_main::betree::Internal] *)
-type betree_internal_t =
+type betree_Internal_t =
{
- betree_internal_id : u64;
- betree_internal_pivot : u64;
- betree_internal_left : betree_node_t;
- betree_internal_right : betree_node_t;
+ id : u64; pivot : u64; left : betree_Node_t; right : betree_Node_t;
}
(** [betree_main::betree::Node] *)
-and betree_node_t =
-| BetreeNodeInternal : betree_internal_t -> betree_node_t
-| BetreeNodeLeaf : betree_leaf_t -> betree_node_t
+and betree_Node_t =
+| Betree_Node_Internal : betree_Internal_t -> betree_Node_t
+| Betree_Node_Leaf : betree_Leaf_t -> betree_Node_t
(** [betree_main::betree::Params] *)
-type betree_params_t =
-{
- betree_params_min_flush_size : u64; betree_params_split_size : u64;
-}
+type betree_Params_t = { min_flush_size : u64; split_size : u64; }
(** [betree_main::betree::NodeIdCounter] *)
-type betree_node_id_counter_t = { betree_node_id_counter_next_node_id : u64; }
+type betree_NodeIdCounter_t = { next_node_id : u64; }
(** [betree_main::betree::BeTree] *)
-type betree_be_tree_t =
+type betree_BeTree_t =
{
- betree_be_tree_params : betree_params_t;
- betree_be_tree_node_id_cnt : betree_node_id_counter_t;
- betree_be_tree_root : betree_node_t;
+ params : betree_Params_t;
+ node_id_cnt : betree_NodeIdCounter_t;
+ root : betree_Node_t;
}
(** The state type used in the state-error monad *)
diff --git a/tests/fstar/betree/Primitives.fst b/tests/fstar/betree/Primitives.fst
index 9db82069..3297803c 100644
--- a/tests/fstar/betree/Primitives.fst
+++ b/tests/fstar/betree/Primitives.fst
@@ -55,8 +55,12 @@ type string = string
let is_zero (n: nat) : bool = n = 0
let decrease (n: nat{n > 0}) : nat = n - 1
-let mem_replace_fwd (a : Type0) (x : a) (y : a) : a = x
-let mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
(*** Scalars *)
/// Rem.: most of the following code was partially generated
@@ -100,6 +104,11 @@ type scalar_ty =
| U64
| U128
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
let scalar_min (ty : scalar_ty) : int =
match ty with
| Isize -> isize_min
@@ -162,6 +171,15 @@ let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scala
let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
mk_scalar ty (x * y)
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
(** Cast an integer from a [src_ty] to a [tgt_ty] *)
// TODO: check the semantics of casts in Rust
let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
@@ -169,17 +187,44 @@ let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) :
/// The scalar types
type isize : eqtype = scalar Isize
-type i8 : eqtype = scalar I8
-type i16 : eqtype = scalar I16
-type i32 : eqtype = scalar I32
-type i64 : eqtype = scalar I64
-type i128 : eqtype = scalar I128
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
type usize : eqtype = scalar Usize
-type u8 : eqtype = scalar U8
-type u16 : eqtype = scalar U16
-type u32 : eqtype = scalar U32
-type u64 : eqtype = scalar U64
-type u128 : eqtype = scalar U128
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
/// Negation
let isize_neg = scalar_neg #Isize
@@ -231,7 +276,7 @@ let u32_add = scalar_add #U32
let u64_add = scalar_add #U64
let u128_add = scalar_add #U128
-/// Substraction
+/// Subtraction
let isize_sub = scalar_sub #Isize
let i8_sub = scalar_sub #I8
let i16_sub = scalar_sub #I16
@@ -259,12 +304,65 @@ let u32_mul = scalar_mul #U32
let u64_mul = scalar_mul #U64
let u128_mul = scalar_mul #U128
-(*** Range *)
-type range (a : Type0) = {
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
start : a;
end_ : a;
}
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
(*** Array *)
type array (a : Type0) (n : usize) = s:list a{length s = n}
@@ -278,15 +376,11 @@ let mk_array (a : Type0) (n : usize)
normalize_term_spec (FStar.List.Tot.length l);
l
-let array_index_shared (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let array_index_mut_fwd (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let array_index_mut_back (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
if i < length x then Return (list_update x i nx)
else Fail Failure
@@ -295,55 +389,54 @@ type slice (a : Type0) = s:list a{length s <= usize_max}
let slice_len (a : Type0) (s : slice a) : usize = length s
-let slice_index_shared (a : Type0) (x : slice a) (i : usize) : result a =
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let slice_index_mut_fwd (a : Type0) (x : slice a) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let slice_index_mut_back (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
if i < length x then Return (list_update x i nx)
else Fail Failure
(*** Subslices *)
-let array_to_slice_shared (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_fwd (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_back (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
if length s = n then Return s
else Fail Failure
// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
-let array_subslice_shared (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
- admit()
-
-let array_subslice_mut_fwd (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let array_subslice_mut_back (a : Type0) (n : usize) (x : array a n) (r : range usize) (ns : slice a) : result (array a n) =
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
admit()
-let slice_subslice_shared (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
admit()
-let slice_subslice_mut_fwd (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let slice_subslice_mut_back (a : Type0) (x : slice a) (r : range usize) (ns : slice a) : result (slice a) =
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
admit()
(*** Vector *)
-type vec (a : Type0) = v:list a{length v <= usize_max}
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
-let vec_new (a : Type0) : vec a = assert_norm(length #a [] == 0); []
-let vec_len (a : Type0) (v : vec a) : usize = length v
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
// The **forward** function shouldn't be used
-let vec_push_fwd (a : Type0) (v : vec a) (x : a) : unit = ()
-let vec_push_back (a : Type0) (v : vec a) (x : a) :
- Pure (result (vec a))
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
(requires True)
(ensures (fun res ->
match res with
@@ -358,18 +451,279 @@ let vec_push_back (a : Type0) (v : vec a) (x : a) :
else Fail Failure
// The **forward** function shouldn't be used
-let vec_insert_fwd (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
if i < length v then Return () else Fail Failure
-let vec_insert_back (a : Type0) (v : vec a) (i : usize) (x : a) : result (vec a) =
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
if i < length v then Return (list_update v i x) else Fail Failure
-// The **backward** function shouldn't be used
-let vec_index_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_back (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
- if i < length v then Return () else Fail Failure
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
-let vec_index_mut_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_mut_back (a : Type0) (v : vec a) (i : usize) (nx : a) : result (vec a) =
- if i < length v then Return (list_update v i nx) else Fail Failure
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/betree_back_stateful/BetreeMain.Clauses.Template.fst b/tests/fstar/betree_back_stateful/BetreeMain.Clauses.Template.fst
index 823df03a..8722f0bf 100644
--- a/tests/fstar/betree_back_stateful/BetreeMain.Clauses.Template.fst
+++ b/tests/fstar/betree_back_stateful/BetreeMain.Clauses.Template.fst
@@ -8,95 +8,95 @@ open BetreeMain.Types
(** [betree_main::betree::List::{1}::len]: decreases clause *)
unfold
-let betree_list_len_decreases (t : Type0) (self : betree_list_t t) : nat =
+let betree_List_len_decreases (t : Type0) (self : betree_List_t t) : nat =
admit ()
(** [betree_main::betree::List::{1}::split_at]: decreases clause *)
unfold
-let betree_list_split_at_decreases (t : Type0) (self : betree_list_t t)
+let betree_List_split_at_decreases (t : Type0) (self : betree_List_t t)
(n : u64) : nat =
admit ()
(** [betree_main::betree::List::{2}::partition_at_pivot]: decreases clause *)
unfold
-let betree_list_partition_at_pivot_decreases (t : Type0)
- (self : betree_list_t (u64 & t)) (pivot : u64) : nat =
+let betree_List_partition_at_pivot_decreases (t : Type0)
+ (self : betree_List_t (u64 & t)) (pivot : u64) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_lookup_first_message_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_upserts]: decreases clause *)
unfold
-let betree_node_apply_upserts_decreases
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
+let betree_Node_apply_upserts_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
(key : u64) (st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : nat =
+let betree_Node_lookup_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : nat =
admit ()
(** [betree_main::betree::Internal::{4}::lookup_in_children]: decreases clause *)
unfold
-let betree_internal_lookup_in_children_decreases (self : betree_internal_t)
+let betree_Internal_lookup_in_children_decreases (self : betree_Internal_t)
(key : u64) (st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup]: decreases clause *)
unfold
-let betree_node_lookup_decreases (self : betree_node_t) (key : u64)
+let betree_Node_lookup_decreases (self : betree_Node_t) (key : u64)
(st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::filter_messages_for_key]: decreases clause *)
unfold
-let betree_node_filter_messages_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_filter_messages_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_after_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_lookup_first_message_after_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_messages_to_internal]: decreases clause *)
unfold
-let betree_node_apply_messages_to_internal_decreases
- (msgs : betree_list_t (u64 & betree_message_t))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_apply_messages_to_internal_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_mut_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : nat =
+let betree_Node_lookup_mut_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_messages_to_leaf]: decreases clause *)
unfold
-let betree_node_apply_messages_to_leaf_decreases
- (bindings : betree_list_t (u64 & u64))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : nat =
+let betree_Node_apply_messages_to_leaf_decreases
+ (bindings : betree_List_t (u64 & u64))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : nat =
admit ()
(** [betree_main::betree::Internal::{4}::flush]: decreases clause *)
unfold
-let betree_internal_flush_decreases (self : betree_internal_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) : nat =
+let betree_Internal_flush_decreases (self : betree_Internal_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) : nat =
admit ()
(** [betree_main::betree::Node::{5}::apply_messages]: decreases clause *)
unfold
-let betree_node_apply_messages_decreases (self : betree_node_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) : nat =
+let betree_Node_apply_messages_decreases (self : betree_Node_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) : nat =
admit ()
diff --git a/tests/fstar/betree_back_stateful/BetreeMain.Clauses.fst b/tests/fstar/betree_back_stateful/BetreeMain.Clauses.fst
index 07484711..cda7b920 100644
--- a/tests/fstar/betree_back_stateful/BetreeMain.Clauses.fst
+++ b/tests/fstar/betree_back_stateful/BetreeMain.Clauses.fst
@@ -8,8 +8,8 @@ open BetreeMain.Types
(*** Well-founded relations *)
(* We had a few issues when proving termination of the mutually recursive functions:
- * - betree_internal_flush
- * - betree_node_apply_messages
+ * - betree_Internal_flush
+ * - betree_Node_apply_messages
*
* The quantity which effectively decreases is:
* (betree_size, messages_length)
@@ -103,108 +103,108 @@ let wf_nat_pair_lem (p0 p1 : nat_pair) :
(** [betree_main::betree::List::{1}::len]: decreases clause *)
unfold
-let betree_list_len_decreases (t : Type0) (self : betree_list_t t) : betree_list_t t =
+let betree_List_len_decreases (t : Type0) (self : betree_List_t t) : betree_List_t t =
self
(** [betree_main::betree::List::{1}::split_at]: decreases clause *)
unfold
-let betree_list_split_at_decreases (t : Type0) (self : betree_list_t t)
+let betree_List_split_at_decreases (t : Type0) (self : betree_List_t t)
(n : u64) : nat =
n
(** [betree_main::betree::List::{2}::partition_at_pivot]: decreases clause *)
unfold
-let betree_list_partition_at_pivot_decreases (t : Type0)
- (self : betree_list_t (u64 & t)) (pivot : u64) : betree_list_t (u64 & t) =
+let betree_List_partition_at_pivot_decreases (t : Type0)
+ (self : betree_List_t (u64 & t)) (pivot : u64) : betree_List_t (u64 & t) =
self
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : betree_list_t (u64 & u64) =
+let betree_Node_lookup_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : betree_List_t (u64 & u64) =
bindings
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_lookup_first_message_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
msgs
(** [betree_main::betree::Node::{5}::apply_upserts]: decreases clause *)
unfold
-let betree_node_apply_upserts_decreases
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
- (key : u64) (st : state) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_apply_upserts_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
+ (key : u64) (st : state) : betree_List_t (u64 & betree_Message_t) =
msgs
(** [betree_main::betree::Internal::{4}::lookup_in_children]: decreases clause *)
unfold
-let betree_internal_lookup_in_children_decreases (self : betree_internal_t)
- (key : u64) (st : state) : betree_internal_t =
+let betree_Internal_lookup_in_children_decreases (self : betree_Internal_t)
+ (key : u64) (st : state) : betree_Internal_t =
self
(** [betree_main::betree::Node::{5}::lookup]: decreases clause *)
unfold
-let betree_node_lookup_decreases (self : betree_node_t) (key : u64)
- (st : state) : betree_node_t =
+let betree_Node_lookup_decreases (self : betree_Node_t) (key : u64)
+ (st : state) : betree_Node_t =
self
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: decreases clause *)
unfold
-let betree_node_lookup_mut_in_bindings_decreases (key : u64)
- (bindings : betree_list_t (u64 & u64)) : betree_list_t (u64 & u64) =
+let betree_Node_lookup_mut_in_bindings_decreases (key : u64)
+ (bindings : betree_List_t (u64 & u64)) : betree_List_t (u64 & u64) =
bindings
unfold
-let betree_node_apply_messages_to_leaf_decreases
- (bindings : betree_list_t (u64 & u64))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_apply_messages_to_leaf_decreases
+ (bindings : betree_List_t (u64 & u64))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
new_msgs
(** [betree_main::betree::Node::{5}::filter_messages_for_key]: decreases clause *)
unfold
-let betree_node_filter_messages_for_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_filter_messages_for_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
msgs
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: decreases clause *)
unfold
-let betree_node_lookup_first_message_after_key_decreases (key : u64)
- (msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_lookup_first_message_after_key_decreases (key : u64)
+ (msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
msgs
-let betree_node_apply_messages_to_internal_decreases
- (msgs : betree_list_t (u64 & betree_message_t))
- (new_msgs : betree_list_t (u64 & betree_message_t)) : betree_list_t (u64 & betree_message_t) =
+let betree_Node_apply_messages_to_internal_decreases
+ (msgs : betree_List_t (u64 & betree_Message_t))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) : betree_List_t (u64 & betree_Message_t) =
new_msgs
(*** Decrease clauses - nat_pair *)
/// The following decrease clauses use the [nat_pair] definition and the well-founded
/// relation proven above.
-let rec betree_size (bt : betree_node_t) : nat =
+let rec betree_size (bt : betree_Node_t) : nat =
match bt with
- | BetreeNodeInternal node -> 1 + betree_internal_size node
- | BetreeNodeLeaf _ -> 1
+ | Betree_Node_Internal node -> 1 + betree_Internal_size node
+ | Betree_Node_Leaf _ -> 1
-and betree_internal_size (node : betree_internal_t) : nat =
- 1 + betree_size node.betree_internal_left + betree_size node.betree_internal_right
+and betree_Internal_size (node : betree_Internal_t) : nat =
+ 1 + betree_size node.left + betree_size node.right
-let rec betree_list_len (#a : Type0) (ls : betree_list_t a) : nat =
+let rec betree_List_len (#a : Type0) (ls : betree_List_t a) : nat =
match ls with
- | BetreeListCons _ tl -> 1 + betree_list_len tl
- | BetreeListNil -> 0
+ | Betree_List_Cons _ tl -> 1 + betree_List_len tl
+ | Betree_List_Nil -> 0
(** [betree_main::betree::Internal::{4}::flush]: decreases clause *)
unfold
-let betree_internal_flush_decreases (self : betree_internal_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) : nat_pair =
- (|betree_internal_size self, 0|)
+let betree_Internal_flush_decreases (self : betree_Internal_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) : nat_pair =
+ (|betree_Internal_size self, 0|)
(** [betree_main::betree::Node::{5}::apply_messages]: decreases clause *)
unfold
-let betree_node_apply_messages_decreases (self : betree_node_t)
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) : nat_pair =
- (|betree_size self, betree_list_len msgs|)
+let betree_Node_apply_messages_decreases (self : betree_Node_t)
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) : nat_pair =
+ (|betree_size self, betree_List_len msgs|)
diff --git a/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst b/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst
index 3d08cd3c..08c4f615 100644
--- a/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst
+++ b/tests/fstar/betree_back_stateful/BetreeMain.Funs.fst
@@ -9,35 +9,35 @@ include BetreeMain.Clauses
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [betree_main::betree::load_internal_node]: forward function *)
-let betree_load_internal_node_fwd
+let betree_load_internal_node
(id : u64) (st : state) :
- result (state & (betree_list_t (u64 & betree_message_t)))
+ result (state & (betree_List_t (u64 & betree_Message_t)))
=
- betree_utils_load_internal_node_fwd id st
+ betree_utils_load_internal_node id st
(** [betree_main::betree::store_internal_node]: forward function *)
-let betree_store_internal_node_fwd
- (id : u64) (content : betree_list_t (u64 & betree_message_t)) (st : state) :
+let betree_store_internal_node
+ (id : u64) (content : betree_List_t (u64 & betree_Message_t)) (st : state) :
result (state & unit)
=
- let* (st0, _) = betree_utils_store_internal_node_fwd id content st in
+ let* (st0, _) = betree_utils_store_internal_node id content st in
Return (st0, ())
(** [betree_main::betree::load_leaf_node]: forward function *)
-let betree_load_leaf_node_fwd
- (id : u64) (st : state) : result (state & (betree_list_t (u64 & u64))) =
- betree_utils_load_leaf_node_fwd id st
+let betree_load_leaf_node
+ (id : u64) (st : state) : result (state & (betree_List_t (u64 & u64))) =
+ betree_utils_load_leaf_node id st
(** [betree_main::betree::store_leaf_node]: forward function *)
-let betree_store_leaf_node_fwd
- (id : u64) (content : betree_list_t (u64 & u64)) (st : state) :
+let betree_store_leaf_node
+ (id : u64) (content : betree_List_t (u64 & u64)) (st : state) :
result (state & unit)
=
- let* (st0, _) = betree_utils_store_leaf_node_fwd id content st in
+ let* (st0, _) = betree_utils_store_leaf_node id content st in
Return (st0, ())
(** [betree_main::betree::fresh_node_id]: forward function *)
-let betree_fresh_node_id_fwd (counter : u64) : result u64 =
+let betree_fresh_node_id (counter : u64) : result u64 =
let* _ = u64_add counter 1 in Return counter
(** [betree_main::betree::fresh_node_id]: backward function 0 *)
@@ -45,1208 +45,1123 @@ let betree_fresh_node_id_back (counter : u64) : result u64 =
u64_add counter 1
(** [betree_main::betree::NodeIdCounter::{0}::new]: forward function *)
-let betree_node_id_counter_new_fwd : result betree_node_id_counter_t =
- Return { betree_node_id_counter_next_node_id = 0 }
+let betree_NodeIdCounter_new : result betree_NodeIdCounter_t =
+ Return { next_node_id = 0 }
(** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: forward function *)
-let betree_node_id_counter_fresh_id_fwd
- (self : betree_node_id_counter_t) : result u64 =
- let* _ = u64_add self.betree_node_id_counter_next_node_id 1 in
- Return self.betree_node_id_counter_next_node_id
+let betree_NodeIdCounter_fresh_id
+ (self : betree_NodeIdCounter_t) : result u64 =
+ let* _ = u64_add self.next_node_id 1 in Return self.next_node_id
(** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: backward function 0 *)
-let betree_node_id_counter_fresh_id_back
- (self : betree_node_id_counter_t) : result betree_node_id_counter_t =
- let* i = u64_add self.betree_node_id_counter_next_node_id 1 in
- Return { betree_node_id_counter_next_node_id = i }
-
-(** [core::num::u64::{9}::MAX] *)
-let core_num_u64_max_body : result u64 = Return 18446744073709551615
-let core_num_u64_max_c : u64 = eval_global core_num_u64_max_body
+let betree_NodeIdCounter_fresh_id_back
+ (self : betree_NodeIdCounter_t) : result betree_NodeIdCounter_t =
+ let* i = u64_add self.next_node_id 1 in Return { next_node_id = i }
(** [betree_main::betree::upsert_update]: forward function *)
-let betree_upsert_update_fwd
- (prev : option u64) (st : betree_upsert_fun_state_t) : result u64 =
+let betree_upsert_update
+ (prev : option u64) (st : betree_UpsertFunState_t) : result u64 =
begin match prev with
| None ->
begin match st with
- | BetreeUpsertFunStateAdd v -> Return v
- | BetreeUpsertFunStateSub i -> Return 0
+ | Betree_UpsertFunState_Add v -> Return v
+ | Betree_UpsertFunState_Sub i -> Return 0
end
| Some prev0 ->
begin match st with
- | BetreeUpsertFunStateAdd v ->
- let* margin = u64_sub core_num_u64_max_c prev0 in
- if margin >= v then u64_add prev0 v else Return core_num_u64_max_c
- | BetreeUpsertFunStateSub v ->
+ | Betree_UpsertFunState_Add v ->
+ let* margin = u64_sub core_u64_max prev0 in
+ if margin >= v then u64_add prev0 v else Return core_u64_max
+ | Betree_UpsertFunState_Sub v ->
if prev0 >= v then u64_sub prev0 v else Return 0
end
end
(** [betree_main::betree::List::{1}::len]: forward function *)
-let rec betree_list_len_fwd
- (t : Type0) (self : betree_list_t t) :
- Tot (result u64) (decreases (betree_list_len_decreases t self))
+let rec betree_List_len
+ (t : Type0) (self : betree_List_t t) :
+ Tot (result u64) (decreases (betree_List_len_decreases t self))
=
begin match self with
- | BetreeListCons x tl -> let* i = betree_list_len_fwd t tl in u64_add 1 i
- | BetreeListNil -> Return 0
+ | Betree_List_Cons x tl -> let* i = betree_List_len t tl in u64_add 1 i
+ | Betree_List_Nil -> Return 0
end
(** [betree_main::betree::List::{1}::split_at]: forward function *)
-let rec betree_list_split_at_fwd
- (t : Type0) (self : betree_list_t t) (n : u64) :
- Tot (result ((betree_list_t t) & (betree_list_t t)))
- (decreases (betree_list_split_at_decreases t self n))
+let rec betree_List_split_at
+ (t : Type0) (self : betree_List_t t) (n : u64) :
+ Tot (result ((betree_List_t t) & (betree_List_t t)))
+ (decreases (betree_List_split_at_decreases t self n))
=
if n = 0
- then Return (BetreeListNil, self)
+ then Return (Betree_List_Nil, self)
else
begin match self with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let* i = u64_sub n 1 in
- let* p = betree_list_split_at_fwd t tl i in
+ let* p = betree_List_split_at t tl i in
let (ls0, ls1) = p in
let l = ls0 in
- Return (BetreeListCons hd l, ls1)
- | BetreeListNil -> Fail Failure
+ Return (Betree_List_Cons hd l, ls1)
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{1}::push_front]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let betree_list_push_front_fwd_back
- (t : Type0) (self : betree_list_t t) (x : t) : result (betree_list_t t) =
- let tl = mem_replace_fwd (betree_list_t t) self BetreeListNil in
+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 (BetreeListCons x l)
+ Return (Betree_List_Cons x l)
(** [betree_main::betree::List::{1}::pop_front]: forward function *)
-let betree_list_pop_front_fwd (t : Type0) (self : betree_list_t t) : result t =
- let ls = mem_replace_fwd (betree_list_t t) self BetreeListNil in
+let betree_List_pop_front (t : Type0) (self : betree_List_t t) : result t =
+ let ls = core_mem_replace (betree_List_t t) self Betree_List_Nil in
begin match ls with
- | BetreeListCons x tl -> Return x
- | BetreeListNil -> Fail Failure
+ | Betree_List_Cons x tl -> Return x
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{1}::pop_front]: backward function 0 *)
-let betree_list_pop_front_back
- (t : Type0) (self : betree_list_t t) : result (betree_list_t t) =
- let ls = mem_replace_fwd (betree_list_t t) self BetreeListNil in
+let betree_List_pop_front_back
+ (t : Type0) (self : betree_List_t t) : result (betree_List_t t) =
+ let ls = core_mem_replace (betree_List_t t) self Betree_List_Nil in
begin match ls with
- | BetreeListCons x tl -> Return tl
- | BetreeListNil -> Fail Failure
+ | Betree_List_Cons x tl -> Return tl
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{1}::hd]: forward function *)
-let betree_list_hd_fwd (t : Type0) (self : betree_list_t t) : result t =
+let betree_List_hd (t : Type0) (self : betree_List_t t) : result t =
begin match self with
- | BetreeListCons hd l -> Return hd
- | BetreeListNil -> Fail Failure
+ | Betree_List_Cons hd l -> Return hd
+ | Betree_List_Nil -> Fail Failure
end
(** [betree_main::betree::List::{2}::head_has_key]: forward function *)
-let betree_list_head_has_key_fwd
- (t : Type0) (self : betree_list_t (u64 & t)) (key : u64) : result bool =
+let betree_List_head_has_key
+ (t : Type0) (self : betree_List_t (u64 & t)) (key : u64) : result bool =
begin match self with
- | BetreeListCons hd l -> let (i, _) = hd in Return (i = key)
- | BetreeListNil -> Return false
+ | Betree_List_Cons hd l -> let (i, _) = hd in Return (i = key)
+ | Betree_List_Nil -> Return false
end
(** [betree_main::betree::List::{2}::partition_at_pivot]: forward function *)
-let rec betree_list_partition_at_pivot_fwd
- (t : Type0) (self : betree_list_t (u64 & t)) (pivot : u64) :
- Tot (result ((betree_list_t (u64 & t)) & (betree_list_t (u64 & t))))
- (decreases (betree_list_partition_at_pivot_decreases t self pivot))
+let rec betree_List_partition_at_pivot
+ (t : Type0) (self : betree_List_t (u64 & t)) (pivot : u64) :
+ Tot (result ((betree_List_t (u64 & t)) & (betree_List_t (u64 & t))))
+ (decreases (betree_List_partition_at_pivot_decreases t self pivot))
=
begin match self with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, x) = hd in
if i >= pivot
- then Return (BetreeListNil, BetreeListCons (i, x) tl)
+ then Return (Betree_List_Nil, Betree_List_Cons (i, x) tl)
else
- let* p = betree_list_partition_at_pivot_fwd t tl pivot in
+ let* p = betree_List_partition_at_pivot t tl pivot in
let (ls0, ls1) = p in
let l = ls0 in
- Return (BetreeListCons (i, x) l, ls1)
- | BetreeListNil -> Return (BetreeListNil, BetreeListNil)
+ Return (Betree_List_Cons (i, x) l, ls1)
+ | Betree_List_Nil -> Return (Betree_List_Nil, Betree_List_Nil)
end
(** [betree_main::betree::Leaf::{3}::split]: forward function *)
-let betree_leaf_split_fwd
- (self : betree_leaf_t) (content : betree_list_t (u64 & u64))
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
+let betree_Leaf_split
+ (self : betree_Leaf_t) (content : betree_List_t (u64 & u64))
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
(st : state) :
- result (state & betree_internal_t)
+ result (state & betree_Internal_t)
=
- let* p =
- betree_list_split_at_fwd (u64 & u64) content
- params.betree_params_split_size in
+ let* p = betree_List_split_at (u64 & u64) content params.split_size in
let (content0, content1) = p in
- let* p0 = betree_list_hd_fwd (u64 & u64) content1 in
+ let* p0 = betree_List_hd (u64 & u64) content1 in
let (pivot, _) = p0 in
- let* id0 = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
- let* id1 = betree_node_id_counter_fresh_id_fwd node_id_cnt0 in
- let* (st0, _) = betree_store_leaf_node_fwd id0 content0 st in
- let* (st1, _) = betree_store_leaf_node_fwd id1 content1 st0 in
- let n = BetreeNodeLeaf
- { betree_leaf_id = id0; betree_leaf_size = params.betree_params_split_size
- } in
- let n0 = BetreeNodeLeaf
- { betree_leaf_id = id1; betree_leaf_size = params.betree_params_split_size
- } in
- Return (st1,
- {
- betree_internal_id = self.betree_leaf_id;
- betree_internal_pivot = pivot;
- betree_internal_left = n;
- betree_internal_right = n0
- })
+ let* id0 = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
+ let* id1 = betree_NodeIdCounter_fresh_id node_id_cnt0 in
+ let* (st0, _) = betree_store_leaf_node id0 content0 st in
+ let* (st1, _) = betree_store_leaf_node id1 content1 st0 in
+ let n = Betree_Node_Leaf { id = id0; size = params.split_size } in
+ let n0 = Betree_Node_Leaf { id = id1; size = params.split_size } in
+ Return (st1, { id = self.id; pivot = pivot; left = n; right = n0 })
(** [betree_main::betree::Leaf::{3}::split]: backward function 0 *)
-let betree_leaf_split_back0
- (self : betree_leaf_t) (content : betree_list_t (u64 & u64))
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
+let betree_Leaf_split_back0
+ (self : betree_Leaf_t) (content : betree_List_t (u64 & u64))
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
(st : state) (st0 : state) :
result (state & unit)
=
- let* p =
- betree_list_split_at_fwd (u64 & u64) content
- params.betree_params_split_size in
+ let* p = betree_List_split_at (u64 & u64) content params.split_size in
let (content0, content1) = p in
- let* _ = betree_list_hd_fwd (u64 & u64) content1 in
- let* id0 = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
- let* id1 = betree_node_id_counter_fresh_id_fwd node_id_cnt0 in
- let* (st1, _) = betree_store_leaf_node_fwd id0 content0 st in
- let* _ = betree_store_leaf_node_fwd id1 content1 st1 in
+ let* _ = betree_List_hd (u64 & u64) content1 in
+ let* id0 = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
+ let* id1 = betree_NodeIdCounter_fresh_id node_id_cnt0 in
+ let* (st1, _) = betree_store_leaf_node id0 content0 st in
+ let* _ = betree_store_leaf_node id1 content1 st1 in
Return (st0, ())
(** [betree_main::betree::Leaf::{3}::split]: backward function 1 *)
-let betree_leaf_split_back1
- (self : betree_leaf_t) (content : betree_list_t (u64 & u64))
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
+let betree_Leaf_split_back1
+ (self : betree_Leaf_t) (content : betree_List_t (u64 & u64))
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
(st : state) (st0 : state) :
result (state & unit)
=
- let* p =
- betree_list_split_at_fwd (u64 & u64) content
- params.betree_params_split_size in
+ let* p = betree_List_split_at (u64 & u64) content params.split_size in
let (content0, content1) = p in
- let* _ = betree_list_hd_fwd (u64 & u64) content1 in
- let* id0 = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
- let* id1 = betree_node_id_counter_fresh_id_fwd node_id_cnt0 in
- let* (st1, _) = betree_store_leaf_node_fwd id0 content0 st in
- let* _ = betree_store_leaf_node_fwd id1 content1 st1 in
+ let* _ = betree_List_hd (u64 & u64) content1 in
+ let* id0 = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
+ let* id1 = betree_NodeIdCounter_fresh_id node_id_cnt0 in
+ let* (st1, _) = betree_store_leaf_node id0 content0 st in
+ let* _ = betree_store_leaf_node id1 content1 st1 in
Return (st0, ())
(** [betree_main::betree::Leaf::{3}::split]: backward function 2 *)
-let betree_leaf_split_back2
- (self : betree_leaf_t) (content : betree_list_t (u64 & u64))
- (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t)
+let betree_Leaf_split_back2
+ (self : betree_Leaf_t) (content : betree_List_t (u64 & u64))
+ (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
(st : state) (st0 : state) :
- result (state & betree_node_id_counter_t)
+ result (state & betree_NodeIdCounter_t)
=
- let* p =
- betree_list_split_at_fwd (u64 & u64) content
- params.betree_params_split_size in
+ let* p = betree_List_split_at (u64 & u64) content params.split_size in
let (content0, content1) = p in
- let* _ = betree_list_hd_fwd (u64 & u64) content1 in
- let* id0 = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
- let* id1 = betree_node_id_counter_fresh_id_fwd node_id_cnt0 in
- let* (st1, _) = betree_store_leaf_node_fwd id0 content0 st in
- let* _ = betree_store_leaf_node_fwd id1 content1 st1 in
- let* node_id_cnt1 = betree_node_id_counter_fresh_id_back node_id_cnt0 in
+ let* _ = betree_List_hd (u64 & u64) content1 in
+ let* id0 = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
+ let* id1 = betree_NodeIdCounter_fresh_id node_id_cnt0 in
+ let* (st1, _) = betree_store_leaf_node id0 content0 st in
+ let* _ = betree_store_leaf_node id1 content1 st1 in
+ let* node_id_cnt1 = betree_NodeIdCounter_fresh_id_back node_id_cnt0 in
Return (st0, node_id_cnt1)
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: forward function *)
-let rec betree_node_lookup_first_message_for_key_fwd
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_for_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_for_key
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_for_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons x next_msgs ->
+ | Betree_List_Cons x next_msgs ->
let (i, m) = x in
if i >= key
- then Return (BetreeListCons (i, m) next_msgs)
- else betree_node_lookup_first_message_for_key_fwd key next_msgs
- | BetreeListNil -> Return BetreeListNil
+ then Return (Betree_List_Cons (i, m) next_msgs)
+ else betree_Node_lookup_first_message_for_key key next_msgs
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: backward function 0 *)
-let rec betree_node_lookup_first_message_for_key_back
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t))
- (ret : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_for_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_for_key_back
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t))
+ (ret : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_for_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons x next_msgs ->
+ | Betree_List_Cons x next_msgs ->
let (i, m) = x in
if i >= key
then Return ret
else
let* next_msgs0 =
- betree_node_lookup_first_message_for_key_back key next_msgs ret in
- Return (BetreeListCons (i, m) next_msgs0)
- | BetreeListNil -> Return ret
+ betree_Node_lookup_first_message_for_key_back key next_msgs ret in
+ Return (Betree_List_Cons (i, m) next_msgs0)
+ | Betree_List_Nil -> Return ret
end
(** [betree_main::betree::Node::{5}::apply_upserts]: forward function *)
-let rec betree_node_apply_upserts_fwd
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
+let rec betree_Node_apply_upserts
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
(key : u64) (st : state) :
Tot (result (state & u64))
- (decreases (betree_node_apply_upserts_decreases msgs prev key st))
+ (decreases (betree_Node_apply_upserts_decreases msgs prev key st))
=
- let* b = betree_list_head_has_key_fwd betree_message_t msgs key in
+ let* b = betree_List_head_has_key betree_Message_t msgs key in
if b
then
- let* msg = betree_list_pop_front_fwd (u64 & betree_message_t) msgs in
+ let* msg = betree_List_pop_front (u64 & betree_Message_t) msgs in
let (_, m) = msg in
begin match m with
- | BetreeMessageInsert i -> Fail Failure
- | BetreeMessageDelete -> Fail Failure
- | BetreeMessageUpsert s ->
- let* v = betree_upsert_update_fwd prev s in
- let* msgs0 = betree_list_pop_front_back (u64 & betree_message_t) msgs in
- betree_node_apply_upserts_fwd msgs0 (Some v) key st
+ | Betree_Message_Insert i -> Fail Failure
+ | Betree_Message_Delete -> Fail Failure
+ | Betree_Message_Upsert s ->
+ let* v = betree_upsert_update prev s in
+ let* msgs0 = betree_List_pop_front_back (u64 & betree_Message_t) msgs in
+ betree_Node_apply_upserts msgs0 (Some v) key st
end
else
- let* (st0, v) = core_option_option_unwrap_fwd u64 prev st in
+ let* (st0, v) = core_option_Option_unwrap u64 prev st in
let* _ =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs (key,
- BetreeMessageInsert v) in
+ betree_List_push_front (u64 & betree_Message_t) msgs (key,
+ Betree_Message_Insert v) in
Return (st0, v)
(** [betree_main::betree::Node::{5}::apply_upserts]: backward function 0 *)
-let rec betree_node_apply_upserts_back
- (msgs : betree_list_t (u64 & betree_message_t)) (prev : option u64)
+let rec betree_Node_apply_upserts_back
+ (msgs : betree_List_t (u64 & betree_Message_t)) (prev : option u64)
(key : u64) (st : state) (st0 : state) :
- Tot (result (state & (betree_list_t (u64 & betree_message_t))))
- (decreases (betree_node_apply_upserts_decreases msgs prev key st))
+ Tot (result (state & (betree_List_t (u64 & betree_Message_t))))
+ (decreases (betree_Node_apply_upserts_decreases msgs prev key st))
=
- let* b = betree_list_head_has_key_fwd betree_message_t msgs key in
+ let* b = betree_List_head_has_key betree_Message_t msgs key in
if b
then
- let* msg = betree_list_pop_front_fwd (u64 & betree_message_t) msgs in
+ let* msg = betree_List_pop_front (u64 & betree_Message_t) msgs in
let (_, m) = msg in
begin match m with
- | BetreeMessageInsert i -> Fail Failure
- | BetreeMessageDelete -> Fail Failure
- | BetreeMessageUpsert s ->
- let* v = betree_upsert_update_fwd prev s in
- let* msgs0 = betree_list_pop_front_back (u64 & betree_message_t) msgs in
- betree_node_apply_upserts_back msgs0 (Some v) key st st0
+ | Betree_Message_Insert i -> Fail Failure
+ | Betree_Message_Delete -> Fail Failure
+ | Betree_Message_Upsert s ->
+ let* v = betree_upsert_update prev s in
+ let* msgs0 = betree_List_pop_front_back (u64 & betree_Message_t) msgs in
+ betree_Node_apply_upserts_back msgs0 (Some v) key st st0
end
else
- let* (_, v) = core_option_option_unwrap_fwd u64 prev st in
+ let* (_, v) = core_option_Option_unwrap u64 prev st in
let* msgs0 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs (key,
- BetreeMessageInsert v) in
+ betree_List_push_front (u64 & betree_Message_t) msgs (key,
+ Betree_Message_Insert v) in
Return (st0, msgs0)
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: forward function *)
-let rec betree_node_lookup_in_bindings_fwd
- (key : u64) (bindings : betree_list_t (u64 & u64)) :
+let rec betree_Node_lookup_in_bindings
+ (key : u64) (bindings : betree_List_t (u64 & u64)) :
Tot (result (option u64))
- (decreases (betree_node_lookup_in_bindings_decreases key bindings))
+ (decreases (betree_Node_lookup_in_bindings_decreases key bindings))
=
begin match bindings with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, i0) = hd in
if i = key
then Return (Some i0)
- else
- if i > key
- then Return None
- else betree_node_lookup_in_bindings_fwd key tl
- | BetreeListNil -> Return None
+ else if i > key then Return None else betree_Node_lookup_in_bindings key tl
+ | Betree_List_Nil -> Return None
end
(** [betree_main::betree::Internal::{4}::lookup_in_children]: forward function *)
-let rec betree_internal_lookup_in_children_fwd
- (self : betree_internal_t) (key : u64) (st : state) :
+let rec betree_Internal_lookup_in_children
+ (self : betree_Internal_t) (key : u64) (st : state) :
Tot (result (state & (option u64)))
- (decreases (betree_internal_lookup_in_children_decreases self key st))
+ (decreases (betree_Internal_lookup_in_children_decreases self key st))
=
- if key < self.betree_internal_pivot
- then betree_node_lookup_fwd self.betree_internal_left key st
- else betree_node_lookup_fwd self.betree_internal_right key st
+ if key < self.pivot
+ then betree_Node_lookup self.left key st
+ else betree_Node_lookup self.right key st
(** [betree_main::betree::Internal::{4}::lookup_in_children]: backward function 0 *)
-and betree_internal_lookup_in_children_back
- (self : betree_internal_t) (key : u64) (st : state) (st0 : state) :
- Tot (result (state & betree_internal_t))
- (decreases (betree_internal_lookup_in_children_decreases self key st))
+and betree_Internal_lookup_in_children_back
+ (self : betree_Internal_t) (key : u64) (st : state) (st0 : state) :
+ Tot (result (state & betree_Internal_t))
+ (decreases (betree_Internal_lookup_in_children_decreases self key st))
=
- if key < self.betree_internal_pivot
+ if key < self.pivot
then
- let* (st1, n) =
- betree_node_lookup_back self.betree_internal_left key st st0 in
- Return (st1, { self with betree_internal_left = n })
+ let* (st1, n) = betree_Node_lookup_back self.left key st st0 in
+ Return (st1, { self with left = n })
else
- let* (st1, n) =
- betree_node_lookup_back self.betree_internal_right key st st0 in
- Return (st1, { self with betree_internal_right = n })
+ let* (st1, n) = betree_Node_lookup_back self.right key st st0 in
+ Return (st1, { self with right = n })
(** [betree_main::betree::Node::{5}::lookup]: forward function *)
-and betree_node_lookup_fwd
- (self : betree_node_t) (key : u64) (st : state) :
+and betree_Node_lookup
+ (self : betree_Node_t) (key : u64) (st : state) :
Tot (result (state & (option u64)))
- (decreases (betree_node_lookup_decreases self key st))
+ (decreases (betree_Node_lookup_decreases self key st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st0, msgs) = betree_load_internal_node_fwd node.betree_internal_id st
- in
- let* pending = betree_node_lookup_first_message_for_key_fwd key msgs in
+ | Betree_Node_Internal node ->
+ let* (st0, msgs) = betree_load_internal_node node.id st in
+ let* pending = betree_Node_lookup_first_message_for_key key msgs in
begin match pending with
- | BetreeListCons p l ->
+ | Betree_List_Cons p l ->
let (k, msg) = p in
if k <> key
then
- let* (st1, opt) = betree_internal_lookup_in_children_fwd node key st0
- in
+ let* (st1, o) = betree_Internal_lookup_in_children node key st0 in
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, msg) l) in
- Return (st1, opt)
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, msg) l) in
+ Return (st1, o)
else
begin match msg with
- | BetreeMessageInsert v ->
+ | Betree_Message_Insert v ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageInsert v) l) in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Insert v) l) in
Return (st0, Some v)
- | BetreeMessageDelete ->
+ | Betree_Message_Delete ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageDelete) l) in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Delete) l) in
Return (st0, None)
- | BetreeMessageUpsert ufs ->
- let* (st1, v) = betree_internal_lookup_in_children_fwd node key st0
- in
+ | Betree_Message_Upsert ufs ->
+ let* (st1, v) = betree_Internal_lookup_in_children node key st0 in
let* (st2, v0) =
- betree_node_apply_upserts_fwd (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1 in
+ betree_Node_apply_upserts (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1 in
let* (st3, node0) =
- betree_internal_lookup_in_children_back node key st0 st2 in
+ betree_Internal_lookup_in_children_back node key st0 st2 in
let* (st4, pending0) =
- betree_node_apply_upserts_back (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1 st3 in
+ betree_Node_apply_upserts_back (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1 st3 in
let* msgs0 =
- betree_node_lookup_first_message_for_key_back key msgs pending0 in
- let* (st5, _) =
- betree_store_internal_node_fwd node0.betree_internal_id msgs0 st4
- in
+ betree_Node_lookup_first_message_for_key_back key msgs pending0 in
+ let* (st5, _) = betree_store_internal_node node0.id msgs0 st4 in
Return (st5, Some v0)
end
- | BetreeListNil ->
- let* (st1, opt) = betree_internal_lookup_in_children_fwd node key st0 in
+ | Betree_List_Nil ->
+ let* (st1, o) = betree_Internal_lookup_in_children node key st0 in
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs BetreeListNil in
- Return (st1, opt)
+ betree_Node_lookup_first_message_for_key_back key msgs Betree_List_Nil
+ in
+ Return (st1, o)
end
- | BetreeNodeLeaf node ->
- let* (st0, bindings) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* opt = betree_node_lookup_in_bindings_fwd key bindings in
- Return (st0, opt)
+ | Betree_Node_Leaf node ->
+ let* (st0, bindings) = betree_load_leaf_node node.id st in
+ let* o = betree_Node_lookup_in_bindings key bindings in
+ Return (st0, o)
end
(** [betree_main::betree::Node::{5}::lookup]: backward function 0 *)
-and betree_node_lookup_back
- (self : betree_node_t) (key : u64) (st : state) (st0 : state) :
- Tot (result (state & betree_node_t))
- (decreases (betree_node_lookup_decreases self key st))
+and betree_Node_lookup_back
+ (self : betree_Node_t) (key : u64) (st : state) (st0 : state) :
+ Tot (result (state & betree_Node_t))
+ (decreases (betree_Node_lookup_decreases self key st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st1, msgs) = betree_load_internal_node_fwd node.betree_internal_id st
- in
- let* pending = betree_node_lookup_first_message_for_key_fwd key msgs in
+ | Betree_Node_Internal node ->
+ let* (st1, msgs) = betree_load_internal_node node.id st in
+ let* pending = betree_Node_lookup_first_message_for_key key msgs in
begin match pending with
- | BetreeListCons p l ->
+ | Betree_List_Cons p l ->
let (k, msg) = p in
if k <> key
then
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, msg) l) in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, msg) l) in
let* (st2, node0) =
- betree_internal_lookup_in_children_back node key st1 st0 in
- Return (st2, BetreeNodeInternal node0)
+ betree_Internal_lookup_in_children_back node key st1 st0 in
+ Return (st2, Betree_Node_Internal node0)
else
begin match msg with
- | BetreeMessageInsert v ->
+ | Betree_Message_Insert v ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageInsert v) l) in
- Return (st0, BetreeNodeInternal node)
- | BetreeMessageDelete ->
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Insert v) l) in
+ Return (st0, Betree_Node_Internal node)
+ | Betree_Message_Delete ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs
- (BetreeListCons (k, BetreeMessageDelete) l) in
- Return (st0, BetreeNodeInternal node)
- | BetreeMessageUpsert ufs ->
- let* (st2, v) = betree_internal_lookup_in_children_fwd node key st1
- in
+ betree_Node_lookup_first_message_for_key_back key msgs
+ (Betree_List_Cons (k, Betree_Message_Delete) l) in
+ Return (st0, Betree_Node_Internal node)
+ | Betree_Message_Upsert ufs ->
+ let* (st2, v) = betree_Internal_lookup_in_children node key st1 in
let* (st3, _) =
- betree_node_apply_upserts_fwd (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st2 in
+ betree_Node_apply_upserts (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st2 in
let* (st4, node0) =
- betree_internal_lookup_in_children_back node key st1 st3 in
+ betree_Internal_lookup_in_children_back node key st1 st3 in
let* (st5, pending0) =
- betree_node_apply_upserts_back (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st2 st4 in
+ betree_Node_apply_upserts_back (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st2 st4 in
let* msgs0 =
- betree_node_lookup_first_message_for_key_back key msgs pending0 in
- let* _ =
- betree_store_internal_node_fwd node0.betree_internal_id msgs0 st5
- in
- Return (st0, BetreeNodeInternal node0)
+ betree_Node_lookup_first_message_for_key_back key msgs pending0 in
+ let* _ = betree_store_internal_node node0.id msgs0 st5 in
+ Return (st0, Betree_Node_Internal node0)
end
- | BetreeListNil ->
+ | Betree_List_Nil ->
let* _ =
- betree_node_lookup_first_message_for_key_back key msgs BetreeListNil in
+ betree_Node_lookup_first_message_for_key_back key msgs Betree_List_Nil
+ in
let* (st2, node0) =
- betree_internal_lookup_in_children_back node key st1 st0 in
- Return (st2, BetreeNodeInternal node0)
+ betree_Internal_lookup_in_children_back node key st1 st0 in
+ Return (st2, Betree_Node_Internal node0)
end
- | BetreeNodeLeaf node ->
- let* (_, bindings) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* _ = betree_node_lookup_in_bindings_fwd key bindings in
- Return (st0, BetreeNodeLeaf node)
+ | Betree_Node_Leaf node ->
+ let* (_, bindings) = betree_load_leaf_node node.id st in
+ let* _ = betree_Node_lookup_in_bindings key bindings in
+ Return (st0, Betree_Node_Leaf node)
end
(** [betree_main::betree::Node::{5}::filter_messages_for_key]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec betree_node_filter_messages_for_key_fwd_back
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_filter_messages_for_key_decreases key msgs))
+let rec betree_Node_filter_messages_for_key
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_filter_messages_for_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons p l ->
+ | Betree_List_Cons p l ->
let (k, m) = p in
if k = key
then
let* msgs0 =
- betree_list_pop_front_back (u64 & betree_message_t) (BetreeListCons (k,
- m) l) in
- betree_node_filter_messages_for_key_fwd_back key msgs0
- else Return (BetreeListCons (k, m) l)
- | BetreeListNil -> Return BetreeListNil
+ betree_List_pop_front_back (u64 & betree_Message_t) (Betree_List_Cons
+ (k, m) l) in
+ betree_Node_filter_messages_for_key key msgs0
+ else Return (Betree_List_Cons (k, m) l)
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: forward function *)
-let rec betree_node_lookup_first_message_after_key_fwd
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_after_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_after_key
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_after_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons p next_msgs ->
+ | Betree_List_Cons p next_msgs ->
let (k, m) = p in
if k = key
- then betree_node_lookup_first_message_after_key_fwd key next_msgs
- else Return (BetreeListCons (k, m) next_msgs)
- | BetreeListNil -> Return BetreeListNil
+ then betree_Node_lookup_first_message_after_key key next_msgs
+ else Return (Betree_List_Cons (k, m) next_msgs)
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: backward function 0 *)
-let rec betree_node_lookup_first_message_after_key_back
- (key : u64) (msgs : betree_list_t (u64 & betree_message_t))
- (ret : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_lookup_first_message_after_key_decreases key msgs))
+let rec betree_Node_lookup_first_message_after_key_back
+ (key : u64) (msgs : betree_List_t (u64 & betree_Message_t))
+ (ret : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_lookup_first_message_after_key_decreases key msgs))
=
begin match msgs with
- | BetreeListCons p next_msgs ->
+ | Betree_List_Cons p next_msgs ->
let (k, m) = p in
if k = key
then
let* next_msgs0 =
- betree_node_lookup_first_message_after_key_back key next_msgs ret in
- Return (BetreeListCons (k, m) next_msgs0)
+ betree_Node_lookup_first_message_after_key_back key next_msgs ret in
+ Return (Betree_List_Cons (k, m) next_msgs0)
else Return ret
- | BetreeListNil -> Return ret
+ | Betree_List_Nil -> Return ret
end
(** [betree_main::betree::Node::{5}::apply_to_internal]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let betree_node_apply_to_internal_fwd_back
- (msgs : betree_list_t (u64 & betree_message_t)) (key : u64)
- (new_msg : betree_message_t) :
- result (betree_list_t (u64 & betree_message_t))
+let betree_Node_apply_to_internal
+ (msgs : betree_List_t (u64 & betree_Message_t)) (key : u64)
+ (new_msg : betree_Message_t) :
+ result (betree_List_t (u64 & betree_Message_t))
=
- let* msgs0 = betree_node_lookup_first_message_for_key_fwd key msgs in
- let* b = betree_list_head_has_key_fwd betree_message_t msgs0 key in
+ let* msgs0 = betree_Node_lookup_first_message_for_key key msgs in
+ let* b = betree_List_head_has_key betree_Message_t msgs0 key in
if b
then
begin match new_msg with
- | BetreeMessageInsert i ->
- let* msgs1 = betree_node_filter_messages_for_key_fwd_back key msgs0 in
+ | Betree_Message_Insert i ->
+ let* msgs1 = betree_Node_filter_messages_for_key key msgs0 in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageInsert i) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageDelete ->
- let* msgs1 = betree_node_filter_messages_for_key_fwd_back key msgs0 in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Insert i) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Delete ->
+ let* msgs1 = betree_Node_filter_messages_for_key key msgs0 in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageDelete) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageUpsert s ->
- let* p = betree_list_hd_fwd (u64 & betree_message_t) msgs0 in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Delete) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Upsert s ->
+ let* p = betree_List_hd (u64 & betree_Message_t) msgs0 in
let (_, m) = p in
begin match m with
- | BetreeMessageInsert prev ->
- let* v = betree_upsert_update_fwd (Some prev) s in
- let* msgs1 = betree_list_pop_front_back (u64 & betree_message_t) msgs0
+ | Betree_Message_Insert prev ->
+ let* v = betree_upsert_update (Some prev) s in
+ let* msgs1 = betree_List_pop_front_back (u64 & betree_Message_t) msgs0
in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageInsert v) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageDelete ->
- let* v = betree_upsert_update_fwd None s in
- let* msgs1 = betree_list_pop_front_back (u64 & betree_message_t) msgs0
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Insert v) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Delete ->
+ let* v = betree_upsert_update None s in
+ let* msgs1 = betree_List_pop_front_back (u64 & betree_Message_t) msgs0
in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageInsert v) in
- betree_node_lookup_first_message_for_key_back key msgs msgs2
- | BetreeMessageUpsert ufs ->
- let* msgs1 = betree_node_lookup_first_message_after_key_fwd key msgs0
- in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Insert v) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs2
+ | Betree_Message_Upsert ufs ->
+ let* msgs1 = betree_Node_lookup_first_message_after_key key msgs0 in
let* msgs2 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs1 (key,
- BetreeMessageUpsert s) in
+ betree_List_push_front (u64 & betree_Message_t) msgs1 (key,
+ Betree_Message_Upsert s) in
let* msgs3 =
- betree_node_lookup_first_message_after_key_back key msgs0 msgs2 in
- betree_node_lookup_first_message_for_key_back key msgs msgs3
+ betree_Node_lookup_first_message_after_key_back key msgs0 msgs2 in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs3
end
end
else
let* msgs1 =
- betree_list_push_front_fwd_back (u64 & betree_message_t) msgs0 (key,
- new_msg) in
- betree_node_lookup_first_message_for_key_back key msgs msgs1
+ betree_List_push_front (u64 & betree_Message_t) msgs0 (key, new_msg) in
+ betree_Node_lookup_first_message_for_key_back key msgs msgs1
(** [betree_main::betree::Node::{5}::apply_messages_to_internal]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec betree_node_apply_messages_to_internal_fwd_back
- (msgs : betree_list_t (u64 & betree_message_t))
- (new_msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & betree_message_t)))
- (decreases (betree_node_apply_messages_to_internal_decreases msgs new_msgs))
+let rec betree_Node_apply_messages_to_internal
+ (msgs : betree_List_t (u64 & betree_Message_t))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & betree_Message_t)))
+ (decreases (betree_Node_apply_messages_to_internal_decreases msgs new_msgs))
=
begin match new_msgs with
- | BetreeListCons new_msg new_msgs_tl ->
+ | Betree_List_Cons new_msg new_msgs_tl ->
let (i, m) = new_msg in
- let* msgs0 = betree_node_apply_to_internal_fwd_back msgs i m in
- betree_node_apply_messages_to_internal_fwd_back msgs0 new_msgs_tl
- | BetreeListNil -> Return msgs
+ let* msgs0 = betree_Node_apply_to_internal msgs i m in
+ betree_Node_apply_messages_to_internal msgs0 new_msgs_tl
+ | Betree_List_Nil -> Return msgs
end
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: forward function *)
-let rec betree_node_lookup_mut_in_bindings_fwd
- (key : u64) (bindings : betree_list_t (u64 & u64)) :
- Tot (result (betree_list_t (u64 & u64)))
- (decreases (betree_node_lookup_mut_in_bindings_decreases key bindings))
+let rec betree_Node_lookup_mut_in_bindings
+ (key : u64) (bindings : betree_List_t (u64 & u64)) :
+ Tot (result (betree_List_t (u64 & u64)))
+ (decreases (betree_Node_lookup_mut_in_bindings_decreases key bindings))
=
begin match bindings with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, i0) = hd in
if i >= key
- then Return (BetreeListCons (i, i0) tl)
- else betree_node_lookup_mut_in_bindings_fwd key tl
- | BetreeListNil -> Return BetreeListNil
+ then Return (Betree_List_Cons (i, i0) tl)
+ else betree_Node_lookup_mut_in_bindings key tl
+ | Betree_List_Nil -> Return Betree_List_Nil
end
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: backward function 0 *)
-let rec betree_node_lookup_mut_in_bindings_back
- (key : u64) (bindings : betree_list_t (u64 & u64))
- (ret : betree_list_t (u64 & u64)) :
- Tot (result (betree_list_t (u64 & u64)))
- (decreases (betree_node_lookup_mut_in_bindings_decreases key bindings))
+let rec betree_Node_lookup_mut_in_bindings_back
+ (key : u64) (bindings : betree_List_t (u64 & u64))
+ (ret : betree_List_t (u64 & u64)) :
+ Tot (result (betree_List_t (u64 & u64)))
+ (decreases (betree_Node_lookup_mut_in_bindings_decreases key bindings))
=
begin match bindings with
- | BetreeListCons hd tl ->
+ | Betree_List_Cons hd tl ->
let (i, i0) = hd in
if i >= key
then Return ret
else
- let* tl0 = betree_node_lookup_mut_in_bindings_back key tl ret in
- Return (BetreeListCons (i, i0) tl0)
- | BetreeListNil -> Return ret
+ let* tl0 = betree_Node_lookup_mut_in_bindings_back key tl ret in
+ Return (Betree_List_Cons (i, i0) tl0)
+ | Betree_List_Nil -> Return ret
end
(** [betree_main::betree::Node::{5}::apply_to_leaf]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let betree_node_apply_to_leaf_fwd_back
- (bindings : betree_list_t (u64 & u64)) (key : u64)
- (new_msg : betree_message_t) :
- result (betree_list_t (u64 & u64))
+let betree_Node_apply_to_leaf
+ (bindings : betree_List_t (u64 & u64)) (key : u64)
+ (new_msg : betree_Message_t) :
+ result (betree_List_t (u64 & u64))
=
- let* bindings0 = betree_node_lookup_mut_in_bindings_fwd key bindings in
- let* b = betree_list_head_has_key_fwd u64 bindings0 key in
+ let* bindings0 = betree_Node_lookup_mut_in_bindings key bindings in
+ let* b = betree_List_head_has_key u64 bindings0 key in
if b
then
- let* hd = betree_list_pop_front_fwd (u64 & u64) bindings0 in
+ let* hd = betree_List_pop_front (u64 & u64) bindings0 in
begin match new_msg with
- | BetreeMessageInsert v ->
- let* bindings1 = betree_list_pop_front_back (u64 & u64) bindings0 in
- let* bindings2 =
- betree_list_push_front_fwd_back (u64 & u64) bindings1 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings2
- | BetreeMessageDelete ->
- let* bindings1 = betree_list_pop_front_back (u64 & u64) bindings0 in
- betree_node_lookup_mut_in_bindings_back key bindings bindings1
- | BetreeMessageUpsert s ->
+ | Betree_Message_Insert v ->
+ let* bindings1 = betree_List_pop_front_back (u64 & u64) bindings0 in
+ let* bindings2 = betree_List_push_front (u64 & u64) bindings1 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings2
+ | Betree_Message_Delete ->
+ let* bindings1 = betree_List_pop_front_back (u64 & u64) bindings0 in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings1
+ | Betree_Message_Upsert s ->
let (_, i) = hd in
- let* v = betree_upsert_update_fwd (Some i) s in
- let* bindings1 = betree_list_pop_front_back (u64 & u64) bindings0 in
- let* bindings2 =
- betree_list_push_front_fwd_back (u64 & u64) bindings1 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings2
+ let* v = betree_upsert_update (Some i) s in
+ let* bindings1 = betree_List_pop_front_back (u64 & u64) bindings0 in
+ let* bindings2 = betree_List_push_front (u64 & u64) bindings1 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings2
end
else
begin match new_msg with
- | BetreeMessageInsert v ->
- let* bindings1 =
- betree_list_push_front_fwd_back (u64 & u64) bindings0 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings1
- | BetreeMessageDelete ->
- betree_node_lookup_mut_in_bindings_back key bindings bindings0
- | BetreeMessageUpsert s ->
- let* v = betree_upsert_update_fwd None s in
- let* bindings1 =
- betree_list_push_front_fwd_back (u64 & u64) bindings0 (key, v) in
- betree_node_lookup_mut_in_bindings_back key bindings bindings1
+ | Betree_Message_Insert v ->
+ let* bindings1 = betree_List_push_front (u64 & u64) bindings0 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings1
+ | Betree_Message_Delete ->
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings0
+ | Betree_Message_Upsert s ->
+ let* v = betree_upsert_update None s in
+ let* bindings1 = betree_List_push_front (u64 & u64) bindings0 (key, v) in
+ betree_Node_lookup_mut_in_bindings_back key bindings bindings1
end
(** [betree_main::betree::Node::{5}::apply_messages_to_leaf]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec betree_node_apply_messages_to_leaf_fwd_back
- (bindings : betree_list_t (u64 & u64))
- (new_msgs : betree_list_t (u64 & betree_message_t)) :
- Tot (result (betree_list_t (u64 & u64)))
- (decreases (betree_node_apply_messages_to_leaf_decreases bindings new_msgs))
+let rec betree_Node_apply_messages_to_leaf
+ (bindings : betree_List_t (u64 & u64))
+ (new_msgs : betree_List_t (u64 & betree_Message_t)) :
+ Tot (result (betree_List_t (u64 & u64)))
+ (decreases (betree_Node_apply_messages_to_leaf_decreases bindings new_msgs))
=
begin match new_msgs with
- | BetreeListCons new_msg new_msgs_tl ->
+ | Betree_List_Cons new_msg new_msgs_tl ->
let (i, m) = new_msg in
- let* bindings0 = betree_node_apply_to_leaf_fwd_back bindings i m in
- betree_node_apply_messages_to_leaf_fwd_back bindings0 new_msgs_tl
- | BetreeListNil -> Return bindings
+ let* bindings0 = betree_Node_apply_to_leaf bindings i m in
+ betree_Node_apply_messages_to_leaf bindings0 new_msgs_tl
+ | Betree_List_Nil -> Return bindings
end
(** [betree_main::betree::Internal::{4}::flush]: forward function *)
-let rec betree_internal_flush_fwd
- (self : betree_internal_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) :
- Tot (result (state & (betree_list_t (u64 & betree_message_t))))
+let rec betree_Internal_flush
+ (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) :
+ Tot (result (state & (betree_List_t (u64 & betree_Message_t))))
(decreases (
- betree_internal_flush_decreases self params node_id_cnt content st))
+ betree_Internal_flush_decreases self params node_id_cnt content st))
=
- let* p =
- betree_list_partition_at_pivot_fwd betree_message_t content
- self.betree_internal_pivot in
+ let* p = betree_List_partition_at_pivot betree_Message_t content self.pivot
+ in
let (msgs_left, msgs_right) = p in
- let* len_left = betree_list_len_fwd (u64 & betree_message_t) msgs_left in
- if len_left >= params.betree_params_min_flush_size
+ let* len_left = betree_List_len (u64 & betree_Message_t) msgs_left in
+ if len_left >= params.min_flush_size
then
let* (st0, _) =
- betree_node_apply_messages_fwd self.betree_internal_left params
- node_id_cnt msgs_left st in
+ betree_Node_apply_messages self.left params node_id_cnt msgs_left st in
let* (st1, (_, node_id_cnt0)) =
- betree_node_apply_messages_back'a self.betree_internal_left params
- node_id_cnt msgs_left st st0 in
+ betree_Node_apply_messages_back'a self.left params node_id_cnt msgs_left
+ st st0 in
let* (st2, ()) =
- betree_node_apply_messages_back1 self.betree_internal_left params
- node_id_cnt msgs_left st st1 in
- let* len_right = betree_list_len_fwd (u64 & betree_message_t) msgs_right in
- if len_right >= params.betree_params_min_flush_size
+ betree_Node_apply_messages_back1 self.left params node_id_cnt msgs_left
+ st st1 in
+ let* len_right = betree_List_len (u64 & betree_Message_t) msgs_right in
+ if len_right >= params.min_flush_size
then
let* (st3, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt0 msgs_right st2 in
+ betree_Node_apply_messages self.right params node_id_cnt0 msgs_right
+ st2 in
let* (st4, (_, _)) =
- betree_node_apply_messages_back'a self.betree_internal_right params
- node_id_cnt0 msgs_right st2 st3 in
+ betree_Node_apply_messages_back'a self.right params node_id_cnt0
+ msgs_right st2 st3 in
let* (st5, ()) =
- betree_node_apply_messages_back1 self.betree_internal_right params
- node_id_cnt0 msgs_right st2 st4 in
- Return (st5, BetreeListNil)
+ betree_Node_apply_messages_back1 self.right params node_id_cnt0
+ msgs_right st2 st4 in
+ Return (st5, Betree_List_Nil)
else Return (st2, msgs_right)
else
let* (st0, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt msgs_right st in
+ betree_Node_apply_messages self.right params node_id_cnt msgs_right st in
let* (st1, (_, _)) =
- betree_node_apply_messages_back'a self.betree_internal_right params
- node_id_cnt msgs_right st st0 in
+ betree_Node_apply_messages_back'a self.right params node_id_cnt
+ msgs_right st st0 in
let* (st2, ()) =
- betree_node_apply_messages_back1 self.betree_internal_right params
- node_id_cnt msgs_right st st1 in
+ betree_Node_apply_messages_back1 self.right params node_id_cnt msgs_right
+ st st1 in
Return (st2, msgs_left)
(** [betree_main::betree::Internal::{4}::flush]: backward function 0 *)
-and betree_internal_flush_back'a
- (self : betree_internal_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) (st0 : state)
+and betree_Internal_flush_back'a
+ (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) (st0 : state)
:
- Tot (result (state & (betree_internal_t & betree_node_id_counter_t)))
+ Tot (result (state & (betree_Internal_t & betree_NodeIdCounter_t)))
(decreases (
- betree_internal_flush_decreases self params node_id_cnt content st))
+ betree_Internal_flush_decreases self params node_id_cnt content st))
=
- let* p =
- betree_list_partition_at_pivot_fwd betree_message_t content
- self.betree_internal_pivot in
+ let* p = betree_List_partition_at_pivot betree_Message_t content self.pivot
+ in
let (msgs_left, msgs_right) = p in
- let* len_left = betree_list_len_fwd (u64 & betree_message_t) msgs_left in
- if len_left >= params.betree_params_min_flush_size
+ let* len_left = betree_List_len (u64 & betree_Message_t) msgs_left in
+ if len_left >= params.min_flush_size
then
let* (st1, _) =
- betree_node_apply_messages_fwd self.betree_internal_left params
- node_id_cnt msgs_left st in
+ betree_Node_apply_messages self.left params node_id_cnt msgs_left st in
let* (st2, (n, node_id_cnt0)) =
- betree_node_apply_messages_back'a self.betree_internal_left params
- node_id_cnt msgs_left st st1 in
+ betree_Node_apply_messages_back'a self.left params node_id_cnt msgs_left
+ st st1 in
let* (st3, ()) =
- betree_node_apply_messages_back1 self.betree_internal_left params
- node_id_cnt msgs_left st st2 in
- let* len_right = betree_list_len_fwd (u64 & betree_message_t) msgs_right in
- if len_right >= params.betree_params_min_flush_size
+ betree_Node_apply_messages_back1 self.left params node_id_cnt msgs_left
+ st st2 in
+ let* len_right = betree_List_len (u64 & betree_Message_t) msgs_right in
+ if len_right >= params.min_flush_size
then
let* (st4, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt0 msgs_right st3 in
+ betree_Node_apply_messages self.right params node_id_cnt0 msgs_right
+ st3 in
let* (st5, (n0, node_id_cnt1)) =
- betree_node_apply_messages_back'a self.betree_internal_right params
- node_id_cnt0 msgs_right st3 st4 in
+ betree_Node_apply_messages_back'a self.right params node_id_cnt0
+ msgs_right st3 st4 in
let* _ =
- betree_node_apply_messages_back1 self.betree_internal_right params
- node_id_cnt0 msgs_right st3 st5 in
- Return (st0,
- ({ self with betree_internal_left = n; betree_internal_right = n0 },
- node_id_cnt1))
- else Return (st0, ({ self with betree_internal_left = n }, node_id_cnt0))
+ betree_Node_apply_messages_back1 self.right params node_id_cnt0
+ msgs_right st3 st5 in
+ Return (st0, ({ self with left = n; right = n0 }, node_id_cnt1))
+ else Return (st0, ({ self with left = n }, node_id_cnt0))
else
let* (st1, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt msgs_right st in
+ betree_Node_apply_messages self.right params node_id_cnt msgs_right st in
let* (st2, (n, node_id_cnt0)) =
- betree_node_apply_messages_back'a self.betree_internal_right params
- node_id_cnt msgs_right st st1 in
+ betree_Node_apply_messages_back'a self.right params node_id_cnt
+ msgs_right st st1 in
let* _ =
- betree_node_apply_messages_back1 self.betree_internal_right params
- node_id_cnt msgs_right st st2 in
- Return (st0, ({ self with betree_internal_right = n }, node_id_cnt0))
+ betree_Node_apply_messages_back1 self.right params node_id_cnt msgs_right
+ st st2 in
+ Return (st0, ({ self with right = n }, node_id_cnt0))
(** [betree_main::betree::Internal::{4}::flush]: backward function 1 *)
-and betree_internal_flush_back1
- (self : betree_internal_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (content : betree_list_t (u64 & betree_message_t)) (st : state) (st0 : state)
+and betree_Internal_flush_back1
+ (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 & betree_Message_t)) (st : state) (st0 : state)
:
Tot (result (state & unit))
(decreases (
- betree_internal_flush_decreases self params node_id_cnt content st))
+ betree_Internal_flush_decreases self params node_id_cnt content st))
=
- let* p =
- betree_list_partition_at_pivot_fwd betree_message_t content
- self.betree_internal_pivot in
+ let* p = betree_List_partition_at_pivot betree_Message_t content self.pivot
+ in
let (msgs_left, msgs_right) = p in
- let* len_left = betree_list_len_fwd (u64 & betree_message_t) msgs_left in
- if len_left >= params.betree_params_min_flush_size
+ let* len_left = betree_List_len (u64 & betree_Message_t) msgs_left in
+ if len_left >= params.min_flush_size
then
let* (st1, _) =
- betree_node_apply_messages_fwd self.betree_internal_left params
- node_id_cnt msgs_left st in
+ betree_Node_apply_messages self.left params node_id_cnt msgs_left st in
let* (st2, (_, node_id_cnt0)) =
- betree_node_apply_messages_back'a self.betree_internal_left params
- node_id_cnt msgs_left st st1 in
+ betree_Node_apply_messages_back'a self.left params node_id_cnt msgs_left
+ st st1 in
let* (st3, ()) =
- betree_node_apply_messages_back1 self.betree_internal_left params
- node_id_cnt msgs_left st st2 in
- let* len_right = betree_list_len_fwd (u64 & betree_message_t) msgs_right in
- if len_right >= params.betree_params_min_flush_size
+ betree_Node_apply_messages_back1 self.left params node_id_cnt msgs_left
+ st st2 in
+ let* len_right = betree_List_len (u64 & betree_Message_t) msgs_right in
+ if len_right >= params.min_flush_size
then
let* (st4, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt0 msgs_right st3 in
+ betree_Node_apply_messages self.right params node_id_cnt0 msgs_right
+ st3 in
let* (st5, (_, _)) =
- betree_node_apply_messages_back'a self.betree_internal_right params
- node_id_cnt0 msgs_right st3 st4 in
+ betree_Node_apply_messages_back'a self.right params node_id_cnt0
+ msgs_right st3 st4 in
let* _ =
- betree_node_apply_messages_back1 self.betree_internal_right params
- node_id_cnt0 msgs_right st3 st5 in
+ betree_Node_apply_messages_back1 self.right params node_id_cnt0
+ msgs_right st3 st5 in
Return (st0, ())
else Return (st0, ())
else
let* (st1, _) =
- betree_node_apply_messages_fwd self.betree_internal_right params
- node_id_cnt msgs_right st in
+ betree_Node_apply_messages self.right params node_id_cnt msgs_right st in
let* (st2, (_, _)) =
- betree_node_apply_messages_back'a self.betree_internal_right params
- node_id_cnt msgs_right st st1 in
+ betree_Node_apply_messages_back'a self.right params node_id_cnt
+ msgs_right st st1 in
let* _ =
- betree_node_apply_messages_back1 self.betree_internal_right params
- node_id_cnt msgs_right st st2 in
+ betree_Node_apply_messages_back1 self.right params node_id_cnt msgs_right
+ st st2 in
Return (st0, ())
(** [betree_main::betree::Node::{5}::apply_messages]: forward function *)
-and betree_node_apply_messages_fwd
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) :
+and betree_Node_apply_messages
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) :
Tot (result (state & unit))
(decreases (
- betree_node_apply_messages_decreases self params node_id_cnt msgs st))
+ betree_Node_apply_messages_decreases self params node_id_cnt msgs st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st0, content) =
- betree_load_internal_node_fwd node.betree_internal_id st in
- let* content0 =
- betree_node_apply_messages_to_internal_fwd_back content msgs in
- let* num_msgs = betree_list_len_fwd (u64 & betree_message_t) content0 in
- if num_msgs >= params.betree_params_min_flush_size
+ | Betree_Node_Internal node ->
+ let* (st0, content) = betree_load_internal_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_internal content msgs in
+ let* num_msgs = betree_List_len (u64 & betree_Message_t) content0 in
+ if num_msgs >= params.min_flush_size
then
let* (st1, content1) =
- betree_internal_flush_fwd node params node_id_cnt content0 st0 in
+ betree_Internal_flush node params node_id_cnt content0 st0 in
let* (st2, (node0, _)) =
- betree_internal_flush_back'a node params node_id_cnt content0 st0 st1
+ betree_Internal_flush_back'a node params node_id_cnt content0 st0 st1
in
- let* (st3, _) =
- betree_store_internal_node_fwd node0.betree_internal_id content1 st2 in
+ let* (st3, _) = betree_store_internal_node node0.id content1 st2 in
Return (st3, ())
else
- let* (st1, _) =
- betree_store_internal_node_fwd node.betree_internal_id content0 st0 in
+ let* (st1, _) = betree_store_internal_node node.id content0 st0 in
Return (st1, ())
- | BetreeNodeLeaf node ->
- let* (st0, content) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* content0 = betree_node_apply_messages_to_leaf_fwd_back content msgs in
- let* len = betree_list_len_fwd (u64 & u64) content0 in
- let* i = u64_mul 2 params.betree_params_split_size in
+ | Betree_Node_Leaf node ->
+ let* (st0, content) = betree_load_leaf_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_leaf content msgs in
+ let* len = betree_List_len (u64 & u64) content0 in
+ let* i = u64_mul 2 params.split_size in
if len >= i
then
- let* (st1, _) =
- betree_leaf_split_fwd node content0 params node_id_cnt st0 in
- let* (st2, _) =
- betree_store_leaf_node_fwd node.betree_leaf_id BetreeListNil st1 in
- betree_leaf_split_back0 node content0 params node_id_cnt st0 st2
+ let* (st1, _) = betree_Leaf_split node content0 params node_id_cnt st0 in
+ let* (st2, _) = betree_store_leaf_node node.id Betree_List_Nil st1 in
+ betree_Leaf_split_back0 node content0 params node_id_cnt st0 st2
else
- let* (st1, _) =
- betree_store_leaf_node_fwd node.betree_leaf_id content0 st0 in
+ let* (st1, _) = betree_store_leaf_node node.id content0 st0 in
Return (st1, ())
end
(** [betree_main::betree::Node::{5}::apply_messages]: backward function 0 *)
-and betree_node_apply_messages_back'a
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) (st0 : state) :
- Tot (result (state & (betree_node_t & betree_node_id_counter_t)))
+and betree_Node_apply_messages_back'a
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) (st0 : state) :
+ Tot (result (state & (betree_Node_t & betree_NodeIdCounter_t)))
(decreases (
- betree_node_apply_messages_decreases self params node_id_cnt msgs st))
+ betree_Node_apply_messages_decreases self params node_id_cnt msgs st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st1, content) =
- betree_load_internal_node_fwd node.betree_internal_id st in
- let* content0 =
- betree_node_apply_messages_to_internal_fwd_back content msgs in
- let* num_msgs = betree_list_len_fwd (u64 & betree_message_t) content0 in
- if num_msgs >= params.betree_params_min_flush_size
+ | Betree_Node_Internal node ->
+ let* (st1, content) = betree_load_internal_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_internal content msgs in
+ let* num_msgs = betree_List_len (u64 & betree_Message_t) content0 in
+ if num_msgs >= params.min_flush_size
then
let* (st2, content1) =
- betree_internal_flush_fwd node params node_id_cnt content0 st1 in
+ betree_Internal_flush node params node_id_cnt content0 st1 in
let* (st3, (node0, node_id_cnt0)) =
- betree_internal_flush_back'a node params node_id_cnt content0 st1 st2
+ betree_Internal_flush_back'a node params node_id_cnt content0 st1 st2
in
- let* _ =
- betree_store_internal_node_fwd node0.betree_internal_id content1 st3 in
- Return (st0, (BetreeNodeInternal node0, node_id_cnt0))
+ let* _ = betree_store_internal_node node0.id content1 st3 in
+ Return (st0, (Betree_Node_Internal node0, node_id_cnt0))
else
- let* _ =
- betree_store_internal_node_fwd node.betree_internal_id content0 st1 in
- Return (st0, (BetreeNodeInternal node, node_id_cnt))
- | BetreeNodeLeaf node ->
- let* (st1, content) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* content0 = betree_node_apply_messages_to_leaf_fwd_back content msgs in
- let* len = betree_list_len_fwd (u64 & u64) content0 in
- let* i = u64_mul 2 params.betree_params_split_size in
+ let* _ = betree_store_internal_node node.id content0 st1 in
+ Return (st0, (Betree_Node_Internal node, node_id_cnt))
+ | Betree_Node_Leaf node ->
+ let* (st1, content) = betree_load_leaf_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_leaf content msgs in
+ let* len = betree_List_len (u64 & u64) content0 in
+ let* i = u64_mul 2 params.split_size in
if len >= i
then
let* (st2, new_node) =
- betree_leaf_split_fwd node content0 params node_id_cnt st1 in
- let* (st3, _) =
- betree_store_leaf_node_fwd node.betree_leaf_id BetreeListNil st2 in
- let* _ = betree_leaf_split_back0 node content0 params node_id_cnt st1 st3
+ betree_Leaf_split node content0 params node_id_cnt st1 in
+ let* (st3, _) = betree_store_leaf_node node.id Betree_List_Nil st2 in
+ let* _ = betree_Leaf_split_back0 node content0 params node_id_cnt st1 st3
in
let* (st4, node_id_cnt0) =
- betree_leaf_split_back2 node content0 params node_id_cnt st1 st0 in
- Return (st4, (BetreeNodeInternal new_node, node_id_cnt0))
+ betree_Leaf_split_back2 node content0 params node_id_cnt st1 st0 in
+ Return (st4, (Betree_Node_Internal new_node, node_id_cnt0))
else
- let* _ = betree_store_leaf_node_fwd node.betree_leaf_id content0 st1 in
- Return (st0, (BetreeNodeLeaf { node with betree_leaf_size = len },
- node_id_cnt))
+ let* _ = betree_store_leaf_node node.id content0 st1 in
+ Return (st0, (Betree_Node_Leaf { node with size = len }, node_id_cnt))
end
(** [betree_main::betree::Node::{5}::apply_messages]: backward function 1 *)
-and betree_node_apply_messages_back1
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t)
- (msgs : betree_list_t (u64 & betree_message_t)) (st : state) (st0 : state) :
+and betree_Node_apply_messages_back1
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 & betree_Message_t)) (st : state) (st0 : state) :
Tot (result (state & unit))
(decreases (
- betree_node_apply_messages_decreases self params node_id_cnt msgs st))
+ betree_Node_apply_messages_decreases self params node_id_cnt msgs st))
=
begin match self with
- | BetreeNodeInternal node ->
- let* (st1, content) =
- betree_load_internal_node_fwd node.betree_internal_id st in
- let* content0 =
- betree_node_apply_messages_to_internal_fwd_back content msgs in
- let* num_msgs = betree_list_len_fwd (u64 & betree_message_t) content0 in
- if num_msgs >= params.betree_params_min_flush_size
+ | Betree_Node_Internal node ->
+ let* (st1, content) = betree_load_internal_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_internal content msgs in
+ let* num_msgs = betree_List_len (u64 & betree_Message_t) content0 in
+ if num_msgs >= params.min_flush_size
then
let* (st2, content1) =
- betree_internal_flush_fwd node params node_id_cnt content0 st1 in
+ betree_Internal_flush node params node_id_cnt content0 st1 in
let* (st3, (node0, _)) =
- betree_internal_flush_back'a node params node_id_cnt content0 st1 st2
+ betree_Internal_flush_back'a node params node_id_cnt content0 st1 st2
in
- let* _ =
- betree_store_internal_node_fwd node0.betree_internal_id content1 st3 in
- betree_internal_flush_back1 node params node_id_cnt content0 st1 st0
+ let* _ = betree_store_internal_node node0.id content1 st3 in
+ betree_Internal_flush_back1 node params node_id_cnt content0 st1 st0
else
- let* _ =
- betree_store_internal_node_fwd node.betree_internal_id content0 st1 in
+ let* _ = betree_store_internal_node node.id content0 st1 in
Return (st0, ())
- | BetreeNodeLeaf node ->
- let* (st1, content) = betree_load_leaf_node_fwd node.betree_leaf_id st in
- let* content0 = betree_node_apply_messages_to_leaf_fwd_back content msgs in
- let* len = betree_list_len_fwd (u64 & u64) content0 in
- let* i = u64_mul 2 params.betree_params_split_size in
+ | Betree_Node_Leaf node ->
+ let* (st1, content) = betree_load_leaf_node node.id st in
+ let* content0 = betree_Node_apply_messages_to_leaf content msgs in
+ let* len = betree_List_len (u64 & u64) content0 in
+ let* i = u64_mul 2 params.split_size in
if len >= i
then
- let* (st2, _) =
- betree_leaf_split_fwd node content0 params node_id_cnt st1 in
- let* (st3, _) =
- betree_store_leaf_node_fwd node.betree_leaf_id BetreeListNil st2 in
- let* _ = betree_leaf_split_back0 node content0 params node_id_cnt st1 st3
+ let* (st2, _) = betree_Leaf_split node content0 params node_id_cnt st1 in
+ let* (st3, _) = betree_store_leaf_node node.id Betree_List_Nil st2 in
+ let* _ = betree_Leaf_split_back0 node content0 params node_id_cnt st1 st3
in
- betree_leaf_split_back1 node content0 params node_id_cnt st1 st0
+ betree_Leaf_split_back1 node content0 params node_id_cnt st1 st0
else
- let* _ = betree_store_leaf_node_fwd node.betree_leaf_id content0 st1 in
- Return (st0, ())
+ let* _ = betree_store_leaf_node node.id content0 st1 in Return (st0, ())
end
(** [betree_main::betree::Node::{5}::apply]: forward function *)
-let betree_node_apply_fwd
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t) (key : u64)
- (new_msg : betree_message_t) (st : state) :
+let betree_Node_apply
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+ (new_msg : betree_Message_t) (st : state) :
result (state & unit)
=
- let l = BetreeListNil in
+ let l = Betree_List_Nil in
let* (st0, _) =
- betree_node_apply_messages_fwd self params node_id_cnt (BetreeListCons
- (key, new_msg) l) st in
+ betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
+ new_msg) l) st in
let* (st1, (_, _)) =
- betree_node_apply_messages_back'a self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back'a self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st st0 in
- betree_node_apply_messages_back1 self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back1 self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st st1
(** [betree_main::betree::Node::{5}::apply]: backward function 0 *)
-let betree_node_apply_back'a
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t) (key : u64)
- (new_msg : betree_message_t) (st : state) (st0 : state) :
- result (state & (betree_node_t & betree_node_id_counter_t))
+let betree_Node_apply_back'a
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+ (new_msg : betree_Message_t) (st : state) (st0 : state) :
+ result (state & (betree_Node_t & betree_NodeIdCounter_t))
=
- let l = BetreeListNil in
+ let l = Betree_List_Nil in
let* (st1, _) =
- betree_node_apply_messages_fwd self params node_id_cnt (BetreeListCons
- (key, new_msg) l) st in
+ betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
+ new_msg) l) st in
let* (st2, (self0, node_id_cnt0)) =
- betree_node_apply_messages_back'a self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back'a self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st st1 in
let* _ =
- betree_node_apply_messages_back1 self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back1 self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st st2 in
Return (st0, (self0, node_id_cnt0))
(** [betree_main::betree::Node::{5}::apply]: backward function 1 *)
-let betree_node_apply_back1
- (self : betree_node_t) (params : betree_params_t)
- (node_id_cnt : betree_node_id_counter_t) (key : u64)
- (new_msg : betree_message_t) (st : state) (st0 : state) :
+let betree_Node_apply_back1
+ (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+ (new_msg : betree_Message_t) (st : state) (st0 : state) :
result (state & unit)
=
- let l = BetreeListNil in
+ let l = Betree_List_Nil in
let* (st1, _) =
- betree_node_apply_messages_fwd self params node_id_cnt (BetreeListCons
- (key, new_msg) l) st in
+ betree_Node_apply_messages self params node_id_cnt (Betree_List_Cons (key,
+ new_msg) l) st in
let* (st2, (_, _)) =
- betree_node_apply_messages_back'a self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back'a self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st st1 in
let* _ =
- betree_node_apply_messages_back1 self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back1 self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st st2 in
Return (st0, ())
(** [betree_main::betree::BeTree::{6}::new]: forward function *)
-let betree_be_tree_new_fwd
+let betree_BeTree_new
(min_flush_size : u64) (split_size : u64) (st : state) :
- result (state & betree_be_tree_t)
+ result (state & betree_BeTree_t)
=
- let* node_id_cnt = betree_node_id_counter_new_fwd in
- let* id = betree_node_id_counter_fresh_id_fwd node_id_cnt in
- let* (st0, _) = betree_store_leaf_node_fwd id BetreeListNil st in
- let* node_id_cnt0 = betree_node_id_counter_fresh_id_back node_id_cnt in
+ let* node_id_cnt = betree_NodeIdCounter_new in
+ let* id = betree_NodeIdCounter_fresh_id node_id_cnt in
+ let* (st0, _) = betree_store_leaf_node id Betree_List_Nil st in
+ let* node_id_cnt0 = betree_NodeIdCounter_fresh_id_back node_id_cnt in
Return (st0,
{
- betree_be_tree_params =
- {
- betree_params_min_flush_size = min_flush_size;
- betree_params_split_size = split_size
- };
- betree_be_tree_node_id_cnt = node_id_cnt0;
- betree_be_tree_root =
- (BetreeNodeLeaf { betree_leaf_id = id; betree_leaf_size = 0 })
+ params = { min_flush_size = min_flush_size; split_size = split_size };
+ node_id_cnt = node_id_cnt0;
+ root = (Betree_Node_Leaf { id = id; size = 0 })
})
(** [betree_main::betree::BeTree::{6}::apply]: forward function *)
-let betree_be_tree_apply_fwd
- (self : betree_be_tree_t) (key : u64) (msg : betree_message_t) (st : state) :
+let betree_BeTree_apply
+ (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t) (st : state) :
result (state & unit)
=
let* (st0, _) =
- betree_node_apply_fwd self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st in
+ betree_Node_apply self.root self.params self.node_id_cnt key msg st in
let* (st1, (_, _)) =
- betree_node_apply_back'a self.betree_be_tree_root
- self.betree_be_tree_params self.betree_be_tree_node_id_cnt key msg st st0
- in
- betree_node_apply_back1 self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st st1
+ betree_Node_apply_back'a self.root self.params self.node_id_cnt key msg st
+ st0 in
+ betree_Node_apply_back1 self.root self.params self.node_id_cnt key msg st st1
(** [betree_main::betree::BeTree::{6}::apply]: backward function 0 *)
-let betree_be_tree_apply_back
- (self : betree_be_tree_t) (key : u64) (msg : betree_message_t) (st : state)
+let betree_BeTree_apply_back
+ (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t) (st : state)
(st0 : state) :
- result (state & betree_be_tree_t)
+ result (state & betree_BeTree_t)
=
let* (st1, _) =
- betree_node_apply_fwd self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st in
+ betree_Node_apply self.root self.params self.node_id_cnt key msg st in
let* (st2, (n, nic)) =
- betree_node_apply_back'a self.betree_be_tree_root
- self.betree_be_tree_params self.betree_be_tree_node_id_cnt key msg st st1
- in
+ betree_Node_apply_back'a self.root self.params self.node_id_cnt key msg st
+ st1 in
let* _ =
- betree_node_apply_back1 self.betree_be_tree_root self.betree_be_tree_params
- self.betree_be_tree_node_id_cnt key msg st st2 in
- Return (st0,
- { self with betree_be_tree_node_id_cnt = nic; betree_be_tree_root = n })
+ betree_Node_apply_back1 self.root self.params self.node_id_cnt key msg st
+ st2 in
+ Return (st0, { self with node_id_cnt = nic; root = n })
(** [betree_main::betree::BeTree::{6}::insert]: forward function *)
-let betree_be_tree_insert_fwd
- (self : betree_be_tree_t) (key : u64) (value : u64) (st : state) :
+let betree_BeTree_insert
+ (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
result (state & unit)
=
- let* (st0, _) =
- betree_be_tree_apply_fwd self key (BetreeMessageInsert value) st in
+ let* (st0, _) = betree_BeTree_apply self key (Betree_Message_Insert value) st
+ in
let* (st1, _) =
- betree_be_tree_apply_back self key (BetreeMessageInsert value) st st0 in
+ betree_BeTree_apply_back self key (Betree_Message_Insert value) st st0 in
Return (st1, ())
(** [betree_main::betree::BeTree::{6}::insert]: backward function 0 *)
-let betree_be_tree_insert_back
- (self : betree_be_tree_t) (key : u64) (value : u64) (st : state)
- (st0 : state) :
- result (state & betree_be_tree_t)
+let betree_BeTree_insert_back
+ (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) (st0 : state)
+ :
+ result (state & betree_BeTree_t)
=
- let* (st1, _) =
- betree_be_tree_apply_fwd self key (BetreeMessageInsert value) st in
+ let* (st1, _) = betree_BeTree_apply self key (Betree_Message_Insert value) st
+ in
let* (_, self0) =
- betree_be_tree_apply_back self key (BetreeMessageInsert value) st st1 in
+ betree_BeTree_apply_back self key (Betree_Message_Insert value) st st1 in
Return (st0, self0)
(** [betree_main::betree::BeTree::{6}::delete]: forward function *)
-let betree_be_tree_delete_fwd
- (self : betree_be_tree_t) (key : u64) (st : state) : result (state & unit) =
- let* (st0, _) = betree_be_tree_apply_fwd self key BetreeMessageDelete st in
- let* (st1, _) = betree_be_tree_apply_back self key BetreeMessageDelete st st0
- in
+let betree_BeTree_delete
+ (self : betree_BeTree_t) (key : u64) (st : state) : result (state & unit) =
+ let* (st0, _) = betree_BeTree_apply self key Betree_Message_Delete st in
+ let* (st1, _) =
+ betree_BeTree_apply_back self key Betree_Message_Delete st st0 in
Return (st1, ())
(** [betree_main::betree::BeTree::{6}::delete]: backward function 0 *)
-let betree_be_tree_delete_back
- (self : betree_be_tree_t) (key : u64) (st : state) (st0 : state) :
- result (state & betree_be_tree_t)
+let betree_BeTree_delete_back
+ (self : betree_BeTree_t) (key : u64) (st : state) (st0 : state) :
+ result (state & betree_BeTree_t)
=
- let* (st1, _) = betree_be_tree_apply_fwd self key BetreeMessageDelete st in
+ let* (st1, _) = betree_BeTree_apply self key Betree_Message_Delete st in
let* (_, self0) =
- betree_be_tree_apply_back self key BetreeMessageDelete st st1 in
+ betree_BeTree_apply_back self key Betree_Message_Delete st st1 in
Return (st0, self0)
(** [betree_main::betree::BeTree::{6}::upsert]: forward function *)
-let betree_be_tree_upsert_fwd
- (self : betree_be_tree_t) (key : u64) (upd : betree_upsert_fun_state_t)
+let betree_BeTree_upsert
+ (self : betree_BeTree_t) (key : u64) (upd : betree_UpsertFunState_t)
(st : state) :
result (state & unit)
=
- let* (st0, _) =
- betree_be_tree_apply_fwd self key (BetreeMessageUpsert upd) st in
+ let* (st0, _) = betree_BeTree_apply self key (Betree_Message_Upsert upd) st
+ in
let* (st1, _) =
- betree_be_tree_apply_back self key (BetreeMessageUpsert upd) st st0 in
+ betree_BeTree_apply_back self key (Betree_Message_Upsert upd) st st0 in
Return (st1, ())
(** [betree_main::betree::BeTree::{6}::upsert]: backward function 0 *)
-let betree_be_tree_upsert_back
- (self : betree_be_tree_t) (key : u64) (upd : betree_upsert_fun_state_t)
+let betree_BeTree_upsert_back
+ (self : betree_BeTree_t) (key : u64) (upd : betree_UpsertFunState_t)
(st : state) (st0 : state) :
- result (state & betree_be_tree_t)
+ result (state & betree_BeTree_t)
=
- let* (st1, _) =
- betree_be_tree_apply_fwd self key (BetreeMessageUpsert upd) st in
+ let* (st1, _) = betree_BeTree_apply self key (Betree_Message_Upsert upd) st
+ in
let* (_, self0) =
- betree_be_tree_apply_back self key (BetreeMessageUpsert upd) st st1 in
+ betree_BeTree_apply_back self key (Betree_Message_Upsert upd) st st1 in
Return (st0, self0)
(** [betree_main::betree::BeTree::{6}::lookup]: forward function *)
-let betree_be_tree_lookup_fwd
- (self : betree_be_tree_t) (key : u64) (st : state) :
+let betree_BeTree_lookup
+ (self : betree_BeTree_t) (key : u64) (st : state) :
result (state & (option u64))
=
- betree_node_lookup_fwd self.betree_be_tree_root key st
+ betree_Node_lookup self.root key st
(** [betree_main::betree::BeTree::{6}::lookup]: backward function 0 *)
-let betree_be_tree_lookup_back
- (self : betree_be_tree_t) (key : u64) (st : state) (st0 : state) :
- result (state & betree_be_tree_t)
+let betree_BeTree_lookup_back
+ (self : betree_BeTree_t) (key : u64) (st : state) (st0 : state) :
+ result (state & betree_BeTree_t)
=
- let* (st1, n) = betree_node_lookup_back self.betree_be_tree_root key st st0
- in
- Return (st1, { self with betree_be_tree_root = n })
+ let* (st1, n) = betree_Node_lookup_back self.root key st st0 in
+ Return (st1, { self with root = n })
(** [betree_main::main]: forward function *)
-let main_fwd : result unit =
+let main : result unit =
Return ()
(** Unit test for [betree_main::main] *)
-let _ = assert_norm (main_fwd = Return ())
+let _ = assert_norm (main = Return ())
diff --git a/tests/fstar/betree_back_stateful/BetreeMain.Opaque.fsti b/tests/fstar/betree_back_stateful/BetreeMain.Opaque.fsti
index c33cf225..c5d0a814 100644
--- a/tests/fstar/betree_back_stateful/BetreeMain.Opaque.fsti
+++ b/tests/fstar/betree_back_stateful/BetreeMain.Opaque.fsti
@@ -7,24 +7,24 @@ include BetreeMain.Types
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [betree_main::betree_utils::load_internal_node]: forward function *)
-val betree_utils_load_internal_node_fwd
- : u64 -> state -> result (state & (betree_list_t (u64 & betree_message_t)))
+val betree_utils_load_internal_node
+ : u64 -> state -> result (state & (betree_List_t (u64 & betree_Message_t)))
(** [betree_main::betree_utils::store_internal_node]: forward function *)
-val betree_utils_store_internal_node_fwd
+val betree_utils_store_internal_node
:
- u64 -> betree_list_t (u64 & betree_message_t) -> state -> result (state &
+ u64 -> betree_List_t (u64 & betree_Message_t) -> state -> result (state &
unit)
(** [betree_main::betree_utils::load_leaf_node]: forward function *)
-val betree_utils_load_leaf_node_fwd
- : u64 -> state -> result (state & (betree_list_t (u64 & u64)))
+val betree_utils_load_leaf_node
+ : u64 -> state -> result (state & (betree_List_t (u64 & u64)))
(** [betree_main::betree_utils::store_leaf_node]: forward function *)
-val betree_utils_store_leaf_node_fwd
- : u64 -> betree_list_t (u64 & u64) -> state -> result (state & unit)
+val betree_utils_store_leaf_node
+ : u64 -> betree_List_t (u64 & u64) -> state -> result (state & unit)
(** [core::option::Option::{0}::unwrap]: forward function *)
-val core_option_option_unwrap_fwd
+val core_option_Option_unwrap
(t : Type0) : option t -> state -> result (state & t)
diff --git a/tests/fstar/betree_back_stateful/BetreeMain.Types.fsti b/tests/fstar/betree_back_stateful/BetreeMain.Types.fsti
index a937c726..9320f6b7 100644
--- a/tests/fstar/betree_back_stateful/BetreeMain.Types.fsti
+++ b/tests/fstar/betree_back_stateful/BetreeMain.Types.fsti
@@ -6,53 +6,47 @@ open Primitives
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [betree_main::betree::List] *)
-type betree_list_t (t : Type0) =
-| BetreeListCons : t -> betree_list_t t -> betree_list_t t
-| BetreeListNil : betree_list_t t
+type betree_List_t (t : Type0) =
+| Betree_List_Cons : t -> betree_List_t t -> betree_List_t t
+| Betree_List_Nil : betree_List_t t
(** [betree_main::betree::UpsertFunState] *)
-type betree_upsert_fun_state_t =
-| BetreeUpsertFunStateAdd : u64 -> betree_upsert_fun_state_t
-| BetreeUpsertFunStateSub : u64 -> betree_upsert_fun_state_t
+type betree_UpsertFunState_t =
+| Betree_UpsertFunState_Add : u64 -> betree_UpsertFunState_t
+| Betree_UpsertFunState_Sub : u64 -> betree_UpsertFunState_t
(** [betree_main::betree::Message] *)
-type betree_message_t =
-| BetreeMessageInsert : u64 -> betree_message_t
-| BetreeMessageDelete : betree_message_t
-| BetreeMessageUpsert : betree_upsert_fun_state_t -> betree_message_t
+type betree_Message_t =
+| Betree_Message_Insert : u64 -> betree_Message_t
+| Betree_Message_Delete : betree_Message_t
+| Betree_Message_Upsert : betree_UpsertFunState_t -> betree_Message_t
(** [betree_main::betree::Leaf] *)
-type betree_leaf_t = { betree_leaf_id : u64; betree_leaf_size : u64; }
+type betree_Leaf_t = { id : u64; size : u64; }
(** [betree_main::betree::Internal] *)
-type betree_internal_t =
+type betree_Internal_t =
{
- betree_internal_id : u64;
- betree_internal_pivot : u64;
- betree_internal_left : betree_node_t;
- betree_internal_right : betree_node_t;
+ id : u64; pivot : u64; left : betree_Node_t; right : betree_Node_t;
}
(** [betree_main::betree::Node] *)
-and betree_node_t =
-| BetreeNodeInternal : betree_internal_t -> betree_node_t
-| BetreeNodeLeaf : betree_leaf_t -> betree_node_t
+and betree_Node_t =
+| Betree_Node_Internal : betree_Internal_t -> betree_Node_t
+| Betree_Node_Leaf : betree_Leaf_t -> betree_Node_t
(** [betree_main::betree::Params] *)
-type betree_params_t =
-{
- betree_params_min_flush_size : u64; betree_params_split_size : u64;
-}
+type betree_Params_t = { min_flush_size : u64; split_size : u64; }
(** [betree_main::betree::NodeIdCounter] *)
-type betree_node_id_counter_t = { betree_node_id_counter_next_node_id : u64; }
+type betree_NodeIdCounter_t = { next_node_id : u64; }
(** [betree_main::betree::BeTree] *)
-type betree_be_tree_t =
+type betree_BeTree_t =
{
- betree_be_tree_params : betree_params_t;
- betree_be_tree_node_id_cnt : betree_node_id_counter_t;
- betree_be_tree_root : betree_node_t;
+ params : betree_Params_t;
+ node_id_cnt : betree_NodeIdCounter_t;
+ root : betree_Node_t;
}
(** The state type used in the state-error monad *)
diff --git a/tests/fstar/betree_back_stateful/Primitives.fst b/tests/fstar/betree_back_stateful/Primitives.fst
index 9db82069..3297803c 100644
--- a/tests/fstar/betree_back_stateful/Primitives.fst
+++ b/tests/fstar/betree_back_stateful/Primitives.fst
@@ -55,8 +55,12 @@ type string = string
let is_zero (n: nat) : bool = n = 0
let decrease (n: nat{n > 0}) : nat = n - 1
-let mem_replace_fwd (a : Type0) (x : a) (y : a) : a = x
-let mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
(*** Scalars *)
/// Rem.: most of the following code was partially generated
@@ -100,6 +104,11 @@ type scalar_ty =
| U64
| U128
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
let scalar_min (ty : scalar_ty) : int =
match ty with
| Isize -> isize_min
@@ -162,6 +171,15 @@ let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scala
let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
mk_scalar ty (x * y)
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
(** Cast an integer from a [src_ty] to a [tgt_ty] *)
// TODO: check the semantics of casts in Rust
let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
@@ -169,17 +187,44 @@ let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) :
/// The scalar types
type isize : eqtype = scalar Isize
-type i8 : eqtype = scalar I8
-type i16 : eqtype = scalar I16
-type i32 : eqtype = scalar I32
-type i64 : eqtype = scalar I64
-type i128 : eqtype = scalar I128
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
type usize : eqtype = scalar Usize
-type u8 : eqtype = scalar U8
-type u16 : eqtype = scalar U16
-type u32 : eqtype = scalar U32
-type u64 : eqtype = scalar U64
-type u128 : eqtype = scalar U128
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
/// Negation
let isize_neg = scalar_neg #Isize
@@ -231,7 +276,7 @@ let u32_add = scalar_add #U32
let u64_add = scalar_add #U64
let u128_add = scalar_add #U128
-/// Substraction
+/// Subtraction
let isize_sub = scalar_sub #Isize
let i8_sub = scalar_sub #I8
let i16_sub = scalar_sub #I16
@@ -259,12 +304,65 @@ let u32_mul = scalar_mul #U32
let u64_mul = scalar_mul #U64
let u128_mul = scalar_mul #U128
-(*** Range *)
-type range (a : Type0) = {
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
start : a;
end_ : a;
}
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
(*** Array *)
type array (a : Type0) (n : usize) = s:list a{length s = n}
@@ -278,15 +376,11 @@ let mk_array (a : Type0) (n : usize)
normalize_term_spec (FStar.List.Tot.length l);
l
-let array_index_shared (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let array_index_mut_fwd (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let array_index_mut_back (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
if i < length x then Return (list_update x i nx)
else Fail Failure
@@ -295,55 +389,54 @@ type slice (a : Type0) = s:list a{length s <= usize_max}
let slice_len (a : Type0) (s : slice a) : usize = length s
-let slice_index_shared (a : Type0) (x : slice a) (i : usize) : result a =
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let slice_index_mut_fwd (a : Type0) (x : slice a) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let slice_index_mut_back (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
if i < length x then Return (list_update x i nx)
else Fail Failure
(*** Subslices *)
-let array_to_slice_shared (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_fwd (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_back (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
if length s = n then Return s
else Fail Failure
// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
-let array_subslice_shared (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
- admit()
-
-let array_subslice_mut_fwd (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let array_subslice_mut_back (a : Type0) (n : usize) (x : array a n) (r : range usize) (ns : slice a) : result (array a n) =
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
admit()
-let slice_subslice_shared (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
admit()
-let slice_subslice_mut_fwd (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let slice_subslice_mut_back (a : Type0) (x : slice a) (r : range usize) (ns : slice a) : result (slice a) =
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
admit()
(*** Vector *)
-type vec (a : Type0) = v:list a{length v <= usize_max}
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
-let vec_new (a : Type0) : vec a = assert_norm(length #a [] == 0); []
-let vec_len (a : Type0) (v : vec a) : usize = length v
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
// The **forward** function shouldn't be used
-let vec_push_fwd (a : Type0) (v : vec a) (x : a) : unit = ()
-let vec_push_back (a : Type0) (v : vec a) (x : a) :
- Pure (result (vec a))
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
(requires True)
(ensures (fun res ->
match res with
@@ -358,18 +451,279 @@ let vec_push_back (a : Type0) (v : vec a) (x : a) :
else Fail Failure
// The **forward** function shouldn't be used
-let vec_insert_fwd (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
if i < length v then Return () else Fail Failure
-let vec_insert_back (a : Type0) (v : vec a) (i : usize) (x : a) : result (vec a) =
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
if i < length v then Return (list_update v i x) else Fail Failure
-// The **backward** function shouldn't be used
-let vec_index_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_back (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
- if i < length v then Return () else Fail Failure
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
-let vec_index_mut_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_mut_back (a : Type0) (v : vec a) (i : usize) (nx : a) : result (vec a) =
- if i < length v then Return (list_update v i nx) else Fail Failure
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/hashmap/Hashmap.Clauses.Template.fst b/tests/fstar/hashmap/Hashmap.Clauses.Template.fst
index 640ae783..a1f81666 100644
--- a/tests/fstar/hashmap/Hashmap.Clauses.Template.fst
+++ b/tests/fstar/hashmap/Hashmap.Clauses.Template.fst
@@ -8,55 +8,55 @@ open Hashmap.Types
(** [hashmap::HashMap::{0}::allocate_slots]: decreases clause *)
unfold
-let hash_map_allocate_slots_loop_decreases (t : Type0) (slots : vec (list_t t))
- (n : usize) : nat =
+let hashMap_allocate_slots_loop_decreases (t : Type0)
+ (slots : alloc_vec_Vec (list_t t)) (n : usize) : nat =
admit ()
(** [hashmap::HashMap::{0}::clear]: decreases clause *)
unfold
-let hash_map_clear_loop_decreases (t : Type0) (slots : vec (list_t t))
+let hashMap_clear_loop_decreases (t : Type0) (slots : alloc_vec_Vec (list_t t))
(i : usize) : nat =
admit ()
(** [hashmap::HashMap::{0}::insert_in_list]: decreases clause *)
unfold
-let hash_map_insert_in_list_loop_decreases (t : Type0) (key : usize)
- (value : t) (ls : list_t t) : nat =
+let hashMap_insert_in_list_loop_decreases (t : Type0) (key : usize) (value : t)
+ (ls : list_t t) : nat =
admit ()
(** [hashmap::HashMap::{0}::move_elements_from_list]: decreases clause *)
unfold
-let hash_map_move_elements_from_list_loop_decreases (t : Type0)
- (ntable : hash_map_t t) (ls : list_t t) : nat =
+let hashMap_move_elements_from_list_loop_decreases (t : Type0)
+ (ntable : hashMap_t t) (ls : list_t t) : nat =
admit ()
(** [hashmap::HashMap::{0}::move_elements]: decreases clause *)
unfold
-let hash_map_move_elements_loop_decreases (t : Type0) (ntable : hash_map_t t)
- (slots : vec (list_t t)) (i : usize) : nat =
+let hashMap_move_elements_loop_decreases (t : Type0) (ntable : hashMap_t t)
+ (slots : alloc_vec_Vec (list_t t)) (i : usize) : nat =
admit ()
(** [hashmap::HashMap::{0}::contains_key_in_list]: decreases clause *)
unfold
-let hash_map_contains_key_in_list_loop_decreases (t : Type0) (key : usize)
+let hashMap_contains_key_in_list_loop_decreases (t : Type0) (key : usize)
(ls : list_t t) : nat =
admit ()
(** [hashmap::HashMap::{0}::get_in_list]: decreases clause *)
unfold
-let hash_map_get_in_list_loop_decreases (t : Type0) (key : usize)
+let hashMap_get_in_list_loop_decreases (t : Type0) (key : usize)
(ls : list_t t) : nat =
admit ()
(** [hashmap::HashMap::{0}::get_mut_in_list]: decreases clause *)
unfold
-let hash_map_get_mut_in_list_loop_decreases (t : Type0) (ls : list_t t)
+let hashMap_get_mut_in_list_loop_decreases (t : Type0) (ls : list_t t)
(key : usize) : nat =
admit ()
(** [hashmap::HashMap::{0}::remove_from_list]: decreases clause *)
unfold
-let hash_map_remove_from_list_loop_decreases (t : Type0) (key : usize)
+let hashMap_remove_from_list_loop_decreases (t : Type0) (key : usize)
(ls : list_t t) : nat =
admit ()
diff --git a/tests/fstar/hashmap/Hashmap.Clauses.fst b/tests/fstar/hashmap/Hashmap.Clauses.fst
index d8bb8d20..6c699d05 100644
--- a/tests/fstar/hashmap/Hashmap.Clauses.fst
+++ b/tests/fstar/hashmap/Hashmap.Clauses.fst
@@ -8,54 +8,54 @@ open Hashmap.Types
(** [hashmap::HashMap::allocate_slots]: decreases clause *)
unfold
-let hash_map_allocate_slots_loop_decreases (t : Type0) (slots : vec (list_t t))
- (n : usize) : nat = n
+let hashMap_allocate_slots_loop_decreases (t : Type0)
+ (slots : alloc_vec_Vec (list_t t)) (n : usize) : nat = n
(** [hashmap::HashMap::clear]: decreases clause *)
unfold
-let hash_map_clear_loop_decreases (t : Type0) (slots : vec (list_t t))
+let hashMap_clear_loop_decreases (t : Type0) (slots : alloc_vec_Vec (list_t t))
(i : usize) : nat =
if i < length slots then length slots - i else 0
(** [hashmap::HashMap::insert_in_list]: decreases clause *)
unfold
-let hash_map_insert_in_list_loop_decreases (t : Type0) (key : usize) (value : t)
+let hashMap_insert_in_list_loop_decreases (t : Type0) (key : usize) (value : t)
(ls : list_t t) : list_t t =
ls
(** [hashmap::HashMap::move_elements_from_list]: decreases clause *)
unfold
-let hash_map_move_elements_from_list_loop_decreases (t : Type0)
- (ntable : hash_map_t t) (ls : list_t t) : list_t t =
+let hashMap_move_elements_from_list_loop_decreases (t : Type0)
+ (ntable : hashMap_t t) (ls : list_t t) : list_t t =
ls
(** [hashmap::HashMap::move_elements]: decreases clause *)
unfold
-let hash_map_move_elements_loop_decreases (t : Type0) (ntable : hash_map_t t)
- (slots : vec (list_t t)) (i : usize) : nat =
+let hashMap_move_elements_loop_decreases (t : Type0) (ntable : hashMap_t t)
+ (slots : alloc_vec_Vec (list_t t)) (i : usize) : nat =
if i < length slots then length slots - i else 0
(** [hashmap::HashMap::contains_key_in_list]: decreases clause *)
unfold
-let hash_map_contains_key_in_list_loop_decreases (t : Type0) (key : usize)
+let hashMap_contains_key_in_list_loop_decreases (t : Type0) (key : usize)
(ls : list_t t) : list_t t =
ls
(** [hashmap::HashMap::get_in_list]: decreases clause *)
unfold
-let hash_map_get_in_list_loop_decreases (t : Type0) (key : usize) (ls : list_t t) :
+let hashMap_get_in_list_loop_decreases (t : Type0) (key : usize) (ls : list_t t) :
list_t t =
ls
(** [hashmap::HashMap::get_mut_in_list]: decreases clause *)
unfold
-let hash_map_get_mut_in_list_loop_decreases (t : Type0) (ls : list_t t)
+let hashMap_get_mut_in_list_loop_decreases (t : Type0) (ls : list_t t)
(key : usize) : list_t t =
ls
(** [hashmap::HashMap::remove_from_list]: decreases clause *)
unfold
-let hash_map_remove_from_list_loop_decreases (t : Type0) (key : usize)
+let hashMap_remove_from_list_loop_decreases (t : Type0) (key : usize)
(ls : list_t t) : list_t t =
ls
diff --git a/tests/fstar/hashmap/Hashmap.Funs.fst b/tests/fstar/hashmap/Hashmap.Funs.fst
index f4c13a7b..0e31e364 100644
--- a/tests/fstar/hashmap/Hashmap.Funs.fst
+++ b/tests/fstar/hashmap/Hashmap.Funs.fst
@@ -8,460 +8,486 @@ include Hashmap.Clauses
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [hashmap::hash_key]: forward function *)
-let hash_key_fwd (k : usize) : result usize =
+let hash_key (k : usize) : result usize =
Return k
(** [hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function *)
-let rec hash_map_allocate_slots_loop_fwd
- (t : Type0) (slots : vec (list_t t)) (n : usize) :
- Tot (result (vec (list_t t)))
- (decreases (hash_map_allocate_slots_loop_decreases t slots n))
+let rec hashMap_allocate_slots_loop
+ (t : Type0) (slots : alloc_vec_Vec (list_t t)) (n : usize) :
+ Tot (result (alloc_vec_Vec (list_t t)))
+ (decreases (hashMap_allocate_slots_loop_decreases t slots n))
=
if n > 0
then
- let* slots0 = vec_push_back (list_t t) slots ListNil in
+ let* slots0 = alloc_vec_Vec_push (list_t t) slots List_Nil in
let* n0 = usize_sub n 1 in
- hash_map_allocate_slots_loop_fwd t slots0 n0
+ hashMap_allocate_slots_loop t slots0 n0
else Return slots
(** [hashmap::HashMap::{0}::allocate_slots]: forward function *)
-let hash_map_allocate_slots_fwd
- (t : Type0) (slots : vec (list_t t)) (n : usize) : result (vec (list_t t)) =
- hash_map_allocate_slots_loop_fwd t slots n
+let hashMap_allocate_slots
+ (t : Type0) (slots : alloc_vec_Vec (list_t t)) (n : usize) :
+ result (alloc_vec_Vec (list_t t))
+ =
+ hashMap_allocate_slots_loop t slots n
(** [hashmap::HashMap::{0}::new_with_capacity]: forward function *)
-let hash_map_new_with_capacity_fwd
+let hashMap_new_with_capacity
(t : Type0) (capacity : usize) (max_load_dividend : usize)
(max_load_divisor : usize) :
- result (hash_map_t t)
+ result (hashMap_t t)
=
- let v = vec_new (list_t t) in
- let* slots = hash_map_allocate_slots_fwd t v capacity in
+ let v = alloc_vec_Vec_new (list_t t) in
+ let* slots = hashMap_allocate_slots t v capacity in
let* i = usize_mul capacity max_load_dividend in
let* i0 = usize_div i max_load_divisor in
Return
{
- hash_map_num_entries = 0;
- hash_map_max_load_factor = (max_load_dividend, max_load_divisor);
- hash_map_max_load = i0;
- hash_map_slots = slots
+ num_entries = 0;
+ max_load_factor = (max_load_dividend, max_load_divisor);
+ max_load = i0;
+ slots = slots
}
(** [hashmap::HashMap::{0}::new]: forward function *)
-let hash_map_new_fwd (t : Type0) : result (hash_map_t t) =
- hash_map_new_with_capacity_fwd t 32 4 5
+let hashMap_new (t : Type0) : result (hashMap_t t) =
+ hashMap_new_with_capacity t 32 4 5
(** [hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec hash_map_clear_loop_fwd_back
- (t : Type0) (slots : vec (list_t t)) (i : usize) :
- Tot (result (vec (list_t t)))
- (decreases (hash_map_clear_loop_decreases t slots i))
+let rec hashMap_clear_loop
+ (t : Type0) (slots : alloc_vec_Vec (list_t t)) (i : usize) :
+ Tot (result (alloc_vec_Vec (list_t t)))
+ (decreases (hashMap_clear_loop_decreases t slots i))
=
- let i0 = vec_len (list_t t) slots in
+ let i0 = alloc_vec_Vec_len (list_t t) slots in
if i < i0
then
let* i1 = usize_add i 1 in
- let* slots0 = vec_index_mut_back (list_t t) slots i ListNil in
- hash_map_clear_loop_fwd_back t slots0 i1
+ let* slots0 =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t)) slots
+ i List_Nil in
+ hashMap_clear_loop t slots0 i1
else Return slots
(** [hashmap::HashMap::{0}::clear]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hash_map_clear_fwd_back
- (t : Type0) (self : hash_map_t t) : result (hash_map_t t) =
- let* v = hash_map_clear_loop_fwd_back t self.hash_map_slots 0 in
- Return { self with hash_map_num_entries = 0; hash_map_slots = v }
+let hashMap_clear (t : Type0) (self : hashMap_t t) : result (hashMap_t t) =
+ let* v = hashMap_clear_loop t self.slots 0 in
+ Return { self with num_entries = 0; slots = v }
(** [hashmap::HashMap::{0}::len]: forward function *)
-let hash_map_len_fwd (t : Type0) (self : hash_map_t t) : result usize =
- Return self.hash_map_num_entries
+let hashMap_len (t : Type0) (self : hashMap_t t) : result usize =
+ Return self.num_entries
(** [hashmap::HashMap::{0}::insert_in_list]: loop 0: forward function *)
-let rec hash_map_insert_in_list_loop_fwd
+let rec hashMap_insert_in_list_loop
(t : Type0) (key : usize) (value : t) (ls : list_t t) :
Tot (result bool)
- (decreases (hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashMap_insert_in_list_loop_decreases t key value ls))
=
begin match ls with
- | ListCons ckey cvalue tl ->
+ | List_Cons ckey cvalue tl ->
if ckey = key
then Return false
- else hash_map_insert_in_list_loop_fwd t key value tl
- | ListNil -> Return true
+ else hashMap_insert_in_list_loop t key value tl
+ | List_Nil -> Return true
end
(** [hashmap::HashMap::{0}::insert_in_list]: forward function *)
-let hash_map_insert_in_list_fwd
+let hashMap_insert_in_list
(t : Type0) (key : usize) (value : t) (ls : list_t t) : result bool =
- hash_map_insert_in_list_loop_fwd t key value ls
+ hashMap_insert_in_list_loop t key value ls
(** [hashmap::HashMap::{0}::insert_in_list]: loop 0: backward function 0 *)
-let rec hash_map_insert_in_list_loop_back
+let rec hashMap_insert_in_list_loop_back
(t : Type0) (key : usize) (value : t) (ls : list_t t) :
Tot (result (list_t t))
- (decreases (hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashMap_insert_in_list_loop_decreases t key value ls))
=
begin match ls with
- | ListCons ckey cvalue tl ->
+ | List_Cons ckey cvalue tl ->
if ckey = key
- then Return (ListCons ckey value tl)
+ then Return (List_Cons ckey value tl)
else
- let* tl0 = hash_map_insert_in_list_loop_back t key value tl in
- Return (ListCons ckey cvalue tl0)
- | ListNil -> let l = ListNil in Return (ListCons key value l)
+ let* tl0 = hashMap_insert_in_list_loop_back t key value tl in
+ Return (List_Cons ckey cvalue tl0)
+ | List_Nil -> let l = List_Nil in Return (List_Cons key value l)
end
(** [hashmap::HashMap::{0}::insert_in_list]: backward function 0 *)
-let hash_map_insert_in_list_back
+let hashMap_insert_in_list_back
(t : Type0) (key : usize) (value : t) (ls : list_t t) : result (list_t t) =
- hash_map_insert_in_list_loop_back t key value ls
+ hashMap_insert_in_list_loop_back t key value ls
(** [hashmap::HashMap::{0}::insert_no_resize]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hash_map_insert_no_resize_fwd_back
- (t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
- result (hash_map_t t)
+let hashMap_insert_no_resize
+ (t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
+ result (hashMap_t t)
=
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_mut_fwd (list_t t) self.hash_map_slots hash_mod in
- let* inserted = hash_map_insert_in_list_fwd t key value l in
+ let* l =
+ alloc_vec_Vec_index_mut (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ let* inserted = hashMap_insert_in_list t key value l in
if inserted
then
- let* i0 = usize_add self.hash_map_num_entries 1 in
- let* l0 = hash_map_insert_in_list_back t key value l in
- let* v = vec_index_mut_back (list_t t) self.hash_map_slots hash_mod l0 in
- Return { self with hash_map_num_entries = i0; hash_map_slots = v }
+ let* i0 = usize_add self.num_entries 1 in
+ let* l0 = hashMap_insert_in_list_back t key value l in
+ let* v =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod l0 in
+ Return { self with num_entries = i0; slots = v }
else
- let* l0 = hash_map_insert_in_list_back t key value l in
- let* v = vec_index_mut_back (list_t t) self.hash_map_slots hash_mod l0 in
- Return { self with hash_map_slots = v }
-
-(** [core::num::u32::{8}::MAX] *)
-let core_num_u32_max_body : result u32 = Return 4294967295
-let core_num_u32_max_c : u32 = eval_global core_num_u32_max_body
+ let* l0 = hashMap_insert_in_list_back t key value l in
+ let* v =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod l0 in
+ Return { self with slots = v }
(** [hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec hash_map_move_elements_from_list_loop_fwd_back
- (t : Type0) (ntable : hash_map_t t) (ls : list_t t) :
- Tot (result (hash_map_t t))
- (decreases (hash_map_move_elements_from_list_loop_decreases t ntable ls))
+let rec hashMap_move_elements_from_list_loop
+ (t : Type0) (ntable : hashMap_t t) (ls : list_t t) :
+ Tot (result (hashMap_t t))
+ (decreases (hashMap_move_elements_from_list_loop_decreases t ntable ls))
=
begin match ls with
- | ListCons k v tl ->
- let* ntable0 = hash_map_insert_no_resize_fwd_back t ntable k v in
- hash_map_move_elements_from_list_loop_fwd_back t ntable0 tl
- | ListNil -> Return ntable
+ | List_Cons k v tl ->
+ let* ntable0 = hashMap_insert_no_resize t ntable k v in
+ hashMap_move_elements_from_list_loop t ntable0 tl
+ | List_Nil -> Return ntable
end
(** [hashmap::HashMap::{0}::move_elements_from_list]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hash_map_move_elements_from_list_fwd_back
- (t : Type0) (ntable : hash_map_t t) (ls : list_t t) : result (hash_map_t t) =
- hash_map_move_elements_from_list_loop_fwd_back t ntable ls
+let hashMap_move_elements_from_list
+ (t : Type0) (ntable : hashMap_t t) (ls : list_t t) : result (hashMap_t t) =
+ hashMap_move_elements_from_list_loop t ntable ls
(** [hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec hash_map_move_elements_loop_fwd_back
- (t : Type0) (ntable : hash_map_t t) (slots : vec (list_t t)) (i : usize) :
- Tot (result ((hash_map_t t) & (vec (list_t t))))
- (decreases (hash_map_move_elements_loop_decreases t ntable slots i))
+let rec hashMap_move_elements_loop
+ (t : Type0) (ntable : hashMap_t t) (slots : alloc_vec_Vec (list_t t))
+ (i : usize) :
+ Tot (result ((hashMap_t t) & (alloc_vec_Vec (list_t t))))
+ (decreases (hashMap_move_elements_loop_decreases t ntable slots i))
=
- let i0 = vec_len (list_t t) slots in
+ let i0 = alloc_vec_Vec_len (list_t t) slots in
if i < i0
then
- let* l = vec_index_mut_fwd (list_t t) slots i in
- let ls = mem_replace_fwd (list_t t) l ListNil in
- let* ntable0 = hash_map_move_elements_from_list_fwd_back t ntable ls in
+ let* l =
+ alloc_vec_Vec_index_mut (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t)) slots
+ i in
+ let ls = core_mem_replace (list_t t) l List_Nil in
+ let* ntable0 = hashMap_move_elements_from_list t ntable ls in
let* i1 = usize_add i 1 in
- let l0 = mem_replace_back (list_t t) l ListNil in
- let* slots0 = vec_index_mut_back (list_t t) slots i l0 in
- hash_map_move_elements_loop_fwd_back t ntable0 slots0 i1
+ let l0 = core_mem_replace_back (list_t t) l List_Nil in
+ let* slots0 =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t)) slots
+ i l0 in
+ hashMap_move_elements_loop t ntable0 slots0 i1
else Return (ntable, slots)
(** [hashmap::HashMap::{0}::move_elements]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hash_map_move_elements_fwd_back
- (t : Type0) (ntable : hash_map_t t) (slots : vec (list_t t)) (i : usize) :
- result ((hash_map_t t) & (vec (list_t t)))
+let hashMap_move_elements
+ (t : Type0) (ntable : hashMap_t t) (slots : alloc_vec_Vec (list_t t))
+ (i : usize) :
+ result ((hashMap_t t) & (alloc_vec_Vec (list_t t)))
=
- hash_map_move_elements_loop_fwd_back t ntable slots i
+ hashMap_move_elements_loop t ntable slots i
(** [hashmap::HashMap::{0}::try_resize]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hash_map_try_resize_fwd_back
- (t : Type0) (self : hash_map_t t) : result (hash_map_t t) =
- let* max_usize = scalar_cast U32 Usize core_num_u32_max_c in
- let capacity = vec_len (list_t t) self.hash_map_slots in
+let hashMap_try_resize
+ (t : Type0) (self : hashMap_t t) : result (hashMap_t t) =
+ let* max_usize = scalar_cast U32 Usize core_u32_max in
+ let capacity = alloc_vec_Vec_len (list_t t) self.slots in
let* n1 = usize_div max_usize 2 in
- let (i, i0) = self.hash_map_max_load_factor in
+ let (i, i0) = self.max_load_factor in
let* i1 = usize_div n1 i in
if capacity <= i1
then
let* i2 = usize_mul capacity 2 in
- let* ntable = hash_map_new_with_capacity_fwd t i2 i i0 in
- let* (ntable0, _) =
- hash_map_move_elements_fwd_back t ntable self.hash_map_slots 0 in
+ let* ntable = hashMap_new_with_capacity t i2 i i0 in
+ let* (ntable0, _) = hashMap_move_elements t ntable self.slots 0 in
Return
- {
- ntable0
- with
- hash_map_num_entries = self.hash_map_num_entries;
- hash_map_max_load_factor = (i, i0)
+ { ntable0 with num_entries = self.num_entries; max_load_factor = (i, i0)
}
- else Return { self with hash_map_max_load_factor = (i, i0) }
+ else Return { self with max_load_factor = (i, i0) }
(** [hashmap::HashMap::{0}::insert]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hash_map_insert_fwd_back
- (t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
- result (hash_map_t t)
+let hashMap_insert
+ (t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
+ result (hashMap_t t)
=
- let* self0 = hash_map_insert_no_resize_fwd_back t self key value in
- let* i = hash_map_len_fwd t self0 in
- if i > self0.hash_map_max_load
- then hash_map_try_resize_fwd_back t self0
- else Return self0
+ let* self0 = hashMap_insert_no_resize t self key value in
+ let* i = hashMap_len t self0 in
+ if i > self0.max_load then hashMap_try_resize t self0 else Return self0
(** [hashmap::HashMap::{0}::contains_key_in_list]: loop 0: forward function *)
-let rec hash_map_contains_key_in_list_loop_fwd
+let rec hashMap_contains_key_in_list_loop
(t : Type0) (key : usize) (ls : list_t t) :
Tot (result bool)
- (decreases (hash_map_contains_key_in_list_loop_decreases t key ls))
+ (decreases (hashMap_contains_key_in_list_loop_decreases t key ls))
=
begin match ls with
- | ListCons ckey x tl ->
+ | List_Cons ckey x tl ->
if ckey = key
then Return true
- else hash_map_contains_key_in_list_loop_fwd t key tl
- | ListNil -> Return false
+ else hashMap_contains_key_in_list_loop t key tl
+ | List_Nil -> Return false
end
(** [hashmap::HashMap::{0}::contains_key_in_list]: forward function *)
-let hash_map_contains_key_in_list_fwd
+let hashMap_contains_key_in_list
(t : Type0) (key : usize) (ls : list_t t) : result bool =
- hash_map_contains_key_in_list_loop_fwd t key ls
+ hashMap_contains_key_in_list_loop t key ls
(** [hashmap::HashMap::{0}::contains_key]: forward function *)
-let hash_map_contains_key_fwd
- (t : Type0) (self : hash_map_t t) (key : usize) : result bool =
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+let hashMap_contains_key
+ (t : Type0) (self : hashMap_t t) (key : usize) : result bool =
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_fwd (list_t t) self.hash_map_slots hash_mod in
- hash_map_contains_key_in_list_fwd t key l
+ let* l =
+ alloc_vec_Vec_index (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ hashMap_contains_key_in_list t key l
(** [hashmap::HashMap::{0}::get_in_list]: loop 0: forward function *)
-let rec hash_map_get_in_list_loop_fwd
+let rec hashMap_get_in_list_loop
(t : Type0) (key : usize) (ls : list_t t) :
- Tot (result t) (decreases (hash_map_get_in_list_loop_decreases t key ls))
+ Tot (result t) (decreases (hashMap_get_in_list_loop_decreases t key ls))
=
begin match ls with
- | ListCons ckey cvalue tl ->
- if ckey = key
- then Return cvalue
- else hash_map_get_in_list_loop_fwd t key tl
- | ListNil -> Fail Failure
+ | List_Cons ckey cvalue tl ->
+ if ckey = key then Return cvalue else hashMap_get_in_list_loop t key tl
+ | List_Nil -> Fail Failure
end
(** [hashmap::HashMap::{0}::get_in_list]: forward function *)
-let hash_map_get_in_list_fwd
- (t : Type0) (key : usize) (ls : list_t t) : result t =
- hash_map_get_in_list_loop_fwd t key ls
+let hashMap_get_in_list (t : Type0) (key : usize) (ls : list_t t) : result t =
+ hashMap_get_in_list_loop t key ls
(** [hashmap::HashMap::{0}::get]: forward function *)
-let hash_map_get_fwd
- (t : Type0) (self : hash_map_t t) (key : usize) : result t =
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+let hashMap_get (t : Type0) (self : hashMap_t t) (key : usize) : result t =
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_fwd (list_t t) self.hash_map_slots hash_mod in
- hash_map_get_in_list_fwd t key l
+ let* l =
+ alloc_vec_Vec_index (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ hashMap_get_in_list t key l
(** [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function *)
-let rec hash_map_get_mut_in_list_loop_fwd
+let rec hashMap_get_mut_in_list_loop
(t : Type0) (ls : list_t t) (key : usize) :
- Tot (result t) (decreases (hash_map_get_mut_in_list_loop_decreases t ls key))
+ Tot (result t) (decreases (hashMap_get_mut_in_list_loop_decreases t ls key))
=
begin match ls with
- | ListCons ckey cvalue tl ->
- if ckey = key
- then Return cvalue
- else hash_map_get_mut_in_list_loop_fwd t tl key
- | ListNil -> Fail Failure
+ | List_Cons ckey cvalue tl ->
+ if ckey = key then Return cvalue else hashMap_get_mut_in_list_loop t tl key
+ | List_Nil -> Fail Failure
end
(** [hashmap::HashMap::{0}::get_mut_in_list]: forward function *)
-let hash_map_get_mut_in_list_fwd
+let hashMap_get_mut_in_list
(t : Type0) (ls : list_t t) (key : usize) : result t =
- hash_map_get_mut_in_list_loop_fwd t ls key
+ hashMap_get_mut_in_list_loop t ls key
(** [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: backward function 0 *)
-let rec hash_map_get_mut_in_list_loop_back
+let rec hashMap_get_mut_in_list_loop_back
(t : Type0) (ls : list_t t) (key : usize) (ret : t) :
Tot (result (list_t t))
- (decreases (hash_map_get_mut_in_list_loop_decreases t ls key))
+ (decreases (hashMap_get_mut_in_list_loop_decreases t ls key))
=
begin match ls with
- | ListCons ckey cvalue tl ->
+ | List_Cons ckey cvalue tl ->
if ckey = key
- then Return (ListCons ckey ret tl)
+ then Return (List_Cons ckey ret tl)
else
- let* tl0 = hash_map_get_mut_in_list_loop_back t tl key ret in
- Return (ListCons ckey cvalue tl0)
- | ListNil -> Fail Failure
+ let* tl0 = hashMap_get_mut_in_list_loop_back t tl key ret in
+ Return (List_Cons ckey cvalue tl0)
+ | List_Nil -> Fail Failure
end
(** [hashmap::HashMap::{0}::get_mut_in_list]: backward function 0 *)
-let hash_map_get_mut_in_list_back
+let hashMap_get_mut_in_list_back
(t : Type0) (ls : list_t t) (key : usize) (ret : t) : result (list_t t) =
- hash_map_get_mut_in_list_loop_back t ls key ret
+ hashMap_get_mut_in_list_loop_back t ls key ret
(** [hashmap::HashMap::{0}::get_mut]: forward function *)
-let hash_map_get_mut_fwd
- (t : Type0) (self : hash_map_t t) (key : usize) : result t =
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+let hashMap_get_mut (t : Type0) (self : hashMap_t t) (key : usize) : result t =
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_mut_fwd (list_t t) self.hash_map_slots hash_mod in
- hash_map_get_mut_in_list_fwd t l key
+ let* l =
+ alloc_vec_Vec_index_mut (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ hashMap_get_mut_in_list t l key
(** [hashmap::HashMap::{0}::get_mut]: backward function 0 *)
-let hash_map_get_mut_back
- (t : Type0) (self : hash_map_t t) (key : usize) (ret : t) :
- result (hash_map_t t)
+let hashMap_get_mut_back
+ (t : Type0) (self : hashMap_t t) (key : usize) (ret : t) :
+ result (hashMap_t t)
=
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_mut_fwd (list_t t) self.hash_map_slots hash_mod in
- let* l0 = hash_map_get_mut_in_list_back t l key ret in
- let* v = vec_index_mut_back (list_t t) self.hash_map_slots hash_mod l0 in
- Return { self with hash_map_slots = v }
+ let* l =
+ alloc_vec_Vec_index_mut (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ let* l0 = hashMap_get_mut_in_list_back t l key ret in
+ let* v =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod l0 in
+ Return { self with slots = v }
(** [hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function *)
-let rec hash_map_remove_from_list_loop_fwd
+let rec hashMap_remove_from_list_loop
(t : Type0) (key : usize) (ls : list_t t) :
Tot (result (option t))
- (decreases (hash_map_remove_from_list_loop_decreases t key ls))
+ (decreases (hashMap_remove_from_list_loop_decreases t key ls))
=
begin match ls with
- | ListCons ckey x tl ->
+ | List_Cons ckey x tl ->
if ckey = key
then
- let mv_ls = mem_replace_fwd (list_t t) (ListCons ckey x tl) ListNil in
+ let mv_ls = core_mem_replace (list_t t) (List_Cons ckey x tl) List_Nil in
begin match mv_ls with
- | ListCons i cvalue tl0 -> Return (Some cvalue)
- | ListNil -> Fail Failure
+ | List_Cons i cvalue tl0 -> Return (Some cvalue)
+ | List_Nil -> Fail Failure
end
- else hash_map_remove_from_list_loop_fwd t key tl
- | ListNil -> Return None
+ else hashMap_remove_from_list_loop t key tl
+ | List_Nil -> Return None
end
(** [hashmap::HashMap::{0}::remove_from_list]: forward function *)
-let hash_map_remove_from_list_fwd
+let hashMap_remove_from_list
(t : Type0) (key : usize) (ls : list_t t) : result (option t) =
- hash_map_remove_from_list_loop_fwd t key ls
+ hashMap_remove_from_list_loop t key ls
(** [hashmap::HashMap::{0}::remove_from_list]: loop 0: backward function 1 *)
-let rec hash_map_remove_from_list_loop_back
+let rec hashMap_remove_from_list_loop_back
(t : Type0) (key : usize) (ls : list_t t) :
Tot (result (list_t t))
- (decreases (hash_map_remove_from_list_loop_decreases t key ls))
+ (decreases (hashMap_remove_from_list_loop_decreases t key ls))
=
begin match ls with
- | ListCons ckey x tl ->
+ | List_Cons ckey x tl ->
if ckey = key
then
- let mv_ls = mem_replace_fwd (list_t t) (ListCons ckey x tl) ListNil in
+ let mv_ls = core_mem_replace (list_t t) (List_Cons ckey x tl) List_Nil in
begin match mv_ls with
- | ListCons i cvalue tl0 -> Return tl0
- | ListNil -> Fail Failure
+ | List_Cons i cvalue tl0 -> Return tl0
+ | List_Nil -> Fail Failure
end
else
- let* tl0 = hash_map_remove_from_list_loop_back t key tl in
- Return (ListCons ckey x tl0)
- | ListNil -> Return ListNil
+ let* tl0 = hashMap_remove_from_list_loop_back t key tl in
+ Return (List_Cons ckey x tl0)
+ | List_Nil -> Return List_Nil
end
(** [hashmap::HashMap::{0}::remove_from_list]: backward function 1 *)
-let hash_map_remove_from_list_back
+let hashMap_remove_from_list_back
(t : Type0) (key : usize) (ls : list_t t) : result (list_t t) =
- hash_map_remove_from_list_loop_back t key ls
+ hashMap_remove_from_list_loop_back t key ls
(** [hashmap::HashMap::{0}::remove]: forward function *)
-let hash_map_remove_fwd
- (t : Type0) (self : hash_map_t t) (key : usize) : result (option t) =
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+let hashMap_remove
+ (t : Type0) (self : hashMap_t t) (key : usize) : result (option t) =
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_mut_fwd (list_t t) self.hash_map_slots hash_mod in
- let* x = hash_map_remove_from_list_fwd t key l in
+ let* l =
+ alloc_vec_Vec_index_mut (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ let* x = hashMap_remove_from_list t key l in
begin match x with
| None -> Return None
- | Some x0 ->
- let* _ = usize_sub self.hash_map_num_entries 1 in Return (Some x0)
+ | Some x0 -> let* _ = usize_sub self.num_entries 1 in Return (Some x0)
end
(** [hashmap::HashMap::{0}::remove]: backward function 0 *)
-let hash_map_remove_back
- (t : Type0) (self : hash_map_t t) (key : usize) : result (hash_map_t t) =
- let* hash = hash_key_fwd key in
- let i = vec_len (list_t t) self.hash_map_slots in
+let hashMap_remove_back
+ (t : Type0) (self : hashMap_t t) (key : usize) : result (hashMap_t t) =
+ let* hash = hash_key key in
+ let i = alloc_vec_Vec_len (list_t t) self.slots in
let* hash_mod = usize_rem hash i in
- let* l = vec_index_mut_fwd (list_t t) self.hash_map_slots hash_mod in
- let* x = hash_map_remove_from_list_fwd t key l in
+ let* l =
+ alloc_vec_Vec_index_mut (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod in
+ let* x = hashMap_remove_from_list t key l in
begin match x with
| None ->
- let* l0 = hash_map_remove_from_list_back t key l in
- let* v = vec_index_mut_back (list_t t) self.hash_map_slots hash_mod l0 in
- Return { self with hash_map_slots = v }
+ let* l0 = hashMap_remove_from_list_back t key l in
+ let* v =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod l0 in
+ Return { self with slots = v }
| Some x0 ->
- let* i0 = usize_sub self.hash_map_num_entries 1 in
- let* l0 = hash_map_remove_from_list_back t key l in
- let* v = vec_index_mut_back (list_t t) self.hash_map_slots hash_mod l0 in
- Return { self with hash_map_num_entries = i0; hash_map_slots = v }
+ let* i0 = usize_sub self.num_entries 1 in
+ let* l0 = hashMap_remove_from_list_back t key l in
+ let* v =
+ alloc_vec_Vec_index_mut_back (list_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t t))
+ self.slots hash_mod l0 in
+ Return { self with num_entries = i0; slots = v }
end
(** [hashmap::test1]: forward function *)
-let test1_fwd : result unit =
- let* hm = hash_map_new_fwd u64 in
- let* hm0 = hash_map_insert_fwd_back u64 hm 0 42 in
- let* hm1 = hash_map_insert_fwd_back u64 hm0 128 18 in
- let* hm2 = hash_map_insert_fwd_back u64 hm1 1024 138 in
- let* hm3 = hash_map_insert_fwd_back u64 hm2 1056 256 in
- let* i = hash_map_get_fwd u64 hm3 128 in
+let test1 : result unit =
+ let* hm = hashMap_new u64 in
+ let* hm0 = hashMap_insert u64 hm 0 42 in
+ let* hm1 = hashMap_insert u64 hm0 128 18 in
+ let* hm2 = hashMap_insert u64 hm1 1024 138 in
+ let* hm3 = hashMap_insert u64 hm2 1056 256 in
+ let* i = hashMap_get u64 hm3 128 in
if not (i = 18)
then Fail Failure
else
- let* hm4 = hash_map_get_mut_back u64 hm3 1024 56 in
- let* i0 = hash_map_get_fwd u64 hm4 1024 in
+ let* hm4 = hashMap_get_mut_back u64 hm3 1024 56 in
+ let* i0 = hashMap_get u64 hm4 1024 in
if not (i0 = 56)
then Fail Failure
else
- let* x = hash_map_remove_fwd u64 hm4 1024 in
+ let* x = hashMap_remove u64 hm4 1024 in
begin match x with
| None -> Fail Failure
| Some x0 ->
if not (x0 = 56)
then Fail Failure
else
- let* hm5 = hash_map_remove_back u64 hm4 1024 in
- let* i1 = hash_map_get_fwd u64 hm5 0 in
+ let* hm5 = hashMap_remove_back u64 hm4 1024 in
+ let* i1 = hashMap_get u64 hm5 0 in
if not (i1 = 42)
then Fail Failure
else
- let* i2 = hash_map_get_fwd u64 hm5 128 in
+ let* i2 = hashMap_get u64 hm5 128 in
if not (i2 = 18)
then Fail Failure
else
- let* i3 = hash_map_get_fwd u64 hm5 1056 in
+ let* i3 = hashMap_get u64 hm5 1056 in
if not (i3 = 256) then Fail Failure else Return ()
end
-(** Unit test for [hashmap::test1] *)
-let _ = assert_norm (test1_fwd = Return ())
-
diff --git a/tests/fstar/hashmap/Hashmap.Properties.fst b/tests/fstar/hashmap/Hashmap.Properties.fst
index 49d96cd5..def520f0 100644
--- a/tests/fstar/hashmap/Hashmap.Properties.fst
+++ b/tests/fstar/hashmap/Hashmap.Properties.fst
@@ -272,7 +272,7 @@ type pos_usize = x:usize{x > 0}
type binding (t : Type0) = key & t
-type slots_t (t : Type0) = vec (list_t t)
+type slots_t (t : Type0) = alloc_vec_Vec (list_t t)
/// We represent hash maps as associative lists
type assoc_list (t : Type0) = list (binding t)
@@ -280,8 +280,8 @@ type assoc_list (t : Type0) = list (binding t)
/// Representation function for [list_t]
let rec list_t_v (#t : Type0) (ls : list_t t) : assoc_list t =
match ls with
- | ListNil -> []
- | ListCons k v tl -> (k,v) :: list_t_v tl
+ | List_Nil -> []
+ | List_Cons k v tl -> (k,v) :: list_t_v tl
let list_t_len (#t : Type0) (ls : list_t t) : nat = length (list_t_v ls)
let list_t_index (#t : Type0) (ls : list_t t) (i : nat{i < list_t_len ls}) : binding t =
@@ -305,30 +305,30 @@ let slots_t_al_v (#t : Type0) (slots : slots_t t) : assoc_list t =
/// list per slot). This is the representation we use most, internally. Note that
/// we later introduce a [map_s] representation, which is the one used in the
/// lemmas shown to the user.
-type hash_map_s t = list (slot_s t)
+type hashMap_s t = list (slot_s t)
// TODO: why not always have the condition on the length?
// 'nes': "non-empty slots"
-type hash_map_s_nes (t : Type0) : Type0 =
- hm:hash_map_s t{is_pos_usize (length hm)}
+type hashMap_s_nes (t : Type0) : Type0 =
+ hm:hashMap_s t{is_pos_usize (length hm)}
-/// Representation function for [hash_map_t] as a list of slots
-let hash_map_t_v (#t : Type0) (hm : hash_map_t t) : hash_map_s t =
- map list_t_v hm.hash_map_slots
+/// Representation function for [hashMap_t] as a list of slots
+let hashMap_t_v (#t : Type0) (hm : hashMap_t t) : hashMap_s t =
+ map list_t_v hm.slots
-/// Representation function for [hash_map_t] as an associative list
-let hash_map_t_al_v (#t : Type0) (hm : hash_map_t t) : assoc_list t =
- flatten (hash_map_t_v hm)
+/// Representation function for [hashMap_t] as an associative list
+let hashMap_t_al_v (#t : Type0) (hm : hashMap_t t) : assoc_list t =
+ flatten (hashMap_t_v hm)
// 'nes': "non-empty slots"
-type hash_map_t_nes (t : Type0) : Type0 =
- hm:hash_map_t t{is_pos_usize (length hm.hash_map_slots)}
+type hashMap_t_nes (t : Type0) : Type0 =
+ hm:hashMap_t t{is_pos_usize (length hm.slots)}
-let hash_key (k : key) : hash =
- Return?.v (hash_key_fwd k)
+let hash_key_s (k : key) : hash =
+ Return?.v (hash_key k)
let hash_mod_key (k : key) (len : usize{len > 0}) : hash =
- (hash_key k) % len
+ (hash_key_s k) % len
let not_same_key (#t : Type0) (k : key) (b : binding t) : bool = fst b <> k
let same_key (#t : Type0) (k : key) (b : binding t) : bool = fst b = k
@@ -339,8 +339,8 @@ let same_hash_mod_key (#t : Type0) (len : usize{len > 0}) (h : nat) (b : binding
let binding_neq (#t : Type0) (b0 b1 : binding t) : bool = fst b0 <> fst b1
-let hash_map_t_len_s (#t : Type0) (hm : hash_map_t t) : nat =
- hm.hash_map_num_entries
+let hashMap_t_len_s (#t : Type0) (hm : hashMap_t t) : nat =
+ hm.num_entries
let assoc_list_find (#t : Type0) (k : key) (slot : assoc_list t) : option t =
match find (same_key k) slot with
@@ -354,26 +354,26 @@ let slot_t_find_s (#t : Type0) (k : key) (slot : list_t t) : option t =
slot_s_find k (slot_t_v slot)
// This is a simpler version of the "find" function, which captures the essence
-// of what happens and operates on [hash_map_s].
-let hash_map_s_find
- (#t : Type0) (hm : hash_map_s_nes t)
+// of what happens and operates on [hashMap_s].
+let hashMap_s_find
+ (#t : Type0) (hm : hashMap_s_nes t)
(k : key) : option t =
let i = hash_mod_key k (length hm) in
let slot = index hm i in
slot_s_find k slot
-let hash_map_s_len
- (#t : Type0) (hm : hash_map_s t) :
+let hashMap_s_len
+ (#t : Type0) (hm : hashMap_s t) :
nat =
length (flatten hm)
-// Same as above, but operates on [hash_map_t]
+// Same as above, but operates on [hashMap_t]
// Note that we don't reuse the above function on purpose: converting to a
-// [hash_map_s] then looking up an element is not the same as what we
+// [hashMap_s] then looking up an element is not the same as what we
// wrote below.
-let hash_map_t_find_s
- (#t : Type0) (hm : hash_map_t t{length hm.hash_map_slots > 0}) (k : key) : option t =
- let slots = hm.hash_map_slots in
+let hashMap_t_find_s
+ (#t : Type0) (hm : hashMap_t t{length hm.slots > 0}) (k : key) : option t =
+ let slots = hm.slots in
let i = hash_mod_key k (length slots) in
let slot = index slots i in
slot_t_find_s k slot
@@ -404,74 +404,74 @@ let slots_t_inv (#t : Type0) (slots : slots_t t{length slots <= usize_max}) : Ty
{:pattern index slots i}
slot_t_inv (length slots) i (index slots i)
-let hash_map_s_inv (#t : Type0) (hm : hash_map_s t) : Type0 =
+let hashMap_s_inv (#t : Type0) (hm : hashMap_s t) : Type0 =
length hm <= usize_max /\
length hm > 0 /\
slots_s_inv hm
/// Base invariant for the hashmap (the complete invariant can be temporarily
/// broken between the moment we inserted an element and the moment we resize)
-let hash_map_t_base_inv (#t : Type0) (hm : hash_map_t t) : Type0 =
- let al = hash_map_t_al_v hm in
+let hashMap_t_base_inv (#t : Type0) (hm : hashMap_t t) : Type0 =
+ let al = hashMap_t_al_v hm in
// [num_entries] correctly tracks the number of entries in the table
// Note that it gives us that the length of the slots array is <= usize_max:
// [> length <= usize_max
- // (because hash_map_num_entries has type `usize`)
- hm.hash_map_num_entries = length al /\
+ // (because hashMap_num_entries has type `usize`)
+ hm.num_entries = length al /\
// Slots invariant
- slots_t_inv hm.hash_map_slots /\
+ slots_t_inv hm.slots /\
// The capacity must be > 0 (otherwise we can't resize, because we
// multiply the capacity by two!)
- length hm.hash_map_slots > 0 /\
+ length hm.slots > 0 /\
// Load computation
begin
- let capacity = length hm.hash_map_slots in
- let (dividend, divisor) = hm.hash_map_max_load_factor in
+ let capacity = length hm.slots in
+ let (dividend, divisor) = hm.max_load_factor in
0 < dividend /\ dividend < divisor /\
capacity * dividend >= divisor /\
- hm.hash_map_max_load = (capacity * dividend) / divisor
+ hm.max_load = (capacity * dividend) / divisor
end
/// We often need to frame some values
-let hash_map_t_same_params (#t : Type0) (hm0 hm1 : hash_map_t t) : Type0 =
- length hm0.hash_map_slots = length hm1.hash_map_slots /\
- hm0.hash_map_max_load = hm1.hash_map_max_load /\
- hm0.hash_map_max_load_factor = hm1.hash_map_max_load_factor
+let hashMap_t_same_params (#t : Type0) (hm0 hm1 : hashMap_t t) : Type0 =
+ length hm0.slots = length hm1.slots /\
+ hm0.max_load = hm1.max_load /\
+ hm0.max_load_factor = hm1.max_load_factor
/// The following invariants, etc. are meant to be revealed to the user through
/// the .fsti.
/// Invariant for the hashmap
-let hash_map_t_inv (#t : Type0) (hm : hash_map_t t) : Type0 =
+let hashMap_t_inv (#t : Type0) (hm : hashMap_t t) : Type0 =
// Base invariant
- hash_map_t_base_inv hm /\
+ hashMap_t_base_inv hm /\
// The hash map is either: not overloaded, or we can't resize it
begin
- let (dividend, divisor) = hm.hash_map_max_load_factor in
- hm.hash_map_num_entries <= hm.hash_map_max_load
- || length hm.hash_map_slots * 2 * dividend > usize_max
+ let (dividend, divisor) = hm.max_load_factor in
+ hm.num_entries <= hm.max_load
+ || length hm.slots * 2 * dividend > usize_max
end
(*** .fsti *)
/// We reveal slightly different version of the above functions to the user
-let len_s (#t : Type0) (hm : hash_map_t t) : nat = hash_map_t_len_s hm
+let len_s (#t : Type0) (hm : hashMap_t t) : nat = hashMap_t_len_s hm
-/// This version doesn't take any precondition (contrary to [hash_map_t_find_s])
-let find_s (#t : Type0) (hm : hash_map_t t) (k : key) : option t =
- if length hm.hash_map_slots = 0 then None
- else hash_map_t_find_s hm k
+/// This version doesn't take any precondition (contrary to [hashMap_t_find_s])
+let find_s (#t : Type0) (hm : hashMap_t t) (k : key) : option t =
+ if length hm.slots = 0 then None
+ else hashMap_t_find_s hm k
(*** Overloading *)
-let hash_map_not_overloaded_lem #t hm = ()
+let hashMap_not_overloaded_lem #t hm = ()
(*** allocate_slots *)
/// Auxiliary lemma
val slots_t_all_nil_inv_lem
- (#t : Type0) (slots : vec (list_t t){length slots <= usize_max}) :
- Lemma (requires (forall (i:nat{i < length slots}). index slots i == ListNil))
+ (#t : Type0) (slots : alloc_vec_Vec (list_t t){length slots <= usize_max}) :
+ Lemma (requires (forall (i:nat{i < length slots}). index slots i == List_Nil))
(ensures (slots_t_inv slots))
#push-options "--fuel 1"
@@ -479,8 +479,8 @@ let slots_t_all_nil_inv_lem #t slots = ()
#pop-options
val slots_t_al_v_all_nil_is_empty_lem
- (#t : Type0) (slots : vec (list_t t)) :
- Lemma (requires (forall (i:nat{i < length slots}). index slots i == ListNil))
+ (#t : Type0) (slots : alloc_vec_Vec (list_t t)) :
+ Lemma (requires (forall (i:nat{i < length slots}). index slots i == List_Nil))
(ensures (slots_t_al_v slots == []))
#push-options "--fuel 1"
@@ -492,44 +492,44 @@ let rec slots_t_al_v_all_nil_is_empty_lem #t slots =
slots_t_al_v_all_nil_is_empty_lem #t slots';
assert(slots_t_al_v slots == list_t_v s @ slots_t_al_v slots');
assert(slots_t_al_v slots == list_t_v s);
- assert(index slots 0 == ListNil)
+ assert(index slots 0 == List_Nil)
#pop-options
/// [allocate_slots]
-val hash_map_allocate_slots_fwd_lem
- (t : Type0) (slots : vec (list_t t)) (n : usize) :
+val hashMap_allocate_slots_lem
+ (t : Type0) (slots : alloc_vec_Vec (list_t t)) (n : usize) :
Lemma
(requires (length slots + n <= usize_max))
(ensures (
- match hash_map_allocate_slots_fwd t slots n with
+ match hashMap_allocate_slots t slots n with
| Fail _ -> False
| Return slots' ->
length slots' = length slots + n /\
// We leave the already allocated slots unchanged
(forall (i:nat{i < length slots}). index slots' i == index slots i) /\
// We allocate n additional empty slots
- (forall (i:nat{length slots <= i /\ i < length slots'}). index slots' i == ListNil)))
- (decreases (hash_map_allocate_slots_loop_decreases t slots n))
+ (forall (i:nat{length slots <= i /\ i < length slots'}). index slots' i == List_Nil)))
+ (decreases (hashMap_allocate_slots_loop_decreases t slots n))
#push-options "--fuel 1"
-let rec hash_map_allocate_slots_fwd_lem t slots n =
+let rec hashMap_allocate_slots_lem t slots n =
begin match n with
| 0 -> ()
| _ ->
- begin match vec_push_back (list_t t) slots ListNil with
+ begin match alloc_vec_Vec_push (list_t t) slots List_Nil with
| Fail _ -> ()
| Return slots1 ->
begin match usize_sub n 1 with
| Fail _ -> ()
| Return i ->
- hash_map_allocate_slots_fwd_lem t slots1 i;
- begin match hash_map_allocate_slots_fwd t slots1 i with
+ hashMap_allocate_slots_lem t slots1 i;
+ begin match hashMap_allocate_slots t slots1 i with
| Fail _ -> ()
| Return slots2 ->
assert(length slots1 = length slots + 1);
- assert(slots1 == slots @ [ListNil]); // Triggers patterns
- assert(index slots1 (length slots) == index [ListNil] 0); // Triggers patterns
- assert(index slots1 (length slots) == ListNil)
+ assert(slots1 == slots @ [List_Nil]); // Triggers patterns
+ assert(index slots1 (length slots) == index [List_Nil] 0); // Triggers patterns
+ assert(index slots1 (length slots) == List_Nil)
end
end
end
@@ -538,7 +538,7 @@ let rec hash_map_allocate_slots_fwd_lem t slots n =
(*** new_with_capacity *)
/// Under proper conditions, [new_with_capacity] doesn't fail and returns an empty hash map.
-val hash_map_new_with_capacity_fwd_lem
+val hashMap_new_with_capacity_lem
(t : Type0) (capacity : usize)
(max_load_dividend : usize) (max_load_divisor : usize) :
Lemma
@@ -549,31 +549,31 @@ val hash_map_new_with_capacity_fwd_lem
capacity * max_load_dividend >= max_load_divisor /\
capacity * max_load_dividend <= usize_max))
(ensures (
- match hash_map_new_with_capacity_fwd t capacity max_load_dividend max_load_divisor with
+ match hashMap_new_with_capacity t capacity max_load_dividend max_load_divisor with
| Fail _ -> False
| Return hm ->
// The hash map invariant is satisfied
- hash_map_t_inv hm /\
+ hashMap_t_inv hm /\
// The parameters are correct
- hm.hash_map_max_load_factor = (max_load_dividend, max_load_divisor) /\
- hm.hash_map_max_load = (capacity * max_load_dividend) / max_load_divisor /\
+ hm.max_load_factor = (max_load_dividend, max_load_divisor) /\
+ hm.max_load = (capacity * max_load_dividend) / max_load_divisor /\
// The hash map has the specified capacity - we need to reveal this
- // otherwise the pre of [hash_map_t_find_s] is not satisfied.
- length hm.hash_map_slots = capacity /\
+ // otherwise the pre of [hashMap_t_find_s] is not satisfied.
+ length hm.slots = capacity /\
// The hash map has 0 values
- hash_map_t_len_s hm = 0 /\
+ hashMap_t_len_s hm = 0 /\
// It contains no bindings
- (forall k. hash_map_t_find_s hm k == None) /\
+ (forall k. hashMap_t_find_s hm k == None) /\
// We need this low-level property for the invariant
- (forall(i:nat{i < length hm.hash_map_slots}). index hm.hash_map_slots i == ListNil)))
+ (forall(i:nat{i < length hm.slots}). index hm.slots i == List_Nil)))
#push-options "--z3rlimit 50 --fuel 1"
-let hash_map_new_with_capacity_fwd_lem (t : Type0) (capacity : usize)
+let hashMap_new_with_capacity_lem (t : Type0) (capacity : usize)
(max_load_dividend : usize) (max_load_divisor : usize) =
- let v = vec_new (list_t t) in
+ let v = alloc_vec_Vec_new (list_t t) in
assert(length v = 0);
- hash_map_allocate_slots_fwd_lem t v capacity;
- begin match hash_map_allocate_slots_fwd t v capacity with
+ hashMap_allocate_slots_lem t v capacity;
+ begin match hashMap_allocate_slots t v capacity with
| Fail _ -> assert(False)
| Return v0 ->
begin match usize_mul capacity max_load_dividend with
@@ -582,9 +582,9 @@ let hash_map_new_with_capacity_fwd_lem (t : Type0) (capacity : usize)
begin match usize_div i max_load_divisor with
| Fail _ -> assert(False)
| Return i0 ->
- let hm = Mkhash_map_t 0 (max_load_dividend, max_load_divisor) i0 v0 in
+ let hm = MkhashMap_t 0 (max_load_dividend, max_load_divisor) i0 v0 in
slots_t_all_nil_inv_lem v0;
- slots_t_al_v_all_nil_is_empty_lem hm.hash_map_slots
+ slots_t_al_v_all_nil_is_empty_lem hm.slots
end
end
end
@@ -593,65 +593,65 @@ let hash_map_new_with_capacity_fwd_lem (t : Type0) (capacity : usize)
(*** new *)
/// [new] doesn't fail and returns an empty hash map
-val hash_map_new_fwd_lem_aux (t : Type0) :
+val hashMap_new_lem_aux (t : Type0) :
Lemma
(ensures (
- match hash_map_new_fwd t with
+ match hashMap_new t with
| Fail _ -> False
| Return hm ->
// The hash map invariant is satisfied
- hash_map_t_inv hm /\
+ hashMap_t_inv hm /\
// The hash map has 0 values
- hash_map_t_len_s hm = 0 /\
+ hashMap_t_len_s hm = 0 /\
// It contains no bindings
- (forall k. hash_map_t_find_s hm k == None)))
+ (forall k. hashMap_t_find_s hm k == None)))
#push-options "--fuel 1"
-let hash_map_new_fwd_lem_aux t =
- hash_map_new_with_capacity_fwd_lem t 32 4 5;
- match hash_map_new_with_capacity_fwd t 32 4 5 with
+let hashMap_new_lem_aux t =
+ hashMap_new_with_capacity_lem t 32 4 5;
+ match hashMap_new_with_capacity t 32 4 5 with
| Fail _ -> ()
| Return hm -> ()
#pop-options
/// The lemma we reveal in the .fsti
-let hash_map_new_fwd_lem t = hash_map_new_fwd_lem_aux t
+let hashMap_new_lem t = hashMap_new_lem_aux t
(*** clear *)
/// [clear]: the loop doesn't fail and simply clears the slots starting at index i
#push-options "--fuel 1"
-let rec hash_map_clear_loop_fwd_back_lem
- (t : Type0) (slots : vec (list_t t)) (i : usize) :
+let rec hashMap_clear_loop_lem
+ (t : Type0) (slots : alloc_vec_Vec (list_t t)) (i : usize) :
Lemma
(ensures (
- match hash_map_clear_loop_fwd_back t slots i with
+ match hashMap_clear_loop t slots i with
| Fail _ -> False
| Return slots' ->
// The length is preserved
length slots' == length slots /\
// The slots before i are left unchanged
(forall (j:nat{j < i /\ j < length slots}). index slots' j == index slots j) /\
- // The slots after i are set to ListNil
- (forall (j:nat{i <= j /\ j < length slots}). index slots' j == ListNil)))
- (decreases (hash_map_clear_loop_decreases t slots i))
+ // The slots after i are set to List_Nil
+ (forall (j:nat{i <= j /\ j < length slots}). index slots' j == List_Nil)))
+ (decreases (hashMap_clear_loop_decreases t slots i))
=
- let i0 = vec_len (list_t t) slots in
+ let i0 = alloc_vec_Vec_len (list_t t) slots in
let b = i < i0 in
if b
then
- begin match vec_index_mut_back (list_t t) slots i ListNil with
+ begin match alloc_vec_Vec_update_usize slots i List_Nil with
| Fail _ -> ()
| Return v ->
begin match usize_add i 1 with
| Fail _ -> ()
| Return i1 ->
- hash_map_clear_loop_fwd_back_lem t v i1;
- begin match hash_map_clear_loop_fwd_back t v i1 with
+ hashMap_clear_loop_lem t v i1;
+ begin match hashMap_clear_loop t v i1 with
| Fail _ -> ()
| Return slots1 ->
assert(length slots1 == length slots);
- assert(forall (j:nat{i+1 <= j /\ j < length slots}). index slots1 j == ListNil);
- assert(index slots1 i == ListNil)
+ assert(forall (j:nat{i+1 <= j /\ j < length slots}). index slots1 j == List_Nil);
+ assert(index slots1 i == List_Nil)
end
end
end
@@ -659,80 +659,80 @@ let rec hash_map_clear_loop_fwd_back_lem
#pop-options
/// [clear] doesn't fail and turns the hash map into an empty map
-val hash_map_clear_fwd_back_lem_aux
- (#t : Type0) (self : hash_map_t t) :
+val hashMap_clear_lem_aux
+ (#t : Type0) (self : hashMap_t t) :
Lemma
- (requires (hash_map_t_base_inv self))
+ (requires (hashMap_t_base_inv self))
(ensures (
- match hash_map_clear_fwd_back t self with
+ match hashMap_clear t self with
| Fail _ -> False
| Return hm ->
// The hash map invariant is satisfied
- hash_map_t_base_inv hm /\
+ hashMap_t_base_inv hm /\
// We preserved the parameters
- hash_map_t_same_params hm self /\
+ hashMap_t_same_params hm self /\
// The hash map has 0 values
- hash_map_t_len_s hm = 0 /\
+ hashMap_t_len_s hm = 0 /\
// It contains no bindings
- (forall k. hash_map_t_find_s hm k == None)))
+ (forall k. hashMap_t_find_s hm k == None)))
// Being lazy: fuel 1 helps a lot...
#push-options "--fuel 1"
-let hash_map_clear_fwd_back_lem_aux #t self =
- let p = self.hash_map_max_load_factor in
- let i = self.hash_map_max_load in
- let v = self.hash_map_slots in
- hash_map_clear_loop_fwd_back_lem t v 0;
- begin match hash_map_clear_loop_fwd_back t v 0 with
+let hashMap_clear_lem_aux #t self =
+ let p = self.max_load_factor in
+ let i = self.max_load in
+ let v = self.slots in
+ hashMap_clear_loop_lem t v 0;
+ begin match hashMap_clear_loop t v 0 with
| Fail _ -> ()
| Return slots1 ->
slots_t_al_v_all_nil_is_empty_lem slots1;
- let hm1 = Mkhash_map_t 0 p i slots1 in
- assert(hash_map_t_base_inv hm1);
- assert(hash_map_t_inv hm1)
+ let hm1 = MkhashMap_t 0 p i slots1 in
+ assert(hashMap_t_base_inv hm1);
+ assert(hashMap_t_inv hm1)
end
#pop-options
-let hash_map_clear_fwd_back_lem #t self = hash_map_clear_fwd_back_lem_aux #t self
+let hashMap_clear_lem #t self = hashMap_clear_lem_aux #t self
(*** len *)
/// [len]: we link it to a non-failing function.
/// Rk.: we might want to make an analysis to not use an error monad to translate
/// functions which statically can't fail.
-let hash_map_len_fwd_lem #t self = ()
+let hashMap_len_lem #t self = ()
(*** insert_in_list *)
(**** insert_in_list'fwd *)
-/// [insert_in_list_fwd]: returns true iff the key is not in the list (functional version)
-val hash_map_insert_in_list_fwd_lem
+/// [insert_in_list]: returns true iff the key is not in the list (functional version)
+val hashMap_insert_in_list_lem
(t : Type0) (key : usize) (value : t) (ls : list_t t) :
Lemma
(ensures (
- match hash_map_insert_in_list_fwd t key value ls with
+ match hashMap_insert_in_list t key value ls with
| Fail _ -> False
| Return b ->
b <==> (slot_t_find_s key ls == None)))
- (decreases (hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashMap_insert_in_list_loop_decreases t key value ls))
#push-options "--fuel 1"
-let rec hash_map_insert_in_list_fwd_lem t key value ls =
+let rec hashMap_insert_in_list_lem t key value ls =
begin match ls with
- | ListCons ckey cvalue ls0 ->
+ | List_Cons ckey cvalue ls0 ->
let b = ckey = key in
if b
then ()
else
begin
- hash_map_insert_in_list_fwd_lem t key value ls0;
- match hash_map_insert_in_list_fwd t key value ls0 with
+ hashMap_insert_in_list_lem t key value ls0;
+ match hashMap_insert_in_list t key value ls0 with
| Fail _ -> ()
| Return b0 -> ()
end
- | ListNil ->
+ | List_Nil ->
assert(list_t_v ls == []);
assert_norm(find (same_key #t key) [] == None)
end
@@ -748,7 +748,7 @@ let rec hash_map_insert_in_list_fwd_lem t key value ls =
/// We write a helper which "captures" what [insert_in_list] does.
/// We then reason about this helper to prove the high-level properties we want
/// (functional properties, preservation of invariants, etc.).
-let hash_map_insert_in_list_s
+let hashMap_insert_in_list_s
(#t : Type0) (key : usize) (value : t) (ls : list (binding t)) :
list (binding t) =
// Check if there is already a binding for the key
@@ -761,86 +761,86 @@ let hash_map_insert_in_list_s
find_update (same_key key) ls (key,value)
/// [insert_in_list]: if the key is not in the map, appends a new bindings (functional version)
-val hash_map_insert_in_list_back_lem_append_s
+val hashMap_insert_in_list_back_lem_append_s
(t : Type0) (key : usize) (value : t) (ls : list_t t) :
Lemma
(requires (
slot_t_find_s key ls == None))
(ensures (
- match hash_map_insert_in_list_back t key value ls with
+ match hashMap_insert_in_list_back t key value ls with
| Fail _ -> False
| Return ls' ->
list_t_v ls' == list_t_v ls @ [(key,value)]))
- (decreases (hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashMap_insert_in_list_loop_decreases t key value ls))
#push-options "--fuel 1"
-let rec hash_map_insert_in_list_back_lem_append_s t key value ls =
+let rec hashMap_insert_in_list_back_lem_append_s t key value ls =
begin match ls with
- | ListCons ckey cvalue ls0 ->
+ | List_Cons ckey cvalue ls0 ->
let b = ckey = key in
if b
then ()
else
begin
- hash_map_insert_in_list_back_lem_append_s t key value ls0;
- match hash_map_insert_in_list_back t key value ls0 with
+ hashMap_insert_in_list_back_lem_append_s t key value ls0;
+ match hashMap_insert_in_list_back t key value ls0 with
| Fail _ -> ()
| Return l -> ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
/// [insert_in_list]: if the key is in the map, we update the binding (functional version)
-val hash_map_insert_in_list_back_lem_update_s
+val hashMap_insert_in_list_back_lem_update_s
(t : Type0) (key : usize) (value : t) (ls : list_t t) :
Lemma
(requires (
Some? (find (same_key key) (list_t_v ls))))
(ensures (
- match hash_map_insert_in_list_back t key value ls with
+ match hashMap_insert_in_list_back t key value ls with
| Fail _ -> False
| Return ls' ->
list_t_v ls' == find_update (same_key key) (list_t_v ls) (key,value)))
- (decreases (hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashMap_insert_in_list_loop_decreases t key value ls))
#push-options "--fuel 1"
-let rec hash_map_insert_in_list_back_lem_update_s t key value ls =
+let rec hashMap_insert_in_list_back_lem_update_s t key value ls =
begin match ls with
- | ListCons ckey cvalue ls0 ->
+ | List_Cons ckey cvalue ls0 ->
let b = ckey = key in
if b
then ()
else
begin
- hash_map_insert_in_list_back_lem_update_s t key value ls0;
- match hash_map_insert_in_list_back t key value ls0 with
+ hashMap_insert_in_list_back_lem_update_s t key value ls0;
+ match hashMap_insert_in_list_back t key value ls0 with
| Fail _ -> ()
| Return l -> ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
/// Put everything together
-val hash_map_insert_in_list_back_lem_s
+val hashMap_insert_in_list_back_lem_s
(t : Type0) (key : usize) (value : t) (ls : list_t t) :
Lemma
(ensures (
- match hash_map_insert_in_list_back t key value ls with
+ match hashMap_insert_in_list_back t key value ls with
| Fail _ -> False
| Return ls' ->
- list_t_v ls' == hash_map_insert_in_list_s key value (list_t_v ls)))
+ list_t_v ls' == hashMap_insert_in_list_s key value (list_t_v ls)))
-let hash_map_insert_in_list_back_lem_s t key value ls =
+let hashMap_insert_in_list_back_lem_s t key value ls =
match find (same_key key) (list_t_v ls) with
- | None -> hash_map_insert_in_list_back_lem_append_s t key value ls
- | Some _ -> hash_map_insert_in_list_back_lem_update_s t key value ls
+ | None -> hashMap_insert_in_list_back_lem_append_s t key value ls
+ | Some _ -> hashMap_insert_in_list_back_lem_update_s t key value ls
(**** Invariants of insert_in_list_s *)
/// Auxiliary lemmas
-/// We work on [hash_map_insert_in_list_s], the "high-level" version of [insert_in_list'back].
+/// We work on [hashMap_insert_in_list_s], the "high-level" version of [insert_in_list'back].
///
/// Note that in F* we can't have recursive proofs inside of other proofs, contrary
/// to Coq, which makes it a bit cumbersome to prove auxiliary results like the
@@ -893,14 +893,14 @@ let rec slot_s_inv_not_find_append_end_inv_lem t len key value ls =
#pop-options
/// [insert_in_list]: if the key is not in the map, appends a new bindings
-val hash_map_insert_in_list_s_lem_append
+val hashMap_insert_in_list_s_lem_append
(t : Type0) (len : usize{len > 0}) (key : usize) (value : t) (ls : list (binding t)) :
Lemma
(requires (
slot_s_inv len (hash_mod_key key len) ls /\
slot_s_find key ls == None))
(ensures (
- let ls' = hash_map_insert_in_list_s key value ls in
+ let ls' = hashMap_insert_in_list_s key value ls in
ls' == ls @ [(key,value)] /\
// The invariant is preserved
slot_s_inv len (hash_mod_key key len) ls' /\
@@ -909,20 +909,20 @@ val hash_map_insert_in_list_s_lem_append
// The other bindings are preserved
(forall k'. k' <> key ==> slot_s_find k' ls' == slot_s_find k' ls)))
-let hash_map_insert_in_list_s_lem_append t len key value ls =
+let hashMap_insert_in_list_s_lem_append t len key value ls =
slot_s_inv_not_find_append_end_inv_lem t len key value ls
/// [insert_in_list]: if the key is not in the map, appends a new bindings (quantifiers)
/// Rk.: we don't use this lemma.
/// TODO: remove?
-val hash_map_insert_in_list_back_lem_append
+val hashMap_insert_in_list_back_lem_append
(t : Type0) (len : usize{len > 0}) (key : usize) (value : t) (ls : list_t t) :
Lemma
(requires (
slot_t_inv len (hash_mod_key key len) ls /\
slot_t_find_s key ls == None))
(ensures (
- match hash_map_insert_in_list_back t key value ls with
+ match hashMap_insert_in_list_back t key value ls with
| Fail _ -> False
| Return ls' ->
list_t_v ls' == list_t_v ls @ [(key,value)] /\
@@ -933,9 +933,9 @@ val hash_map_insert_in_list_back_lem_append
// The other bindings are preserved
(forall k'. k' <> key ==> slot_t_find_s k' ls' == slot_t_find_s k' ls)))
-let hash_map_insert_in_list_back_lem_append t len key value ls =
- hash_map_insert_in_list_back_lem_s t key value ls;
- hash_map_insert_in_list_s_lem_append t len key value (list_t_v ls)
+let hashMap_insert_in_list_back_lem_append t len key value ls =
+ hashMap_insert_in_list_back_lem_s t key value ls;
+ hashMap_insert_in_list_s_lem_append t len key value (list_t_v ls)
(** Auxiliary lemmas: update case *)
@@ -1013,14 +1013,14 @@ let rec slot_s_inv_find_append_end_inv_lem t len key value ls =
#pop-options
/// [insert_in_list]: if the key is in the map, update the bindings
-val hash_map_insert_in_list_s_lem_update
+val hashMap_insert_in_list_s_lem_update
(t : Type0) (len : usize{len > 0}) (key : usize) (value : t) (ls : list (binding t)) :
Lemma
(requires (
slot_s_inv len (hash_mod_key key len) ls /\
Some? (slot_s_find key ls)))
(ensures (
- let ls' = hash_map_insert_in_list_s key value ls in
+ let ls' = hashMap_insert_in_list_s key value ls in
ls' == find_update (same_key key) ls (key,value) /\
// The invariant is preserved
slot_s_inv len (hash_mod_key key len) ls' /\
@@ -1029,20 +1029,20 @@ val hash_map_insert_in_list_s_lem_update
// The other bindings are preserved
(forall k'. k' <> key ==> slot_s_find k' ls' == slot_s_find k' ls)))
-let hash_map_insert_in_list_s_lem_update t len key value ls =
+let hashMap_insert_in_list_s_lem_update t len key value ls =
slot_s_inv_find_append_end_inv_lem t len key value ls
/// [insert_in_list]: if the key is in the map, update the bindings
/// TODO: not used: remove?
-val hash_map_insert_in_list_back_lem_update
+val hashMap_insert_in_list_back_lem_update
(t : Type0) (len : usize{len > 0}) (key : usize) (value : t) (ls : list_t t) :
Lemma
(requires (
slot_t_inv len (hash_mod_key key len) ls /\
Some? (slot_t_find_s key ls)))
(ensures (
- match hash_map_insert_in_list_back t key value ls with
+ match hashMap_insert_in_list_back t key value ls with
| Fail _ -> False
| Return ls' ->
let als = list_t_v ls in
@@ -1054,20 +1054,20 @@ val hash_map_insert_in_list_back_lem_update
// The other bindings are preserved
(forall k'. k' <> key ==> slot_t_find_s k' ls' == slot_t_find_s k' ls)))
-let hash_map_insert_in_list_back_lem_update t len key value ls =
- hash_map_insert_in_list_back_lem_s t key value ls;
- hash_map_insert_in_list_s_lem_update t len key value (list_t_v ls)
+let hashMap_insert_in_list_back_lem_update t len key value ls =
+ hashMap_insert_in_list_back_lem_s t key value ls;
+ hashMap_insert_in_list_s_lem_update t len key value (list_t_v ls)
(** Final lemmas about [insert_in_list] *)
/// High-level version
-val hash_map_insert_in_list_s_lem
+val hashMap_insert_in_list_s_lem
(t : Type0) (len : usize{len > 0}) (key : usize) (value : t) (ls : list (binding t)) :
Lemma
(requires (
slot_s_inv len (hash_mod_key key len) ls))
(ensures (
- let ls' = hash_map_insert_in_list_s key value ls in
+ let ls' = hashMap_insert_in_list_s key value ls in
// The invariant is preserved
slot_s_inv len (hash_mod_key key len) ls' /\
// [key] maps to [value]
@@ -1079,22 +1079,22 @@ val hash_map_insert_in_list_s_lem
| None -> length ls' = length ls + 1
| Some _ -> length ls' = length ls)))
-let hash_map_insert_in_list_s_lem t len key value ls =
+let hashMap_insert_in_list_s_lem t len key value ls =
match slot_s_find key ls with
| None ->
assert_norm(length [(key,value)] = 1);
- hash_map_insert_in_list_s_lem_append t len key value ls
+ hashMap_insert_in_list_s_lem_append t len key value ls
| Some _ ->
- hash_map_insert_in_list_s_lem_update t len key value ls
+ hashMap_insert_in_list_s_lem_update t len key value ls
/// [insert_in_list]
/// TODO: not used: remove?
-val hash_map_insert_in_list_back_lem
+val hashMap_insert_in_list_back_lem
(t : Type0) (len : usize{len > 0}) (key : usize) (value : t) (ls : list_t t) :
Lemma
(requires (slot_t_inv len (hash_mod_key key len) ls))
(ensures (
- match hash_map_insert_in_list_back t key value ls with
+ match hashMap_insert_in_list_back t key value ls with
| Fail _ -> False
| Return ls' ->
// The invariant is preserved
@@ -1111,127 +1111,127 @@ val hash_map_insert_in_list_back_lem
| Some _ ->
list_t_v ls' == find_update (same_key key) (list_t_v ls) (key,value) /\
list_t_len ls' = list_t_len ls)))
- (decreases (hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashMap_insert_in_list_loop_decreases t key value ls))
-let hash_map_insert_in_list_back_lem t len key value ls =
- hash_map_insert_in_list_back_lem_s t key value ls;
- hash_map_insert_in_list_s_lem t len key value (list_t_v ls)
+let hashMap_insert_in_list_back_lem t len key value ls =
+ hashMap_insert_in_list_back_lem_s t key value ls;
+ hashMap_insert_in_list_s_lem t len key value (list_t_v ls)
(*** insert_no_resize *)
(**** Refinement proof *)
/// Same strategy as for [insert_in_list]: we introduce a high-level version of
/// the function, and reason about it.
-/// We work on [hash_map_s] (we use a higher-level view of the hash-map, but
+/// We work on [hashMap_s] (we use a higher-level view of the hash-map, but
/// not too high).
/// A high-level version of insert, which doesn't check if the table is saturated
-let hash_map_insert_no_fail_s
- (#t : Type0) (hm : hash_map_s_nes t)
+let hashMap_insert_no_fail_s
+ (#t : Type0) (hm : hashMap_s_nes t)
(key : usize) (value : t) :
- hash_map_s t =
+ hashMap_s t =
let len = length hm in
let i = hash_mod_key key len in
let slot = index hm i in
- let slot' = hash_map_insert_in_list_s key value slot in
+ let slot' = hashMap_insert_in_list_s key value slot in
let hm' = list_update hm i slot' in
hm'
-// TODO: at some point I used hash_map_s_nes and it broke proofs...x
-let hash_map_insert_no_resize_s
- (#t : Type0) (hm : hash_map_s_nes t)
+// TODO: at some point I used hashMap_s_nes and it broke proofs...x
+let hashMap_insert_no_resize_s
+ (#t : Type0) (hm : hashMap_s_nes t)
(key : usize) (value : t) :
- result (hash_map_s t) =
+ result (hashMap_s t) =
// Check if the table is saturated (too many entries, and we need to insert one)
let num_entries = length (flatten hm) in
- if None? (hash_map_s_find hm key) && num_entries = usize_max then Fail Failure
- else Return (hash_map_insert_no_fail_s hm key value)
+ if None? (hashMap_s_find hm key) && num_entries = usize_max then Fail Failure
+ else Return (hashMap_insert_no_fail_s hm key value)
-/// Prove that [hash_map_insert_no_resize_s] is refined by
-/// [hash_map_insert_no_resize'fwd_back]
-val hash_map_insert_no_resize_fwd_back_lem_s
- (t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
+/// Prove that [hashMap_insert_no_resize_s] is refined by
+/// [hashMap_insert_no_resize'fwd_back]
+val hashMap_insert_no_resize_lem_s
+ (t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
Lemma
(requires (
- hash_map_t_base_inv self /\
- hash_map_s_len (hash_map_t_v self) = hash_map_t_len_s self))
+ hashMap_t_base_inv self /\
+ hashMap_s_len (hashMap_t_v self) = hashMap_t_len_s self))
(ensures (
begin
- match hash_map_insert_no_resize_fwd_back t self key value,
- hash_map_insert_no_resize_s (hash_map_t_v self) key value
+ match hashMap_insert_no_resize t self key value,
+ hashMap_insert_no_resize_s (hashMap_t_v self) key value
with
| Fail _, Fail _ -> True
| Return hm, Return hm_v ->
- hash_map_t_base_inv hm /\
- hash_map_t_same_params hm self /\
- hash_map_t_v hm == hm_v /\
- hash_map_s_len hm_v == hash_map_t_len_s hm
+ hashMap_t_base_inv hm /\
+ hashMap_t_same_params hm self /\
+ hashMap_t_v hm == hm_v /\
+ hashMap_s_len hm_v == hashMap_t_len_s hm
| _ -> False
end))
-let hash_map_insert_no_resize_fwd_back_lem_s t self key value =
- begin match hash_key_fwd key with
+let hashMap_insert_no_resize_lem_s t self key value =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let i0 = self.hash_map_num_entries in
- let p = self.hash_map_max_load_factor in
- let i1 = self.hash_map_max_load in
- let v = self.hash_map_slots in
- let i2 = vec_len (list_t t) v in
+ let i0 = self.num_entries in
+ let p = self.max_load_factor in
+ let i1 = self.max_load in
+ let v = self.slots in
+ let i2 = alloc_vec_Vec_len (list_t t) v in
let len = length v in
begin match usize_rem i i2 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_mut_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
begin
- // Checking that: list_t_v (index ...) == index (hash_map_t_v ...) ...
- assert(list_t_v l == index (hash_map_t_v self) hash_mod);
- hash_map_insert_in_list_fwd_lem t key value l;
- match hash_map_insert_in_list_fwd t key value l with
+ // Checking that: list_t_v (index ...) == index (hashMap_t_v ...) ...
+ assert(list_t_v l == index (hashMap_t_v self) hash_mod);
+ hashMap_insert_in_list_lem t key value l;
+ match hashMap_insert_in_list t key value l with
| Fail _ -> ()
| Return b ->
assert(b = None? (slot_s_find key (list_t_v l)));
- hash_map_insert_in_list_back_lem t len key value l;
+ hashMap_insert_in_list_back_lem t len key value l;
if b
then
begin match usize_add i0 1 with
| Fail _ -> ()
| Return i3 ->
begin
- match hash_map_insert_in_list_back t key value l with
+ match hashMap_insert_in_list_back t key value l with
| Fail _ -> ()
| Return l0 ->
- begin match vec_index_mut_back (list_t t) v hash_mod l0 with
+ begin match alloc_vec_Vec_update_usize v hash_mod l0 with
| Fail _ -> ()
| Return v0 ->
- let self_v = hash_map_t_v self in
- let hm = Mkhash_map_t i3 p i1 v0 in
- let hm_v = hash_map_t_v hm in
+ let self_v = hashMap_t_v self in
+ let hm = MkhashMap_t i3 p i1 v0 in
+ let hm_v = hashMap_t_v hm in
assert(hm_v == list_update self_v hash_mod (list_t_v l0));
assert_norm(length [(key,value)] = 1);
assert(length (list_t_v l0) = length (list_t_v l) + 1);
length_flatten_update self_v hash_mod (list_t_v l0);
- assert(hash_map_s_len hm_v = hash_map_t_len_s hm)
+ assert(hashMap_s_len hm_v = hashMap_t_len_s hm)
end
end
end
else
begin
- match hash_map_insert_in_list_back t key value l with
+ match hashMap_insert_in_list_back t key value l with
| Fail _ -> ()
| Return l0 ->
- begin match vec_index_mut_back (list_t t) v hash_mod l0 with
+ begin match alloc_vec_Vec_update_usize v hash_mod l0 with
| Fail _ -> ()
| Return v0 ->
- let self_v = hash_map_t_v self in
- let hm = Mkhash_map_t i0 p i1 v0 in
- let hm_v = hash_map_t_v hm in
+ let self_v = hashMap_t_v self in
+ let hm = MkhashMap_t i0 p i1 v0 in
+ let hm_v = hashMap_t_v hm in
assert(hm_v == list_update self_v hash_mod (list_t_v l0));
assert(length (list_t_v l0) = length (list_t_v l));
length_flatten_update self_v hash_mod (list_t_v l0);
- assert(hash_map_s_len hm_v = hash_map_t_len_s hm)
+ assert(hashMap_s_len hm_v = hashMap_t_len_s hm)
end
end
end
@@ -1241,108 +1241,108 @@ let hash_map_insert_no_resize_fwd_back_lem_s t self key value =
(**** insert_{no_fail,no_resize}: invariants *)
-let hash_map_s_updated_binding
- (#t : Type0) (hm : hash_map_s_nes t)
- (key : usize) (opt_value : option t) (hm' : hash_map_s_nes t) : Type0 =
+let hashMap_s_updated_binding
+ (#t : Type0) (hm : hashMap_s_nes t)
+ (key : usize) (opt_value : option t) (hm' : hashMap_s_nes t) : Type0 =
// [key] maps to [value]
- hash_map_s_find hm' key == opt_value /\
+ hashMap_s_find hm' key == opt_value /\
// The other bindings are preserved
- (forall k'. k' <> key ==> hash_map_s_find hm' k' == hash_map_s_find hm k')
+ (forall k'. k' <> key ==> hashMap_s_find hm' k' == hashMap_s_find hm k')
-let insert_post (#t : Type0) (hm : hash_map_s_nes t)
- (key : usize) (value : t) (hm' : hash_map_s_nes t) : Type0 =
+let insert_post (#t : Type0) (hm : hashMap_s_nes t)
+ (key : usize) (value : t) (hm' : hashMap_s_nes t) : Type0 =
// The invariant is preserved
- hash_map_s_inv hm' /\
+ hashMap_s_inv hm' /\
// [key] maps to [value] and the other bindings are preserved
- hash_map_s_updated_binding hm key (Some value) hm' /\
+ hashMap_s_updated_binding hm key (Some value) hm' /\
// The length is incremented, iff we inserted a new key
- (match hash_map_s_find hm key with
- | None -> hash_map_s_len hm' = hash_map_s_len hm + 1
- | Some _ -> hash_map_s_len hm' = hash_map_s_len hm)
+ (match hashMap_s_find hm key with
+ | None -> hashMap_s_len hm' = hashMap_s_len hm + 1
+ | Some _ -> hashMap_s_len hm' = hashMap_s_len hm)
-val hash_map_insert_no_fail_s_lem
- (#t : Type0) (hm : hash_map_s_nes t)
+val hashMap_insert_no_fail_s_lem
+ (#t : Type0) (hm : hashMap_s_nes t)
(key : usize) (value : t) :
Lemma
- (requires (hash_map_s_inv hm))
+ (requires (hashMap_s_inv hm))
(ensures (
- let hm' = hash_map_insert_no_fail_s hm key value in
+ let hm' = hashMap_insert_no_fail_s hm key value in
insert_post hm key value hm'))
-let hash_map_insert_no_fail_s_lem #t hm key value =
+let hashMap_insert_no_fail_s_lem #t hm key value =
let len = length hm in
let i = hash_mod_key key len in
let slot = index hm i in
- hash_map_insert_in_list_s_lem t len key value slot;
- let slot' = hash_map_insert_in_list_s key value slot in
+ hashMap_insert_in_list_s_lem t len key value slot;
+ let slot' = hashMap_insert_in_list_s key value slot in
length_flatten_update hm i slot'
-val hash_map_insert_no_resize_s_lem
- (#t : Type0) (hm : hash_map_s_nes t)
+val hashMap_insert_no_resize_s_lem
+ (#t : Type0) (hm : hashMap_s_nes t)
(key : usize) (value : t) :
Lemma
- (requires (hash_map_s_inv hm))
+ (requires (hashMap_s_inv hm))
(ensures (
- match hash_map_insert_no_resize_s hm key value with
+ match hashMap_insert_no_resize_s hm key value with
| Fail _ ->
// Can fail only if we need to create a new binding in
// an already saturated map
- hash_map_s_len hm = usize_max /\
- None? (hash_map_s_find hm key)
+ hashMap_s_len hm = usize_max /\
+ None? (hashMap_s_find hm key)
| Return hm' ->
insert_post hm key value hm'))
-let hash_map_insert_no_resize_s_lem #t hm key value =
+let hashMap_insert_no_resize_s_lem #t hm key value =
let num_entries = length (flatten hm) in
- if None? (hash_map_s_find hm key) && num_entries = usize_max then ()
- else hash_map_insert_no_fail_s_lem hm key value
+ if None? (hashMap_s_find hm key) && num_entries = usize_max then ()
+ else hashMap_insert_no_fail_s_lem hm key value
(**** find after insert *)
/// Lemmas about what happens if we call [find] after an insertion
-val hash_map_insert_no_resize_s_get_same_lem
- (#t : Type0) (hm : hash_map_s t)
+val hashMap_insert_no_resize_s_get_same_lem
+ (#t : Type0) (hm : hashMap_s t)
(key : usize) (value : t) :
- Lemma (requires (hash_map_s_inv hm))
+ Lemma (requires (hashMap_s_inv hm))
(ensures (
- match hash_map_insert_no_resize_s hm key value with
+ match hashMap_insert_no_resize_s hm key value with
| Fail _ -> True
| Return hm' ->
- hash_map_s_find hm' key == Some value))
+ hashMap_s_find hm' key == Some value))
-let hash_map_insert_no_resize_s_get_same_lem #t hm key value =
+let hashMap_insert_no_resize_s_get_same_lem #t hm key value =
let num_entries = length (flatten hm) in
- if None? (hash_map_s_find hm key) && num_entries = usize_max then ()
+ if None? (hashMap_s_find hm key) && num_entries = usize_max then ()
else
begin
- let hm' = Return?.v (hash_map_insert_no_resize_s hm key value) in
+ let hm' = Return?.v (hashMap_insert_no_resize_s hm key value) in
let len = length hm in
let i = hash_mod_key key len in
let slot = index hm i in
- hash_map_insert_in_list_s_lem t len key value slot
+ hashMap_insert_in_list_s_lem t len key value slot
end
-val hash_map_insert_no_resize_s_get_diff_lem
- (#t : Type0) (hm : hash_map_s t)
+val hashMap_insert_no_resize_s_get_diff_lem
+ (#t : Type0) (hm : hashMap_s t)
(key : usize) (value : t) (key' : usize{key' <> key}) :
- Lemma (requires (hash_map_s_inv hm))
+ Lemma (requires (hashMap_s_inv hm))
(ensures (
- match hash_map_insert_no_resize_s hm key value with
+ match hashMap_insert_no_resize_s hm key value with
| Fail _ -> True
| Return hm' ->
- hash_map_s_find hm' key' == hash_map_s_find hm key'))
+ hashMap_s_find hm' key' == hashMap_s_find hm key'))
-let hash_map_insert_no_resize_s_get_diff_lem #t hm key value key' =
+let hashMap_insert_no_resize_s_get_diff_lem #t hm key value key' =
let num_entries = length (flatten hm) in
- if None? (hash_map_s_find hm key) && num_entries = usize_max then ()
+ if None? (hashMap_s_find hm key) && num_entries = usize_max then ()
else
begin
- let hm' = Return?.v (hash_map_insert_no_resize_s hm key value) in
+ let hm' = Return?.v (hashMap_insert_no_resize_s hm key value) in
let len = length hm in
let i = hash_mod_key key len in
let slot = index hm i in
- hash_map_insert_in_list_s_lem t len key value slot;
+ hashMap_insert_in_list_s_lem t len key value slot;
let i' = hash_mod_key key' len in
if i <> i' then ()
else
@@ -1354,116 +1354,116 @@ let hash_map_insert_no_resize_s_get_diff_lem #t hm key value key' =
(*** move_elements_from_list *)
-/// Having a great time here: if we use `result (hash_map_s_res t)` as the
-/// return type for [hash_map_move_elements_from_list_s] instead of having this
-/// awkward match, the proof of [hash_map_move_elements_fwd_back_lem_refin] fails.
+/// Having a great time here: if we use `result (hashMap_s_res t)` as the
+/// return type for [hashMap_move_elements_from_list_s] instead of having this
+/// awkward match, the proof of [hashMap_move_elements_lem_refin] fails.
/// I guess it comes from F*'s poor subtyping.
-/// Followingly, I'm not taking any chance and using [result_hash_map_s]
+/// Followingly, I'm not taking any chance and using [result_hashMap_s]
/// everywhere.
-type result_hash_map_s_nes (t : Type0) : Type0 =
- res:result (hash_map_s t) {
+type result_hashMap_s_nes (t : Type0) : Type0 =
+ res:result (hashMap_s t) {
match res with
| Fail _ -> True
| Return hm -> is_pos_usize (length hm)
}
-let rec hash_map_move_elements_from_list_s
- (#t : Type0) (hm : hash_map_s_nes t)
+let rec hashMap_move_elements_from_list_s
+ (#t : Type0) (hm : hashMap_s_nes t)
(ls : slot_s t) :
- // Do *NOT* use `result (hash_map_s t)`
- Tot (result_hash_map_s_nes t)
+ // Do *NOT* use `result (hashMap_s t)`
+ Tot (result_hashMap_s_nes t)
(decreases ls) =
match ls with
| [] -> Return hm
| (key, value) :: ls' ->
- match hash_map_insert_no_resize_s hm key value with
+ match hashMap_insert_no_resize_s hm key value with
| Fail e -> Fail e
| Return hm' ->
- hash_map_move_elements_from_list_s hm' ls'
+ hashMap_move_elements_from_list_s hm' ls'
/// Refinement lemma
-val hash_map_move_elements_from_list_fwd_back_lem
- (t : Type0) (ntable : hash_map_t_nes t) (ls : list_t t) :
- Lemma (requires (hash_map_t_base_inv ntable))
+val hashMap_move_elements_from_list_lem
+ (t : Type0) (ntable : hashMap_t_nes t) (ls : list_t t) :
+ Lemma (requires (hashMap_t_base_inv ntable))
(ensures (
- match hash_map_move_elements_from_list_fwd_back t ntable ls,
- hash_map_move_elements_from_list_s (hash_map_t_v ntable) (slot_t_v ls)
+ match hashMap_move_elements_from_list t ntable ls,
+ hashMap_move_elements_from_list_s (hashMap_t_v ntable) (slot_t_v ls)
with
| Fail _, Fail _ -> True
| Return hm', Return hm_v ->
- hash_map_t_base_inv hm' /\
- hash_map_t_v hm' == hm_v /\
- hash_map_t_same_params hm' ntable
+ hashMap_t_base_inv hm' /\
+ hashMap_t_v hm' == hm_v /\
+ hashMap_t_same_params hm' ntable
| _ -> False))
- (decreases (hash_map_move_elements_from_list_loop_decreases t ntable ls))
+ (decreases (hashMap_move_elements_from_list_loop_decreases t ntable ls))
#push-options "--fuel 1"
-let rec hash_map_move_elements_from_list_fwd_back_lem t ntable ls =
+let rec hashMap_move_elements_from_list_lem t ntable ls =
begin match ls with
- | ListCons k v tl ->
+ | List_Cons k v tl ->
assert(list_t_v ls == (k, v) :: list_t_v tl);
let ls_v = list_t_v ls in
let (_,_) :: tl_v = ls_v in
- hash_map_insert_no_resize_fwd_back_lem_s t ntable k v;
- begin match hash_map_insert_no_resize_fwd_back t ntable k v with
+ hashMap_insert_no_resize_lem_s t ntable k v;
+ begin match hashMap_insert_no_resize t ntable k v with
| Fail _ -> ()
| Return h ->
- let h_v = Return?.v (hash_map_insert_no_resize_s (hash_map_t_v ntable) k v) in
- assert(hash_map_t_v h == h_v);
- hash_map_move_elements_from_list_fwd_back_lem t h tl;
- begin match hash_map_move_elements_from_list_fwd_back t h tl with
+ let h_v = Return?.v (hashMap_insert_no_resize_s (hashMap_t_v ntable) k v) in
+ assert(hashMap_t_v h == h_v);
+ hashMap_move_elements_from_list_lem t h tl;
+ begin match hashMap_move_elements_from_list t h tl with
| Fail _ -> ()
| Return h0 -> ()
end
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
(*** move_elements *)
(**** move_elements: refinement 0 *)
-/// The proof for [hash_map_move_elements_fwd_back_lem_refin] broke so many times
+/// The proof for [hashMap_move_elements_lem_refin] broke so many times
/// (while it is supposed to be super simple!) that we decided to add one refinement
/// level, to really do things step by step...
/// Doing this refinement layer made me notice that maybe the problem came from
-/// the fact that at some point we have to prove `list_t_v ListNil == []`: I
+/// the fact that at some point we have to prove `list_t_v List_Nil == []`: I
/// added the corresponding assert to help Z3 and everything became stable.
/// I finally didn't use this "simple" refinement lemma, but I still keep it here
-/// because it allows for easy comparisons with [hash_map_move_elements_s].
+/// because it allows for easy comparisons with [hashMap_move_elements_s].
-/// [hash_map_move_elements_fwd] refines this function, which is actually almost
+/// [hashMap_move_elements] refines this function, which is actually almost
/// the same (just a little bit shorter and cleaner, and has a pre).
///
/// The way I wrote the high-level model is the following:
-/// - I copy-pasted the definition of [hash_map_move_elements_fwd], wrote the
-/// signature which links this new definition to [hash_map_move_elements_fwd] and
+/// - I copy-pasted the definition of [hashMap_move_elements], wrote the
+/// signature which links this new definition to [hashMap_move_elements] and
/// checked that the proof passed
/// - I gradually simplified it, while making sure the proof still passes
#push-options "--fuel 1"
-let rec hash_map_move_elements_s_simpl
- (t : Type0) (ntable : hash_map_t t)
- (slots : vec (list_t t))
+let rec hashMap_move_elements_s_simpl
+ (t : Type0) (ntable : hashMap_t t)
+ (slots : alloc_vec_Vec (list_t t))
(i : usize{i <= length slots /\ length slots <= usize_max}) :
- Pure (result ((hash_map_t t) & (vec (list_t t))))
+ Pure (result ((hashMap_t t) & (alloc_vec_Vec (list_t t))))
(requires (True))
(ensures (fun res ->
- match res, hash_map_move_elements_fwd_back t ntable slots i with
+ match res, hashMap_move_elements t ntable slots i with
| Fail _, Fail _ -> True
| Return (ntable1, slots1), Return (ntable2, slots2) ->
ntable1 == ntable2 /\
slots1 == slots2
| _ -> False))
- (decreases (hash_map_move_elements_loop_decreases t ntable slots i))
+ (decreases (hashMap_move_elements_loop_decreases t ntable slots i))
=
if i < length slots
then
let slot = index slots i in
- begin match hash_map_move_elements_from_list_fwd_back t ntable slot with
+ begin match hashMap_move_elements_from_list t ntable slot with
| Fail e -> Fail e
| Return hm' ->
- let slots' = list_update slots i ListNil in
- hash_map_move_elements_s_simpl t hm' slots' (i+1)
+ let slots' = list_update slots i List_Nil in
+ hashMap_move_elements_s_simpl t hm' slots' (i+1)
end
else Return (ntable, slots)
#pop-options
@@ -1476,71 +1476,71 @@ let rec hash_map_move_elements_s_simpl
// Note that we ignore the returned slots (we thus don't return a pair:
// only the new hash map in which we moved the elements from the slots):
// this returned value is not used.
-let rec hash_map_move_elements_s
- (#t : Type0) (hm : hash_map_s_nes t)
+let rec hashMap_move_elements_s
+ (#t : Type0) (hm : hashMap_s_nes t)
(slots : slots_s t) (i : usize{i <= length slots /\ length slots <= usize_max}) :
- Tot (result_hash_map_s_nes t)
+ Tot (result_hashMap_s_nes t)
(decreases (length slots - i)) =
let len = length slots in
if i < len then
begin
let slot = index slots i in
- match hash_map_move_elements_from_list_s hm slot with
+ match hashMap_move_elements_from_list_s hm slot with
| Fail e -> Fail e
| Return hm' ->
let slots' = list_update slots i [] in
- hash_map_move_elements_s hm' slots' (i+1)
+ hashMap_move_elements_s hm' slots' (i+1)
end
else Return hm
-val hash_map_move_elements_fwd_back_lem_refin
- (t : Type0) (ntable : hash_map_t t)
- (slots : vec (list_t t)) (i : usize{i <= length slots}) :
+val hashMap_move_elements_lem_refin
+ (t : Type0) (ntable : hashMap_t t)
+ (slots : alloc_vec_Vec (list_t t)) (i : usize{i <= length slots}) :
Lemma
(requires (
- hash_map_t_base_inv ntable))
+ hashMap_t_base_inv ntable))
(ensures (
- match hash_map_move_elements_fwd_back t ntable slots i,
- hash_map_move_elements_s (hash_map_t_v ntable) (slots_t_v slots) i
+ match hashMap_move_elements t ntable slots i,
+ hashMap_move_elements_s (hashMap_t_v ntable) (slots_t_v slots) i
with
| Fail _, Fail _ -> True // We will prove later that this is not possible
| Return (ntable', _), Return ntable'_v ->
- hash_map_t_base_inv ntable' /\
- hash_map_t_v ntable' == ntable'_v /\
- hash_map_t_same_params ntable' ntable
+ hashMap_t_base_inv ntable' /\
+ hashMap_t_v ntable' == ntable'_v /\
+ hashMap_t_same_params ntable' ntable
| _ -> False))
(decreases (length slots - i))
#restart-solver
#push-options "--fuel 1"
-let rec hash_map_move_elements_fwd_back_lem_refin t ntable slots i =
- assert(hash_map_t_base_inv ntable);
- let i0 = vec_len (list_t t) slots in
+let rec hashMap_move_elements_lem_refin t ntable slots i =
+ assert(hashMap_t_base_inv ntable);
+ let i0 = alloc_vec_Vec_len (list_t t) slots in
let b = i < i0 in
if b
then
- begin match vec_index_mut_fwd (list_t t) slots i with
+ begin match alloc_vec_Vec_index_usize slots i with
| Fail _ -> ()
| Return l ->
- let l0 = mem_replace_fwd (list_t t) l ListNil in
+ let l0 = core_mem_replace (list_t t) l List_Nil in
assert(l0 == l);
- hash_map_move_elements_from_list_fwd_back_lem t ntable l0;
- begin match hash_map_move_elements_from_list_fwd_back t ntable l0 with
+ hashMap_move_elements_from_list_lem t ntable l0;
+ begin match hashMap_move_elements_from_list t ntable l0 with
| Fail _ -> ()
| Return h ->
- let l1 = mem_replace_back (list_t t) l ListNil in
- assert(l1 == ListNil);
- assert(slot_t_v #t ListNil == []); // THIS IS IMPORTANT
- begin match vec_index_mut_back (list_t t) slots i l1 with
+ let l1 = core_mem_replace_back (list_t t) l List_Nil in
+ assert(l1 == List_Nil);
+ assert(slot_t_v #t List_Nil == []); // THIS IS IMPORTANT
+ begin match alloc_vec_Vec_update_usize slots i l1 with
| Fail _ -> ()
| Return v ->
begin match usize_add i 1 with
| Fail _ -> ()
| Return i1 ->
- hash_map_move_elements_fwd_back_lem_refin t h v i1;
- begin match hash_map_move_elements_fwd_back t h v i1 with
+ hashMap_move_elements_lem_refin t h v i1;
+ begin match hashMap_move_elements t h v i1 with
| Fail _ ->
- assert(Fail? (hash_map_move_elements_fwd_back t ntable slots i));
+ assert(Fail? (hashMap_move_elements t ntable slots i));
()
| Return (ntable', v0) -> ()
end
@@ -1560,19 +1560,19 @@ let rec hash_map_move_elements_fwd_back_lem_refin t ntable slots i =
/// [ntable] is the hash map to which we move the elements
/// [slots] is the current hash map, from which we remove the elements, and seen
/// as a "flat" associative list (and not a list of lists)
-/// This is actually exactly [hash_map_move_elements_from_list_s]...
-let rec hash_map_move_elements_s_flat
- (#t : Type0) (ntable : hash_map_s_nes t)
+/// This is actually exactly [hashMap_move_elements_from_list_s]...
+let rec hashMap_move_elements_s_flat
+ (#t : Type0) (ntable : hashMap_s_nes t)
(slots : assoc_list t) :
- Tot (result_hash_map_s_nes t)
+ Tot (result_hashMap_s_nes t)
(decreases slots) =
match slots with
| [] -> Return ntable
| (k,v) :: slots' ->
- match hash_map_insert_no_resize_s ntable k v with
+ match hashMap_insert_no_resize_s ntable k v with
| Fail e -> Fail e
| Return ntable' ->
- hash_map_move_elements_s_flat ntable' slots'
+ hashMap_move_elements_s_flat ntable' slots'
/// The refinment lemmas
/// First, auxiliary helpers.
@@ -1656,42 +1656,42 @@ let rec flatten_nil_prefix_as_flatten_i #a l i =
/// The proof is trivial, the functions are the same.
/// Just keeping two definitions to allow changes...
-val hash_map_move_elements_from_list_s_as_flat_lem
- (#t : Type0) (hm : hash_map_s_nes t)
+val hashMap_move_elements_from_list_s_as_flat_lem
+ (#t : Type0) (hm : hashMap_s_nes t)
(ls : slot_s t) :
Lemma
(ensures (
- hash_map_move_elements_from_list_s hm ls ==
- hash_map_move_elements_s_flat hm ls))
+ hashMap_move_elements_from_list_s hm ls ==
+ hashMap_move_elements_s_flat hm ls))
(decreases ls)
#push-options "--fuel 1"
-let rec hash_map_move_elements_from_list_s_as_flat_lem #t hm ls =
+let rec hashMap_move_elements_from_list_s_as_flat_lem #t hm ls =
match ls with
| [] -> ()
| (key, value) :: ls' ->
- match hash_map_insert_no_resize_s hm key value with
+ match hashMap_insert_no_resize_s hm key value with
| Fail _ -> ()
| Return hm' ->
- hash_map_move_elements_from_list_s_as_flat_lem hm' ls'
+ hashMap_move_elements_from_list_s_as_flat_lem hm' ls'
#pop-options
-/// Composition of two calls to [hash_map_move_elements_s_flat]
-let hash_map_move_elements_s_flat_comp
- (#t : Type0) (hm : hash_map_s_nes t) (slot0 slot1 : slot_s t) :
- Tot (result_hash_map_s_nes t) =
- match hash_map_move_elements_s_flat hm slot0 with
+/// Composition of two calls to [hashMap_move_elements_s_flat]
+let hashMap_move_elements_s_flat_comp
+ (#t : Type0) (hm : hashMap_s_nes t) (slot0 slot1 : slot_s t) :
+ Tot (result_hashMap_s_nes t) =
+ match hashMap_move_elements_s_flat hm slot0 with
| Fail e -> Fail e
- | Return hm1 -> hash_map_move_elements_s_flat hm1 slot1
+ | Return hm1 -> hashMap_move_elements_s_flat hm1 slot1
/// High-level desc:
/// move_elements (move_elements hm slot0) slo1 == move_elements hm (slot0 @ slot1)
-val hash_map_move_elements_s_flat_append_lem
- (#t : Type0) (hm : hash_map_s_nes t) (slot0 slot1 : slot_s t) :
+val hashMap_move_elements_s_flat_append_lem
+ (#t : Type0) (hm : hashMap_s_nes t) (slot0 slot1 : slot_s t) :
Lemma
(ensures (
- match hash_map_move_elements_s_flat_comp hm slot0 slot1,
- hash_map_move_elements_s_flat hm (slot0 @ slot1)
+ match hashMap_move_elements_s_flat_comp hm slot0 slot1,
+ hashMap_move_elements_s_flat hm (slot0 @ slot1)
with
| Fail _, Fail _ -> True
| Return hm1, Return hm2 -> hm1 == hm2
@@ -1699,14 +1699,14 @@ val hash_map_move_elements_s_flat_append_lem
(decreases (slot0))
#push-options "--fuel 1"
-let rec hash_map_move_elements_s_flat_append_lem #t hm slot0 slot1 =
+let rec hashMap_move_elements_s_flat_append_lem #t hm slot0 slot1 =
match slot0 with
| [] -> ()
| (k,v) :: slot0' ->
- match hash_map_insert_no_resize_s hm k v with
+ match hashMap_insert_no_resize_s hm k v with
| Fail _ -> ()
| Return hm' ->
- hash_map_move_elements_s_flat_append_lem hm' slot0' slot1
+ hashMap_move_elements_s_flat_append_lem hm' slot0' slot1
#pop-options
val flatten_i_same_suffix (#a : Type) (l0 l1 : list (list a)) (i : nat) :
@@ -1726,16 +1726,16 @@ let rec flatten_i_same_suffix #a l0 l1 i =
#pop-options
/// Refinement lemma:
-/// [hash_map_move_elements_s] refines [hash_map_move_elements_s_flat]
+/// [hashMap_move_elements_s] refines [hashMap_move_elements_s_flat]
/// (actually the functions are equal on all inputs).
-val hash_map_move_elements_s_lem_refin_flat
- (#t : Type0) (hm : hash_map_s_nes t)
+val hashMap_move_elements_s_lem_refin_flat
+ (#t : Type0) (hm : hashMap_s_nes t)
(slots : slots_s t)
(i : nat{i <= length slots /\ length slots <= usize_max}) :
Lemma
(ensures (
- match hash_map_move_elements_s hm slots i,
- hash_map_move_elements_s_flat hm (flatten_i slots i)
+ match hashMap_move_elements_s hm slots i,
+ hashMap_move_elements_s_flat hm (flatten_i slots i)
with
| Fail _, Fail _ -> True
| Return hm, Return hm' -> hm == hm'
@@ -1743,22 +1743,22 @@ val hash_map_move_elements_s_lem_refin_flat
(decreases (length slots - i))
#push-options "--fuel 1"
-let rec hash_map_move_elements_s_lem_refin_flat #t hm slots i =
+let rec hashMap_move_elements_s_lem_refin_flat #t hm slots i =
let len = length slots in
if i < len then
begin
let slot = index slots i in
- hash_map_move_elements_from_list_s_as_flat_lem hm slot;
- match hash_map_move_elements_from_list_s hm slot with
+ hashMap_move_elements_from_list_s_as_flat_lem hm slot;
+ match hashMap_move_elements_from_list_s hm slot with
| Fail _ ->
assert(flatten_i slots i == slot @ flatten_i slots (i+1));
- hash_map_move_elements_s_flat_append_lem hm slot (flatten_i slots (i+1));
- assert(Fail? (hash_map_move_elements_s_flat hm (flatten_i slots i)))
+ hashMap_move_elements_s_flat_append_lem hm slot (flatten_i slots (i+1));
+ assert(Fail? (hashMap_move_elements_s_flat hm (flatten_i slots i)))
| Return hm' ->
let slots' = list_update slots i [] in
flatten_i_same_suffix slots slots' (i+1);
- hash_map_move_elements_s_lem_refin_flat hm' slots' (i+1);
- hash_map_move_elements_s_flat_append_lem hm slot (flatten_i slots' (i+1));
+ hashMap_move_elements_s_lem_refin_flat hm' slots' (i+1);
+ hashMap_move_elements_s_flat_append_lem hm slot (flatten_i slots' (i+1));
()
end
else ()
@@ -1769,21 +1769,21 @@ let assoc_list_inv (#t : Type0) (al : assoc_list t) : Type0 =
pairwise_rel binding_neq al
let disjoint_hm_al_on_key
- (#t : Type0) (hm : hash_map_s_nes t) (al : assoc_list t) (k : key) : Type0 =
- match hash_map_s_find hm k, assoc_list_find k al with
+ (#t : Type0) (hm : hashMap_s_nes t) (al : assoc_list t) (k : key) : Type0 =
+ match hashMap_s_find hm k, assoc_list_find k al with
| Some _, None
| None, Some _
| None, None -> True
| Some _, Some _ -> False
/// Playing a dangerous game here: using forall quantifiers
-let disjoint_hm_al (#t : Type0) (hm : hash_map_s_nes t) (al : assoc_list t) : Type0 =
+let disjoint_hm_al (#t : Type0) (hm : hashMap_s_nes t) (al : assoc_list t) : Type0 =
forall (k:key). disjoint_hm_al_on_key hm al k
let find_in_union_hm_al
- (#t : Type0) (hm : hash_map_s_nes t) (al : assoc_list t) (k : key) :
+ (#t : Type0) (hm : hashMap_s_nes t) (al : assoc_list t) (k : key) :
option t =
- match hash_map_s_find hm k with
+ match hashMap_s_find hm k with
| Some b -> Some b
| None -> assoc_list_find k al
@@ -1799,58 +1799,58 @@ let rec for_all_binding_neq_find_lem #t k v al =
| b :: al' -> for_all_binding_neq_find_lem k v al'
#pop-options
-val hash_map_move_elements_s_flat_lem
- (#t : Type0) (hm : hash_map_s_nes t) (al : assoc_list t) :
+val hashMap_move_elements_s_flat_lem
+ (#t : Type0) (hm : hashMap_s_nes t) (al : assoc_list t) :
Lemma
(requires (
// Invariants
- hash_map_s_inv hm /\
+ hashMap_s_inv hm /\
assoc_list_inv al /\
// The two are disjoint
disjoint_hm_al hm al /\
// We can add all the elements to the hashmap
- hash_map_s_len hm + length al <= usize_max))
+ hashMap_s_len hm + length al <= usize_max))
(ensures (
- match hash_map_move_elements_s_flat hm al with
+ match hashMap_move_elements_s_flat hm al with
| Fail _ -> False // We can't fail
| Return hm' ->
// The invariant is preserved
- hash_map_s_inv hm' /\
+ hashMap_s_inv hm' /\
// The new hash map is the union of the two maps
- (forall (k:key). hash_map_s_find hm' k == find_in_union_hm_al hm al k) /\
- hash_map_s_len hm' = hash_map_s_len hm + length al))
+ (forall (k:key). hashMap_s_find hm' k == find_in_union_hm_al hm al k) /\
+ hashMap_s_len hm' = hashMap_s_len hm + length al))
(decreases al)
#restart-solver
#push-options "--z3rlimit 200 --fuel 1"
-let rec hash_map_move_elements_s_flat_lem #t hm al =
+let rec hashMap_move_elements_s_flat_lem #t hm al =
match al with
| [] -> ()
| (k,v) :: al' ->
- hash_map_insert_no_resize_s_lem hm k v;
- match hash_map_insert_no_resize_s hm k v with
+ hashMap_insert_no_resize_s_lem hm k v;
+ match hashMap_insert_no_resize_s hm k v with
| Fail _ -> ()
| Return hm' ->
- assert(hash_map_s_inv hm');
+ assert(hashMap_s_inv hm');
assert(assoc_list_inv al');
let disjoint_lem (k' : key) :
Lemma (disjoint_hm_al_on_key hm' al' k')
[SMTPat (disjoint_hm_al_on_key hm' al' k')] =
if k' = k then
begin
- assert(hash_map_s_find hm' k' == Some v);
+ assert(hashMap_s_find hm' k' == Some v);
for_all_binding_neq_find_lem k v al';
assert(assoc_list_find k' al' == None)
end
else
begin
- assert(hash_map_s_find hm' k' == hash_map_s_find hm k');
+ assert(hashMap_s_find hm' k' == hashMap_s_find hm k');
assert(assoc_list_find k' al' == assoc_list_find k' al)
end
in
assert(disjoint_hm_al hm' al');
- assert(hash_map_s_len hm' + length al' <= usize_max);
- hash_map_move_elements_s_flat_lem hm' al'
+ assert(hashMap_s_len hm' + length al' <= usize_max);
+ hashMap_move_elements_s_flat_lem hm' al'
#pop-options
/// We need to prove that the invariants on the "low-level" representations of
@@ -1866,18 +1866,18 @@ let slots_t_inv_implies_slots_s_inv #t slots =
// Problem is: I can never really predict for sure with F*...
()
-val hash_map_t_base_inv_implies_hash_map_s_inv
- (#t : Type0) (hm : hash_map_t t) :
- Lemma (requires (hash_map_t_base_inv hm))
- (ensures (hash_map_s_inv (hash_map_t_v hm)))
+val hashMap_t_base_inv_implies_hashMap_s_inv
+ (#t : Type0) (hm : hashMap_t t) :
+ Lemma (requires (hashMap_t_base_inv hm))
+ (ensures (hashMap_s_inv (hashMap_t_v hm)))
-let hash_map_t_base_inv_implies_hash_map_s_inv #t hm = () // same as previous
+let hashMap_t_base_inv_implies_hashMap_s_inv #t hm = () // same as previous
/// Introducing a "partial" version of the hash map invariant, which operates on
/// a suffix of the hash map.
-let partial_hash_map_s_inv
+let partial_hashMap_s_inv
(#t : Type0) (len : usize{len > 0}) (offset : usize)
- (hm : hash_map_s t{offset + length hm <= usize_max}) : Type0 =
+ (hm : hashMap_s t{offset + length hm <= usize_max}) : Type0 =
forall(i:nat{i < length hm}). {:pattern index hm i} slot_s_inv len (offset + i) (index hm i)
/// Auxiliary lemma.
@@ -1887,13 +1887,13 @@ val binding_in_previous_slot_implies_neq
(#t : Type0) (len : usize{len > 0})
(i : usize) (b : binding t)
(offset : usize{i < offset})
- (slots : hash_map_s t{offset + length slots <= usize_max}) :
+ (slots : hashMap_s t{offset + length slots <= usize_max}) :
Lemma
(requires (
// The binding comes from a slot not in [slots]
hash_mod_key (fst b) len = i /\
// The slots are the well-formed suffix of a hash map
- partial_hash_map_s_inv len offset slots))
+ partial_hashMap_s_inv len offset slots))
(ensures (
for_all (binding_neq b) (flatten slots)))
(decreases slots)
@@ -1924,17 +1924,17 @@ let rec binding_in_previous_slot_implies_neq #t len i b offset slots =
for_all_append (binding_neq b) s (flatten slots')
#pop-options
-val partial_hash_map_s_inv_implies_assoc_list_lem
+val partial_hashMap_s_inv_implies_assoc_list_lem
(#t : Type0) (len : usize{len > 0}) (offset : usize)
- (hm : hash_map_s t{offset + length hm <= usize_max}) :
+ (hm : hashMap_s t{offset + length hm <= usize_max}) :
Lemma
(requires (
- partial_hash_map_s_inv len offset hm))
+ partial_hashMap_s_inv len offset hm))
(ensures (assoc_list_inv (flatten hm)))
(decreases (length hm + length (flatten hm)))
#push-options "--fuel 1"
-let rec partial_hash_map_s_inv_implies_assoc_list_lem #t len offset hm =
+let rec partial_hashMap_s_inv_implies_assoc_list_lem #t len offset hm =
match hm with
| [] -> ()
| slot :: hm' ->
@@ -1943,8 +1943,8 @@ let rec partial_hash_map_s_inv_implies_assoc_list_lem #t len offset hm =
match slot with
| [] ->
assert(flatten hm == flatten hm');
- assert(partial_hash_map_s_inv len (offset+1) hm'); // Triggers instantiations
- partial_hash_map_s_inv_implies_assoc_list_lem len (offset+1) hm'
+ assert(partial_hashMap_s_inv len (offset+1) hm'); // Triggers instantiations
+ partial_hashMap_s_inv_implies_assoc_list_lem len (offset+1) hm'
| x :: slot' ->
assert(flatten (slot' :: hm') == slot' @ flatten hm');
let hm'' = slot' :: hm' in
@@ -1953,45 +1953,45 @@ let rec partial_hash_map_s_inv_implies_assoc_list_lem #t len offset hm =
assert(index hm 0 == slot); // Triggers instantiations
assert(slot_s_inv len offset slot);
assert(slot_s_inv len offset slot');
- assert(partial_hash_map_s_inv len offset hm'');
- partial_hash_map_s_inv_implies_assoc_list_lem len offset (slot' :: hm');
+ assert(partial_hashMap_s_inv len offset hm'');
+ partial_hashMap_s_inv_implies_assoc_list_lem len offset (slot' :: hm');
// Proving that the key in `x` is different from all the other keys in
// the flattened map
assert(for_all (binding_neq x) slot');
for_all_append (binding_neq x) slot' (flatten hm');
- assert(partial_hash_map_s_inv len (offset+1) hm');
+ assert(partial_hashMap_s_inv len (offset+1) hm');
binding_in_previous_slot_implies_neq #t len offset x (offset+1) hm';
assert(for_all (binding_neq x) (flatten hm'));
assert(for_all (binding_neq x) (flatten (slot' :: hm')))
#pop-options
-val hash_map_s_inv_implies_assoc_list_lem
- (#t : Type0) (hm : hash_map_s t) :
- Lemma (requires (hash_map_s_inv hm))
+val hashMap_s_inv_implies_assoc_list_lem
+ (#t : Type0) (hm : hashMap_s t) :
+ Lemma (requires (hashMap_s_inv hm))
(ensures (assoc_list_inv (flatten hm)))
-let hash_map_s_inv_implies_assoc_list_lem #t hm =
- partial_hash_map_s_inv_implies_assoc_list_lem (length hm) 0 hm
+let hashMap_s_inv_implies_assoc_list_lem #t hm =
+ partial_hashMap_s_inv_implies_assoc_list_lem (length hm) 0 hm
-val hash_map_t_base_inv_implies_assoc_list_lem
- (#t : Type0) (hm : hash_map_t t):
- Lemma (requires (hash_map_t_base_inv hm))
- (ensures (assoc_list_inv (hash_map_t_al_v hm)))
+val hashMap_t_base_inv_implies_assoc_list_lem
+ (#t : Type0) (hm : hashMap_t t):
+ Lemma (requires (hashMap_t_base_inv hm))
+ (ensures (assoc_list_inv (hashMap_t_al_v hm)))
-let hash_map_t_base_inv_implies_assoc_list_lem #t hm =
- hash_map_s_inv_implies_assoc_list_lem (hash_map_t_v hm)
+let hashMap_t_base_inv_implies_assoc_list_lem #t hm =
+ hashMap_s_inv_implies_assoc_list_lem (hashMap_t_v hm)
/// For some reason, we can't write the below [forall] directly in the [ensures]
/// clause of the next lemma: it makes Z3 fails even with a huge rlimit.
/// I have no idea what's going on.
-let hash_map_is_assoc_list
- (#t : Type0) (ntable : hash_map_t t{length ntable.hash_map_slots > 0})
+let hashMap_is_assoc_list
+ (#t : Type0) (ntable : hashMap_t t{length ntable.slots > 0})
(al : assoc_list t) : Type0 =
- (forall (k:key). hash_map_t_find_s ntable k == assoc_list_find k al)
+ (forall (k:key). hashMap_t_find_s ntable k == assoc_list_find k al)
-let partial_hash_map_s_find
+let partial_hashMap_s_find
(#t : Type0) (len : usize{len > 0}) (offset : usize)
- (hm : hash_map_s_nes t{offset + length hm = len})
+ (hm : hashMap_s_nes t{offset + length hm = len})
(k : key{hash_mod_key k len >= offset}) : option t =
let i = hash_mod_key k len in
let slot = index hm (i - offset) in
@@ -2021,13 +2021,13 @@ val key_in_previous_slot_implies_not_found
(#t : Type0) (len : usize{len > 0})
(k : key)
(offset : usize)
- (slots : hash_map_s t{offset + length slots = len}) :
+ (slots : hashMap_s t{offset + length slots = len}) :
Lemma
(requires (
// The binding comes from a slot not in [slots]
hash_mod_key k len < offset /\
// The slots are the well-formed suffix of a hash map
- partial_hash_map_s_inv len offset slots))
+ partial_hashMap_s_inv len offset slots))
(ensures (
assoc_list_find k (flatten slots) == None))
(decreases slots)
@@ -2045,19 +2045,19 @@ let rec key_in_previous_slot_implies_not_found #t len k offset slots =
key_in_previous_slot_implies_not_found len k (offset+1) slots'
#pop-options
-val partial_hash_map_s_is_assoc_list_lem
+val partial_hashMap_s_is_assoc_list_lem
(#t : Type0) (len : usize{len > 0}) (offset : usize)
- (hm : hash_map_s_nes t{offset + length hm = len})
+ (hm : hashMap_s_nes t{offset + length hm = len})
(k : key{hash_mod_key k len >= offset}) :
Lemma
(requires (
- partial_hash_map_s_inv len offset hm))
+ partial_hashMap_s_inv len offset hm))
(ensures (
- partial_hash_map_s_find len offset hm k == assoc_list_find k (flatten hm)))
+ partial_hashMap_s_find len offset hm k == assoc_list_find k (flatten hm)))
(decreases hm)
#push-options "--fuel 1"
-let rec partial_hash_map_s_is_assoc_list_lem #t len offset hm k =
+let rec partial_hashMap_s_is_assoc_list_lem #t len offset hm k =
match hm with
| [] -> ()
| slot :: hm' ->
@@ -2066,7 +2066,7 @@ let rec partial_hash_map_s_is_assoc_list_lem #t len offset hm k =
if i = 0 then
begin
// We must look in the current slot
- assert(partial_hash_map_s_find len offset hm k == slot_s_find k slot);
+ assert(partial_hashMap_s_find len offset hm k == slot_s_find k slot);
find_append (same_key k) slot (flatten hm');
assert(forall (i:nat{i < length hm'}). index hm' i == index hm (i+1)); // Triggers instantiations
key_in_previous_slot_implies_not_found #t len k (offset+1) hm';
@@ -2085,64 +2085,64 @@ let rec partial_hash_map_s_is_assoc_list_lem #t len offset hm k =
else
begin
// We must ignore the current slot
- assert(partial_hash_map_s_find len offset hm k ==
- partial_hash_map_s_find len (offset+1) hm' k);
+ assert(partial_hashMap_s_find len offset hm k ==
+ partial_hashMap_s_find len (offset+1) hm' k);
find_append (same_key k) slot (flatten hm');
assert(index hm 0 == slot); // Triggers instantiations
not_same_hash_key_not_found_in_slot #t len k offset slot;
assert(forall (i:nat{i < length hm'}). index hm' i == index hm (i+1)); // Triggers instantiations
- partial_hash_map_s_is_assoc_list_lem #t len (offset+1) hm' k
+ partial_hashMap_s_is_assoc_list_lem #t len (offset+1) hm' k
end
#pop-options
-val hash_map_is_assoc_list_lem (#t : Type0) (hm : hash_map_t t) :
- Lemma (requires (hash_map_t_base_inv hm))
- (ensures (hash_map_is_assoc_list hm (hash_map_t_al_v hm)))
+val hashMap_is_assoc_list_lem (#t : Type0) (hm : hashMap_t t) :
+ Lemma (requires (hashMap_t_base_inv hm))
+ (ensures (hashMap_is_assoc_list hm (hashMap_t_al_v hm)))
-let hash_map_is_assoc_list_lem #t hm =
+let hashMap_is_assoc_list_lem #t hm =
let aux (k:key) :
- Lemma (hash_map_t_find_s hm k == assoc_list_find k (hash_map_t_al_v hm))
- [SMTPat (hash_map_t_find_s hm k)] =
- let hm_v = hash_map_t_v hm in
+ Lemma (hashMap_t_find_s hm k == assoc_list_find k (hashMap_t_al_v hm))
+ [SMTPat (hashMap_t_find_s hm k)] =
+ let hm_v = hashMap_t_v hm in
let len = length hm_v in
- partial_hash_map_s_is_assoc_list_lem #t len 0 hm_v k
+ partial_hashMap_s_is_assoc_list_lem #t len 0 hm_v k
in
()
/// The final lemma about [move_elements]: calling it on an empty hash table moves
/// all the elements to this empty table.
-val hash_map_move_elements_fwd_back_lem
- (t : Type0) (ntable : hash_map_t t) (slots : vec (list_t t)) :
+val hashMap_move_elements_lem
+ (t : Type0) (ntable : hashMap_t t) (slots : alloc_vec_Vec (list_t t)) :
Lemma
(requires (
let al = flatten (slots_t_v slots) in
- hash_map_t_base_inv ntable /\
+ hashMap_t_base_inv ntable /\
length al <= usize_max /\
assoc_list_inv al /\
// The table is empty
- hash_map_t_len_s ntable = 0 /\
- (forall (k:key). hash_map_t_find_s ntable k == None)))
+ hashMap_t_len_s ntable = 0 /\
+ (forall (k:key). hashMap_t_find_s ntable k == None)))
(ensures (
let al = flatten (slots_t_v slots) in
- match hash_map_move_elements_fwd_back t ntable slots 0,
- hash_map_move_elements_s_flat (hash_map_t_v ntable) al
+ match hashMap_move_elements t ntable slots 0,
+ hashMap_move_elements_s_flat (hashMap_t_v ntable) al
with
| Return (ntable', _), Return ntable'_v ->
// The invariant is preserved
- hash_map_t_base_inv ntable' /\
+ hashMap_t_base_inv ntable' /\
// We preserved the parameters
- hash_map_t_same_params ntable' ntable /\
+ hashMap_t_same_params ntable' ntable /\
// The table has the same number of slots
- length ntable'.hash_map_slots = length ntable.hash_map_slots /\
+ length ntable'.slots = length ntable.slots /\
// The count is good
- hash_map_t_len_s ntable' = length al /\
+ hashMap_t_len_s ntable' = length al /\
// The table can be linked to its model (we need this only to reveal
// "pretty" functional lemmas to the user in the fsti - so that we
// can write lemmas with SMT patterns - this is very F* specific)
- hash_map_t_v ntable' == ntable'_v /\
+ hashMap_t_v ntable' == ntable'_v /\
// The new table contains exactly all the bindings from the slots
- // Rk.: see the comment for [hash_map_is_assoc_list]
- hash_map_is_assoc_list ntable' al
+ // Rk.: see the comment for [hashMap_is_assoc_list]
+ hashMap_is_assoc_list ntable' al
| _ -> False // We can only succeed
))
@@ -2154,41 +2154,41 @@ val hash_map_move_elements_fwd_back_lem
// lack of ifuel (this kind of proofs is annoying, really).
#restart-solver
#push-options "--z3rlimit 100"
-let hash_map_move_elements_fwd_back_lem t ntable slots =
- let ntable_v = hash_map_t_v ntable in
+let hashMap_move_elements_lem t ntable slots =
+ let ntable_v = hashMap_t_v ntable in
let slots_v = slots_t_v slots in
let al = flatten slots_v in
- hash_map_move_elements_fwd_back_lem_refin t ntable slots 0;
+ hashMap_move_elements_lem_refin t ntable slots 0;
begin
- match hash_map_move_elements_fwd_back t ntable slots 0,
- hash_map_move_elements_s ntable_v slots_v 0
+ match hashMap_move_elements t ntable slots 0,
+ hashMap_move_elements_s ntable_v slots_v 0
with
| Fail _, Fail _ -> ()
| Return (ntable', _), Return ntable'_v ->
- assert(hash_map_t_base_inv ntable');
- assert(hash_map_t_v ntable' == ntable'_v)
+ assert(hashMap_t_base_inv ntable');
+ assert(hashMap_t_v ntable' == ntable'_v)
| _ -> assert(False)
end;
- hash_map_move_elements_s_lem_refin_flat ntable_v slots_v 0;
+ hashMap_move_elements_s_lem_refin_flat ntable_v slots_v 0;
begin
- match hash_map_move_elements_s ntable_v slots_v 0,
- hash_map_move_elements_s_flat ntable_v (flatten_i slots_v 0)
+ match hashMap_move_elements_s ntable_v slots_v 0,
+ hashMap_move_elements_s_flat ntable_v (flatten_i slots_v 0)
with
| Fail _, Fail _ -> ()
| Return hm, Return hm' -> assert(hm == hm')
| _ -> assert(False)
end;
flatten_0_is_flatten slots_v; // flatten_i slots_v 0 == flatten slots_v
- hash_map_move_elements_s_flat_lem ntable_v al;
- match hash_map_move_elements_fwd_back t ntable slots 0,
- hash_map_move_elements_s_flat ntable_v al
+ hashMap_move_elements_s_flat_lem ntable_v al;
+ match hashMap_move_elements t ntable slots 0,
+ hashMap_move_elements_s_flat ntable_v al
with
| Return (ntable', _), Return ntable'_v ->
- assert(hash_map_t_base_inv ntable');
- assert(length ntable'.hash_map_slots = length ntable.hash_map_slots);
- assert(hash_map_t_len_s ntable' = length al);
- assert(hash_map_t_v ntable' == ntable'_v);
- assert(hash_map_is_assoc_list ntable' al)
+ assert(hashMap_t_base_inv ntable');
+ assert(length ntable'.slots = length ntable.slots);
+ assert(hashMap_t_len_s ntable' = length al);
+ assert(hashMap_t_v ntable' == ntable'_v);
+ assert(hashMap_is_assoc_list ntable' al)
| _ -> assert(False)
#pop-options
@@ -2197,47 +2197,47 @@ let hash_map_move_elements_fwd_back_lem t ntable slots =
/// High-level model 1.
/// This is one is slightly "crude": we just simplify a bit the function.
-let hash_map_try_resize_s_simpl
+let hashMap_try_resize_s_simpl
(#t : Type0)
- (hm : hash_map_t t) :
- Pure (result (hash_map_t t))
+ (hm : hashMap_t t) :
+ Pure (result (hashMap_t t))
(requires (
- let (divid, divis) = hm.hash_map_max_load_factor in
+ let (divid, divis) = hm.max_load_factor in
divid > 0 /\ divis > 0))
(ensures (fun _ -> True)) =
- let capacity = length hm.hash_map_slots in
- let (divid, divis) = hm.hash_map_max_load_factor in
+ let capacity = length hm.slots in
+ let (divid, divis) = hm.max_load_factor in
if capacity <= (usize_max / 2) / divid then
let ncapacity : usize = capacity * 2 in
- begin match hash_map_new_with_capacity_fwd t ncapacity divid divis with
+ begin match hashMap_new_with_capacity t ncapacity divid divis with
| Fail e -> Fail e
| Return ntable ->
- match hash_map_move_elements_fwd_back t ntable hm.hash_map_slots 0 with
+ match hashMap_move_elements t ntable hm.slots 0 with
| Fail e -> Fail e
| Return (ntable', _) ->
let hm =
- { hm with hash_map_slots = ntable'.hash_map_slots;
- hash_map_max_load = ntable'.hash_map_max_load }
+ { hm with slots = ntable'.slots;
+ max_load = ntable'.max_load }
in
Return hm
end
else Return hm
-val hash_map_try_resize_fwd_back_lem_refin
- (t : Type0) (self : hash_map_t t) :
+val hashMap_try_resize_lem_refin
+ (t : Type0) (self : hashMap_t t) :
Lemma
(requires (
- let (divid, divis) = self.hash_map_max_load_factor in
+ let (divid, divis) = self.max_load_factor in
divid > 0 /\ divis > 0))
(ensures (
- match hash_map_try_resize_fwd_back t self,
- hash_map_try_resize_s_simpl self
+ match hashMap_try_resize t self,
+ hashMap_try_resize_s_simpl self
with
| Fail _, Fail _ -> True
| Return hm1, Return hm2 -> hm1 == hm2
| _ -> False))
-let hash_map_try_resize_fwd_back_lem_refin t self = ()
+let hashMap_try_resize_lem_refin t self = ()
/// Isolating arithmetic proofs
@@ -2342,78 +2342,78 @@ let new_max_load_lem len capacity divid divis =
assert(nmax_load >= max_load + 1)
#pop-options
-val hash_map_try_resize_s_simpl_lem (#t : Type0) (hm : hash_map_t t) :
+val hashMap_try_resize_s_simpl_lem (#t : Type0) (hm : hashMap_t t) :
Lemma
(requires (
// The base invariant is satisfied
- hash_map_t_base_inv hm /\
+ hashMap_t_base_inv hm /\
// However, the "full" invariant is broken, as we call [try_resize]
// only if the current number of entries is > the max load.
//
// There are two situations:
// - either we just reached the max load
// - or we were already saturated and can't resize
- (let (dividend, divisor) = hm.hash_map_max_load_factor in
- hm.hash_map_num_entries == hm.hash_map_max_load + 1 \/
- length hm.hash_map_slots * 2 * dividend > usize_max)
+ (let (dividend, divisor) = hm.max_load_factor in
+ hm.num_entries == hm.max_load + 1 \/
+ length hm.slots * 2 * dividend > usize_max)
))
(ensures (
- match hash_map_try_resize_s_simpl hm with
+ match hashMap_try_resize_s_simpl hm with
| Fail _ -> False
| Return hm' ->
// The full invariant is now satisfied (the full invariant is "base
// invariant" + the map is not overloaded (or can't be resized because
// already too big)
- hash_map_t_inv hm' /\
+ hashMap_t_inv hm' /\
// It contains the same bindings as the initial map
- (forall (k:key). hash_map_t_find_s hm' k == hash_map_t_find_s hm k)))
+ (forall (k:key). hashMap_t_find_s hm' k == hashMap_t_find_s hm k)))
#restart-solver
#push-options "--z3rlimit 400"
-let hash_map_try_resize_s_simpl_lem #t hm =
- let capacity = length hm.hash_map_slots in
- let (divid, divis) = hm.hash_map_max_load_factor in
+let hashMap_try_resize_s_simpl_lem #t hm =
+ let capacity = length hm.slots in
+ let (divid, divis) = hm.max_load_factor in
if capacity <= (usize_max / 2) / divid then
begin
let ncapacity : usize = capacity * 2 in
assert(ncapacity * divid <= usize_max);
- assert(hash_map_t_len_s hm = hm.hash_map_max_load + 1);
- new_max_load_lem (hash_map_t_len_s hm) capacity divid divis;
- hash_map_new_with_capacity_fwd_lem t ncapacity divid divis;
- match hash_map_new_with_capacity_fwd t ncapacity divid divis with
+ assert(hashMap_t_len_s hm = hm.max_load + 1);
+ new_max_load_lem (hashMap_t_len_s hm) capacity divid divis;
+ hashMap_new_with_capacity_lem t ncapacity divid divis;
+ match hashMap_new_with_capacity t ncapacity divid divis with
| Fail _ -> ()
| Return ntable ->
- let slots = hm.hash_map_slots in
+ let slots = hm.slots in
let al = flatten (slots_t_v slots) in
- // Proving that: length al = hm.hash_map_num_entries
+ // Proving that: length al = hm.num_entries
assert(al == flatten (map slot_t_v slots));
assert(al == flatten (map list_t_v slots));
- assert(hash_map_t_al_v hm == flatten (hash_map_t_v hm));
- assert(hash_map_t_al_v hm == flatten (map list_t_v hm.hash_map_slots));
- assert(al == hash_map_t_al_v hm);
- assert(hash_map_t_base_inv ntable);
- assert(length al = hm.hash_map_num_entries);
+ assert(hashMap_t_al_v hm == flatten (hashMap_t_v hm));
+ assert(hashMap_t_al_v hm == flatten (map list_t_v hm.slots));
+ assert(al == hashMap_t_al_v hm);
+ assert(hashMap_t_base_inv ntable);
+ assert(length al = hm.num_entries);
assert(length al <= usize_max);
- hash_map_t_base_inv_implies_assoc_list_lem hm;
+ hashMap_t_base_inv_implies_assoc_list_lem hm;
assert(assoc_list_inv al);
- assert(hash_map_t_len_s ntable = 0);
- assert(forall (k:key). hash_map_t_find_s ntable k == None);
- hash_map_move_elements_fwd_back_lem t ntable hm.hash_map_slots;
- match hash_map_move_elements_fwd_back t ntable hm.hash_map_slots 0 with
+ assert(hashMap_t_len_s ntable = 0);
+ assert(forall (k:key). hashMap_t_find_s ntable k == None);
+ hashMap_move_elements_lem t ntable hm.slots;
+ match hashMap_move_elements t ntable hm.slots 0 with
| Fail _ -> ()
| Return (ntable', _) ->
- hash_map_is_assoc_list_lem hm;
- assert(hash_map_is_assoc_list hm (hash_map_t_al_v hm));
+ hashMap_is_assoc_list_lem hm;
+ assert(hashMap_is_assoc_list hm (hashMap_t_al_v hm));
let hm' =
- { hm with hash_map_slots = ntable'.hash_map_slots;
- hash_map_max_load = ntable'.hash_map_max_load }
+ { hm with slots = ntable'.slots;
+ max_load = ntable'.max_load }
in
- assert(hash_map_t_base_inv ntable');
- assert(hash_map_t_base_inv hm');
- assert(hash_map_t_len_s hm' = hash_map_t_len_s hm);
- new_max_load_lem (hash_map_t_len_s hm') capacity divid divis;
- assert(hash_map_t_len_s hm' <= hm'.hash_map_max_load); // Requires a lemma
- assert(hash_map_t_inv hm')
+ assert(hashMap_t_base_inv ntable');
+ assert(hashMap_t_base_inv hm');
+ assert(hashMap_t_len_s hm' = hashMap_t_len_s hm);
+ new_max_load_lem (hashMap_t_len_s hm') capacity divid divis;
+ assert(hashMap_t_len_s hm' <= hm'.max_load); // Requires a lemma
+ assert(hashMap_t_inv hm')
end
else
begin
@@ -2422,203 +2422,203 @@ let hash_map_try_resize_s_simpl_lem #t hm =
end
#pop-options
-let hash_map_t_same_bindings (#t : Type0) (hm hm' : hash_map_t_nes t) : Type0 =
- forall (k:key). hash_map_t_find_s hm k == hash_map_t_find_s hm' k
+let hashMap_t_same_bindings (#t : Type0) (hm hm' : hashMap_t_nes t) : Type0 =
+ forall (k:key). hashMap_t_find_s hm k == hashMap_t_find_s hm' k
/// The final lemma about [try_resize]
-val hash_map_try_resize_fwd_back_lem (#t : Type0) (hm : hash_map_t t) :
+val hashMap_try_resize_lem (#t : Type0) (hm : hashMap_t t) :
Lemma
(requires (
- hash_map_t_base_inv hm /\
+ hashMap_t_base_inv hm /\
// However, the "full" invariant is broken, as we call [try_resize]
// only if the current number of entries is > the max load.
//
// There are two situations:
// - either we just reached the max load
// - or we were already saturated and can't resize
- (let (dividend, divisor) = hm.hash_map_max_load_factor in
- hm.hash_map_num_entries == hm.hash_map_max_load + 1 \/
- length hm.hash_map_slots * 2 * dividend > usize_max)))
+ (let (dividend, divisor) = hm.max_load_factor in
+ hm.num_entries == hm.max_load + 1 \/
+ length hm.slots * 2 * dividend > usize_max)))
(ensures (
- match hash_map_try_resize_fwd_back t hm with
+ match hashMap_try_resize t hm with
| Fail _ -> False
| Return hm' ->
// The full invariant is now satisfied (the full invariant is "base
// invariant" + the map is not overloaded (or can't be resized because
// already too big)
- hash_map_t_inv hm' /\
+ hashMap_t_inv hm' /\
// The length is the same
- hash_map_t_len_s hm' = hash_map_t_len_s hm /\
+ hashMap_t_len_s hm' = hashMap_t_len_s hm /\
// It contains the same bindings as the initial map
- hash_map_t_same_bindings hm' hm))
+ hashMap_t_same_bindings hm' hm))
-let hash_map_try_resize_fwd_back_lem #t hm =
- hash_map_try_resize_fwd_back_lem_refin t hm;
- hash_map_try_resize_s_simpl_lem hm
+let hashMap_try_resize_lem #t hm =
+ hashMap_try_resize_lem_refin t hm;
+ hashMap_try_resize_s_simpl_lem hm
(*** insert *)
/// The high-level model (very close to the original function: we don't need something
/// very high level, just to clean it a bit)
-let hash_map_insert_s
- (#t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
- result (hash_map_t t) =
- match hash_map_insert_no_resize_fwd_back t self key value with
+let hashMap_insert_s
+ (#t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
+ result (hashMap_t t) =
+ match hashMap_insert_no_resize t self key value with
| Fail e -> Fail e
| Return hm' ->
- if hash_map_t_len_s hm' > hm'.hash_map_max_load then
- hash_map_try_resize_fwd_back t hm'
+ if hashMap_t_len_s hm' > hm'.max_load then
+ hashMap_try_resize t hm'
else Return hm'
-val hash_map_insert_fwd_back_lem_refin
- (t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
+val hashMap_insert_lem_refin
+ (t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
Lemma (requires True)
(ensures (
- match hash_map_insert_fwd_back t self key value,
- hash_map_insert_s self key value
+ match hashMap_insert t self key value,
+ hashMap_insert_s self key value
with
| Fail _, Fail _ -> True
| Return hm1, Return hm2 -> hm1 == hm2
| _ -> False))
-let hash_map_insert_fwd_back_lem_refin t self key value = ()
+let hashMap_insert_lem_refin t self key value = ()
/// Helper
-let hash_map_insert_fwd_back_bindings_lem
- (t : Type0) (self : hash_map_t_nes t) (key : usize) (value : t)
- (hm' hm'' : hash_map_t_nes t) :
+let hashMap_insert_bindings_lem
+ (t : Type0) (self : hashMap_t_nes t) (key : usize) (value : t)
+ (hm' hm'' : hashMap_t_nes t) :
Lemma
(requires (
- hash_map_s_updated_binding (hash_map_t_v self) key
- (Some value) (hash_map_t_v hm') /\
- hash_map_t_same_bindings hm' hm''))
+ hashMap_s_updated_binding (hashMap_t_v self) key
+ (Some value) (hashMap_t_v hm') /\
+ hashMap_t_same_bindings hm' hm''))
(ensures (
- hash_map_s_updated_binding (hash_map_t_v self) key
- (Some value) (hash_map_t_v hm'')))
+ hashMap_s_updated_binding (hashMap_t_v self) key
+ (Some value) (hashMap_t_v hm'')))
= ()
-val hash_map_insert_fwd_back_lem_aux
- (#t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
- Lemma (requires (hash_map_t_inv self))
+val hashMap_insert_lem_aux
+ (#t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
+ Lemma (requires (hashMap_t_inv self))
(ensures (
- match hash_map_insert_fwd_back t self key value with
+ match hashMap_insert t self key value with
| Fail _ ->
// We can fail only if:
// - the key is not in the map and we need to add it
// - we are already saturated
- hash_map_t_len_s self = usize_max /\
- None? (hash_map_t_find_s self key)
+ hashMap_t_len_s self = usize_max /\
+ None? (hashMap_t_find_s self key)
| Return hm' ->
// The invariant is preserved
- hash_map_t_inv hm' /\
+ hashMap_t_inv hm' /\
// [key] maps to [value] and the other bindings are preserved
- hash_map_s_updated_binding (hash_map_t_v self) key (Some value) (hash_map_t_v hm') /\
+ hashMap_s_updated_binding (hashMap_t_v self) key (Some value) (hashMap_t_v hm') /\
// The length is incremented, iff we inserted a new key
- (match hash_map_t_find_s self key with
- | None -> hash_map_t_len_s hm' = hash_map_t_len_s self + 1
- | Some _ -> hash_map_t_len_s hm' = hash_map_t_len_s self)))
+ (match hashMap_t_find_s self key with
+ | None -> hashMap_t_len_s hm' = hashMap_t_len_s self + 1
+ | Some _ -> hashMap_t_len_s hm' = hashMap_t_len_s self)))
#restart-solver
#push-options "--z3rlimit 200"
-let hash_map_insert_fwd_back_lem_aux #t self key value =
- hash_map_insert_no_resize_fwd_back_lem_s t self key value;
- hash_map_insert_no_resize_s_lem (hash_map_t_v self) key value;
- match hash_map_insert_no_resize_fwd_back t self key value with
+let hashMap_insert_lem_aux #t self key value =
+ hashMap_insert_no_resize_lem_s t self key value;
+ hashMap_insert_no_resize_s_lem (hashMap_t_v self) key value;
+ match hashMap_insert_no_resize t self key value with
| Fail _ -> ()
| Return hm' ->
- // Expanding the post of [hash_map_insert_no_resize_fwd_back_lem_s]
- let self_v = hash_map_t_v self in
- let hm'_v = Return?.v (hash_map_insert_no_resize_s self_v key value) in
- assert(hash_map_t_base_inv hm');
- assert(hash_map_t_same_params hm' self);
- assert(hash_map_t_v hm' == hm'_v);
- assert(hash_map_s_len hm'_v == hash_map_t_len_s hm');
- // Expanding the post of [hash_map_insert_no_resize_s_lem]
+ // Expanding the post of [hashMap_insert_no_resize_lem_s]
+ let self_v = hashMap_t_v self in
+ let hm'_v = Return?.v (hashMap_insert_no_resize_s self_v key value) in
+ assert(hashMap_t_base_inv hm');
+ assert(hashMap_t_same_params hm' self);
+ assert(hashMap_t_v hm' == hm'_v);
+ assert(hashMap_s_len hm'_v == hashMap_t_len_s hm');
+ // Expanding the post of [hashMap_insert_no_resize_s_lem]
assert(insert_post self_v key value hm'_v);
// Expanding [insert_post]
- assert(hash_map_s_inv hm'_v);
+ assert(hashMap_s_inv hm'_v);
assert(
- match hash_map_s_find self_v key with
- | None -> hash_map_s_len hm'_v = hash_map_s_len self_v + 1
- | Some _ -> hash_map_s_len hm'_v = hash_map_s_len self_v);
- if hash_map_t_len_s hm' > hm'.hash_map_max_load then
+ match hashMap_s_find self_v key with
+ | None -> hashMap_s_len hm'_v = hashMap_s_len self_v + 1
+ | Some _ -> hashMap_s_len hm'_v = hashMap_s_len self_v);
+ if hashMap_t_len_s hm' > hm'.max_load then
begin
- hash_map_try_resize_fwd_back_lem hm';
- // Expanding the post of [hash_map_try_resize_fwd_back_lem]
- let hm'' = Return?.v (hash_map_try_resize_fwd_back t hm') in
- assert(hash_map_t_inv hm'');
- let hm''_v = hash_map_t_v hm'' in
- assert(forall k. hash_map_t_find_s hm'' k == hash_map_t_find_s hm' k);
- assert(hash_map_t_len_s hm'' = hash_map_t_len_s hm'); // TODO
+ hashMap_try_resize_lem hm';
+ // Expanding the post of [hashMap_try_resize_lem]
+ let hm'' = Return?.v (hashMap_try_resize t hm') in
+ assert(hashMap_t_inv hm'');
+ let hm''_v = hashMap_t_v hm'' in
+ assert(forall k. hashMap_t_find_s hm'' k == hashMap_t_find_s hm' k);
+ assert(hashMap_t_len_s hm'' = hashMap_t_len_s hm'); // TODO
// Proving the post
- assert(hash_map_t_inv hm'');
- hash_map_insert_fwd_back_bindings_lem t self key value hm' hm'';
+ assert(hashMap_t_inv hm'');
+ hashMap_insert_bindings_lem t self key value hm' hm'';
assert(
- match hash_map_t_find_s self key with
- | None -> hash_map_t_len_s hm'' = hash_map_t_len_s self + 1
- | Some _ -> hash_map_t_len_s hm'' = hash_map_t_len_s self)
+ match hashMap_t_find_s self key with
+ | None -> hashMap_t_len_s hm'' = hashMap_t_len_s self + 1
+ | Some _ -> hashMap_t_len_s hm'' = hashMap_t_len_s self)
end
else ()
#pop-options
-let hash_map_insert_fwd_back_lem #t self key value =
- hash_map_insert_fwd_back_lem_aux #t self key value
+let hashMap_insert_lem #t self key value =
+ hashMap_insert_lem_aux #t self key value
(*** contains_key *)
(**** contains_key_in_list *)
-val hash_map_contains_key_in_list_fwd_lem
+val hashMap_contains_key_in_list_lem
(#t : Type0) (key : usize) (ls : list_t t) :
Lemma
(ensures (
- match hash_map_contains_key_in_list_fwd t key ls with
+ match hashMap_contains_key_in_list t key ls with
| Fail _ -> False
| Return b ->
b = Some? (slot_t_find_s key ls)))
#push-options "--fuel 1"
-let rec hash_map_contains_key_in_list_fwd_lem #t key ls =
+let rec hashMap_contains_key_in_list_lem #t key ls =
match ls with
- | ListCons ckey x ls0 ->
+ | List_Cons ckey x ls0 ->
let b = ckey = key in
if b
then ()
else
begin
- hash_map_contains_key_in_list_fwd_lem key ls0;
- match hash_map_contains_key_in_list_fwd t key ls0 with
+ hashMap_contains_key_in_list_lem key ls0;
+ match hashMap_contains_key_in_list t key ls0 with
| Fail _ -> ()
| Return b0 -> ()
end
- | ListNil -> ()
+ | List_Nil -> ()
#pop-options
(**** contains_key *)
-val hash_map_contains_key_fwd_lem_aux
- (#t : Type0) (self : hash_map_t_nes t) (key : usize) :
+val hashMap_contains_key_lem_aux
+ (#t : Type0) (self : hashMap_t_nes t) (key : usize) :
Lemma
(ensures (
- match hash_map_contains_key_fwd t self key with
+ match hashMap_contains_key t self key with
| Fail _ -> False
- | Return b -> b = Some? (hash_map_t_find_s self key)))
+ | Return b -> b = Some? (hashMap_t_find_s self key)))
-let hash_map_contains_key_fwd_lem_aux #t self key =
- begin match hash_key_fwd key with
+let hashMap_contains_key_lem_aux #t self key =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let v = self.hash_map_slots in
- let i0 = vec_len (list_t t) v in
+ let v = self.slots in
+ let i0 = alloc_vec_Vec_len (list_t t) v in
begin match usize_rem i i0 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
- hash_map_contains_key_in_list_fwd_lem key l;
- begin match hash_map_contains_key_in_list_fwd t key l with
+ hashMap_contains_key_in_list_lem key l;
+ begin match hashMap_contains_key_in_list t key l with
| Fail _ -> ()
| Return b -> ()
end
@@ -2627,66 +2627,66 @@ let hash_map_contains_key_fwd_lem_aux #t self key =
end
/// The lemma in the .fsti
-let hash_map_contains_key_fwd_lem #t self key =
- hash_map_contains_key_fwd_lem_aux #t self key
+let hashMap_contains_key_lem #t self key =
+ hashMap_contains_key_lem_aux #t self key
(*** get *)
(**** get_in_list *)
-val hash_map_get_in_list_fwd_lem
+val hashMap_get_in_list_lem
(#t : Type0) (key : usize) (ls : list_t t) :
Lemma
(ensures (
- match hash_map_get_in_list_fwd t key ls, slot_t_find_s key ls with
+ match hashMap_get_in_list t key ls, slot_t_find_s key ls with
| Fail _, None -> True
| Return x, Some x' -> x == x'
| _ -> False))
#push-options "--fuel 1"
-let rec hash_map_get_in_list_fwd_lem #t key ls =
+let rec hashMap_get_in_list_lem #t key ls =
begin match ls with
- | ListCons ckey cvalue ls0 ->
+ | List_Cons ckey cvalue ls0 ->
let b = ckey = key in
if b
then ()
else
begin
- hash_map_get_in_list_fwd_lem key ls0;
- match hash_map_get_in_list_fwd t key ls0 with
+ hashMap_get_in_list_lem key ls0;
+ match hashMap_get_in_list t key ls0 with
| Fail _ -> ()
| Return x -> ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
(**** get *)
-val hash_map_get_fwd_lem_aux
- (#t : Type0) (self : hash_map_t_nes t) (key : usize) :
+val hashMap_get_lem_aux
+ (#t : Type0) (self : hashMap_t_nes t) (key : usize) :
Lemma
(ensures (
- match hash_map_get_fwd t self key, hash_map_t_find_s self key with
+ match hashMap_get t self key, hashMap_t_find_s self key with
| Fail _, None -> True
| Return x, Some x' -> x == x'
| _ -> False))
-let hash_map_get_fwd_lem_aux #t self key =
- begin match hash_key_fwd key with
+let hashMap_get_lem_aux #t self key =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let v = self.hash_map_slots in
- let i0 = vec_len (list_t t) v in
+ let v = self.slots in
+ let i0 = alloc_vec_Vec_len (list_t t) v in
begin match usize_rem i i0 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
begin
- hash_map_get_in_list_fwd_lem key l;
- match hash_map_get_in_list_fwd t key l with
+ hashMap_get_in_list_lem key l;
+ match hashMap_get_in_list t key l with
| Fail _ -> ()
| Return x -> ()
end
@@ -2695,66 +2695,66 @@ let hash_map_get_fwd_lem_aux #t self key =
end
/// .fsti
-let hash_map_get_fwd_lem #t self key = hash_map_get_fwd_lem_aux #t self key
+let hashMap_get_lem #t self key = hashMap_get_lem_aux #t self key
(*** get_mut'fwd *)
(**** get_mut_in_list'fwd *)
-val hash_map_get_mut_in_list_loop_fwd_lem
+val hashMap_get_mut_in_list_loop_lem
(#t : Type0) (ls : list_t t) (key : usize) :
Lemma
(ensures (
- match hash_map_get_mut_in_list_loop_fwd t ls key, slot_t_find_s key ls with
+ match hashMap_get_mut_in_list_loop t ls key, slot_t_find_s key ls with
| Fail _, None -> True
| Return x, Some x' -> x == x'
| _ -> False))
#push-options "--fuel 1"
-let rec hash_map_get_mut_in_list_loop_fwd_lem #t ls key =
+let rec hashMap_get_mut_in_list_loop_lem #t ls key =
begin match ls with
- | ListCons ckey cvalue ls0 ->
+ | List_Cons ckey cvalue ls0 ->
let b = ckey = key in
if b
then ()
else
begin
- hash_map_get_mut_in_list_loop_fwd_lem ls0 key;
- match hash_map_get_mut_in_list_loop_fwd t ls0 key with
+ hashMap_get_mut_in_list_loop_lem ls0 key;
+ match hashMap_get_mut_in_list_loop t ls0 key with
| Fail _ -> ()
| Return x -> ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
(**** get_mut'fwd *)
-val hash_map_get_mut_fwd_lem_aux
- (#t : Type0) (self : hash_map_t_nes t) (key : usize) :
+val hashMap_get_mut_lem_aux
+ (#t : Type0) (self : hashMap_t_nes t) (key : usize) :
Lemma
(ensures (
- match hash_map_get_mut_fwd t self key, hash_map_t_find_s self key with
+ match hashMap_get_mut t self key, hashMap_t_find_s self key with
| Fail _, None -> True
| Return x, Some x' -> x == x'
| _ -> False))
-let hash_map_get_mut_fwd_lem_aux #t self key =
- begin match hash_key_fwd key with
+let hashMap_get_mut_lem_aux #t self key =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let v = self.hash_map_slots in
- let i0 = vec_len (list_t t) v in
+ let v = self.slots in
+ let i0 = alloc_vec_Vec_len (list_t t) v in
begin match usize_rem i i0 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
begin
- hash_map_get_mut_in_list_loop_fwd_lem l key;
- match hash_map_get_mut_in_list_loop_fwd t l key with
+ hashMap_get_mut_in_list_loop_lem l key;
+ match hashMap_get_mut_in_list_loop t l key with
| Fail _ -> ()
| Return x -> ()
end
@@ -2762,78 +2762,78 @@ let hash_map_get_mut_fwd_lem_aux #t self key =
end
end
-let hash_map_get_mut_fwd_lem #t self key =
- hash_map_get_mut_fwd_lem_aux #t self key
+let hashMap_get_mut_lem #t self key =
+ hashMap_get_mut_lem_aux #t self key
(*** get_mut'back *)
(**** get_mut_in_list'back *)
-val hash_map_get_mut_in_list_loop_back_lem
+val hashMap_get_mut_in_list_loop_back_lem
(#t : Type0) (ls : list_t t) (key : usize) (ret : t) :
Lemma
(requires (Some? (slot_t_find_s key ls)))
(ensures (
- match hash_map_get_mut_in_list_loop_back t ls key ret with
+ match hashMap_get_mut_in_list_loop_back t ls key ret with
| Fail _ -> False
| Return ls' -> list_t_v ls' == find_update (same_key key) (list_t_v ls) (key,ret)
| _ -> False))
#push-options "--fuel 1"
-let rec hash_map_get_mut_in_list_loop_back_lem #t ls key ret =
+let rec hashMap_get_mut_in_list_loop_back_lem #t ls key ret =
begin match ls with
- | ListCons ckey cvalue ls0 ->
+ | List_Cons ckey cvalue ls0 ->
let b = ckey = key in
if b
- then let ls1 = ListCons ckey ret ls0 in ()
+ then let ls1 = List_Cons ckey ret ls0 in ()
else
begin
- hash_map_get_mut_in_list_loop_back_lem ls0 key ret;
- match hash_map_get_mut_in_list_loop_back t ls0 key ret with
+ hashMap_get_mut_in_list_loop_back_lem ls0 key ret;
+ match hashMap_get_mut_in_list_loop_back t ls0 key ret with
| Fail _ -> ()
- | Return l -> let ls1 = ListCons ckey cvalue l in ()
+ | Return l -> let ls1 = List_Cons ckey cvalue l in ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
(**** get_mut'back *)
/// Refinement lemma
-val hash_map_get_mut_back_lem_refin
- (#t : Type0) (self : hash_map_t t{length self.hash_map_slots > 0})
+val hashMap_get_mut_back_lem_refin
+ (#t : Type0) (self : hashMap_t t{length self.slots > 0})
(key : usize) (ret : t) :
Lemma
- (requires (Some? (hash_map_t_find_s self key)))
+ (requires (Some? (hashMap_t_find_s self key)))
(ensures (
- match hash_map_get_mut_back t self key ret with
+ match hashMap_get_mut_back t self key ret with
| Fail _ -> False
| Return hm' ->
- hash_map_t_v hm' == hash_map_insert_no_fail_s (hash_map_t_v self) key ret))
+ hashMap_t_v hm' == hashMap_insert_no_fail_s (hashMap_t_v self) key ret))
-let hash_map_get_mut_back_lem_refin #t self key ret =
- begin match hash_key_fwd key with
+let hashMap_get_mut_back_lem_refin #t self key ret =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let i0 = self.hash_map_num_entries in
- let p = self.hash_map_max_load_factor in
- let i1 = self.hash_map_max_load in
- let v = self.hash_map_slots in
- let i2 = vec_len (list_t t) v in
+ let i0 = self.num_entries in
+ let p = self.max_load_factor in
+ let i1 = self.max_load in
+ let v = self.slots in
+ let i2 = alloc_vec_Vec_len (list_t t) v in
begin match usize_rem i i2 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_mut_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
begin
- hash_map_get_mut_in_list_loop_back_lem l key ret;
- match hash_map_get_mut_in_list_loop_back t l key ret with
+ hashMap_get_mut_in_list_loop_back_lem l key ret;
+ match hashMap_get_mut_in_list_loop_back t l key ret with
| Fail _ -> ()
| Return l0 ->
- begin match vec_index_mut_back (list_t t) v hash_mod l0 with
+ begin match alloc_vec_Vec_update_usize v hash_mod l0 with
| Fail _ -> ()
- | Return v0 -> let self0 = Mkhash_map_t i0 p i1 v0 in ()
+ | Return v0 -> let self0 = MkhashMap_t i0 p i1 v0 in ()
end
end
end
@@ -2841,102 +2841,102 @@ let hash_map_get_mut_back_lem_refin #t self key ret =
end
/// Final lemma
-val hash_map_get_mut_back_lem_aux
- (#t : Type0) (hm : hash_map_t t)
+val hashMap_get_mut_back_lem_aux
+ (#t : Type0) (hm : hashMap_t t)
(key : usize) (ret : t) :
Lemma
(requires (
- hash_map_t_inv hm /\
- Some? (hash_map_t_find_s hm key)))
+ hashMap_t_inv hm /\
+ Some? (hashMap_t_find_s hm key)))
(ensures (
- match hash_map_get_mut_back t hm key ret with
+ match hashMap_get_mut_back t hm key ret with
| Fail _ -> False
| Return hm' ->
// Functional spec
- hash_map_t_v hm' == hash_map_insert_no_fail_s (hash_map_t_v hm) key ret /\
+ hashMap_t_v hm' == hashMap_insert_no_fail_s (hashMap_t_v hm) key ret /\
// The invariant is preserved
- hash_map_t_inv hm' /\
+ hashMap_t_inv hm' /\
// The length is preserved
- hash_map_t_len_s hm' = hash_map_t_len_s hm /\
+ hashMap_t_len_s hm' = hashMap_t_len_s hm /\
// [key] maps to [value]
- hash_map_t_find_s hm' key == Some ret /\
+ hashMap_t_find_s hm' key == Some ret /\
// The other bindings are preserved
- (forall k'. k' <> key ==> hash_map_t_find_s hm' k' == hash_map_t_find_s hm k')))
+ (forall k'. k' <> key ==> hashMap_t_find_s hm' k' == hashMap_t_find_s hm k')))
-let hash_map_get_mut_back_lem_aux #t hm key ret =
- let hm_v = hash_map_t_v hm in
- hash_map_get_mut_back_lem_refin hm key ret;
- match hash_map_get_mut_back t hm key ret with
+let hashMap_get_mut_back_lem_aux #t hm key ret =
+ let hm_v = hashMap_t_v hm in
+ hashMap_get_mut_back_lem_refin hm key ret;
+ match hashMap_get_mut_back t hm key ret with
| Fail _ -> assert(False)
| Return hm' ->
- hash_map_insert_no_fail_s_lem hm_v key ret
+ hashMap_insert_no_fail_s_lem hm_v key ret
/// .fsti
-let hash_map_get_mut_back_lem #t hm key ret = hash_map_get_mut_back_lem_aux hm key ret
+let hashMap_get_mut_back_lem #t hm key ret = hashMap_get_mut_back_lem_aux hm key ret
(*** remove'fwd *)
-val hash_map_remove_from_list_fwd_lem
+val hashMap_remove_from_list_lem
(#t : Type0) (key : usize) (ls : list_t t) :
Lemma
(ensures (
- match hash_map_remove_from_list_fwd t key ls with
+ match hashMap_remove_from_list t key ls with
| Fail _ -> False
| Return opt_x ->
opt_x == slot_t_find_s key ls /\
(Some? opt_x ==> length (slot_t_v ls) > 0)))
#push-options "--fuel 1"
-let rec hash_map_remove_from_list_fwd_lem #t key ls =
+let rec hashMap_remove_from_list_lem #t key ls =
begin match ls with
- | ListCons ckey x tl ->
+ | List_Cons ckey x tl ->
let b = ckey = key in
if b
then
- let mv_ls = mem_replace_fwd (list_t t) (ListCons ckey x tl) ListNil in
+ let mv_ls = core_mem_replace (list_t t) (List_Cons ckey x tl) List_Nil in
begin match mv_ls with
- | ListCons i cvalue tl0 -> ()
- | ListNil -> ()
+ | List_Cons i cvalue tl0 -> ()
+ | List_Nil -> ()
end
else
begin
- hash_map_remove_from_list_fwd_lem key tl;
- match hash_map_remove_from_list_fwd t key tl with
+ hashMap_remove_from_list_lem key tl;
+ match hashMap_remove_from_list t key tl with
| Fail _ -> ()
| Return opt -> ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
-val hash_map_remove_fwd_lem_aux
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_remove_lem_aux
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
(requires (
// We need the invariant to prove that upon decrementing the entries counter,
// the counter doesn't become negative
- hash_map_t_inv self))
+ hashMap_t_inv self))
(ensures (
- match hash_map_remove_fwd t self key with
+ match hashMap_remove t self key with
| Fail _ -> False
- | Return opt_x -> opt_x == hash_map_t_find_s self key))
+ | Return opt_x -> opt_x == hashMap_t_find_s self key))
-let hash_map_remove_fwd_lem_aux #t self key =
- begin match hash_key_fwd key with
+let hashMap_remove_lem_aux #t self key =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let i0 = self.hash_map_num_entries in
- let v = self.hash_map_slots in
- let i1 = vec_len (list_t t) v in
+ let i0 = self.num_entries in
+ let v = self.slots in
+ let i1 = alloc_vec_Vec_len (list_t t) v in
begin match usize_rem i i1 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_mut_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
begin
- hash_map_remove_from_list_fwd_lem key l;
- match hash_map_remove_from_list_fwd t key l with
+ hashMap_remove_from_list_lem key l;
+ match hashMap_remove_from_list t key l with
| Fail _ -> ()
| Return x ->
begin match x with
@@ -2945,7 +2945,7 @@ let hash_map_remove_fwd_lem_aux #t self key =
begin
assert(l == index v hash_mod);
assert(length (list_t_v #t l) > 0);
- length_flatten_index (hash_map_t_v self) hash_mod;
+ length_flatten_index (hashMap_t_v self) hash_mod;
match usize_sub i0 1 with
| Fail _ -> ()
| Return _ -> ()
@@ -2957,27 +2957,27 @@ let hash_map_remove_fwd_lem_aux #t self key =
end
/// .fsti
-let hash_map_remove_fwd_lem #t self key = hash_map_remove_fwd_lem_aux #t self key
+let hashMap_remove_lem #t self key = hashMap_remove_lem_aux #t self key
(*** remove'back *)
(**** Refinement proofs *)
/// High-level model for [remove_from_list'back]
-let hash_map_remove_from_list_s
+let hashMap_remove_from_list_s
(#t : Type0) (key : usize) (ls : slot_s t) :
slot_s t =
filter_one (not_same_key key) ls
/// Refinement lemma
-val hash_map_remove_from_list_back_lem_refin
+val hashMap_remove_from_list_back_lem_refin
(#t : Type0) (key : usize) (ls : list_t t) :
Lemma
(ensures (
- match hash_map_remove_from_list_back t key ls with
+ match hashMap_remove_from_list_back t key ls with
| Fail _ -> False
| Return ls' ->
- list_t_v ls' == hash_map_remove_from_list_s key (list_t_v ls) /\
+ list_t_v ls' == hashMap_remove_from_list_s key (list_t_v ls) /\
// The length is decremented, iff the key was in the slot
(let len = length (list_t_v ls) in
let len' = length (list_t_v ls') in
@@ -2986,89 +2986,89 @@ val hash_map_remove_from_list_back_lem_refin
| Some _ -> len = len' + 1)))
#push-options "--fuel 1"
-let rec hash_map_remove_from_list_back_lem_refin #t key ls =
+let rec hashMap_remove_from_list_back_lem_refin #t key ls =
begin match ls with
- | ListCons ckey x tl ->
+ | List_Cons ckey x tl ->
let b = ckey = key in
if b
then
- let mv_ls = mem_replace_fwd (list_t t) (ListCons ckey x tl) ListNil in
+ let mv_ls = core_mem_replace (list_t t) (List_Cons ckey x tl) List_Nil in
begin match mv_ls with
- | ListCons i cvalue tl0 -> ()
- | ListNil -> ()
+ | List_Cons i cvalue tl0 -> ()
+ | List_Nil -> ()
end
else
begin
- hash_map_remove_from_list_back_lem_refin key tl;
- match hash_map_remove_from_list_back t key tl with
+ hashMap_remove_from_list_back_lem_refin key tl;
+ match hashMap_remove_from_list_back t key tl with
| Fail _ -> ()
- | Return l -> let ls0 = ListCons ckey x l in ()
+ | Return l -> let ls0 = List_Cons ckey x l in ()
end
- | ListNil -> ()
+ | List_Nil -> ()
end
#pop-options
/// High-level model for [remove_from_list'back]
-let hash_map_remove_s
- (#t : Type0) (self : hash_map_s_nes t) (key : usize) :
- hash_map_s t =
+let hashMap_remove_s
+ (#t : Type0) (self : hashMap_s_nes t) (key : usize) :
+ hashMap_s t =
let len = length self in
let hash = hash_mod_key key len in
let slot = index self hash in
- let slot' = hash_map_remove_from_list_s key slot in
+ let slot' = hashMap_remove_from_list_s key slot in
list_update self hash slot'
/// Refinement lemma
-val hash_map_remove_back_lem_refin
- (#t : Type0) (self : hash_map_t_nes t) (key : usize) :
+val hashMap_remove_back_lem_refin
+ (#t : Type0) (self : hashMap_t_nes t) (key : usize) :
Lemma
(requires (
// We need the invariant to prove that upon decrementing the entries counter,
// the counter doesn't become negative
- hash_map_t_inv self))
+ hashMap_t_inv self))
(ensures (
- match hash_map_remove_back t self key with
+ match hashMap_remove_back t self key with
| Fail _ -> False
| Return hm' ->
- hash_map_t_same_params hm' self /\
- hash_map_t_v hm' == hash_map_remove_s (hash_map_t_v self) key /\
+ hashMap_t_same_params hm' self /\
+ hashMap_t_v hm' == hashMap_remove_s (hashMap_t_v self) key /\
// The length is decremented iff the key was in the map
- (let len = hash_map_t_len_s self in
- let len' = hash_map_t_len_s hm' in
- match hash_map_t_find_s self key with
+ (let len = hashMap_t_len_s self in
+ let len' = hashMap_t_len_s hm' in
+ match hashMap_t_find_s self key with
| None -> len = len'
| Some _ -> len = len' + 1)))
-let hash_map_remove_back_lem_refin #t self key =
- begin match hash_key_fwd key with
+let hashMap_remove_back_lem_refin #t self key =
+ begin match hash_key key with
| Fail _ -> ()
| Return i ->
- let i0 = self.hash_map_num_entries in
- let p = self.hash_map_max_load_factor in
- let i1 = self.hash_map_max_load in
- let v = self.hash_map_slots in
- let i2 = vec_len (list_t t) v in
+ let i0 = self.num_entries in
+ let p = self.max_load_factor in
+ let i1 = self.max_load in
+ let v = self.slots in
+ let i2 = alloc_vec_Vec_len (list_t t) v in
begin match usize_rem i i2 with
| Fail _ -> ()
| Return hash_mod ->
- begin match vec_index_mut_fwd (list_t t) v hash_mod with
+ begin match alloc_vec_Vec_index_usize v hash_mod with
| Fail _ -> ()
| Return l ->
begin
- hash_map_remove_from_list_fwd_lem key l;
- match hash_map_remove_from_list_fwd t key l with
+ hashMap_remove_from_list_lem key l;
+ match hashMap_remove_from_list t key l with
| Fail _ -> ()
| Return x ->
begin match x with
| None ->
begin
- hash_map_remove_from_list_back_lem_refin key l;
- match hash_map_remove_from_list_back t key l with
+ hashMap_remove_from_list_back_lem_refin key l;
+ match hashMap_remove_from_list_back t key l with
| Fail _ -> ()
| Return l0 ->
begin
length_flatten_update (slots_t_v v) hash_mod (list_t_v l0);
- match vec_index_mut_back (list_t t) v hash_mod l0 with
+ match alloc_vec_Vec_update_usize v hash_mod l0 with
| Fail _ -> ()
| Return v0 -> ()
end
@@ -3077,18 +3077,18 @@ let hash_map_remove_back_lem_refin #t self key =
begin
assert(l == index v hash_mod);
assert(length (list_t_v #t l) > 0);
- length_flatten_index (hash_map_t_v self) hash_mod;
+ length_flatten_index (hashMap_t_v self) hash_mod;
match usize_sub i0 1 with
| Fail _ -> ()
| Return i3 ->
begin
- hash_map_remove_from_list_back_lem_refin key l;
- match hash_map_remove_from_list_back t key l with
+ hashMap_remove_from_list_back_lem_refin key l;
+ match hashMap_remove_from_list_back t key l with
| Fail _ -> ()
| Return l0 ->
begin
length_flatten_update (slots_t_v v) hash_mod (list_t_v l0);
- match vec_index_mut_back (list_t t) v hash_mod l0 with
+ match alloc_vec_Vec_update_usize v hash_mod l0 with
| Fail _ -> ()
| Return v0 -> ()
end
@@ -3102,12 +3102,12 @@ let hash_map_remove_back_lem_refin #t self key =
(**** Invariants, high-level properties *)
-val hash_map_remove_from_list_s_lem
+val hashMap_remove_from_list_s_lem
(#t : Type0) (k : usize) (slot : slot_s t) (len : usize{len > 0}) (i : usize) :
Lemma
(requires (slot_s_inv len i slot))
(ensures (
- let slot' = hash_map_remove_from_list_s k slot in
+ let slot' = hashMap_remove_from_list_s k slot in
slot_s_inv len i slot' /\
slot_s_find k slot' == None /\
(forall (k':key{k' <> k}). slot_s_find k' slot' == slot_s_find k' slot) /\
@@ -3117,14 +3117,14 @@ val hash_map_remove_from_list_s_lem
))
#push-options "--fuel 1"
-let rec hash_map_remove_from_list_s_lem #t key slot len i =
+let rec hashMap_remove_from_list_s_lem #t key slot len i =
match slot with
| [] -> ()
| (k',v) :: slot' ->
if k' <> key then
begin
- hash_map_remove_from_list_s_lem key slot' len i;
- let slot'' = hash_map_remove_from_list_s key slot' in
+ hashMap_remove_from_list_s_lem key slot' len i;
+ let slot'' = hashMap_remove_from_list_s key slot' in
assert(for_all (same_hash_mod_key len i) ((k',v)::slot''));
assert(for_all (binding_neq (k',v)) slot'); // Triggers instanciation
assert(for_all (binding_neq (k',v)) slot'')
@@ -3136,51 +3136,51 @@ let rec hash_map_remove_from_list_s_lem #t key slot len i =
end
#pop-options
-val hash_map_remove_s_lem
- (#t : Type0) (self : hash_map_s_nes t) (key : usize) :
+val hashMap_remove_s_lem
+ (#t : Type0) (self : hashMap_s_nes t) (key : usize) :
Lemma
- (requires (hash_map_s_inv self))
+ (requires (hashMap_s_inv self))
(ensures (
- let hm' = hash_map_remove_s self key in
+ let hm' = hashMap_remove_s self key in
// The invariant is preserved
- hash_map_s_inv hm' /\
+ hashMap_s_inv hm' /\
// We updated the binding
- hash_map_s_updated_binding self key None hm'))
+ hashMap_s_updated_binding self key None hm'))
-let hash_map_remove_s_lem #t self key =
+let hashMap_remove_s_lem #t self key =
let len = length self in
let hash = hash_mod_key key len in
let slot = index self hash in
- hash_map_remove_from_list_s_lem key slot len hash;
- let slot' = hash_map_remove_from_list_s key slot in
+ hashMap_remove_from_list_s_lem key slot len hash;
+ let slot' = hashMap_remove_from_list_s key slot in
let hm' = list_update self hash slot' in
- assert(hash_map_s_inv self)
+ assert(hashMap_s_inv self)
/// Final lemma about [remove'back]
-val hash_map_remove_back_lem_aux
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_remove_back_lem_aux
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_remove_back t self key with
+ match hashMap_remove_back t self key with
| Fail _ -> False
| Return hm' ->
- hash_map_t_inv self /\
- hash_map_t_same_params hm' self /\
+ hashMap_t_inv self /\
+ hashMap_t_same_params hm' self /\
// We updated the binding
- hash_map_s_updated_binding (hash_map_t_v self) key None (hash_map_t_v hm') /\
- hash_map_t_v hm' == hash_map_remove_s (hash_map_t_v self) key /\
+ hashMap_s_updated_binding (hashMap_t_v self) key None (hashMap_t_v hm') /\
+ hashMap_t_v hm' == hashMap_remove_s (hashMap_t_v self) key /\
// The length is decremented iff the key was in the map
- (let len = hash_map_t_len_s self in
- let len' = hash_map_t_len_s hm' in
- match hash_map_t_find_s self key with
+ (let len = hashMap_t_len_s self in
+ let len' = hashMap_t_len_s hm' in
+ match hashMap_t_find_s self key with
| None -> len = len'
| Some _ -> len = len' + 1)))
-let hash_map_remove_back_lem_aux #t self key =
- hash_map_remove_back_lem_refin self key;
- hash_map_remove_s_lem (hash_map_t_v self) key
+let hashMap_remove_back_lem_aux #t self key =
+ hashMap_remove_back_lem_refin self key;
+ hashMap_remove_s_lem (hashMap_t_v self) key
/// .fsti
-let hash_map_remove_back_lem #t self key =
- hash_map_remove_back_lem_aux #t self key
+let hashMap_remove_back_lem #t self key =
+ hashMap_remove_back_lem_aux #t self key
diff --git a/tests/fstar/hashmap/Hashmap.Properties.fsti b/tests/fstar/hashmap/Hashmap.Properties.fsti
index 0a4f0134..26c0ec06 100644
--- a/tests/fstar/hashmap/Hashmap.Properties.fsti
+++ b/tests/fstar/hashmap/Hashmap.Properties.fsti
@@ -18,11 +18,11 @@ type key : eqtype = usize
type hash : eqtype = usize
-val hash_map_t_inv (#t : Type0) (hm : hash_map_t t) : Type0
+val hashMap_t_inv (#t : Type0) (hm : hashMap_t t) : Type0
-val len_s (#t : Type0) (hm : hash_map_t t) : nat
+val len_s (#t : Type0) (hm : hashMap_t t) : nat
-val find_s (#t : Type0) (hm : hash_map_t t) (k : key) : option t
+val find_s (#t : Type0) (hm : hashMap_t t) (k : key) : option t
(*** Overloading *)
@@ -32,16 +32,16 @@ val find_s (#t : Type0) (hm : hash_map_t t) (k : key) : option t
/// limiting the hash collisions.
/// This is expressed by the following property, which is maintained in the hash
/// map invariant.
-val hash_map_not_overloaded_lem (#t : Type0) (hm : hash_map_t t) :
+val hashMap_not_overloaded_lem (#t : Type0) (hm : hashMap_t t) :
Lemma
- (requires (hash_map_t_inv hm))
+ (requires (hashMap_t_inv hm))
(ensures (
// The capacity is the number of slots
- let capacity = length hm.hash_map_slots in
+ let capacity = length hm.slots in
// The max load factor defines a threshold on the number of entries:
// if there are more entries than a given fraction of the number of slots,
// we resize the slots vector to limit the hash collisions
- let (dividend, divisor) = hm.hash_map_max_load_factor in
+ let (dividend, divisor) = hm.max_load_factor in
// technicality: this postcondition won't typecheck if we don't reveal
// that divisor > 0 (because of the division)
divisor > 0 /\
@@ -63,14 +63,14 @@ val hash_map_not_overloaded_lem (#t : Type0) (hm : hash_map_t t) :
(**** [new'fwd] *)
/// [new] doesn't fail and returns an empty hash map
-val hash_map_new_fwd_lem (t : Type0) :
+val hashMap_new_lem (t : Type0) :
Lemma
(ensures (
- match hash_map_new_fwd t with
+ match hashMap_new t with
| Fail _ -> False
| Return hm ->
// The hash map invariant is satisfied
- hash_map_t_inv hm /\
+ hashMap_t_inv hm /\
// The hash map has a length of 0
len_s hm = 0 /\
// It contains no bindings
@@ -79,16 +79,16 @@ val hash_map_new_fwd_lem (t : Type0) :
(**** [clear] *)
/// [clear] doesn't fail and turns the hash map into an empty map
-val hash_map_clear_fwd_back_lem
- (#t : Type0) (self : hash_map_t t) :
+val hashMap_clear_lem
+ (#t : Type0) (self : hashMap_t t) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_clear_fwd_back t self with
+ match hashMap_clear t self with
| Fail _ -> False
| Return hm ->
// The hash map invariant is satisfied
- hash_map_t_inv hm /\
+ hashMap_t_inv hm /\
// The hash map has a length of 0
len_s hm = 0 /\
// It contains no bindings
@@ -97,11 +97,11 @@ val hash_map_clear_fwd_back_lem
(**** [len] *)
/// [len] can't fail and returns the length (the number of elements) of the hash map
-val hash_map_len_fwd_lem (#t : Type0) (self : hash_map_t t) :
+val hashMap_len_lem (#t : Type0) (self : hashMap_t t) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_len_fwd t self with
+ match hashMap_len t self with
| Fail _ -> False
| Return l -> l = len_s self))
@@ -114,12 +114,12 @@ val hash_map_len_fwd_lem (#t : Type0) (self : hash_map_t t) :
/// entirely encompassed by the effect of the backward function alone).
///
/// [insert'fwd_back] simply inserts a binding.
-val hash_map_insert_fwd_back_lem
- (#t : Type0) (self : hash_map_t t) (key : usize) (value : t) :
+val hashMap_insert_lem
+ (#t : Type0) (self : hashMap_t t) (key : usize) (value : t) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_insert_fwd_back t self key value with
+ match hashMap_insert t self key value with
| Fail _ ->
// We can fail only if:
// - the key is not in the map and we thus need to add it
@@ -128,7 +128,7 @@ val hash_map_insert_fwd_back_lem
len_s self = usize_max
| Return hm' ->
// The invariant is preserved
- hash_map_t_inv hm' /\
+ hashMap_t_inv hm' /\
// [key] maps to [value]
find_s hm' key == Some value /\
// The other bindings are preserved
@@ -145,24 +145,24 @@ val hash_map_insert_fwd_back_lem
/// [contains_key'fwd] can't fail and returns `true` if and only if there is
/// a binding for key [key]
-val hash_map_contains_key_fwd_lem
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_contains_key_lem
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_contains_key_fwd t self key with
+ match hashMap_contains_key t self key with
| Fail _ -> False
| Return b -> b = Some? (find_s self key)))
(**** [get'fwd] *)
/// [get] returns (a shared borrow to) the binding for key [key]
-val hash_map_get_fwd_lem
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_get_lem
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_get_fwd t self key, find_s self key with
+ match hashMap_get t self key, find_s self key with
| Fail _, None -> True
| Return x, Some x' -> x == x'
| _ -> False))
@@ -175,12 +175,12 @@ val hash_map_get_fwd_lem
/// in Rust, which gives the possibility of modifying this element in place. Then,
/// upon ending the borrow, the effect of the modification is modelled in the
/// translation through a call to the backward function.
-val hash_map_get_mut_fwd_lem
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_get_mut_lem
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_get_mut_fwd t self key, find_s self key with
+ match hashMap_get_mut t self key, find_s self key with
| Fail _, None -> True
| Return x, Some x' -> x == x'
| _ -> False))
@@ -192,11 +192,11 @@ val hash_map_get_mut_fwd_lem
/// A call to [get_mut'back] must follow a call to [get_mut'fwd], which gives
/// us that there must be a binding for key [key] in the map (otherwise we
/// can't prove the absence of failure).
-val hash_map_get_mut_back_lem
- (#t : Type0) (hm : hash_map_t t) (key : usize) (ret : t) :
+val hashMap_get_mut_back_lem
+ (#t : Type0) (hm : hashMap_t t) (key : usize) (ret : t) :
Lemma
(requires (
- hash_map_t_inv hm /\
+ hashMap_t_inv hm /\
// A call to the backward function must follow a call to the forward
// function, whose success gives us that there is a binding for the key.
// In the case of *forward* functions, "success" has to be understood as
@@ -207,14 +207,14 @@ val hash_map_get_mut_back_lem
// "failure" is to be understood as the semantics getting stuck.
// This is of course true unless we filtered the call to the forward function
// because its effect is encompassed by the backward function, as with
- // [hash_map_clear_fwd_back]).
+ // [hashMap_clear]).
Some? (find_s hm key)))
(ensures (
- match hash_map_get_mut_back t hm key ret with
+ match hashMap_get_mut_back t hm key ret with
| Fail _ -> False // Can't fail
| Return hm' ->
// The invariant is preserved
- hash_map_t_inv hm' /\
+ hashMap_t_inv hm' /\
// The length is preserved
len_s hm' = len_s hm /\
// [key] maps to the update value, [ret]
@@ -228,12 +228,12 @@ val hash_map_get_mut_back_lem
/// (the rust function *moves* it out of the map). Note that the effect of the update
/// on the map is modelles through the call to [remove'back] ([remove] takes a
/// mutable borrow to the hash map as parameter).
-val hash_map_remove_fwd_lem
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_remove_lem
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_remove_fwd t self key with
+ match hashMap_remove t self key with
| Fail _ -> False
| Return opt_x -> opt_x == find_s self key))
@@ -243,16 +243,16 @@ val hash_map_remove_fwd_lem
/// The hash map given as parameter to [remove] is given through a mutable borrow:
/// hence the backward function which gives back the updated map, without the
/// binding.
-val hash_map_remove_back_lem
- (#t : Type0) (self : hash_map_t t) (key : usize) :
+val hashMap_remove_back_lem
+ (#t : Type0) (self : hashMap_t t) (key : usize) :
Lemma
- (requires (hash_map_t_inv self))
+ (requires (hashMap_t_inv self))
(ensures (
- match hash_map_remove_back t self key with
+ match hashMap_remove_back t self key with
| Fail _ -> False
| Return hm' ->
// The invariant is preserved
- hash_map_t_inv self /\
+ hashMap_t_inv self /\
// The binding for [key] is not there anymore
find_s hm' key == None /\
// The other bindings are preserved
diff --git a/tests/fstar/hashmap/Hashmap.Types.fst b/tests/fstar/hashmap/Hashmap.Types.fst
index 91ee26c6..753730fe 100644
--- a/tests/fstar/hashmap/Hashmap.Types.fst
+++ b/tests/fstar/hashmap/Hashmap.Types.fst
@@ -7,15 +7,15 @@ open Primitives
(** [hashmap::List] *)
type list_t (t : Type0) =
-| ListCons : usize -> t -> list_t t -> list_t t
-| ListNil : list_t t
+| List_Cons : usize -> t -> list_t t -> list_t t
+| List_Nil : list_t t
(** [hashmap::HashMap] *)
-type hash_map_t (t : Type0) =
+type hashMap_t (t : Type0) =
{
- hash_map_num_entries : usize;
- hash_map_max_load_factor : (usize & usize);
- hash_map_max_load : usize;
- hash_map_slots : vec (list_t t);
+ num_entries : usize;
+ max_load_factor : (usize & usize);
+ max_load : usize;
+ slots : alloc_vec_Vec (list_t t);
}
diff --git a/tests/fstar/hashmap/Primitives.fst b/tests/fstar/hashmap/Primitives.fst
index 9db82069..3297803c 100644
--- a/tests/fstar/hashmap/Primitives.fst
+++ b/tests/fstar/hashmap/Primitives.fst
@@ -55,8 +55,12 @@ type string = string
let is_zero (n: nat) : bool = n = 0
let decrease (n: nat{n > 0}) : nat = n - 1
-let mem_replace_fwd (a : Type0) (x : a) (y : a) : a = x
-let mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
(*** Scalars *)
/// Rem.: most of the following code was partially generated
@@ -100,6 +104,11 @@ type scalar_ty =
| U64
| U128
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
let scalar_min (ty : scalar_ty) : int =
match ty with
| Isize -> isize_min
@@ -162,6 +171,15 @@ let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scala
let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
mk_scalar ty (x * y)
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
(** Cast an integer from a [src_ty] to a [tgt_ty] *)
// TODO: check the semantics of casts in Rust
let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
@@ -169,17 +187,44 @@ let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) :
/// The scalar types
type isize : eqtype = scalar Isize
-type i8 : eqtype = scalar I8
-type i16 : eqtype = scalar I16
-type i32 : eqtype = scalar I32
-type i64 : eqtype = scalar I64
-type i128 : eqtype = scalar I128
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
type usize : eqtype = scalar Usize
-type u8 : eqtype = scalar U8
-type u16 : eqtype = scalar U16
-type u32 : eqtype = scalar U32
-type u64 : eqtype = scalar U64
-type u128 : eqtype = scalar U128
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
/// Negation
let isize_neg = scalar_neg #Isize
@@ -231,7 +276,7 @@ let u32_add = scalar_add #U32
let u64_add = scalar_add #U64
let u128_add = scalar_add #U128
-/// Substraction
+/// Subtraction
let isize_sub = scalar_sub #Isize
let i8_sub = scalar_sub #I8
let i16_sub = scalar_sub #I16
@@ -259,12 +304,65 @@ let u32_mul = scalar_mul #U32
let u64_mul = scalar_mul #U64
let u128_mul = scalar_mul #U128
-(*** Range *)
-type range (a : Type0) = {
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
start : a;
end_ : a;
}
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
(*** Array *)
type array (a : Type0) (n : usize) = s:list a{length s = n}
@@ -278,15 +376,11 @@ let mk_array (a : Type0) (n : usize)
normalize_term_spec (FStar.List.Tot.length l);
l
-let array_index_shared (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let array_index_mut_fwd (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let array_index_mut_back (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
if i < length x then Return (list_update x i nx)
else Fail Failure
@@ -295,55 +389,54 @@ type slice (a : Type0) = s:list a{length s <= usize_max}
let slice_len (a : Type0) (s : slice a) : usize = length s
-let slice_index_shared (a : Type0) (x : slice a) (i : usize) : result a =
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let slice_index_mut_fwd (a : Type0) (x : slice a) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let slice_index_mut_back (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
if i < length x then Return (list_update x i nx)
else Fail Failure
(*** Subslices *)
-let array_to_slice_shared (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_fwd (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_back (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
if length s = n then Return s
else Fail Failure
// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
-let array_subslice_shared (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
- admit()
-
-let array_subslice_mut_fwd (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let array_subslice_mut_back (a : Type0) (n : usize) (x : array a n) (r : range usize) (ns : slice a) : result (array a n) =
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
admit()
-let slice_subslice_shared (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
admit()
-let slice_subslice_mut_fwd (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let slice_subslice_mut_back (a : Type0) (x : slice a) (r : range usize) (ns : slice a) : result (slice a) =
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
admit()
(*** Vector *)
-type vec (a : Type0) = v:list a{length v <= usize_max}
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
-let vec_new (a : Type0) : vec a = assert_norm(length #a [] == 0); []
-let vec_len (a : Type0) (v : vec a) : usize = length v
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
// The **forward** function shouldn't be used
-let vec_push_fwd (a : Type0) (v : vec a) (x : a) : unit = ()
-let vec_push_back (a : Type0) (v : vec a) (x : a) :
- Pure (result (vec a))
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
(requires True)
(ensures (fun res ->
match res with
@@ -358,18 +451,279 @@ let vec_push_back (a : Type0) (v : vec a) (x : a) :
else Fail Failure
// The **forward** function shouldn't be used
-let vec_insert_fwd (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
if i < length v then Return () else Fail Failure
-let vec_insert_back (a : Type0) (v : vec a) (i : usize) (x : a) : result (vec a) =
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
if i < length v then Return (list_update v i x) else Fail Failure
-// The **backward** function shouldn't be used
-let vec_index_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_back (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
- if i < length v then Return () else Fail Failure
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
-let vec_index_mut_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_mut_back (a : Type0) (v : vec a) (i : usize) (nx : a) : result (vec a) =
- if i < length v then Return (list_update v i nx) else Fail Failure
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.Template.fst b/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.Template.fst
index 615c670d..61885ac7 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.Template.fst
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.Template.fst
@@ -8,56 +8,56 @@ open HashmapMain.Types
(** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: decreases clause *)
unfold
-let hashmap_hash_map_allocate_slots_loop_decreases (t : Type0)
- (slots : vec (hashmap_list_t t)) (n : usize) : nat =
+let hashmap_HashMap_allocate_slots_loop_decreases (t : Type0)
+ (slots : alloc_vec_Vec (hashmap_List_t t)) (n : usize) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::clear]: decreases clause *)
unfold
-let hashmap_hash_map_clear_loop_decreases (t : Type0)
- (slots : vec (hashmap_list_t t)) (i : usize) : nat =
+let hashmap_HashMap_clear_loop_decreases (t : Type0)
+ (slots : alloc_vec_Vec (hashmap_List_t t)) (i : usize) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_insert_in_list_loop_decreases (t : Type0) (key : usize)
- (value : t) (ls : hashmap_list_t t) : nat =
+let hashmap_HashMap_insert_in_list_loop_decreases (t : Type0) (key : usize)
+ (value : t) (ls : hashmap_List_t t) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list]: decreases clause *)
unfold
-let hashmap_hash_map_move_elements_from_list_loop_decreases (t : Type0)
- (ntable : hashmap_hash_map_t t) (ls : hashmap_list_t t) : nat =
+let hashmap_HashMap_move_elements_from_list_loop_decreases (t : Type0)
+ (ntable : hashmap_HashMap_t t) (ls : hashmap_List_t t) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::move_elements]: decreases clause *)
unfold
-let hashmap_hash_map_move_elements_loop_decreases (t : Type0)
- (ntable : hashmap_hash_map_t t) (slots : vec (hashmap_list_t t)) (i : usize)
- : nat =
+let hashmap_HashMap_move_elements_loop_decreases (t : Type0)
+ (ntable : hashmap_HashMap_t t) (slots : alloc_vec_Vec (hashmap_List_t t))
+ (i : usize) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_contains_key_in_list_loop_decreases (t : Type0)
- (key : usize) (ls : hashmap_list_t t) : nat =
+let hashmap_HashMap_contains_key_in_list_loop_decreases (t : Type0)
+ (key : usize) (ls : hashmap_List_t t) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_get_in_list_loop_decreases (t : Type0) (key : usize)
- (ls : hashmap_list_t t) : nat =
+let hashmap_HashMap_get_in_list_loop_decreases (t : Type0) (key : usize)
+ (ls : hashmap_List_t t) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_get_mut_in_list_loop_decreases (t : Type0)
- (ls : hashmap_list_t t) (key : usize) : nat =
+let hashmap_HashMap_get_mut_in_list_loop_decreases (t : Type0)
+ (ls : hashmap_List_t t) (key : usize) : nat =
admit ()
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: decreases clause *)
unfold
-let hashmap_hash_map_remove_from_list_loop_decreases (t : Type0) (key : usize)
- (ls : hashmap_list_t t) : nat =
+let hashmap_HashMap_remove_from_list_loop_decreases (t : Type0) (key : usize)
+ (ls : hashmap_List_t t) : nat =
admit ()
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.fst b/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.fst
index 699ff3b2..be5a4ab1 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.fst
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Clauses.fst
@@ -8,54 +8,54 @@ open HashmapMain.Types
(** [hashmap::HashMap::allocate_slots]: decreases clause *)
unfold
-let hashmap_hash_map_allocate_slots_loop_decreases (t : Type0) (slots : vec (hashmap_list_t t))
+let hashmap_HashMap_allocate_slots_loop_decreases (t : Type0) (slots : alloc_vec_Vec (hashmap_List_t t))
(n : usize) : nat = n
(** [hashmap::HashMap::clear]: decreases clause *)
unfold
-let hashmap_hash_map_clear_loop_decreases (t : Type0) (slots : vec (hashmap_list_t t))
+let hashmap_HashMap_clear_loop_decreases (t : Type0) (slots : alloc_vec_Vec (hashmap_List_t t))
(i : usize) : nat =
if i < length slots then length slots - i else 0
(** [hashmap::HashMap::insert_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_insert_in_list_loop_decreases (t : Type0) (key : usize) (value : t)
- (ls : hashmap_list_t t) : hashmap_list_t t =
+let hashmap_HashMap_insert_in_list_loop_decreases (t : Type0) (key : usize) (value : t)
+ (ls : hashmap_List_t t) : hashmap_List_t t =
ls
(** [hashmap::HashMap::move_elements_from_list]: decreases clause *)
unfold
-let hashmap_hash_map_move_elements_from_list_loop_decreases (t : Type0)
- (ntable : hashmap_hash_map_t t) (ls : hashmap_list_t t) : hashmap_list_t t =
+let hashmap_HashMap_move_elements_from_list_loop_decreases (t : Type0)
+ (ntable : hashmap_HashMap_t t) (ls : hashmap_List_t t) : hashmap_List_t t =
ls
(** [hashmap::HashMap::move_elements]: decreases clause *)
unfold
-let hashmap_hash_map_move_elements_loop_decreases (t : Type0) (ntable : hashmap_hash_map_t t)
- (slots : vec (hashmap_list_t t)) (i : usize) : nat =
+let hashmap_HashMap_move_elements_loop_decreases (t : Type0) (ntable : hashmap_HashMap_t t)
+ (slots : alloc_vec_Vec (hashmap_List_t t)) (i : usize) : nat =
if i < length slots then length slots - i else 0
(** [hashmap::HashMap::contains_key_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_contains_key_in_list_loop_decreases (t : Type0) (key : usize)
- (ls : hashmap_list_t t) : hashmap_list_t t =
+let hashmap_HashMap_contains_key_in_list_loop_decreases (t : Type0) (key : usize)
+ (ls : hashmap_List_t t) : hashmap_List_t t =
ls
(** [hashmap::HashMap::get_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_get_in_list_loop_decreases (t : Type0) (key : usize) (ls : hashmap_list_t t) :
- hashmap_list_t t =
+let hashmap_HashMap_get_in_list_loop_decreases (t : Type0) (key : usize) (ls : hashmap_List_t t) :
+ hashmap_List_t t =
ls
(** [hashmap::HashMap::get_mut_in_list]: decreases clause *)
unfold
-let hashmap_hash_map_get_mut_in_list_loop_decreases (t : Type0)
- (ls : hashmap_list_t t) (key : usize) : hashmap_list_t t =
+let hashmap_HashMap_get_mut_in_list_loop_decreases (t : Type0)
+ (ls : hashmap_List_t t) (key : usize) : hashmap_List_t t =
ls
(** [hashmap::HashMap::remove_from_list]: decreases clause *)
unfold
-let hashmap_hash_map_remove_from_list_loop_decreases (t : Type0) (key : usize)
- (ls : hashmap_list_t t) : hashmap_list_t t =
+let hashmap_HashMap_remove_from_list_loop_decreases (t : Type0) (key : usize)
+ (ls : hashmap_List_t t) : hashmap_List_t t =
ls
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst b/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst
index 1c94209c..5f227596 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Funs.fst
@@ -9,529 +9,528 @@ include HashmapMain.Clauses
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [hashmap_main::hashmap::hash_key]: forward function *)
-let hashmap_hash_key_fwd (k : usize) : result usize =
+let hashmap_hash_key (k : usize) : result usize =
Return k
(** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function *)
-let rec hashmap_hash_map_allocate_slots_loop_fwd
- (t : Type0) (slots : vec (hashmap_list_t t)) (n : usize) :
- Tot (result (vec (hashmap_list_t t)))
- (decreases (hashmap_hash_map_allocate_slots_loop_decreases t slots n))
+let rec hashmap_HashMap_allocate_slots_loop
+ (t : Type0) (slots : alloc_vec_Vec (hashmap_List_t t)) (n : usize) :
+ Tot (result (alloc_vec_Vec (hashmap_List_t t)))
+ (decreases (hashmap_HashMap_allocate_slots_loop_decreases t slots n))
=
if n > 0
then
- let* slots0 = vec_push_back (hashmap_list_t t) slots HashmapListNil in
+ let* slots0 = alloc_vec_Vec_push (hashmap_List_t t) slots Hashmap_List_Nil
+ in
let* n0 = usize_sub n 1 in
- hashmap_hash_map_allocate_slots_loop_fwd t slots0 n0
+ hashmap_HashMap_allocate_slots_loop t slots0 n0
else Return slots
(** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: forward function *)
-let hashmap_hash_map_allocate_slots_fwd
- (t : Type0) (slots : vec (hashmap_list_t t)) (n : usize) :
- result (vec (hashmap_list_t t))
+let hashmap_HashMap_allocate_slots
+ (t : Type0) (slots : alloc_vec_Vec (hashmap_List_t t)) (n : usize) :
+ result (alloc_vec_Vec (hashmap_List_t t))
=
- hashmap_hash_map_allocate_slots_loop_fwd t slots n
+ hashmap_HashMap_allocate_slots_loop t slots n
(** [hashmap_main::hashmap::HashMap::{0}::new_with_capacity]: forward function *)
-let hashmap_hash_map_new_with_capacity_fwd
+let hashmap_HashMap_new_with_capacity
(t : Type0) (capacity : usize) (max_load_dividend : usize)
(max_load_divisor : usize) :
- result (hashmap_hash_map_t t)
+ result (hashmap_HashMap_t t)
=
- let v = vec_new (hashmap_list_t t) in
- let* slots = hashmap_hash_map_allocate_slots_fwd t v capacity in
+ let v = alloc_vec_Vec_new (hashmap_List_t t) in
+ let* slots = hashmap_HashMap_allocate_slots t v capacity in
let* i = usize_mul capacity max_load_dividend in
let* i0 = usize_div i max_load_divisor in
Return
{
- hashmap_hash_map_num_entries = 0;
- hashmap_hash_map_max_load_factor = (max_load_dividend, max_load_divisor);
- hashmap_hash_map_max_load = i0;
- hashmap_hash_map_slots = slots
+ num_entries = 0;
+ max_load_factor = (max_load_dividend, max_load_divisor);
+ max_load = i0;
+ slots = slots
}
(** [hashmap_main::hashmap::HashMap::{0}::new]: forward function *)
-let hashmap_hash_map_new_fwd (t : Type0) : result (hashmap_hash_map_t t) =
- hashmap_hash_map_new_with_capacity_fwd t 32 4 5
+let hashmap_HashMap_new (t : Type0) : result (hashmap_HashMap_t t) =
+ hashmap_HashMap_new_with_capacity t 32 4 5
(** [hashmap_main::hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec hashmap_hash_map_clear_loop_fwd_back
- (t : Type0) (slots : vec (hashmap_list_t t)) (i : usize) :
- Tot (result (vec (hashmap_list_t t)))
- (decreases (hashmap_hash_map_clear_loop_decreases t slots i))
+let rec hashmap_HashMap_clear_loop
+ (t : Type0) (slots : alloc_vec_Vec (hashmap_List_t t)) (i : usize) :
+ Tot (result (alloc_vec_Vec (hashmap_List_t t)))
+ (decreases (hashmap_HashMap_clear_loop_decreases t slots i))
=
- let i0 = vec_len (hashmap_list_t t) slots in
+ let i0 = alloc_vec_Vec_len (hashmap_List_t t) slots in
if i < i0
then
let* i1 = usize_add i 1 in
- let* slots0 = vec_index_mut_back (hashmap_list_t t) slots i HashmapListNil
- in
- hashmap_hash_map_clear_loop_fwd_back t slots0 i1
+ let* slots0 =
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) slots i Hashmap_List_Nil in
+ hashmap_HashMap_clear_loop t slots0 i1
else Return slots
(** [hashmap_main::hashmap::HashMap::{0}::clear]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hashmap_hash_map_clear_fwd_back
- (t : Type0) (self : hashmap_hash_map_t t) : result (hashmap_hash_map_t t) =
- let* v = hashmap_hash_map_clear_loop_fwd_back t self.hashmap_hash_map_slots 0
- in
- Return
- { self with hashmap_hash_map_num_entries = 0; hashmap_hash_map_slots = v }
+let hashmap_HashMap_clear
+ (t : Type0) (self : hashmap_HashMap_t t) : result (hashmap_HashMap_t t) =
+ let* v = hashmap_HashMap_clear_loop t self.slots 0 in
+ Return { self with num_entries = 0; slots = v }
(** [hashmap_main::hashmap::HashMap::{0}::len]: forward function *)
-let hashmap_hash_map_len_fwd
- (t : Type0) (self : hashmap_hash_map_t t) : result usize =
- Return self.hashmap_hash_map_num_entries
+let hashmap_HashMap_len
+ (t : Type0) (self : hashmap_HashMap_t t) : result usize =
+ Return self.num_entries
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: loop 0: forward function *)
-let rec hashmap_hash_map_insert_in_list_loop_fwd
- (t : Type0) (key : usize) (value : t) (ls : hashmap_list_t t) :
+let rec hashmap_HashMap_insert_in_list_loop
+ (t : Type0) (key : usize) (value : t) (ls : hashmap_List_t t) :
Tot (result bool)
- (decreases (hashmap_hash_map_insert_in_list_loop_decreases t key value ls))
+ (decreases (hashmap_HashMap_insert_in_list_loop_decreases t key value ls))
=
begin match ls with
- | HashmapListCons ckey cvalue tl ->
+ | Hashmap_List_Cons ckey cvalue tl ->
if ckey = key
then Return false
- else hashmap_hash_map_insert_in_list_loop_fwd t key value tl
- | HashmapListNil -> Return true
+ else hashmap_HashMap_insert_in_list_loop t key value tl
+ | Hashmap_List_Nil -> Return true
end
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: forward function *)
-let hashmap_hash_map_insert_in_list_fwd
- (t : Type0) (key : usize) (value : t) (ls : hashmap_list_t t) : result bool =
- hashmap_hash_map_insert_in_list_loop_fwd t key value ls
+let hashmap_HashMap_insert_in_list
+ (t : Type0) (key : usize) (value : t) (ls : hashmap_List_t t) : result bool =
+ hashmap_HashMap_insert_in_list_loop t key value ls
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: loop 0: backward function 0 *)
-let rec hashmap_hash_map_insert_in_list_loop_back
- (t : Type0) (key : usize) (value : t) (ls : hashmap_list_t t) :
- Tot (result (hashmap_list_t t))
- (decreases (hashmap_hash_map_insert_in_list_loop_decreases t key value ls))
+let rec hashmap_HashMap_insert_in_list_loop_back
+ (t : Type0) (key : usize) (value : t) (ls : hashmap_List_t t) :
+ Tot (result (hashmap_List_t t))
+ (decreases (hashmap_HashMap_insert_in_list_loop_decreases t key value ls))
=
begin match ls with
- | HashmapListCons ckey cvalue tl ->
+ | Hashmap_List_Cons ckey cvalue tl ->
if ckey = key
- then Return (HashmapListCons ckey value tl)
+ then Return (Hashmap_List_Cons ckey value tl)
else
- let* tl0 = hashmap_hash_map_insert_in_list_loop_back t key value tl in
- Return (HashmapListCons ckey cvalue tl0)
- | HashmapListNil ->
- let l = HashmapListNil in Return (HashmapListCons key value l)
+ let* tl0 = hashmap_HashMap_insert_in_list_loop_back t key value tl in
+ Return (Hashmap_List_Cons ckey cvalue tl0)
+ | Hashmap_List_Nil ->
+ let l = Hashmap_List_Nil in Return (Hashmap_List_Cons key value l)
end
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: backward function 0 *)
-let hashmap_hash_map_insert_in_list_back
- (t : Type0) (key : usize) (value : t) (ls : hashmap_list_t t) :
- result (hashmap_list_t t)
+let hashmap_HashMap_insert_in_list_back
+ (t : Type0) (key : usize) (value : t) (ls : hashmap_List_t t) :
+ result (hashmap_List_t t)
=
- hashmap_hash_map_insert_in_list_loop_back t key value ls
+ hashmap_HashMap_insert_in_list_loop_back t key value ls
(** [hashmap_main::hashmap::HashMap::{0}::insert_no_resize]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hashmap_hash_map_insert_no_resize_fwd_back
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) (value : t) :
- result (hashmap_hash_map_t t)
+let hashmap_HashMap_insert_no_resize
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) (value : t) :
+ result (hashmap_HashMap_t t)
=
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_mut_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod
- in
- let* inserted = hashmap_hash_map_insert_in_list_fwd t key value l in
+ alloc_vec_Vec_index_mut (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ let* inserted = hashmap_HashMap_insert_in_list t key value l in
if inserted
then
- let* i0 = usize_add self.hashmap_hash_map_num_entries 1 in
- let* l0 = hashmap_hash_map_insert_in_list_back t key value l in
+ let* i0 = usize_add self.num_entries 1 in
+ let* l0 = hashmap_HashMap_insert_in_list_back t key value l in
let* v =
- vec_index_mut_back (hashmap_list_t t) self.hashmap_hash_map_slots
- hash_mod l0 in
- Return
- { self with hashmap_hash_map_num_entries = i0; hashmap_hash_map_slots = v
- }
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) self.slots hash_mod l0 in
+ Return { self with num_entries = i0; slots = v }
else
- let* l0 = hashmap_hash_map_insert_in_list_back t key value l in
+ let* l0 = hashmap_HashMap_insert_in_list_back t key value l in
let* v =
- vec_index_mut_back (hashmap_list_t t) self.hashmap_hash_map_slots
- hash_mod l0 in
- Return { self with hashmap_hash_map_slots = v }
-
-(** [core::num::u32::{8}::MAX] *)
-let core_num_u32_max_body : result u32 = Return 4294967295
-let core_num_u32_max_c : u32 = eval_global core_num_u32_max_body
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) self.slots hash_mod l0 in
+ Return { self with slots = v }
(** [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec hashmap_hash_map_move_elements_from_list_loop_fwd_back
- (t : Type0) (ntable : hashmap_hash_map_t t) (ls : hashmap_list_t t) :
- Tot (result (hashmap_hash_map_t t))
+let rec hashmap_HashMap_move_elements_from_list_loop
+ (t : Type0) (ntable : hashmap_HashMap_t t) (ls : hashmap_List_t t) :
+ Tot (result (hashmap_HashMap_t t))
(decreases (
- hashmap_hash_map_move_elements_from_list_loop_decreases t ntable ls))
+ hashmap_HashMap_move_elements_from_list_loop_decreases t ntable ls))
=
begin match ls with
- | HashmapListCons k v tl ->
- let* ntable0 = hashmap_hash_map_insert_no_resize_fwd_back t ntable k v in
- hashmap_hash_map_move_elements_from_list_loop_fwd_back t ntable0 tl
- | HashmapListNil -> Return ntable
+ | Hashmap_List_Cons k v tl ->
+ let* ntable0 = hashmap_HashMap_insert_no_resize t ntable k v in
+ hashmap_HashMap_move_elements_from_list_loop t ntable0 tl
+ | Hashmap_List_Nil -> Return ntable
end
(** [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hashmap_hash_map_move_elements_from_list_fwd_back
- (t : Type0) (ntable : hashmap_hash_map_t t) (ls : hashmap_list_t t) :
- result (hashmap_hash_map_t t)
+let hashmap_HashMap_move_elements_from_list
+ (t : Type0) (ntable : hashmap_HashMap_t t) (ls : hashmap_List_t t) :
+ result (hashmap_HashMap_t t)
=
- hashmap_hash_map_move_elements_from_list_loop_fwd_back t ntable ls
+ hashmap_HashMap_move_elements_from_list_loop t ntable ls
(** [hashmap_main::hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec hashmap_hash_map_move_elements_loop_fwd_back
- (t : Type0) (ntable : hashmap_hash_map_t t) (slots : vec (hashmap_list_t t))
- (i : usize) :
- Tot (result ((hashmap_hash_map_t t) & (vec (hashmap_list_t t))))
- (decreases (hashmap_hash_map_move_elements_loop_decreases t ntable slots i))
+let rec hashmap_HashMap_move_elements_loop
+ (t : Type0) (ntable : hashmap_HashMap_t t)
+ (slots : alloc_vec_Vec (hashmap_List_t t)) (i : usize) :
+ Tot (result ((hashmap_HashMap_t t) & (alloc_vec_Vec (hashmap_List_t t))))
+ (decreases (hashmap_HashMap_move_elements_loop_decreases t ntable slots i))
=
- let i0 = vec_len (hashmap_list_t t) slots in
+ let i0 = alloc_vec_Vec_len (hashmap_List_t t) slots in
if i < i0
then
- let* l = vec_index_mut_fwd (hashmap_list_t t) slots i in
- let ls = mem_replace_fwd (hashmap_list_t t) l HashmapListNil in
- let* ntable0 =
- hashmap_hash_map_move_elements_from_list_fwd_back t ntable ls in
+ let* l =
+ alloc_vec_Vec_index_mut (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) slots i in
+ let ls = core_mem_replace (hashmap_List_t t) l Hashmap_List_Nil in
+ let* ntable0 = hashmap_HashMap_move_elements_from_list t ntable ls in
let* i1 = usize_add i 1 in
- let l0 = mem_replace_back (hashmap_list_t t) l HashmapListNil in
- let* slots0 = vec_index_mut_back (hashmap_list_t t) slots i l0 in
- hashmap_hash_map_move_elements_loop_fwd_back t ntable0 slots0 i1
+ let l0 = core_mem_replace_back (hashmap_List_t t) l Hashmap_List_Nil in
+ let* slots0 =
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) slots i l0 in
+ hashmap_HashMap_move_elements_loop t ntable0 slots0 i1
else Return (ntable, slots)
(** [hashmap_main::hashmap::HashMap::{0}::move_elements]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hashmap_hash_map_move_elements_fwd_back
- (t : Type0) (ntable : hashmap_hash_map_t t) (slots : vec (hashmap_list_t t))
- (i : usize) :
- result ((hashmap_hash_map_t t) & (vec (hashmap_list_t t)))
+let hashmap_HashMap_move_elements
+ (t : Type0) (ntable : hashmap_HashMap_t t)
+ (slots : alloc_vec_Vec (hashmap_List_t t)) (i : usize) :
+ result ((hashmap_HashMap_t t) & (alloc_vec_Vec (hashmap_List_t t)))
=
- hashmap_hash_map_move_elements_loop_fwd_back t ntable slots i
+ hashmap_HashMap_move_elements_loop t ntable slots i
(** [hashmap_main::hashmap::HashMap::{0}::try_resize]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hashmap_hash_map_try_resize_fwd_back
- (t : Type0) (self : hashmap_hash_map_t t) : result (hashmap_hash_map_t t) =
- let* max_usize = scalar_cast U32 Usize core_num_u32_max_c in
- let capacity = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+let hashmap_HashMap_try_resize
+ (t : Type0) (self : hashmap_HashMap_t t) : result (hashmap_HashMap_t t) =
+ let* max_usize = scalar_cast U32 Usize core_u32_max in
+ let capacity = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* n1 = usize_div max_usize 2 in
- let (i, i0) = self.hashmap_hash_map_max_load_factor in
+ let (i, i0) = self.max_load_factor in
let* i1 = usize_div n1 i in
if capacity <= i1
then
let* i2 = usize_mul capacity 2 in
- let* ntable = hashmap_hash_map_new_with_capacity_fwd t i2 i i0 in
- let* (ntable0, _) =
- hashmap_hash_map_move_elements_fwd_back t ntable
- self.hashmap_hash_map_slots 0 in
+ let* ntable = hashmap_HashMap_new_with_capacity t i2 i i0 in
+ let* (ntable0, _) = hashmap_HashMap_move_elements t ntable self.slots 0 in
Return
- {
- ntable0
- with
- hashmap_hash_map_num_entries = self.hashmap_hash_map_num_entries;
- hashmap_hash_map_max_load_factor = (i, i0)
+ { ntable0 with num_entries = self.num_entries; max_load_factor = (i, i0)
}
- else Return { self with hashmap_hash_map_max_load_factor = (i, i0) }
+ else Return { self with max_load_factor = (i, i0) }
(** [hashmap_main::hashmap::HashMap::{0}::insert]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let hashmap_hash_map_insert_fwd_back
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) (value : t) :
- result (hashmap_hash_map_t t)
+let hashmap_HashMap_insert
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) (value : t) :
+ result (hashmap_HashMap_t t)
=
- let* self0 = hashmap_hash_map_insert_no_resize_fwd_back t self key value in
- let* i = hashmap_hash_map_len_fwd t self0 in
- if i > self0.hashmap_hash_map_max_load
- then hashmap_hash_map_try_resize_fwd_back t self0
+ let* self0 = hashmap_HashMap_insert_no_resize t self key value in
+ let* i = hashmap_HashMap_len t self0 in
+ if i > self0.max_load
+ then hashmap_HashMap_try_resize t self0
else Return self0
(** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: loop 0: forward function *)
-let rec hashmap_hash_map_contains_key_in_list_loop_fwd
- (t : Type0) (key : usize) (ls : hashmap_list_t t) :
+let rec hashmap_HashMap_contains_key_in_list_loop
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) :
Tot (result bool)
- (decreases (hashmap_hash_map_contains_key_in_list_loop_decreases t key ls))
+ (decreases (hashmap_HashMap_contains_key_in_list_loop_decreases t key ls))
=
begin match ls with
- | HashmapListCons ckey x tl ->
+ | Hashmap_List_Cons ckey x tl ->
if ckey = key
then Return true
- else hashmap_hash_map_contains_key_in_list_loop_fwd t key tl
- | HashmapListNil -> Return false
+ else hashmap_HashMap_contains_key_in_list_loop t key tl
+ | Hashmap_List_Nil -> Return false
end
(** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: forward function *)
-let hashmap_hash_map_contains_key_in_list_fwd
- (t : Type0) (key : usize) (ls : hashmap_list_t t) : result bool =
- hashmap_hash_map_contains_key_in_list_loop_fwd t key ls
+let hashmap_HashMap_contains_key_in_list
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) : result bool =
+ hashmap_HashMap_contains_key_in_list_loop t key ls
(** [hashmap_main::hashmap::HashMap::{0}::contains_key]: forward function *)
-let hashmap_hash_map_contains_key_fwd
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) : result bool =
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+let hashmap_HashMap_contains_key
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) : result bool =
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod in
- hashmap_hash_map_contains_key_in_list_fwd t key l
+ alloc_vec_Vec_index (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ hashmap_HashMap_contains_key_in_list t key l
(** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: loop 0: forward function *)
-let rec hashmap_hash_map_get_in_list_loop_fwd
- (t : Type0) (key : usize) (ls : hashmap_list_t t) :
+let rec hashmap_HashMap_get_in_list_loop
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) :
Tot (result t)
- (decreases (hashmap_hash_map_get_in_list_loop_decreases t key ls))
+ (decreases (hashmap_HashMap_get_in_list_loop_decreases t key ls))
=
begin match ls with
- | HashmapListCons ckey cvalue tl ->
+ | Hashmap_List_Cons ckey cvalue tl ->
if ckey = key
then Return cvalue
- else hashmap_hash_map_get_in_list_loop_fwd t key tl
- | HashmapListNil -> Fail Failure
+ else hashmap_HashMap_get_in_list_loop t key tl
+ | Hashmap_List_Nil -> Fail Failure
end
(** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: forward function *)
-let hashmap_hash_map_get_in_list_fwd
- (t : Type0) (key : usize) (ls : hashmap_list_t t) : result t =
- hashmap_hash_map_get_in_list_loop_fwd t key ls
+let hashmap_HashMap_get_in_list
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) : result t =
+ hashmap_HashMap_get_in_list_loop t key ls
(** [hashmap_main::hashmap::HashMap::{0}::get]: forward function *)
-let hashmap_hash_map_get_fwd
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) : result t =
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+let hashmap_HashMap_get
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) : result t =
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod in
- hashmap_hash_map_get_in_list_fwd t key l
+ alloc_vec_Vec_index (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ hashmap_HashMap_get_in_list t key l
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function *)
-let rec hashmap_hash_map_get_mut_in_list_loop_fwd
- (t : Type0) (ls : hashmap_list_t t) (key : usize) :
+let rec hashmap_HashMap_get_mut_in_list_loop
+ (t : Type0) (ls : hashmap_List_t t) (key : usize) :
Tot (result t)
- (decreases (hashmap_hash_map_get_mut_in_list_loop_decreases t ls key))
+ (decreases (hashmap_HashMap_get_mut_in_list_loop_decreases t ls key))
=
begin match ls with
- | HashmapListCons ckey cvalue tl ->
+ | Hashmap_List_Cons ckey cvalue tl ->
if ckey = key
then Return cvalue
- else hashmap_hash_map_get_mut_in_list_loop_fwd t tl key
- | HashmapListNil -> Fail Failure
+ else hashmap_HashMap_get_mut_in_list_loop t tl key
+ | Hashmap_List_Nil -> Fail Failure
end
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: forward function *)
-let hashmap_hash_map_get_mut_in_list_fwd
- (t : Type0) (ls : hashmap_list_t t) (key : usize) : result t =
- hashmap_hash_map_get_mut_in_list_loop_fwd t ls key
+let hashmap_HashMap_get_mut_in_list
+ (t : Type0) (ls : hashmap_List_t t) (key : usize) : result t =
+ hashmap_HashMap_get_mut_in_list_loop t ls key
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: backward function 0 *)
-let rec hashmap_hash_map_get_mut_in_list_loop_back
- (t : Type0) (ls : hashmap_list_t t) (key : usize) (ret : t) :
- Tot (result (hashmap_list_t t))
- (decreases (hashmap_hash_map_get_mut_in_list_loop_decreases t ls key))
+let rec hashmap_HashMap_get_mut_in_list_loop_back
+ (t : Type0) (ls : hashmap_List_t t) (key : usize) (ret : t) :
+ Tot (result (hashmap_List_t t))
+ (decreases (hashmap_HashMap_get_mut_in_list_loop_decreases t ls key))
=
begin match ls with
- | HashmapListCons ckey cvalue tl ->
+ | Hashmap_List_Cons ckey cvalue tl ->
if ckey = key
- then Return (HashmapListCons ckey ret tl)
+ then Return (Hashmap_List_Cons ckey ret tl)
else
- let* tl0 = hashmap_hash_map_get_mut_in_list_loop_back t tl key ret in
- Return (HashmapListCons ckey cvalue tl0)
- | HashmapListNil -> Fail Failure
+ let* tl0 = hashmap_HashMap_get_mut_in_list_loop_back t tl key ret in
+ Return (Hashmap_List_Cons ckey cvalue tl0)
+ | Hashmap_List_Nil -> Fail Failure
end
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: backward function 0 *)
-let hashmap_hash_map_get_mut_in_list_back
- (t : Type0) (ls : hashmap_list_t t) (key : usize) (ret : t) :
- result (hashmap_list_t t)
+let hashmap_HashMap_get_mut_in_list_back
+ (t : Type0) (ls : hashmap_List_t t) (key : usize) (ret : t) :
+ result (hashmap_List_t t)
=
- hashmap_hash_map_get_mut_in_list_loop_back t ls key ret
+ hashmap_HashMap_get_mut_in_list_loop_back t ls key ret
(** [hashmap_main::hashmap::HashMap::{0}::get_mut]: forward function *)
-let hashmap_hash_map_get_mut_fwd
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) : result t =
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+let hashmap_HashMap_get_mut
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) : result t =
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_mut_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod
- in
- hashmap_hash_map_get_mut_in_list_fwd t l key
+ alloc_vec_Vec_index_mut (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ hashmap_HashMap_get_mut_in_list t l key
(** [hashmap_main::hashmap::HashMap::{0}::get_mut]: backward function 0 *)
-let hashmap_hash_map_get_mut_back
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) (ret : t) :
- result (hashmap_hash_map_t t)
+let hashmap_HashMap_get_mut_back
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) (ret : t) :
+ result (hashmap_HashMap_t t)
=
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_mut_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod
- in
- let* l0 = hashmap_hash_map_get_mut_in_list_back t l key ret in
+ alloc_vec_Vec_index_mut (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ let* l0 = hashmap_HashMap_get_mut_in_list_back t l key ret in
let* v =
- vec_index_mut_back (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod
- l0 in
- Return { self with hashmap_hash_map_slots = v }
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod l0 in
+ Return { self with slots = v }
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function *)
-let rec hashmap_hash_map_remove_from_list_loop_fwd
- (t : Type0) (key : usize) (ls : hashmap_list_t t) :
+let rec hashmap_HashMap_remove_from_list_loop
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) :
Tot (result (option t))
- (decreases (hashmap_hash_map_remove_from_list_loop_decreases t key ls))
+ (decreases (hashmap_HashMap_remove_from_list_loop_decreases t key ls))
=
begin match ls with
- | HashmapListCons ckey x tl ->
+ | Hashmap_List_Cons ckey x tl ->
if ckey = key
then
let mv_ls =
- mem_replace_fwd (hashmap_list_t t) (HashmapListCons ckey x tl)
- HashmapListNil in
+ core_mem_replace (hashmap_List_t t) (Hashmap_List_Cons ckey x tl)
+ Hashmap_List_Nil in
begin match mv_ls with
- | HashmapListCons i cvalue tl0 -> Return (Some cvalue)
- | HashmapListNil -> Fail Failure
+ | Hashmap_List_Cons i cvalue tl0 -> Return (Some cvalue)
+ | Hashmap_List_Nil -> Fail Failure
end
- else hashmap_hash_map_remove_from_list_loop_fwd t key tl
- | HashmapListNil -> Return None
+ else hashmap_HashMap_remove_from_list_loop t key tl
+ | Hashmap_List_Nil -> Return None
end
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: forward function *)
-let hashmap_hash_map_remove_from_list_fwd
- (t : Type0) (key : usize) (ls : hashmap_list_t t) : result (option t) =
- hashmap_hash_map_remove_from_list_loop_fwd t key ls
+let hashmap_HashMap_remove_from_list
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) : result (option t) =
+ hashmap_HashMap_remove_from_list_loop t key ls
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: backward function 1 *)
-let rec hashmap_hash_map_remove_from_list_loop_back
- (t : Type0) (key : usize) (ls : hashmap_list_t t) :
- Tot (result (hashmap_list_t t))
- (decreases (hashmap_hash_map_remove_from_list_loop_decreases t key ls))
+let rec hashmap_HashMap_remove_from_list_loop_back
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) :
+ Tot (result (hashmap_List_t t))
+ (decreases (hashmap_HashMap_remove_from_list_loop_decreases t key ls))
=
begin match ls with
- | HashmapListCons ckey x tl ->
+ | Hashmap_List_Cons ckey x tl ->
if ckey = key
then
let mv_ls =
- mem_replace_fwd (hashmap_list_t t) (HashmapListCons ckey x tl)
- HashmapListNil in
+ core_mem_replace (hashmap_List_t t) (Hashmap_List_Cons ckey x tl)
+ Hashmap_List_Nil in
begin match mv_ls with
- | HashmapListCons i cvalue tl0 -> Return tl0
- | HashmapListNil -> Fail Failure
+ | Hashmap_List_Cons i cvalue tl0 -> Return tl0
+ | Hashmap_List_Nil -> Fail Failure
end
else
- let* tl0 = hashmap_hash_map_remove_from_list_loop_back t key tl in
- Return (HashmapListCons ckey x tl0)
- | HashmapListNil -> Return HashmapListNil
+ let* tl0 = hashmap_HashMap_remove_from_list_loop_back t key tl in
+ Return (Hashmap_List_Cons ckey x tl0)
+ | Hashmap_List_Nil -> Return Hashmap_List_Nil
end
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: backward function 1 *)
-let hashmap_hash_map_remove_from_list_back
- (t : Type0) (key : usize) (ls : hashmap_list_t t) :
- result (hashmap_list_t t)
+let hashmap_HashMap_remove_from_list_back
+ (t : Type0) (key : usize) (ls : hashmap_List_t t) :
+ result (hashmap_List_t t)
=
- hashmap_hash_map_remove_from_list_loop_back t key ls
+ hashmap_HashMap_remove_from_list_loop_back t key ls
(** [hashmap_main::hashmap::HashMap::{0}::remove]: forward function *)
-let hashmap_hash_map_remove_fwd
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) : result (option t) =
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+let hashmap_HashMap_remove
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) : result (option t) =
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_mut_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod
- in
- let* x = hashmap_hash_map_remove_from_list_fwd t key l in
+ alloc_vec_Vec_index_mut (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ let* x = hashmap_HashMap_remove_from_list t key l in
begin match x with
| None -> Return None
- | Some x0 ->
- let* _ = usize_sub self.hashmap_hash_map_num_entries 1 in Return (Some x0)
+ | Some x0 -> let* _ = usize_sub self.num_entries 1 in Return (Some x0)
end
(** [hashmap_main::hashmap::HashMap::{0}::remove]: backward function 0 *)
-let hashmap_hash_map_remove_back
- (t : Type0) (self : hashmap_hash_map_t t) (key : usize) :
- result (hashmap_hash_map_t t)
+let hashmap_HashMap_remove_back
+ (t : Type0) (self : hashmap_HashMap_t t) (key : usize) :
+ result (hashmap_HashMap_t t)
=
- let* hash = hashmap_hash_key_fwd key in
- let i = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
+ let* hash = hashmap_hash_key key in
+ let i = alloc_vec_Vec_len (hashmap_List_t t) self.slots in
let* hash_mod = usize_rem hash i in
let* l =
- vec_index_mut_fwd (hashmap_list_t t) self.hashmap_hash_map_slots hash_mod
- in
- let* x = hashmap_hash_map_remove_from_list_fwd t key l in
+ alloc_vec_Vec_index_mut (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t t))
+ self.slots hash_mod in
+ let* x = hashmap_HashMap_remove_from_list t key l in
begin match x with
| None ->
- let* l0 = hashmap_hash_map_remove_from_list_back t key l in
+ let* l0 = hashmap_HashMap_remove_from_list_back t key l in
let* v =
- vec_index_mut_back (hashmap_list_t t) self.hashmap_hash_map_slots
- hash_mod l0 in
- Return { self with hashmap_hash_map_slots = v }
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) self.slots hash_mod l0 in
+ Return { self with slots = v }
| Some x0 ->
- let* i0 = usize_sub self.hashmap_hash_map_num_entries 1 in
- let* l0 = hashmap_hash_map_remove_from_list_back t key l in
+ let* i0 = usize_sub self.num_entries 1 in
+ let* l0 = hashmap_HashMap_remove_from_list_back t key l in
let* v =
- vec_index_mut_back (hashmap_list_t t) self.hashmap_hash_map_slots
- hash_mod l0 in
- Return
- { self with hashmap_hash_map_num_entries = i0; hashmap_hash_map_slots = v
- }
+ alloc_vec_Vec_index_mut_back (hashmap_List_t t) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ t)) self.slots hash_mod l0 in
+ Return { self with num_entries = i0; slots = v }
end
(** [hashmap_main::hashmap::test1]: forward function *)
-let hashmap_test1_fwd : result unit =
- let* hm = hashmap_hash_map_new_fwd u64 in
- let* hm0 = hashmap_hash_map_insert_fwd_back u64 hm 0 42 in
- let* hm1 = hashmap_hash_map_insert_fwd_back u64 hm0 128 18 in
- let* hm2 = hashmap_hash_map_insert_fwd_back u64 hm1 1024 138 in
- let* hm3 = hashmap_hash_map_insert_fwd_back u64 hm2 1056 256 in
- let* i = hashmap_hash_map_get_fwd u64 hm3 128 in
+let hashmap_test1 : result unit =
+ let* hm = hashmap_HashMap_new u64 in
+ let* hm0 = hashmap_HashMap_insert u64 hm 0 42 in
+ let* hm1 = hashmap_HashMap_insert u64 hm0 128 18 in
+ let* hm2 = hashmap_HashMap_insert u64 hm1 1024 138 in
+ let* hm3 = hashmap_HashMap_insert u64 hm2 1056 256 in
+ let* i = hashmap_HashMap_get u64 hm3 128 in
if not (i = 18)
then Fail Failure
else
- let* hm4 = hashmap_hash_map_get_mut_back u64 hm3 1024 56 in
- let* i0 = hashmap_hash_map_get_fwd u64 hm4 1024 in
+ let* hm4 = hashmap_HashMap_get_mut_back u64 hm3 1024 56 in
+ let* i0 = hashmap_HashMap_get u64 hm4 1024 in
if not (i0 = 56)
then Fail Failure
else
- let* x = hashmap_hash_map_remove_fwd u64 hm4 1024 in
+ let* x = hashmap_HashMap_remove u64 hm4 1024 in
begin match x with
| None -> Fail Failure
| Some x0 ->
if not (x0 = 56)
then Fail Failure
else
- let* hm5 = hashmap_hash_map_remove_back u64 hm4 1024 in
- let* i1 = hashmap_hash_map_get_fwd u64 hm5 0 in
+ let* hm5 = hashmap_HashMap_remove_back u64 hm4 1024 in
+ let* i1 = hashmap_HashMap_get u64 hm5 0 in
if not (i1 = 42)
then Fail Failure
else
- let* i2 = hashmap_hash_map_get_fwd u64 hm5 128 in
+ let* i2 = hashmap_HashMap_get u64 hm5 128 in
if not (i2 = 18)
then Fail Failure
else
- let* i3 = hashmap_hash_map_get_fwd u64 hm5 1056 in
+ let* i3 = hashmap_HashMap_get u64 hm5 1056 in
if not (i3 = 256) then Fail Failure else Return ()
end
-(** Unit test for [hashmap_main::hashmap::test1] *)
-let _ = assert_norm (hashmap_test1_fwd = Return ())
-
(** [hashmap_main::insert_on_disk]: forward function *)
-let insert_on_disk_fwd
+let insert_on_disk
(key : usize) (value : u64) (st : state) : result (state & unit) =
- let* (st0, hm) = hashmap_utils_deserialize_fwd st in
- let* hm0 = hashmap_hash_map_insert_fwd_back u64 hm key value in
- let* (st1, _) = hashmap_utils_serialize_fwd hm0 st0 in
+ let* (st0, hm) = hashmap_utils_deserialize st in
+ let* hm0 = hashmap_HashMap_insert u64 hm key value in
+ let* (st1, _) = hashmap_utils_serialize hm0 st0 in
Return (st1, ())
(** [hashmap_main::main]: forward function *)
-let main_fwd : result unit =
+let main : result unit =
Return ()
-(** Unit test for [hashmap_main::main] *)
-let _ = assert_norm (main_fwd = Return ())
-
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Opaque.fsti b/tests/fstar/hashmap_on_disk/HashmapMain.Opaque.fsti
index 78a6c3ba..d6cecf36 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Opaque.fsti
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Opaque.fsti
@@ -7,10 +7,10 @@ include HashmapMain.Types
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [hashmap_main::hashmap_utils::deserialize]: forward function *)
-val hashmap_utils_deserialize_fwd
- : state -> result (state & (hashmap_hash_map_t u64))
+val hashmap_utils_deserialize
+ : state -> result (state & (hashmap_HashMap_t u64))
(** [hashmap_main::hashmap_utils::serialize]: forward function *)
-val hashmap_utils_serialize_fwd
- : hashmap_hash_map_t u64 -> state -> result (state & unit)
+val hashmap_utils_serialize
+ : hashmap_HashMap_t u64 -> state -> result (state & unit)
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Properties.fst b/tests/fstar/hashmap_on_disk/HashmapMain.Properties.fst
index 106fe05a..358df29e 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Properties.fst
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Properties.fst
@@ -13,36 +13,36 @@ open HashmapMain.Funs
/// [state_v] gives us the hash map currently stored on disk
assume
-val state_v : state -> hashmap_hash_map_t u64
+val state_v : state -> hashmap_HashMap_t u64
/// [serialize] updates the hash map stored on disk
assume
-val serialize_lem (hm : hashmap_hash_map_t u64) (st : state) : Lemma (
- match hashmap_utils_serialize_fwd hm st with
+val serialize_lem (hm : hashmap_HashMap_t u64) (st : state) : Lemma (
+ match hashmap_utils_serialize hm st with
| Fail _ -> True
| Return (st', ()) -> state_v st' == hm)
- [SMTPat (hashmap_utils_serialize_fwd hm st)]
+ [SMTPat (hashmap_utils_serialize hm st)]
/// [deserialize] gives us the hash map stored on disk, without updating it
assume
val deserialize_lem (st : state) : Lemma (
- match hashmap_utils_deserialize_fwd st with
+ match hashmap_utils_deserialize st with
| Fail _ -> True
| Return (st', hm) -> hm == state_v st /\ st' == st)
- [SMTPat (hashmap_utils_deserialize_fwd st)]
+ [SMTPat (hashmap_utils_deserialize st)]
(*** Lemmas *)
/// The obvious lemma about [insert_on_disk]: the updated hash map stored on disk
/// is exactly the hash map produced from inserting the binding ([key], [value])
/// in the hash map previously stored on disk.
-val insert_on_disk_fwd_lem (key : usize) (value : u64) (st : state) : Lemma (
- match insert_on_disk_fwd key value st with
+val insert_on_disk_lem (key : usize) (value : u64) (st : state) : Lemma (
+ match insert_on_disk key value st with
| Fail _ -> True
| Return (st', ()) ->
let hm = state_v st in
- match hashmap_hash_map_insert_fwd_back u64 hm key value with
+ match hashmap_HashMap_insert u64 hm key value with
| Fail _ -> False
| Return hm' -> hm' == state_v st')
-let insert_on_disk_fwd_lem key value st = ()
+let insert_on_disk_lem key value st = ()
diff --git a/tests/fstar/hashmap_on_disk/HashmapMain.Types.fsti b/tests/fstar/hashmap_on_disk/HashmapMain.Types.fsti
index e289174b..24b78c2a 100644
--- a/tests/fstar/hashmap_on_disk/HashmapMain.Types.fsti
+++ b/tests/fstar/hashmap_on_disk/HashmapMain.Types.fsti
@@ -6,17 +6,17 @@ open Primitives
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [hashmap_main::hashmap::List] *)
-type hashmap_list_t (t : Type0) =
-| HashmapListCons : usize -> t -> hashmap_list_t t -> hashmap_list_t t
-| HashmapListNil : hashmap_list_t t
+type hashmap_List_t (t : Type0) =
+| Hashmap_List_Cons : usize -> t -> hashmap_List_t t -> hashmap_List_t t
+| Hashmap_List_Nil : hashmap_List_t t
(** [hashmap_main::hashmap::HashMap] *)
-type hashmap_hash_map_t (t : Type0) =
+type hashmap_HashMap_t (t : Type0) =
{
- hashmap_hash_map_num_entries : usize;
- hashmap_hash_map_max_load_factor : (usize & usize);
- hashmap_hash_map_max_load : usize;
- hashmap_hash_map_slots : vec (hashmap_list_t t);
+ num_entries : usize;
+ max_load_factor : (usize & usize);
+ max_load : usize;
+ slots : alloc_vec_Vec (hashmap_List_t t);
}
(** The state type used in the state-error monad *)
diff --git a/tests/fstar/hashmap_on_disk/Primitives.fst b/tests/fstar/hashmap_on_disk/Primitives.fst
index 9db82069..3297803c 100644
--- a/tests/fstar/hashmap_on_disk/Primitives.fst
+++ b/tests/fstar/hashmap_on_disk/Primitives.fst
@@ -55,8 +55,12 @@ type string = string
let is_zero (n: nat) : bool = n = 0
let decrease (n: nat{n > 0}) : nat = n - 1
-let mem_replace_fwd (a : Type0) (x : a) (y : a) : a = x
-let mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
(*** Scalars *)
/// Rem.: most of the following code was partially generated
@@ -100,6 +104,11 @@ type scalar_ty =
| U64
| U128
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
let scalar_min (ty : scalar_ty) : int =
match ty with
| Isize -> isize_min
@@ -162,6 +171,15 @@ let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scala
let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
mk_scalar ty (x * y)
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
(** Cast an integer from a [src_ty] to a [tgt_ty] *)
// TODO: check the semantics of casts in Rust
let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
@@ -169,17 +187,44 @@ let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) :
/// The scalar types
type isize : eqtype = scalar Isize
-type i8 : eqtype = scalar I8
-type i16 : eqtype = scalar I16
-type i32 : eqtype = scalar I32
-type i64 : eqtype = scalar I64
-type i128 : eqtype = scalar I128
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
type usize : eqtype = scalar Usize
-type u8 : eqtype = scalar U8
-type u16 : eqtype = scalar U16
-type u32 : eqtype = scalar U32
-type u64 : eqtype = scalar U64
-type u128 : eqtype = scalar U128
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
/// Negation
let isize_neg = scalar_neg #Isize
@@ -231,7 +276,7 @@ let u32_add = scalar_add #U32
let u64_add = scalar_add #U64
let u128_add = scalar_add #U128
-/// Substraction
+/// Subtraction
let isize_sub = scalar_sub #Isize
let i8_sub = scalar_sub #I8
let i16_sub = scalar_sub #I16
@@ -259,12 +304,65 @@ let u32_mul = scalar_mul #U32
let u64_mul = scalar_mul #U64
let u128_mul = scalar_mul #U128
-(*** Range *)
-type range (a : Type0) = {
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
start : a;
end_ : a;
}
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
(*** Array *)
type array (a : Type0) (n : usize) = s:list a{length s = n}
@@ -278,15 +376,11 @@ let mk_array (a : Type0) (n : usize)
normalize_term_spec (FStar.List.Tot.length l);
l
-let array_index_shared (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let array_index_mut_fwd (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let array_index_mut_back (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
if i < length x then Return (list_update x i nx)
else Fail Failure
@@ -295,55 +389,54 @@ type slice (a : Type0) = s:list a{length s <= usize_max}
let slice_len (a : Type0) (s : slice a) : usize = length s
-let slice_index_shared (a : Type0) (x : slice a) (i : usize) : result a =
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let slice_index_mut_fwd (a : Type0) (x : slice a) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let slice_index_mut_back (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
if i < length x then Return (list_update x i nx)
else Fail Failure
(*** Subslices *)
-let array_to_slice_shared (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_fwd (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_back (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
if length s = n then Return s
else Fail Failure
// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
-let array_subslice_shared (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
- admit()
-
-let array_subslice_mut_fwd (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let array_subslice_mut_back (a : Type0) (n : usize) (x : array a n) (r : range usize) (ns : slice a) : result (array a n) =
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
admit()
-let slice_subslice_shared (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
admit()
-let slice_subslice_mut_fwd (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let slice_subslice_mut_back (a : Type0) (x : slice a) (r : range usize) (ns : slice a) : result (slice a) =
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
admit()
(*** Vector *)
-type vec (a : Type0) = v:list a{length v <= usize_max}
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
-let vec_new (a : Type0) : vec a = assert_norm(length #a [] == 0); []
-let vec_len (a : Type0) (v : vec a) : usize = length v
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
// The **forward** function shouldn't be used
-let vec_push_fwd (a : Type0) (v : vec a) (x : a) : unit = ()
-let vec_push_back (a : Type0) (v : vec a) (x : a) :
- Pure (result (vec a))
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
(requires True)
(ensures (fun res ->
match res with
@@ -358,18 +451,279 @@ let vec_push_back (a : Type0) (v : vec a) (x : a) :
else Fail Failure
// The **forward** function shouldn't be used
-let vec_insert_fwd (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
if i < length v then Return () else Fail Failure
-let vec_insert_back (a : Type0) (v : vec a) (i : usize) (x : a) : result (vec a) =
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
if i < length v then Return (list_update v i x) else Fail Failure
-// The **backward** function shouldn't be used
-let vec_index_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_back (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
- if i < length v then Return () else Fail Failure
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
-let vec_index_mut_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_mut_back (a : Type0) (v : vec a) (i : usize) (nx : a) : result (vec a) =
- if i < length v then Return (list_update v i nx) else Fail Failure
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/misc/Constants.fst b/tests/fstar/misc/Constants.fst
index d2b0415e..c21d6a5f 100644
--- a/tests/fstar/misc/Constants.fst
+++ b/tests/fstar/misc/Constants.fst
@@ -9,12 +9,8 @@ open Primitives
let x0_body : result u32 = Return 0
let x0_c : u32 = eval_global x0_body
-(** [core::num::u32::{8}::MAX] *)
-let core_num_u32_max_body : result u32 = Return 4294967295
-let core_num_u32_max_c : u32 = eval_global core_num_u32_max_body
-
(** [constants::X1] *)
-let x1_body : result u32 = Return core_num_u32_max_c
+let x1_body : result u32 = Return core_u32_max
let x1_c : u32 = eval_global x1_body
(** [constants::X2] *)
@@ -22,30 +18,30 @@ let x2_body : result u32 = Return 3
let x2_c : u32 = eval_global x2_body
(** [constants::incr]: forward function *)
-let incr_fwd (n : u32) : result u32 =
+let incr (n : u32) : result u32 =
u32_add n 1
(** [constants::X3] *)
-let x3_body : result u32 = incr_fwd 32
+let x3_body : result u32 = incr 32
let x3_c : u32 = eval_global x3_body
(** [constants::mk_pair0]: forward function *)
-let mk_pair0_fwd (x : u32) (y : u32) : result (u32 & u32) =
+let mk_pair0 (x : u32) (y : u32) : result (u32 & u32) =
Return (x, y)
(** [constants::Pair] *)
-type pair_t (t1 t2 : Type0) = { pair_x : t1; pair_y : t2; }
+type pair_t (t1 t2 : Type0) = { x : t1; y : t2; }
(** [constants::mk_pair1]: forward function *)
-let mk_pair1_fwd (x : u32) (y : u32) : result (pair_t u32 u32) =
- Return { pair_x = x; pair_y = y }
+let mk_pair1 (x : u32) (y : u32) : result (pair_t u32 u32) =
+ Return { x = x; y = y }
(** [constants::P0] *)
-let p0_body : result (u32 & u32) = mk_pair0_fwd 0 1
+let p0_body : result (u32 & u32) = mk_pair0 0 1
let p0_c : (u32 & u32) = eval_global p0_body
(** [constants::P1] *)
-let p1_body : result (pair_t u32 u32) = mk_pair1_fwd 0 1
+let p1_body : result (pair_t u32 u32) = mk_pair1 0 1
let p1_c : pair_t u32 u32 = eval_global p1_body
(** [constants::P2] *)
@@ -53,26 +49,26 @@ let p2_body : result (u32 & u32) = Return (0, 1)
let p2_c : (u32 & u32) = eval_global p2_body
(** [constants::P3] *)
-let p3_body : result (pair_t u32 u32) = Return { pair_x = 0; pair_y = 1 }
+let p3_body : result (pair_t u32 u32) = Return { x = 0; y = 1 }
let p3_c : pair_t u32 u32 = eval_global p3_body
(** [constants::Wrap] *)
-type wrap_t (t : Type0) = { wrap_val : t; }
+type wrap_t (t : Type0) = { value : t; }
(** [constants::Wrap::{0}::new]: forward function *)
-let wrap_new_fwd (t : Type0) (val0 : t) : result (wrap_t t) =
- Return { wrap_val = val0 }
+let wrap_new (t : Type0) (value : t) : result (wrap_t t) =
+ Return { value = value }
(** [constants::Y] *)
-let y_body : result (wrap_t i32) = wrap_new_fwd i32 2
+let y_body : result (wrap_t i32) = wrap_new i32 2
let y_c : wrap_t i32 = eval_global y_body
(** [constants::unwrap_y]: forward function *)
-let unwrap_y_fwd : result i32 =
- Return y_c.wrap_val
+let unwrap_y : result i32 =
+ Return y_c.value
(** [constants::YVAL] *)
-let yval_body : result i32 = unwrap_y_fwd
+let yval_body : result i32 = unwrap_y
let yval_c : i32 = eval_global yval_body
(** [constants::get_z1::Z1] *)
@@ -80,11 +76,11 @@ let get_z1_z1_body : result i32 = Return 3
let get_z1_z1_c : i32 = eval_global get_z1_z1_body
(** [constants::get_z1]: forward function *)
-let get_z1_fwd : result i32 =
+let get_z1 : result i32 =
Return get_z1_z1_c
(** [constants::add]: forward function *)
-let add_fwd (a : i32) (b : i32) : result i32 =
+let add (a : i32) (b : i32) : result i32 =
i32_add a b
(** [constants::Q1] *)
@@ -96,19 +92,19 @@ let q2_body : result i32 = Return q1_c
let q2_c : i32 = eval_global q2_body
(** [constants::Q3] *)
-let q3_body : result i32 = add_fwd q2_c 3
+let q3_body : result i32 = add q2_c 3
let q3_c : i32 = eval_global q3_body
(** [constants::get_z2]: forward function *)
-let get_z2_fwd : result i32 =
- let* i = get_z1_fwd in let* i0 = add_fwd i q3_c in add_fwd q1_c i0
+let get_z2 : result i32 =
+ let* i = get_z1 in let* i0 = add i q3_c in add q1_c i0
(** [constants::S1] *)
let s1_body : result u32 = Return 6
let s1_c : u32 = eval_global s1_body
(** [constants::S2] *)
-let s2_body : result u32 = incr_fwd s1_c
+let s2_body : result u32 = incr s1_c
let s2_c : u32 = eval_global s2_body
(** [constants::S3] *)
@@ -116,6 +112,6 @@ let s3_body : result (pair_t u32 u32) = Return p3_c
let s3_c : pair_t u32 u32 = eval_global s3_body
(** [constants::S4] *)
-let s4_body : result (pair_t u32 u32) = mk_pair1_fwd 7 8
+let s4_body : result (pair_t u32 u32) = mk_pair1 7 8
let s4_c : pair_t u32 u32 = eval_global s4_body
diff --git a/tests/fstar/misc/External.Funs.fst b/tests/fstar/misc/External.Funs.fst
index f118a2cf..e26014ac 100644
--- a/tests/fstar/misc/External.Funs.fst
+++ b/tests/fstar/misc/External.Funs.fst
@@ -8,8 +8,8 @@ include External.Opaque
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [external::swap]: forward function *)
-let swap_fwd (t : Type0) (x : t) (y : t) (st : state) : result (state & unit) =
- let* (st0, _) = core_mem_swap_fwd t x y st in
+let swap (t : Type0) (x : t) (y : t) (st : state) : result (state & unit) =
+ let* (st0, _) = core_mem_swap t x y st in
let* (st1, _) = core_mem_swap_back0 t x y st st0 in
let* (st2, _) = core_mem_swap_back1 t x y st st1 in
Return (st2, ())
@@ -19,28 +19,29 @@ let swap_back
(t : Type0) (x : t) (y : t) (st : state) (st0 : state) :
result (state & (t & t))
=
- let* (st1, _) = core_mem_swap_fwd t x y st in
+ let* (st1, _) = core_mem_swap t x y st in
let* (st2, x0) = core_mem_swap_back0 t x y st st1 in
let* (_, y0) = core_mem_swap_back1 t x y st st2 in
Return (st0, (x0, y0))
(** [external::test_new_non_zero_u32]: forward function *)
-let test_new_non_zero_u32_fwd
- (x : u32) (st : state) : result (state & core_num_nonzero_non_zero_u32_t) =
- let* (st0, opt) = core_num_nonzero_non_zero_u32_new_fwd x st in
- core_option_option_unwrap_fwd core_num_nonzero_non_zero_u32_t opt st0
+let test_new_non_zero_u32
+ (x : u32) (st : state) : result (state & core_num_nonzero_NonZeroU32_t) =
+ let* (st0, o) = core_num_nonzero_NonZeroU32_new x st in
+ core_option_Option_unwrap core_num_nonzero_NonZeroU32_t o st0
(** [external::test_vec]: forward function *)
-let test_vec_fwd : result unit =
- let v = vec_new u32 in let* _ = vec_push_back u32 v 0 in Return ()
+let test_vec : result unit =
+ let v = alloc_vec_Vec_new u32 in
+ let* _ = alloc_vec_Vec_push u32 v 0 in
+ Return ()
(** Unit test for [external::test_vec] *)
-let _ = assert_norm (test_vec_fwd = Return ())
+let _ = assert_norm (test_vec = Return ())
(** [external::custom_swap]: forward function *)
-let custom_swap_fwd
- (t : Type0) (x : t) (y : t) (st : state) : result (state & t) =
- let* (st0, _) = core_mem_swap_fwd t x y st in
+let custom_swap (t : Type0) (x : t) (y : t) (st : state) : result (state & t) =
+ let* (st0, _) = core_mem_swap t x y st in
let* (st1, x0) = core_mem_swap_back0 t x y st st0 in
let* (st2, _) = core_mem_swap_back1 t x y st st1 in
Return (st2, x0)
@@ -50,15 +51,14 @@ let custom_swap_back
(t : Type0) (x : t) (y : t) (st : state) (ret : t) (st0 : state) :
result (state & (t & t))
=
- let* (st1, _) = core_mem_swap_fwd t x y st in
+ let* (st1, _) = core_mem_swap t x y st in
let* (st2, _) = core_mem_swap_back0 t x y st st1 in
let* (_, y0) = core_mem_swap_back1 t x y st st2 in
Return (st0, (ret, y0))
(** [external::test_custom_swap]: forward function *)
-let test_custom_swap_fwd
- (x : u32) (y : u32) (st : state) : result (state & unit) =
- let* (st0, _) = custom_swap_fwd u32 x y st in Return (st0, ())
+let test_custom_swap (x : u32) (y : u32) (st : state) : result (state & unit) =
+ let* (st0, _) = custom_swap u32 x y st in Return (st0, ())
(** [external::test_custom_swap]: backward function 0 *)
let test_custom_swap_back
@@ -68,8 +68,8 @@ let test_custom_swap_back
custom_swap_back u32 x y st 1 st0
(** [external::test_swap_non_zero]: forward function *)
-let test_swap_non_zero_fwd (x : u32) (st : state) : result (state & u32) =
- let* (st0, _) = swap_fwd u32 x 0 st in
+let test_swap_non_zero (x : u32) (st : state) : result (state & u32) =
+ let* (st0, _) = swap u32 x 0 st in
let* (st1, (x0, _)) = swap_back u32 x 0 st st0 in
if x0 = 0 then Fail Failure else Return (st1, x0)
diff --git a/tests/fstar/misc/External.Opaque.fsti b/tests/fstar/misc/External.Opaque.fsti
index 2e19f767..85cf285c 100644
--- a/tests/fstar/misc/External.Opaque.fsti
+++ b/tests/fstar/misc/External.Opaque.fsti
@@ -7,7 +7,7 @@ include External.Types
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [core::mem::swap]: forward function *)
-val core_mem_swap_fwd (t : Type0) : t -> t -> state -> result (state & unit)
+val core_mem_swap (t : Type0) : t -> t -> state -> result (state & unit)
(** [core::mem::swap]: backward function 0 *)
val core_mem_swap_back0
@@ -18,10 +18,10 @@ val core_mem_swap_back1
(t : Type0) : t -> t -> state -> state -> result (state & t)
(** [core::num::nonzero::NonZeroU32::{14}::new]: forward function *)
-val core_num_nonzero_non_zero_u32_new_fwd
- : u32 -> state -> result (state & (option core_num_nonzero_non_zero_u32_t))
+val core_num_nonzero_NonZeroU32_new
+ : u32 -> state -> result (state & (option core_num_nonzero_NonZeroU32_t))
(** [core::option::Option::{0}::unwrap]: forward function *)
-val core_option_option_unwrap_fwd
+val core_option_Option_unwrap
(t : Type0) : option t -> state -> result (state & t)
diff --git a/tests/fstar/misc/External.Types.fsti b/tests/fstar/misc/External.Types.fsti
index 4a13a744..78b5228d 100644
--- a/tests/fstar/misc/External.Types.fsti
+++ b/tests/fstar/misc/External.Types.fsti
@@ -6,7 +6,7 @@ open Primitives
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [core::num::nonzero::NonZeroU32] *)
-val core_num_nonzero_non_zero_u32_t : Type0
+val core_num_nonzero_NonZeroU32_t : Type0
(** The state type used in the state-error monad *)
val state : Type0
diff --git a/tests/fstar/misc/Loops.Clauses.Template.fst b/tests/fstar/misc/Loops.Clauses.Template.fst
index 053b7663..9920bdc1 100644
--- a/tests/fstar/misc/Loops.Clauses.Template.fst
+++ b/tests/fstar/misc/Loops.Clauses.Template.fst
@@ -22,7 +22,8 @@ let sum_with_shared_borrows_loop_decreases (max : u32) (i : u32) (s : u32) :
admit ()
(** [loops::clear]: decreases clause *)
-unfold let clear_loop_decreases (v : vec u32) (i : usize) : nat = admit ()
+unfold
+let clear_loop_decreases (v : alloc_vec_Vec u32) (i : usize) : nat = admit ()
(** [loops::list_mem]: decreases clause *)
unfold let list_mem_loop_decreases (x : u32) (ls : list_t u32) : nat = admit ()
diff --git a/tests/fstar/misc/Loops.Clauses.fst b/tests/fstar/misc/Loops.Clauses.fst
index 82f34de1..75194437 100644
--- a/tests/fstar/misc/Loops.Clauses.fst
+++ b/tests/fstar/misc/Loops.Clauses.fst
@@ -20,7 +20,7 @@ let sum_with_shared_borrows_loop_decreases (max : u32) (i : u32) (s : u32) : nat
if max >= i then max - i else 0
(** [loops::clear]: decreases clause *)
-unfold let clear_loop_decreases (v : vec u32) (i : usize) : nat =
+unfold let clear_loop_decreases (v : alloc_vec_Vec u32) (i : usize) : nat =
if i <= List.Tot.length v then List.Tot.length v - i else 0
(** [loops::list_mem]: decreases clause *)
diff --git a/tests/fstar/misc/Loops.Funs.fst b/tests/fstar/misc/Loops.Funs.fst
index 9a80f415..0f755351 100644
--- a/tests/fstar/misc/Loops.Funs.fst
+++ b/tests/fstar/misc/Loops.Funs.fst
@@ -8,20 +8,20 @@ include Loops.Clauses
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [loops::sum]: loop 0: forward function *)
-let rec sum_loop_fwd
+let rec sum_loop
(max : u32) (i : u32) (s : u32) :
Tot (result u32) (decreases (sum_loop_decreases max i s))
=
if i < max
- then let* s0 = u32_add s i in let* i0 = u32_add i 1 in sum_loop_fwd max i0 s0
+ then let* s0 = u32_add s i in let* i0 = u32_add i 1 in sum_loop max i0 s0
else u32_mul s 2
(** [loops::sum]: forward function *)
-let sum_fwd (max : u32) : result u32 =
- sum_loop_fwd max 0 0
+let sum (max : u32) : result u32 =
+ sum_loop max 0 0
(** [loops::sum_with_mut_borrows]: loop 0: forward function *)
-let rec sum_with_mut_borrows_loop_fwd
+let rec sum_with_mut_borrows_loop
(max : u32) (mi : u32) (ms : u32) :
Tot (result u32) (decreases (sum_with_mut_borrows_loop_decreases max mi ms))
=
@@ -29,15 +29,15 @@ let rec sum_with_mut_borrows_loop_fwd
then
let* ms0 = u32_add ms mi in
let* mi0 = u32_add mi 1 in
- sum_with_mut_borrows_loop_fwd max mi0 ms0
+ sum_with_mut_borrows_loop max mi0 ms0
else u32_mul ms 2
(** [loops::sum_with_mut_borrows]: forward function *)
-let sum_with_mut_borrows_fwd (max : u32) : result u32 =
- sum_with_mut_borrows_loop_fwd max 0 0
+let sum_with_mut_borrows (max : u32) : result u32 =
+ sum_with_mut_borrows_loop max 0 0
(** [loops::sum_with_shared_borrows]: loop 0: forward function *)
-let rec sum_with_shared_borrows_loop_fwd
+let rec sum_with_shared_borrows_loop
(max : u32) (i : u32) (s : u32) :
Tot (result u32) (decreases (sum_with_shared_borrows_loop_decreases max i s))
=
@@ -45,62 +45,64 @@ let rec sum_with_shared_borrows_loop_fwd
then
let* i0 = u32_add i 1 in
let* s0 = u32_add s i0 in
- sum_with_shared_borrows_loop_fwd max i0 s0
+ sum_with_shared_borrows_loop max i0 s0
else u32_mul s 2
(** [loops::sum_with_shared_borrows]: forward function *)
-let sum_with_shared_borrows_fwd (max : u32) : result u32 =
- sum_with_shared_borrows_loop_fwd max 0 0
+let sum_with_shared_borrows (max : u32) : result u32 =
+ sum_with_shared_borrows_loop max 0 0
(** [loops::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let rec clear_loop_fwd_back
- (v : vec u32) (i : usize) :
- Tot (result (vec u32)) (decreases (clear_loop_decreases v i))
+let rec clear_loop
+ (v : alloc_vec_Vec u32) (i : usize) :
+ Tot (result (alloc_vec_Vec u32)) (decreases (clear_loop_decreases v i))
=
- let i0 = vec_len u32 v in
+ let i0 = alloc_vec_Vec_len u32 v in
if i < i0
then
let* i1 = usize_add i 1 in
- let* v0 = vec_index_mut_back u32 v i 0 in
- clear_loop_fwd_back v0 i1
+ let* v0 =
+ alloc_vec_Vec_index_mut_back u32 usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst u32) v i 0 in
+ clear_loop v0 i1
else Return v
(** [loops::clear]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let clear_fwd_back (v : vec u32) : result (vec u32) =
- clear_loop_fwd_back v 0
+let clear (v : alloc_vec_Vec u32) : result (alloc_vec_Vec u32) =
+ clear_loop v 0
(** [loops::list_mem]: loop 0: forward function *)
-let rec list_mem_loop_fwd
+let rec list_mem_loop
(x : u32) (ls : list_t u32) :
Tot (result bool) (decreases (list_mem_loop_decreases x ls))
=
begin match ls with
- | ListCons y tl -> if y = x then Return true else list_mem_loop_fwd x tl
- | ListNil -> Return false
+ | List_Cons y tl -> if y = x then Return true else list_mem_loop x tl
+ | List_Nil -> Return false
end
(** [loops::list_mem]: forward function *)
-let list_mem_fwd (x : u32) (ls : list_t u32) : result bool =
- list_mem_loop_fwd x ls
+let list_mem (x : u32) (ls : list_t u32) : result bool =
+ list_mem_loop x ls
(** [loops::list_nth_mut_loop]: loop 0: forward function *)
-let rec list_nth_mut_loop_loop_fwd
+let rec list_nth_mut_loop_loop
(t : Type0) (ls : list_t t) (i : u32) :
Tot (result t) (decreases (list_nth_mut_loop_loop_decreases t ls i))
=
begin match ls with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
then Return x
- else let* i0 = u32_sub i 1 in list_nth_mut_loop_loop_fwd t tl i0
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_mut_loop_loop t tl i0
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop]: forward function *)
-let list_nth_mut_loop_fwd (t : Type0) (ls : list_t t) (i : u32) : result t =
- list_nth_mut_loop_loop_fwd t ls i
+let list_nth_mut_loop (t : Type0) (ls : list_t t) (i : u32) : result t =
+ list_nth_mut_loop_loop t ls i
(** [loops::list_nth_mut_loop]: loop 0: backward function 0 *)
let rec list_nth_mut_loop_loop_back
@@ -108,14 +110,14 @@ let rec list_nth_mut_loop_loop_back
Tot (result (list_t t)) (decreases (list_nth_mut_loop_loop_decreases t ls i))
=
begin match ls with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else
let* i0 = u32_sub i 1 in
let* tl0 = list_nth_mut_loop_loop_back t tl i0 ret in
- Return (ListCons x tl0)
- | ListNil -> Fail Failure
+ Return (List_Cons x tl0)
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop]: backward function 0 *)
@@ -124,36 +126,40 @@ let list_nth_mut_loop_back
list_nth_mut_loop_loop_back t ls i ret
(** [loops::list_nth_shared_loop]: loop 0: forward function *)
-let rec list_nth_shared_loop_loop_fwd
+let rec list_nth_shared_loop_loop
(t : Type0) (ls : list_t t) (i : u32) :
Tot (result t) (decreases (list_nth_shared_loop_loop_decreases t ls i))
=
begin match ls with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
then Return x
- else let* i0 = u32_sub i 1 in list_nth_shared_loop_loop_fwd t tl i0
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_shared_loop_loop t tl i0
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_loop]: forward function *)
-let list_nth_shared_loop_fwd (t : Type0) (ls : list_t t) (i : u32) : result t =
- list_nth_shared_loop_loop_fwd t ls i
+let list_nth_shared_loop (t : Type0) (ls : list_t t) (i : u32) : result t =
+ list_nth_shared_loop_loop t ls i
(** [loops::get_elem_mut]: loop 0: forward function *)
-let rec get_elem_mut_loop_fwd
+let rec get_elem_mut_loop
(x : usize) (ls : list_t usize) :
Tot (result usize) (decreases (get_elem_mut_loop_decreases x ls))
=
begin match ls with
- | ListCons y tl -> if y = x then Return y else get_elem_mut_loop_fwd x tl
- | ListNil -> Fail Failure
+ | List_Cons y tl -> if y = x then Return y else get_elem_mut_loop x tl
+ | List_Nil -> Fail Failure
end
(** [loops::get_elem_mut]: forward function *)
-let get_elem_mut_fwd (slots : vec (list_t usize)) (x : usize) : result usize =
- let* l = vec_index_mut_fwd (list_t usize) slots 0 in
- get_elem_mut_loop_fwd x l
+let get_elem_mut
+ (slots : alloc_vec_Vec (list_t usize)) (x : usize) : result usize =
+ let* l =
+ alloc_vec_Vec_index_mut (list_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t usize))
+ slots 0 in
+ get_elem_mut_loop x l
(** [loops::get_elem_mut]: loop 0: backward function 0 *)
let rec get_elem_mut_loop_back
@@ -161,39 +167,48 @@ let rec get_elem_mut_loop_back
Tot (result (list_t usize)) (decreases (get_elem_mut_loop_decreases x ls))
=
begin match ls with
- | ListCons y tl ->
+ | List_Cons y tl ->
if y = x
- then Return (ListCons ret tl)
- else let* tl0 = get_elem_mut_loop_back x tl ret in Return (ListCons y tl0)
- | ListNil -> Fail Failure
+ then Return (List_Cons ret tl)
+ else let* tl0 = get_elem_mut_loop_back x tl ret in Return (List_Cons y tl0)
+ | List_Nil -> Fail Failure
end
(** [loops::get_elem_mut]: backward function 0 *)
let get_elem_mut_back
- (slots : vec (list_t usize)) (x : usize) (ret : usize) :
- result (vec (list_t usize))
+ (slots : alloc_vec_Vec (list_t usize)) (x : usize) (ret : usize) :
+ result (alloc_vec_Vec (list_t usize))
=
- let* l = vec_index_mut_fwd (list_t usize) slots 0 in
+ let* l =
+ alloc_vec_Vec_index_mut (list_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t usize))
+ slots 0 in
let* l0 = get_elem_mut_loop_back x l ret in
- vec_index_mut_back (list_t usize) slots 0 l0
+ alloc_vec_Vec_index_mut_back (list_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t usize)) slots
+ 0 l0
(** [loops::get_elem_shared]: loop 0: forward function *)
-let rec get_elem_shared_loop_fwd
+let rec get_elem_shared_loop
(x : usize) (ls : list_t usize) :
Tot (result usize) (decreases (get_elem_shared_loop_decreases x ls))
=
begin match ls with
- | ListCons y tl -> if y = x then Return y else get_elem_shared_loop_fwd x tl
- | ListNil -> Fail Failure
+ | List_Cons y tl -> if y = x then Return y else get_elem_shared_loop x tl
+ | List_Nil -> Fail Failure
end
(** [loops::get_elem_shared]: forward function *)
-let get_elem_shared_fwd
- (slots : vec (list_t usize)) (x : usize) : result usize =
- let* l = vec_index_fwd (list_t usize) slots 0 in get_elem_shared_loop_fwd x l
+let get_elem_shared
+ (slots : alloc_vec_Vec (list_t usize)) (x : usize) : result usize =
+ let* l =
+ alloc_vec_Vec_index (list_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (list_t usize))
+ slots 0 in
+ get_elem_shared_loop x l
(** [loops::id_mut]: forward function *)
-let id_mut_fwd (t : Type0) (ls : list_t t) : result (list_t t) =
+let id_mut (t : Type0) (ls : list_t t) : result (list_t t) =
Return ls
(** [loops::id_mut]: backward function 0 *)
@@ -202,26 +217,26 @@ let id_mut_back
Return ret
(** [loops::id_shared]: forward function *)
-let id_shared_fwd (t : Type0) (ls : list_t t) : result (list_t t) =
+let id_shared (t : Type0) (ls : list_t t) : result (list_t t) =
Return ls
(** [loops::list_nth_mut_loop_with_id]: loop 0: forward function *)
-let rec list_nth_mut_loop_with_id_loop_fwd
+let rec list_nth_mut_loop_with_id_loop
(t : Type0) (i : u32) (ls : list_t t) :
Tot (result t) (decreases (list_nth_mut_loop_with_id_loop_decreases t i ls))
=
begin match ls with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
then Return x
- else let* i0 = u32_sub i 1 in list_nth_mut_loop_with_id_loop_fwd t i0 tl
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_mut_loop_with_id_loop t i0 tl
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_with_id]: forward function *)
-let list_nth_mut_loop_with_id_fwd
+let list_nth_mut_loop_with_id
(t : Type0) (ls : list_t t) (i : u32) : result t =
- let* ls0 = id_mut_fwd t ls in list_nth_mut_loop_with_id_loop_fwd t i ls0
+ let* ls0 = id_mut t ls in list_nth_mut_loop_with_id_loop t i ls0
(** [loops::list_nth_mut_loop_with_id]: loop 0: backward function 0 *)
let rec list_nth_mut_loop_with_id_loop_back
@@ -230,66 +245,64 @@ let rec list_nth_mut_loop_with_id_loop_back
(decreases (list_nth_mut_loop_with_id_loop_decreases t i ls))
=
begin match ls with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else
let* i0 = u32_sub i 1 in
let* tl0 = list_nth_mut_loop_with_id_loop_back t i0 tl ret in
- Return (ListCons x tl0)
- | ListNil -> Fail Failure
+ Return (List_Cons x tl0)
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_with_id]: backward function 0 *)
let list_nth_mut_loop_with_id_back
(t : Type0) (ls : list_t t) (i : u32) (ret : t) : result (list_t t) =
- let* ls0 = id_mut_fwd t ls in
+ let* ls0 = id_mut t ls in
let* l = list_nth_mut_loop_with_id_loop_back t i ls0 ret in
id_mut_back t ls l
(** [loops::list_nth_shared_loop_with_id]: loop 0: forward function *)
-let rec list_nth_shared_loop_with_id_loop_fwd
+let rec list_nth_shared_loop_with_id_loop
(t : Type0) (i : u32) (ls : list_t t) :
Tot (result t)
(decreases (list_nth_shared_loop_with_id_loop_decreases t i ls))
=
begin match ls with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
then Return x
- else let* i0 = u32_sub i 1 in list_nth_shared_loop_with_id_loop_fwd t i0 tl
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_shared_loop_with_id_loop t i0 tl
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_loop_with_id]: forward function *)
-let list_nth_shared_loop_with_id_fwd
+let list_nth_shared_loop_with_id
(t : Type0) (ls : list_t t) (i : u32) : result t =
- let* ls0 = id_shared_fwd t ls in
- list_nth_shared_loop_with_id_loop_fwd t i ls0
+ let* ls0 = id_shared t ls in list_nth_shared_loop_with_id_loop t i ls0
(** [loops::list_nth_mut_loop_pair]: loop 0: forward function *)
-let rec list_nth_mut_loop_pair_loop_fwd
+let rec list_nth_mut_loop_pair_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_mut_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
- else
- let* i0 = u32_sub i 1 in list_nth_mut_loop_pair_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_mut_loop_pair_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_pair]: forward function *)
-let list_nth_mut_loop_pair_fwd
+let list_nth_mut_loop_pair
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_mut_loop_pair_loop_fwd t ls0 ls1 i
+ list_nth_mut_loop_pair_loop t ls0 ls1 i
(** [loops::list_nth_mut_loop_pair]: loop 0: backward function 0 *)
let rec list_nth_mut_loop_pair_loop_back'a
@@ -298,18 +311,18 @@ let rec list_nth_mut_loop_pair_loop_back'a
(decreases (list_nth_mut_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then Return (ListCons ret tl0)
+ then Return (List_Cons ret tl0)
else
let* i0 = u32_sub i 1 in
let* tl00 = list_nth_mut_loop_pair_loop_back'a t tl0 tl1 i0 ret in
- Return (ListCons x0 tl00)
- | ListNil -> Fail Failure
+ Return (List_Cons x0 tl00)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_pair]: backward function 0 *)
@@ -326,18 +339,18 @@ let rec list_nth_mut_loop_pair_loop_back'b
(decreases (list_nth_mut_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then Return (ListCons ret tl1)
+ then Return (List_Cons ret tl1)
else
let* i0 = u32_sub i 1 in
let* tl10 = list_nth_mut_loop_pair_loop_back'b t tl0 tl1 i0 ret in
- Return (ListCons x1 tl10)
- | ListNil -> Fail Failure
+ Return (List_Cons x1 tl10)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_pair]: backward function 1 *)
@@ -348,54 +361,51 @@ let list_nth_mut_loop_pair_back'b
list_nth_mut_loop_pair_loop_back'b t ls0 ls1 i ret
(** [loops::list_nth_shared_loop_pair]: loop 0: forward function *)
-let rec list_nth_shared_loop_pair_loop_fwd
+let rec list_nth_shared_loop_pair_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_shared_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
- else
- let* i0 = u32_sub i 1 in
- list_nth_shared_loop_pair_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_shared_loop_pair_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_loop_pair]: forward function *)
-let list_nth_shared_loop_pair_fwd
+let list_nth_shared_loop_pair
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_shared_loop_pair_loop_fwd t ls0 ls1 i
+ list_nth_shared_loop_pair_loop t ls0 ls1 i
(** [loops::list_nth_mut_loop_pair_merge]: loop 0: forward function *)
-let rec list_nth_mut_loop_pair_merge_loop_fwd
+let rec list_nth_mut_loop_pair_merge_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_mut_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
else
- let* i0 = u32_sub i 1 in
- list_nth_mut_loop_pair_merge_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ let* i0 = u32_sub i 1 in list_nth_mut_loop_pair_merge_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_pair_merge]: forward function *)
-let list_nth_mut_loop_pair_merge_fwd
+let list_nth_mut_loop_pair_merge
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_mut_loop_pair_merge_loop_fwd t ls0 ls1 i
+ list_nth_mut_loop_pair_merge_loop t ls0 ls1 i
(** [loops::list_nth_mut_loop_pair_merge]: loop 0: backward function 0 *)
let rec list_nth_mut_loop_pair_merge_loop_back
@@ -404,19 +414,19 @@ let rec list_nth_mut_loop_pair_merge_loop_back
(decreases (list_nth_mut_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then let (x, x2) = ret in Return (ListCons x tl0, ListCons x2 tl1)
+ then let (x, x2) = ret in Return (List_Cons x tl0, List_Cons x2 tl1)
else
let* i0 = u32_sub i 1 in
let* (tl00, tl10) =
list_nth_mut_loop_pair_merge_loop_back t tl0 tl1 i0 ret in
- Return (ListCons x0 tl00, ListCons x1 tl10)
- | ListNil -> Fail Failure
+ Return (List_Cons x0 tl00, List_Cons x1 tl10)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_loop_pair_merge]: backward function 0 *)
@@ -427,54 +437,54 @@ let list_nth_mut_loop_pair_merge_back
list_nth_mut_loop_pair_merge_loop_back t ls0 ls1 i ret
(** [loops::list_nth_shared_loop_pair_merge]: loop 0: forward function *)
-let rec list_nth_shared_loop_pair_merge_loop_fwd
+let rec list_nth_shared_loop_pair_merge_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_shared_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
else
let* i0 = u32_sub i 1 in
- list_nth_shared_loop_pair_merge_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ list_nth_shared_loop_pair_merge_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_loop_pair_merge]: forward function *)
-let list_nth_shared_loop_pair_merge_fwd
+let list_nth_shared_loop_pair_merge
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_shared_loop_pair_merge_loop_fwd t ls0 ls1 i
+ list_nth_shared_loop_pair_merge_loop t ls0 ls1 i
(** [loops::list_nth_mut_shared_loop_pair]: loop 0: forward function *)
-let rec list_nth_mut_shared_loop_pair_loop_fwd
+let rec list_nth_mut_shared_loop_pair_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_mut_shared_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
else
let* i0 = u32_sub i 1 in
- list_nth_mut_shared_loop_pair_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ list_nth_mut_shared_loop_pair_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_shared_loop_pair]: forward function *)
-let list_nth_mut_shared_loop_pair_fwd
+let list_nth_mut_shared_loop_pair
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_mut_shared_loop_pair_loop_fwd t ls0 ls1 i
+ list_nth_mut_shared_loop_pair_loop t ls0 ls1 i
(** [loops::list_nth_mut_shared_loop_pair]: loop 0: backward function 0 *)
let rec list_nth_mut_shared_loop_pair_loop_back
@@ -483,18 +493,18 @@ let rec list_nth_mut_shared_loop_pair_loop_back
(decreases (list_nth_mut_shared_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then Return (ListCons ret tl0)
+ then Return (List_Cons ret tl0)
else
let* i0 = u32_sub i 1 in
let* tl00 = list_nth_mut_shared_loop_pair_loop_back t tl0 tl1 i0 ret in
- Return (ListCons x0 tl00)
- | ListNil -> Fail Failure
+ Return (List_Cons x0 tl00)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_shared_loop_pair]: backward function 0 *)
@@ -505,29 +515,29 @@ let list_nth_mut_shared_loop_pair_back
list_nth_mut_shared_loop_pair_loop_back t ls0 ls1 i ret
(** [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: forward function *)
-let rec list_nth_mut_shared_loop_pair_merge_loop_fwd
+let rec list_nth_mut_shared_loop_pair_merge_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_mut_shared_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
else
let* i0 = u32_sub i 1 in
- list_nth_mut_shared_loop_pair_merge_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ list_nth_mut_shared_loop_pair_merge_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_shared_loop_pair_merge]: forward function *)
-let list_nth_mut_shared_loop_pair_merge_fwd
+let list_nth_mut_shared_loop_pair_merge
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_mut_shared_loop_pair_merge_loop_fwd t ls0 ls1 i
+ list_nth_mut_shared_loop_pair_merge_loop t ls0 ls1 i
(** [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: backward function 0 *)
let rec list_nth_mut_shared_loop_pair_merge_loop_back
@@ -536,19 +546,19 @@ let rec list_nth_mut_shared_loop_pair_merge_loop_back
(decreases (list_nth_mut_shared_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then Return (ListCons ret tl0)
+ then Return (List_Cons ret tl0)
else
let* i0 = u32_sub i 1 in
let* tl00 =
list_nth_mut_shared_loop_pair_merge_loop_back t tl0 tl1 i0 ret in
- Return (ListCons x0 tl00)
- | ListNil -> Fail Failure
+ Return (List_Cons x0 tl00)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_mut_shared_loop_pair_merge]: backward function 0 *)
@@ -559,29 +569,29 @@ let list_nth_mut_shared_loop_pair_merge_back
list_nth_mut_shared_loop_pair_merge_loop_back t ls0 ls1 i ret
(** [loops::list_nth_shared_mut_loop_pair]: loop 0: forward function *)
-let rec list_nth_shared_mut_loop_pair_loop_fwd
+let rec list_nth_shared_mut_loop_pair_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_shared_mut_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
else
let* i0 = u32_sub i 1 in
- list_nth_shared_mut_loop_pair_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ list_nth_shared_mut_loop_pair_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_mut_loop_pair]: forward function *)
-let list_nth_shared_mut_loop_pair_fwd
+let list_nth_shared_mut_loop_pair
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_shared_mut_loop_pair_loop_fwd t ls0 ls1 i
+ list_nth_shared_mut_loop_pair_loop t ls0 ls1 i
(** [loops::list_nth_shared_mut_loop_pair]: loop 0: backward function 1 *)
let rec list_nth_shared_mut_loop_pair_loop_back
@@ -590,18 +600,18 @@ let rec list_nth_shared_mut_loop_pair_loop_back
(decreases (list_nth_shared_mut_loop_pair_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then Return (ListCons ret tl1)
+ then Return (List_Cons ret tl1)
else
let* i0 = u32_sub i 1 in
let* tl10 = list_nth_shared_mut_loop_pair_loop_back t tl0 tl1 i0 ret in
- Return (ListCons x1 tl10)
- | ListNil -> Fail Failure
+ Return (List_Cons x1 tl10)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_mut_loop_pair]: backward function 1 *)
@@ -612,29 +622,29 @@ let list_nth_shared_mut_loop_pair_back
list_nth_shared_mut_loop_pair_loop_back t ls0 ls1 i ret
(** [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: forward function *)
-let rec list_nth_shared_mut_loop_pair_merge_loop_fwd
+let rec list_nth_shared_mut_loop_pair_merge_loop
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) :
Tot (result (t & t))
(decreases (list_nth_shared_mut_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
then Return (x0, x1)
else
let* i0 = u32_sub i 1 in
- list_nth_shared_mut_loop_pair_merge_loop_fwd t tl0 tl1 i0
- | ListNil -> Fail Failure
+ list_nth_shared_mut_loop_pair_merge_loop t tl0 tl1 i0
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_mut_loop_pair_merge]: forward function *)
-let list_nth_shared_mut_loop_pair_merge_fwd
+let list_nth_shared_mut_loop_pair_merge
(t : Type0) (ls0 : list_t t) (ls1 : list_t t) (i : u32) : result (t & t) =
- list_nth_shared_mut_loop_pair_merge_loop_fwd t ls0 ls1 i
+ list_nth_shared_mut_loop_pair_merge_loop t ls0 ls1 i
(** [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: backward function 0 *)
let rec list_nth_shared_mut_loop_pair_merge_loop_back
@@ -643,19 +653,19 @@ let rec list_nth_shared_mut_loop_pair_merge_loop_back
(decreases (list_nth_shared_mut_loop_pair_merge_loop_decreases t ls0 ls1 i))
=
begin match ls0 with
- | ListCons x0 tl0 ->
+ | List_Cons x0 tl0 ->
begin match ls1 with
- | ListCons x1 tl1 ->
+ | List_Cons x1 tl1 ->
if i = 0
- then Return (ListCons ret tl1)
+ then Return (List_Cons ret tl1)
else
let* i0 = u32_sub i 1 in
let* tl10 =
list_nth_shared_mut_loop_pair_merge_loop_back t tl0 tl1 i0 ret in
- Return (ListCons x1 tl10)
- | ListNil -> Fail Failure
+ Return (List_Cons x1 tl10)
+ | List_Nil -> Fail Failure
end
- | ListNil -> Fail Failure
+ | List_Nil -> Fail Failure
end
(** [loops::list_nth_shared_mut_loop_pair_merge]: backward function 0 *)
diff --git a/tests/fstar/misc/Loops.Types.fst b/tests/fstar/misc/Loops.Types.fst
index 2e032fe7..c622c548 100644
--- a/tests/fstar/misc/Loops.Types.fst
+++ b/tests/fstar/misc/Loops.Types.fst
@@ -7,6 +7,6 @@ open Primitives
(** [loops::List] *)
type list_t (t : Type0) =
-| ListCons : t -> list_t t -> list_t t
-| ListNil : list_t t
+| List_Cons : t -> list_t t -> list_t t
+| List_Nil : list_t t
diff --git a/tests/fstar/misc/NoNestedBorrows.fst b/tests/fstar/misc/NoNestedBorrows.fst
index 2cdd6e21..e97927aa 100644
--- a/tests/fstar/misc/NoNestedBorrows.fst
+++ b/tests/fstar/misc/NoNestedBorrows.fst
@@ -6,95 +6,107 @@ open Primitives
#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
(** [no_nested_borrows::Pair] *)
-type pair_t (t1 t2 : Type0) = { pair_x : t1; pair_y : t2; }
+type pair_t (t1 t2 : Type0) = { x : t1; y : t2; }
(** [no_nested_borrows::List] *)
type list_t (t : Type0) =
-| ListCons : t -> list_t t -> list_t t
-| ListNil : list_t t
+| List_Cons : t -> list_t t -> list_t t
+| List_Nil : list_t t
(** [no_nested_borrows::One] *)
-type one_t (t1 : Type0) = | OneOne : t1 -> one_t t1
+type one_t (t1 : Type0) = | One_One : t1 -> one_t t1
(** [no_nested_borrows::EmptyEnum] *)
-type empty_enum_t = | EmptyEnumEmpty : empty_enum_t
+type emptyEnum_t = | EmptyEnum_Empty : emptyEnum_t
(** [no_nested_borrows::Enum] *)
-type enum_t = | EnumVariant1 : enum_t | EnumVariant2 : enum_t
+type enum_t = | Enum_Variant1 : enum_t | Enum_Variant2 : enum_t
(** [no_nested_borrows::EmptyStruct] *)
-type empty_struct_t = unit
+type emptyStruct_t = unit
(** [no_nested_borrows::Sum] *)
type sum_t (t1 t2 : Type0) =
-| SumLeft : t1 -> sum_t t1 t2
-| SumRight : t2 -> sum_t t1 t2
+| Sum_Left : t1 -> sum_t t1 t2
+| Sum_Right : t2 -> sum_t t1 t2
(** [no_nested_borrows::neg_test]: forward function *)
-let neg_test_fwd (x : i32) : result i32 =
+let neg_test (x : i32) : result i32 =
i32_neg x
(** [no_nested_borrows::add_test]: forward function *)
-let add_test_fwd (x : u32) (y : u32) : result u32 =
+let add_test (x : u32) (y : u32) : result u32 =
u32_add x y
(** [no_nested_borrows::subs_test]: forward function *)
-let subs_test_fwd (x : u32) (y : u32) : result u32 =
+let subs_test (x : u32) (y : u32) : result u32 =
u32_sub x y
(** [no_nested_borrows::div_test]: forward function *)
-let div_test_fwd (x : u32) (y : u32) : result u32 =
+let div_test (x : u32) (y : u32) : result u32 =
u32_div x y
(** [no_nested_borrows::div_test1]: forward function *)
-let div_test1_fwd (x : u32) : result u32 =
+let div_test1 (x : u32) : result u32 =
u32_div x 2
(** [no_nested_borrows::rem_test]: forward function *)
-let rem_test_fwd (x : u32) (y : u32) : result u32 =
+let rem_test (x : u32) (y : u32) : result u32 =
u32_rem x y
+(** [no_nested_borrows::mul_test]: forward function *)
+let mul_test (x : u32) (y : u32) : result u32 =
+ u32_mul x y
+
+(** [no_nested_borrows::CONST0] *)
+let const0_body : result usize = usize_add 1 1
+let const0_c : usize = eval_global const0_body
+
+(** [no_nested_borrows::CONST1] *)
+let const1_body : result usize = usize_mul 2 2
+let const1_c : usize = eval_global const1_body
+
(** [no_nested_borrows::cast_test]: forward function *)
-let cast_test_fwd (x : u32) : result i32 =
+let cast_test (x : u32) : result i32 =
scalar_cast U32 I32 x
(** [no_nested_borrows::test2]: forward function *)
-let test2_fwd : result unit =
+let test2 : result unit =
let* _ = u32_add 23 44 in Return ()
(** Unit test for [no_nested_borrows::test2] *)
-let _ = assert_norm (test2_fwd = Return ())
+let _ = assert_norm (test2 = Return ())
(** [no_nested_borrows::get_max]: forward function *)
-let get_max_fwd (x : u32) (y : u32) : result u32 =
+let get_max (x : u32) (y : u32) : result u32 =
if x >= y then Return x else Return y
(** [no_nested_borrows::test3]: forward function *)
-let test3_fwd : result unit =
- let* x = get_max_fwd 4 3 in
- let* y = get_max_fwd 10 11 in
+let test3 : result unit =
+ let* x = get_max 4 3 in
+ let* y = get_max 10 11 in
let* z = u32_add x y in
if not (z = 15) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test3] *)
-let _ = assert_norm (test3_fwd = Return ())
+let _ = assert_norm (test3 = Return ())
(** [no_nested_borrows::test_neg1]: forward function *)
-let test_neg1_fwd : result unit =
+let test_neg1 : result unit =
let* y = i32_neg 3 in if not (y = -3) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_neg1] *)
-let _ = assert_norm (test_neg1_fwd = Return ())
+let _ = assert_norm (test_neg1 = Return ())
(** [no_nested_borrows::refs_test1]: forward function *)
-let refs_test1_fwd : result unit =
+let refs_test1 : result unit =
if not (1 = 1) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::refs_test1] *)
-let _ = assert_norm (refs_test1_fwd = Return ())
+let _ = assert_norm (refs_test1 = Return ())
(** [no_nested_borrows::refs_test2]: forward function *)
-let refs_test2_fwd : result unit =
+let refs_test2 : result unit =
if not (2 = 2)
then Fail Failure
else
@@ -106,76 +118,76 @@ let refs_test2_fwd : result unit =
else if not (2 = 2) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::refs_test2] *)
-let _ = assert_norm (refs_test2_fwd = Return ())
+let _ = assert_norm (refs_test2 = Return ())
(** [no_nested_borrows::test_list1]: forward function *)
-let test_list1_fwd : result unit =
+let test_list1 : result unit =
Return ()
(** Unit test for [no_nested_borrows::test_list1] *)
-let _ = assert_norm (test_list1_fwd = Return ())
+let _ = assert_norm (test_list1 = Return ())
(** [no_nested_borrows::test_box1]: forward function *)
-let test_box1_fwd : result unit =
+let test_box1 : result unit =
let b = 1 in let x = b in if not (x = 1) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_box1] *)
-let _ = assert_norm (test_box1_fwd = Return ())
+let _ = assert_norm (test_box1 = Return ())
(** [no_nested_borrows::copy_int]: forward function *)
-let copy_int_fwd (x : i32) : result i32 =
+let copy_int (x : i32) : result i32 =
Return x
(** [no_nested_borrows::test_unreachable]: forward function *)
-let test_unreachable_fwd (b : bool) : result unit =
+let test_unreachable (b : bool) : result unit =
if b then Fail Failure else Return ()
(** [no_nested_borrows::test_panic]: forward function *)
-let test_panic_fwd (b : bool) : result unit =
+let test_panic (b : bool) : result unit =
if b then Fail Failure else Return ()
(** [no_nested_borrows::test_copy_int]: forward function *)
-let test_copy_int_fwd : result unit =
- let* y = copy_int_fwd 0 in if not (0 = y) then Fail Failure else Return ()
+let test_copy_int : result unit =
+ let* y = copy_int 0 in if not (0 = y) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_copy_int] *)
-let _ = assert_norm (test_copy_int_fwd = Return ())
+let _ = assert_norm (test_copy_int = Return ())
(** [no_nested_borrows::is_cons]: forward function *)
-let is_cons_fwd (t : Type0) (l : list_t t) : result bool =
+let is_cons (t : Type0) (l : list_t t) : result bool =
begin match l with
- | ListCons x l0 -> Return true
- | ListNil -> Return false
+ | List_Cons x l0 -> Return true
+ | List_Nil -> Return false
end
(** [no_nested_borrows::test_is_cons]: forward function *)
-let test_is_cons_fwd : result unit =
- let l = ListNil in
- let* b = is_cons_fwd i32 (ListCons 0 l) in
+let test_is_cons : result unit =
+ let l = List_Nil in
+ let* b = is_cons i32 (List_Cons 0 l) in
if not b then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_is_cons] *)
-let _ = assert_norm (test_is_cons_fwd = Return ())
+let _ = assert_norm (test_is_cons = Return ())
(** [no_nested_borrows::split_list]: forward function *)
-let split_list_fwd (t : Type0) (l : list_t t) : result (t & (list_t t)) =
+let split_list (t : Type0) (l : list_t t) : result (t & (list_t t)) =
begin match l with
- | ListCons hd tl -> Return (hd, tl)
- | ListNil -> Fail Failure
+ | List_Cons hd tl -> Return (hd, tl)
+ | List_Nil -> Fail Failure
end
(** [no_nested_borrows::test_split_list]: forward function *)
-let test_split_list_fwd : result unit =
- let l = ListNil in
- let* p = split_list_fwd i32 (ListCons 0 l) in
+let test_split_list : result unit =
+ let l = List_Nil in
+ let* p = split_list i32 (List_Cons 0 l) in
let (hd, _) = p in
if not (hd = 0) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_split_list] *)
-let _ = assert_norm (test_split_list_fwd = Return ())
+let _ = assert_norm (test_split_list = Return ())
(** [no_nested_borrows::choose]: forward function *)
-let choose_fwd (t : Type0) (b : bool) (x : t) (y : t) : result t =
+let choose (t : Type0) (b : bool) (x : t) (y : t) : result t =
if b then Return x else Return y
(** [no_nested_borrows::choose]: backward function 0 *)
@@ -184,8 +196,8 @@ let choose_back
if b then Return (ret, y) else Return (x, ret)
(** [no_nested_borrows::choose_test]: forward function *)
-let choose_test_fwd : result unit =
- let* z = choose_fwd i32 true 0 0 in
+let choose_test : result unit =
+ let* z = choose i32 true 0 0 in
let* z0 = i32_add z 1 in
if not (z0 = 1)
then Fail Failure
@@ -196,115 +208,112 @@ let choose_test_fwd : result unit =
else if not (y = 0) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::choose_test] *)
-let _ = assert_norm (choose_test_fwd = Return ())
+let _ = assert_norm (choose_test = Return ())
(** [no_nested_borrows::test_char]: forward function *)
-let test_char_fwd : result char =
+let test_char : result char =
Return 'a'
(** [no_nested_borrows::Tree] *)
type tree_t (t : Type0) =
-| TreeLeaf : t -> tree_t t
-| TreeNode : t -> node_elem_t t -> tree_t t -> tree_t t
+| Tree_Leaf : t -> tree_t t
+| Tree_Node : t -> nodeElem_t t -> tree_t t -> tree_t t
(** [no_nested_borrows::NodeElem] *)
-and node_elem_t (t : Type0) =
-| NodeElemCons : tree_t t -> node_elem_t t -> node_elem_t t
-| NodeElemNil : node_elem_t t
+and nodeElem_t (t : Type0) =
+| NodeElem_Cons : tree_t t -> nodeElem_t t -> nodeElem_t t
+| NodeElem_Nil : nodeElem_t t
(** [no_nested_borrows::list_length]: forward function *)
-let rec list_length_fwd (t : Type0) (l : list_t t) : result u32 =
+let rec list_length (t : Type0) (l : list_t t) : result u32 =
begin match l with
- | ListCons x l1 -> let* i = list_length_fwd t l1 in u32_add 1 i
- | ListNil -> Return 0
+ | List_Cons x l1 -> let* i = list_length t l1 in u32_add 1 i
+ | List_Nil -> Return 0
end
(** [no_nested_borrows::list_nth_shared]: forward function *)
-let rec list_nth_shared_fwd (t : Type0) (l : list_t t) (i : u32) : result t =
+let rec list_nth_shared (t : Type0) (l : list_t t) (i : u32) : result t =
begin match l with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
then Return x
- else let* i0 = u32_sub i 1 in list_nth_shared_fwd t tl i0
- | ListNil -> Fail Failure
+ else let* i0 = u32_sub i 1 in list_nth_shared t tl i0
+ | List_Nil -> Fail Failure
end
(** [no_nested_borrows::list_nth_mut]: forward function *)
-let rec list_nth_mut_fwd (t : Type0) (l : list_t t) (i : u32) : result t =
+let rec list_nth_mut (t : Type0) (l : list_t t) (i : u32) : result t =
begin match l with
- | ListCons x tl ->
- if i = 0
- then Return x
- else let* i0 = u32_sub i 1 in list_nth_mut_fwd t tl i0
- | ListNil -> Fail Failure
+ | List_Cons x tl ->
+ if i = 0 then Return x else let* i0 = u32_sub i 1 in list_nth_mut t tl i0
+ | List_Nil -> Fail Failure
end
(** [no_nested_borrows::list_nth_mut]: backward function 0 *)
let rec list_nth_mut_back
(t : Type0) (l : list_t t) (i : u32) (ret : t) : result (list_t t) =
begin match l with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else
let* i0 = u32_sub i 1 in
let* tl0 = list_nth_mut_back t tl i0 ret in
- Return (ListCons x tl0)
- | ListNil -> Fail Failure
+ Return (List_Cons x tl0)
+ | List_Nil -> Fail Failure
end
(** [no_nested_borrows::list_rev_aux]: forward function *)
-let rec list_rev_aux_fwd
+let rec list_rev_aux
(t : Type0) (li : list_t t) (lo : list_t t) : result (list_t t) =
begin match li with
- | ListCons hd tl -> list_rev_aux_fwd t tl (ListCons hd lo)
- | ListNil -> Return lo
+ | List_Cons hd tl -> list_rev_aux t tl (List_Cons hd lo)
+ | List_Nil -> Return lo
end
(** [no_nested_borrows::list_rev]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let list_rev_fwd_back (t : Type0) (l : list_t t) : result (list_t t) =
- let li = mem_replace_fwd (list_t t) l ListNil in
- list_rev_aux_fwd t li ListNil
+let list_rev (t : Type0) (l : list_t t) : result (list_t t) =
+ let li = core_mem_replace (list_t t) l List_Nil in list_rev_aux t li List_Nil
(** [no_nested_borrows::test_list_functions]: forward function *)
-let test_list_functions_fwd : result unit =
- let l = ListNil in
- let l0 = ListCons 2 l in
- let l1 = ListCons 1 l0 in
- let* i = list_length_fwd i32 (ListCons 0 l1) in
+let test_list_functions : result unit =
+ let l = List_Nil in
+ let l0 = List_Cons 2 l in
+ let l1 = List_Cons 1 l0 in
+ let* i = list_length i32 (List_Cons 0 l1) in
if not (i = 3)
then Fail Failure
else
- let* i0 = list_nth_shared_fwd i32 (ListCons 0 l1) 0 in
+ let* i0 = list_nth_shared i32 (List_Cons 0 l1) 0 in
if not (i0 = 0)
then Fail Failure
else
- let* i1 = list_nth_shared_fwd i32 (ListCons 0 l1) 1 in
+ let* i1 = list_nth_shared i32 (List_Cons 0 l1) 1 in
if not (i1 = 1)
then Fail Failure
else
- let* i2 = list_nth_shared_fwd i32 (ListCons 0 l1) 2 in
+ let* i2 = list_nth_shared i32 (List_Cons 0 l1) 2 in
if not (i2 = 2)
then Fail Failure
else
- let* ls = list_nth_mut_back i32 (ListCons 0 l1) 1 3 in
- let* i3 = list_nth_shared_fwd i32 ls 0 in
+ let* ls = list_nth_mut_back i32 (List_Cons 0 l1) 1 3 in
+ let* i3 = list_nth_shared i32 ls 0 in
if not (i3 = 0)
then Fail Failure
else
- let* i4 = list_nth_shared_fwd i32 ls 1 in
+ let* i4 = list_nth_shared i32 ls 1 in
if not (i4 = 3)
then Fail Failure
else
- let* i5 = list_nth_shared_fwd i32 ls 2 in
+ let* i5 = list_nth_shared i32 ls 2 in
if not (i5 = 2) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_list_functions] *)
-let _ = assert_norm (test_list_functions_fwd = Return ())
+let _ = assert_norm (test_list_functions = Return ())
(** [no_nested_borrows::id_mut_pair1]: forward function *)
-let id_mut_pair1_fwd (t1 t2 : Type0) (x : t1) (y : t2) : result (t1 & t2) =
+let id_mut_pair1 (t1 t2 : Type0) (x : t1) (y : t2) : result (t1 & t2) =
Return (x, y)
(** [no_nested_borrows::id_mut_pair1]: backward function 0 *)
@@ -313,7 +322,7 @@ let id_mut_pair1_back
let (x0, x1) = ret in Return (x0, x1)
(** [no_nested_borrows::id_mut_pair2]: forward function *)
-let id_mut_pair2_fwd (t1 t2 : Type0) (p : (t1 & t2)) : result (t1 & t2) =
+let id_mut_pair2 (t1 t2 : Type0) (p : (t1 & t2)) : result (t1 & t2) =
let (x, x0) = p in Return (x, x0)
(** [no_nested_borrows::id_mut_pair2]: backward function 0 *)
@@ -322,7 +331,7 @@ let id_mut_pair2_back
let (x, x0) = ret in Return (x, x0)
(** [no_nested_borrows::id_mut_pair3]: forward function *)
-let id_mut_pair3_fwd (t1 t2 : Type0) (x : t1) (y : t2) : result (t1 & t2) =
+let id_mut_pair3 (t1 t2 : Type0) (x : t1) (y : t2) : result (t1 & t2) =
Return (x, y)
(** [no_nested_borrows::id_mut_pair3]: backward function 0 *)
@@ -336,7 +345,7 @@ let id_mut_pair3_back'b
Return ret
(** [no_nested_borrows::id_mut_pair4]: forward function *)
-let id_mut_pair4_fwd (t1 t2 : Type0) (p : (t1 & t2)) : result (t1 & t2) =
+let id_mut_pair4 (t1 t2 : Type0) (p : (t1 & t2)) : result (t1 & t2) =
let (x, x0) = p in Return (x, x0)
(** [no_nested_borrows::id_mut_pair4]: backward function 0 *)
@@ -350,81 +359,76 @@ let id_mut_pair4_back'b
Return ret
(** [no_nested_borrows::StructWithTuple] *)
-type struct_with_tuple_t (t1 t2 : Type0) = { struct_with_tuple_p : (t1 & t2); }
+type structWithTuple_t (t1 t2 : Type0) = { p : (t1 & t2); }
(** [no_nested_borrows::new_tuple1]: forward function *)
-let new_tuple1_fwd : result (struct_with_tuple_t u32 u32) =
- Return { struct_with_tuple_p = (1, 2) }
+let new_tuple1 : result (structWithTuple_t u32 u32) =
+ Return { p = (1, 2) }
(** [no_nested_borrows::new_tuple2]: forward function *)
-let new_tuple2_fwd : result (struct_with_tuple_t i16 i16) =
- Return { struct_with_tuple_p = (1, 2) }
+let new_tuple2 : result (structWithTuple_t i16 i16) =
+ Return { p = (1, 2) }
(** [no_nested_borrows::new_tuple3]: forward function *)
-let new_tuple3_fwd : result (struct_with_tuple_t u64 i64) =
- Return { struct_with_tuple_p = (1, 2) }
+let new_tuple3 : result (structWithTuple_t u64 i64) =
+ Return { p = (1, 2) }
(** [no_nested_borrows::StructWithPair] *)
-type struct_with_pair_t (t1 t2 : Type0) =
-{
- struct_with_pair_p : pair_t t1 t2;
-}
+type structWithPair_t (t1 t2 : Type0) = { p : pair_t t1 t2; }
(** [no_nested_borrows::new_pair1]: forward function *)
-let new_pair1_fwd : result (struct_with_pair_t u32 u32) =
- Return { struct_with_pair_p = { pair_x = 1; pair_y = 2 } }
+let new_pair1 : result (structWithPair_t u32 u32) =
+ Return { p = { x = 1; y = 2 } }
(** [no_nested_borrows::test_constants]: forward function *)
-let test_constants_fwd : result unit =
- let* swt = new_tuple1_fwd in
- let (i, _) = swt.struct_with_tuple_p in
+let test_constants : result unit =
+ let* swt = new_tuple1 in
+ let (i, _) = swt.p in
if not (i = 1)
then Fail Failure
else
- let* swt0 = new_tuple2_fwd in
- let (i0, _) = swt0.struct_with_tuple_p in
+ let* swt0 = new_tuple2 in
+ let (i0, _) = swt0.p in
if not (i0 = 1)
then Fail Failure
else
- let* swt1 = new_tuple3_fwd in
- let (i1, _) = swt1.struct_with_tuple_p in
+ let* swt1 = new_tuple3 in
+ let (i1, _) = swt1.p in
if not (i1 = 1)
then Fail Failure
else
- let* swp = new_pair1_fwd in
- if not (swp.struct_with_pair_p.pair_x = 1)
- then Fail Failure
- else Return ()
+ let* swp = new_pair1 in
+ if not (swp.p.x = 1) then Fail Failure else Return ()
(** Unit test for [no_nested_borrows::test_constants] *)
-let _ = assert_norm (test_constants_fwd = Return ())
+let _ = assert_norm (test_constants = Return ())
(** [no_nested_borrows::test_weird_borrows1]: forward function *)
-let test_weird_borrows1_fwd : result unit =
+let test_weird_borrows1 : result unit =
Return ()
(** Unit test for [no_nested_borrows::test_weird_borrows1] *)
-let _ = assert_norm (test_weird_borrows1_fwd = Return ())
+let _ = assert_norm (test_weird_borrows1 = Return ())
(** [no_nested_borrows::test_mem_replace]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let test_mem_replace_fwd_back (px : u32) : result u32 =
- let y = mem_replace_fwd u32 px 1 in
+let test_mem_replace (px : u32) : result u32 =
+ let y = core_mem_replace u32 px 1 in
if not (y = 0) then Fail Failure else Return 2
(** [no_nested_borrows::test_shared_borrow_bool1]: forward function *)
-let test_shared_borrow_bool1_fwd (b : bool) : result u32 =
+let test_shared_borrow_bool1 (b : bool) : result u32 =
if b then Return 0 else Return 1
(** [no_nested_borrows::test_shared_borrow_bool2]: forward function *)
-let test_shared_borrow_bool2_fwd : result u32 =
+let test_shared_borrow_bool2 : result u32 =
Return 0
(** [no_nested_borrows::test_shared_borrow_enum1]: forward function *)
-let test_shared_borrow_enum1_fwd (l : list_t u32) : result u32 =
- begin match l with | ListCons i l0 -> Return 1 | ListNil -> Return 0 end
+let test_shared_borrow_enum1 (l : list_t u32) : result u32 =
+ begin match l with | List_Cons i l0 -> Return 1 | List_Nil -> Return 0 end
(** [no_nested_borrows::test_shared_borrow_enum2]: forward function *)
-let test_shared_borrow_enum2_fwd : result u32 =
+let test_shared_borrow_enum2 : result u32 =
Return 0
diff --git a/tests/fstar/misc/Paper.fst b/tests/fstar/misc/Paper.fst
index e2d692c2..bfb710dc 100644
--- a/tests/fstar/misc/Paper.fst
+++ b/tests/fstar/misc/Paper.fst
@@ -7,19 +7,18 @@ open Primitives
(** [paper::ref_incr]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-let ref_incr_fwd_back (x : i32) : result i32 =
+let ref_incr (x : i32) : result i32 =
i32_add x 1
(** [paper::test_incr]: forward function *)
-let test_incr_fwd : result unit =
- let* x = ref_incr_fwd_back 0 in
- if not (x = 1) then Fail Failure else Return ()
+let test_incr : result unit =
+ let* x = ref_incr 0 in if not (x = 1) then Fail Failure else Return ()
(** Unit test for [paper::test_incr] *)
-let _ = assert_norm (test_incr_fwd = Return ())
+let _ = assert_norm (test_incr = Return ())
(** [paper::choose]: forward function *)
-let choose_fwd (t : Type0) (b : bool) (x : t) (y : t) : result t =
+let choose (t : Type0) (b : bool) (x : t) (y : t) : result t =
if b then Return x else Return y
(** [paper::choose]: backward function 0 *)
@@ -28,8 +27,8 @@ let choose_back
if b then Return (ret, y) else Return (x, ret)
(** [paper::test_choose]: forward function *)
-let test_choose_fwd : result unit =
- let* z = choose_fwd i32 true 0 0 in
+let test_choose : result unit =
+ let* z = choose i32 true 0 0 in
let* z0 = i32_add z 1 in
if not (z0 = 1)
then Fail Failure
@@ -40,62 +39,60 @@ let test_choose_fwd : result unit =
else if not (y = 0) then Fail Failure else Return ()
(** Unit test for [paper::test_choose] *)
-let _ = assert_norm (test_choose_fwd = Return ())
+let _ = assert_norm (test_choose = Return ())
(** [paper::List] *)
type list_t (t : Type0) =
-| ListCons : t -> list_t t -> list_t t
-| ListNil : list_t t
+| List_Cons : t -> list_t t -> list_t t
+| List_Nil : list_t t
(** [paper::list_nth_mut]: forward function *)
-let rec list_nth_mut_fwd (t : Type0) (l : list_t t) (i : u32) : result t =
+let rec list_nth_mut (t : Type0) (l : list_t t) (i : u32) : result t =
begin match l with
- | ListCons x tl ->
- if i = 0
- then Return x
- else let* i0 = u32_sub i 1 in list_nth_mut_fwd t tl i0
- | ListNil -> Fail Failure
+ | List_Cons x tl ->
+ if i = 0 then Return x else let* i0 = u32_sub i 1 in list_nth_mut t tl i0
+ | List_Nil -> Fail Failure
end
(** [paper::list_nth_mut]: backward function 0 *)
let rec list_nth_mut_back
(t : Type0) (l : list_t t) (i : u32) (ret : t) : result (list_t t) =
begin match l with
- | ListCons x tl ->
+ | List_Cons x tl ->
if i = 0
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else
let* i0 = u32_sub i 1 in
let* tl0 = list_nth_mut_back t tl i0 ret in
- Return (ListCons x tl0)
- | ListNil -> Fail Failure
+ Return (List_Cons x tl0)
+ | List_Nil -> Fail Failure
end
(** [paper::sum]: forward function *)
-let rec sum_fwd (l : list_t i32) : result i32 =
+let rec sum (l : list_t i32) : result i32 =
begin match l with
- | ListCons x tl -> let* i = sum_fwd tl in i32_add x i
- | ListNil -> Return 0
+ | List_Cons x tl -> let* i = sum tl in i32_add x i
+ | List_Nil -> Return 0
end
(** [paper::test_nth]: forward function *)
-let test_nth_fwd : result unit =
- let l = ListNil in
- let l0 = ListCons 3 l in
- let l1 = ListCons 2 l0 in
- let* x = list_nth_mut_fwd i32 (ListCons 1 l1) 2 in
+let test_nth : result unit =
+ let l = List_Nil in
+ let l0 = List_Cons 3 l in
+ let l1 = List_Cons 2 l0 in
+ let* x = list_nth_mut i32 (List_Cons 1 l1) 2 in
let* x0 = i32_add x 1 in
- let* l2 = list_nth_mut_back i32 (ListCons 1 l1) 2 x0 in
- let* i = sum_fwd l2 in
+ let* l2 = list_nth_mut_back i32 (List_Cons 1 l1) 2 x0 in
+ let* i = sum l2 in
if not (i = 7) then Fail Failure else Return ()
(** Unit test for [paper::test_nth] *)
-let _ = assert_norm (test_nth_fwd = Return ())
+let _ = assert_norm (test_nth = Return ())
(** [paper::call_choose]: forward function *)
-let call_choose_fwd (p : (u32 & u32)) : result u32 =
+let call_choose (p : (u32 & u32)) : result u32 =
let (px, py) = p in
- let* pz = choose_fwd u32 true px py in
+ let* pz = choose u32 true px py in
let* pz0 = u32_add pz 1 in
let* (px0, _) = choose_back u32 true px py pz0 in
Return px0
diff --git a/tests/fstar/misc/PoloniusList.fst b/tests/fstar/misc/PoloniusList.fst
index 79c86606..428c4210 100644
--- a/tests/fstar/misc/PoloniusList.fst
+++ b/tests/fstar/misc/PoloniusList.fst
@@ -7,25 +7,25 @@ open Primitives
(** [polonius_list::List] *)
type list_t (t : Type0) =
-| ListCons : t -> list_t t -> list_t t
-| ListNil : list_t t
+| List_Cons : t -> list_t t -> list_t t
+| List_Nil : list_t t
(** [polonius_list::get_list_at_x]: forward function *)
-let rec get_list_at_x_fwd (ls : list_t u32) (x : u32) : result (list_t u32) =
+let rec get_list_at_x (ls : list_t u32) (x : u32) : result (list_t u32) =
begin match ls with
- | ListCons hd tl ->
- if hd = x then Return (ListCons hd tl) else get_list_at_x_fwd tl x
- | ListNil -> Return ListNil
+ | List_Cons hd tl ->
+ if hd = x then Return (List_Cons hd tl) else get_list_at_x tl x
+ | List_Nil -> Return List_Nil
end
(** [polonius_list::get_list_at_x]: backward function 0 *)
let rec get_list_at_x_back
(ls : list_t u32) (x : u32) (ret : list_t u32) : result (list_t u32) =
begin match ls with
- | ListCons hd tl ->
+ | List_Cons hd tl ->
if hd = x
then Return ret
- else let* tl0 = get_list_at_x_back tl x ret in Return (ListCons hd tl0)
- | ListNil -> Return ret
+ else let* tl0 = get_list_at_x_back tl x ret in Return (List_Cons hd tl0)
+ | List_Nil -> Return ret
end
diff --git a/tests/fstar/misc/Primitives.fst b/tests/fstar/misc/Primitives.fst
index 9db82069..3297803c 100644
--- a/tests/fstar/misc/Primitives.fst
+++ b/tests/fstar/misc/Primitives.fst
@@ -55,8 +55,12 @@ type string = string
let is_zero (n: nat) : bool = n = 0
let decrease (n: nat{n > 0}) : nat = n - 1
-let mem_replace_fwd (a : Type0) (x : a) (y : a) : a = x
-let mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
(*** Scalars *)
/// Rem.: most of the following code was partially generated
@@ -100,6 +104,11 @@ type scalar_ty =
| U64
| U128
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
let scalar_min (ty : scalar_ty) : int =
match ty with
| Isize -> isize_min
@@ -162,6 +171,15 @@ let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scala
let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
mk_scalar ty (x * y)
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
(** Cast an integer from a [src_ty] to a [tgt_ty] *)
// TODO: check the semantics of casts in Rust
let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
@@ -169,17 +187,44 @@ let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) :
/// The scalar types
type isize : eqtype = scalar Isize
-type i8 : eqtype = scalar I8
-type i16 : eqtype = scalar I16
-type i32 : eqtype = scalar I32
-type i64 : eqtype = scalar I64
-type i128 : eqtype = scalar I128
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
type usize : eqtype = scalar Usize
-type u8 : eqtype = scalar U8
-type u16 : eqtype = scalar U16
-type u32 : eqtype = scalar U32
-type u64 : eqtype = scalar U64
-type u128 : eqtype = scalar U128
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
/// Negation
let isize_neg = scalar_neg #Isize
@@ -231,7 +276,7 @@ let u32_add = scalar_add #U32
let u64_add = scalar_add #U64
let u128_add = scalar_add #U128
-/// Substraction
+/// Subtraction
let isize_sub = scalar_sub #Isize
let i8_sub = scalar_sub #I8
let i16_sub = scalar_sub #I16
@@ -259,12 +304,65 @@ let u32_mul = scalar_mul #U32
let u64_mul = scalar_mul #U64
let u128_mul = scalar_mul #U128
-(*** Range *)
-type range (a : Type0) = {
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
start : a;
end_ : a;
}
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
(*** Array *)
type array (a : Type0) (n : usize) = s:list a{length s = n}
@@ -278,15 +376,11 @@ let mk_array (a : Type0) (n : usize)
normalize_term_spec (FStar.List.Tot.length l);
l
-let array_index_shared (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let array_index_mut_fwd (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let array_index_mut_back (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
if i < length x then Return (list_update x i nx)
else Fail Failure
@@ -295,55 +389,54 @@ type slice (a : Type0) = s:list a{length s <= usize_max}
let slice_len (a : Type0) (s : slice a) : usize = length s
-let slice_index_shared (a : Type0) (x : slice a) (i : usize) : result a =
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
if i < length x then Return (index x i)
else Fail Failure
-let slice_index_mut_fwd (a : Type0) (x : slice a) (i : usize) : result a =
- if i < length x then Return (index x i)
- else Fail Failure
-
-let slice_index_mut_back (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
if i < length x then Return (list_update x i nx)
else Fail Failure
(*** Subslices *)
-let array_to_slice_shared (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_fwd (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
-let array_to_slice_mut_back (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
if length s = n then Return s
else Fail Failure
// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
-let array_subslice_shared (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
- admit()
-
-let array_subslice_mut_fwd (a : Type0) (n : usize) (x : array a n) (r : range usize) : result (slice a) =
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let array_subslice_mut_back (a : Type0) (n : usize) (x : array a n) (r : range usize) (ns : slice a) : result (array a n) =
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
admit()
-let slice_subslice_shared (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
admit()
-let slice_subslice_mut_fwd (a : Type0) (x : slice a) (r : range usize) : result (slice a) =
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
admit()
-let slice_subslice_mut_back (a : Type0) (x : slice a) (r : range usize) (ns : slice a) : result (slice a) =
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
admit()
(*** Vector *)
-type vec (a : Type0) = v:list a{length v <= usize_max}
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
-let vec_new (a : Type0) : vec a = assert_norm(length #a [] == 0); []
-let vec_len (a : Type0) (v : vec a) : usize = length v
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
// The **forward** function shouldn't be used
-let vec_push_fwd (a : Type0) (v : vec a) (x : a) : unit = ()
-let vec_push_back (a : Type0) (v : vec a) (x : a) :
- Pure (result (vec a))
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
(requires True)
(ensures (fun res ->
match res with
@@ -358,18 +451,279 @@ let vec_push_back (a : Type0) (v : vec a) (x : a) :
else Fail Failure
// The **forward** function shouldn't be used
-let vec_insert_fwd (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
if i < length v then Return () else Fail Failure
-let vec_insert_back (a : Type0) (v : vec a) (i : usize) (x : a) : result (vec a) =
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
if i < length v then Return (list_update v i x) else Fail Failure
-// The **backward** function shouldn't be used
-let vec_index_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_back (a : Type0) (v : vec a) (i : usize) (x : a) : result unit =
- if i < length v then Return () else Fail Failure
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
-let vec_index_mut_fwd (a : Type0) (v : vec a) (i : usize) : result a =
- if i < length v then Return (index v i) else Fail Failure
-let vec_index_mut_back (a : Type0) (v : vec a) (i : usize) (nx : a) : result (vec a) =
- if i < length v then Return (list_update v i nx) else Fail Failure
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/traits/Makefile b/tests/fstar/traits/Makefile
new file mode 100644
index 00000000..fa7d1f36
--- /dev/null
+++ b/tests/fstar/traits/Makefile
@@ -0,0 +1,49 @@
+# This file was automatically generated - modify ../Makefile.template instead
+INCLUDE_DIRS = .
+
+FSTAR_INCLUDES = $(addprefix --include ,$(INCLUDE_DIRS))
+
+FSTAR_HINTS ?= --use_hints --use_hint_hashes --record_hints
+
+FSTAR_OPTIONS = $(FSTAR_HINTS) \
+ --cache_checked_modules $(FSTAR_INCLUDES) --cmi \
+ --warn_error '+241@247+285-274' \
+
+FSTAR_EXE ?= fstar.exe
+FSTAR_NO_FLAGS = $(FSTAR_EXE) --already_cached 'Prims FStar LowStar Steel' --odir obj --cache_dir obj
+
+FSTAR = $(FSTAR_NO_FLAGS) $(FSTAR_OPTIONS)
+
+# The F* roots are used to compute the dependency graph, and generate the .depend file
+FSTAR_ROOTS ?= $(wildcard *.fst *.fsti)
+
+# Build all the files
+all: $(addprefix obj/,$(addsuffix .checked,$(FSTAR_ROOTS)))
+
+# This is the right way to ensure the .depend file always gets re-built.
+ifeq (,$(filter %-in,$(MAKECMDGOALS)))
+ifndef NODEPEND
+ifndef MAKE_RESTARTS
+.depend: .FORCE
+ $(FSTAR_NO_FLAGS) --dep full $(notdir $(FSTAR_ROOTS)) > $@
+
+.PHONY: .FORCE
+.FORCE:
+endif
+endif
+
+include .depend
+endif
+
+# For the interactive mode
+%.fst-in %.fsti-in:
+ @echo $(FSTAR_OPTIONS)
+
+# Generete the .checked files in batch mode
+%.checked:
+ $(FSTAR) $(FSTAR_OPTIONS) $< && \
+ touch -c $@
+
+.PHONY: clean
+clean:
+ rm -f obj/*
diff --git a/tests/fstar/traits/Primitives.fst b/tests/fstar/traits/Primitives.fst
new file mode 100644
index 00000000..3297803c
--- /dev/null
+++ b/tests/fstar/traits/Primitives.fst
@@ -0,0 +1,729 @@
+/// This file lists primitive and assumed functions and types
+module Primitives
+open FStar.Mul
+open FStar.List.Tot
+
+#set-options "--z3rlimit 15 --fuel 0 --ifuel 1"
+
+(*** Utilities *)
+val list_update (#a : Type0) (ls : list a) (i : nat{i < length ls}) (x : a) :
+ ls':list a{
+ length ls' = length ls /\
+ index ls' i == x
+ }
+#push-options "--fuel 1"
+let rec list_update #a ls i x =
+ match ls with
+ | x' :: ls -> if i = 0 then x :: ls else x' :: list_update ls (i-1) x
+#pop-options
+
+(*** Result *)
+type error : Type0 =
+| Failure
+| OutOfFuel
+
+type result (a : Type0) : Type0 =
+| Return : v:a -> result a
+| Fail : e:error -> result a
+
+// Monadic return operator
+unfold let return (#a : Type0) (x : a) : result a = Return x
+
+// Monadic bind operator.
+// Allows to use the notation:
+// ```
+// let* x = y in
+// ...
+// ```
+unfold let (let*) (#a #b : Type0) (m: result a)
+ (f: (x:a) -> Pure (result b) (requires (m == Return x)) (ensures fun _ -> True)) :
+ result b =
+ match m with
+ | Return x -> f x
+ | Fail e -> Fail e
+
+// Monadic assert(...)
+let massert (b:bool) : result unit = if b then Return () else Fail Failure
+
+// Normalize and unwrap a successful result (used for globals).
+let eval_global (#a : Type0) (x : result a{Return? (normalize_term x)}) : a = Return?.v x
+
+(*** Misc *)
+type char = FStar.Char.char
+type string = string
+
+let is_zero (n: nat) : bool = n = 0
+let decrease (n: nat{n > 0}) : nat = n - 1
+
+let core_mem_replace (a : Type0) (x : a) (y : a) : a = x
+let core_mem_replace_back (a : Type0) (x : a) (y : a) : a = y
+
+// We don't really use raw pointers for now
+type mut_raw_ptr (t : Type0) = { v : t }
+type const_raw_ptr (t : Type0) = { v : t }
+
+(*** Scalars *)
+/// Rem.: most of the following code was partially generated
+
+let isize_min : int = -9223372036854775808 // TODO: should be opaque
+let isize_max : int = 9223372036854775807 // TODO: should be opaque
+let i8_min : int = -128
+let i8_max : int = 127
+let i16_min : int = -32768
+let i16_max : int = 32767
+let i32_min : int = -2147483648
+let i32_max : int = 2147483647
+let i64_min : int = -9223372036854775808
+let i64_max : int = 9223372036854775807
+let i128_min : int = -170141183460469231731687303715884105728
+let i128_max : int = 170141183460469231731687303715884105727
+let usize_min : int = 0
+let usize_max : int = 4294967295 // TODO: should be opaque
+let u8_min : int = 0
+let u8_max : int = 255
+let u16_min : int = 0
+let u16_max : int = 65535
+let u32_min : int = 0
+let u32_max : int = 4294967295
+let u64_min : int = 0
+let u64_max : int = 18446744073709551615
+let u128_min : int = 0
+let u128_max : int = 340282366920938463463374607431768211455
+
+type scalar_ty =
+| Isize
+| I8
+| I16
+| I32
+| I64
+| I128
+| Usize
+| U8
+| U16
+| U32
+| U64
+| U128
+
+let is_unsigned = function
+ | Isize | I8 | I16 | I32 | I64 | I128 -> false
+ | Usize | U8 | U16 | U32 | U64 | U128 -> true
+
+
+let scalar_min (ty : scalar_ty) : int =
+ match ty with
+ | Isize -> isize_min
+ | I8 -> i8_min
+ | I16 -> i16_min
+ | I32 -> i32_min
+ | I64 -> i64_min
+ | I128 -> i128_min
+ | Usize -> usize_min
+ | U8 -> u8_min
+ | U16 -> u16_min
+ | U32 -> u32_min
+ | U64 -> u64_min
+ | U128 -> u128_min
+
+let scalar_max (ty : scalar_ty) : int =
+ match ty with
+ | Isize -> isize_max
+ | I8 -> i8_max
+ | I16 -> i16_max
+ | I32 -> i32_max
+ | I64 -> i64_max
+ | I128 -> i128_max
+ | Usize -> usize_max
+ | U8 -> u8_max
+ | U16 -> u16_max
+ | U32 -> u32_max
+ | U64 -> u64_max
+ | U128 -> u128_max
+
+type scalar (ty : scalar_ty) : eqtype = x:int{scalar_min ty <= x && x <= scalar_max ty}
+
+let mk_scalar (ty : scalar_ty) (x : int) : result (scalar ty) =
+ if scalar_min ty <= x && scalar_max ty >= x then Return x else Fail Failure
+
+let scalar_neg (#ty : scalar_ty) (x : scalar ty) : result (scalar ty) = mk_scalar ty (-x)
+
+let scalar_div (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
+ if y <> 0 then mk_scalar ty (x / y) else Fail Failure
+
+/// The remainder operation
+let int_rem (x : int) (y : int{y <> 0}) : int =
+ if x >= 0 then (x % y) else -(x % y)
+
+(* Checking consistency with Rust *)
+let _ = assert_norm(int_rem 1 2 = 1)
+let _ = assert_norm(int_rem (-1) 2 = -1)
+let _ = assert_norm(int_rem 1 (-2) = 1)
+let _ = assert_norm(int_rem (-1) (-2) = -1)
+
+let scalar_rem (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
+ if y <> 0 then mk_scalar ty (int_rem x y) else Fail Failure
+
+let scalar_add (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
+ mk_scalar ty (x + y)
+
+let scalar_sub (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
+ mk_scalar ty (x - y)
+
+let scalar_mul (#ty : scalar_ty) (x : scalar ty) (y : scalar ty) : result (scalar ty) =
+ mk_scalar ty (x * y)
+
+let scalar_lxor (#ty : scalar_ty { is_unsigned ty && ty <> Usize })
+ (x : scalar ty) (y : scalar ty) : scalar ty =
+ match ty with
+ | U8 -> FStar.UInt.logxor #8 x y
+ | U16 -> FStar.UInt.logxor #16 x y
+ | U32 -> FStar.UInt.logxor #32 x y
+ | U64 -> FStar.UInt.logxor #64 x y
+ | U128 -> FStar.UInt.logxor #128 x y
+
+(** Cast an integer from a [src_ty] to a [tgt_ty] *)
+// TODO: check the semantics of casts in Rust
+let scalar_cast (src_ty : scalar_ty) (tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) =
+ mk_scalar tgt_ty x
+
+/// The scalar types
+type isize : eqtype = scalar Isize
+type i8 : eqtype = scalar I8
+type i16 : eqtype = scalar I16
+type i32 : eqtype = scalar I32
+type i64 : eqtype = scalar I64
+type i128 : eqtype = scalar I128
+type usize : eqtype = scalar Usize
+type u8 : eqtype = scalar U8
+type u16 : eqtype = scalar U16
+type u32 : eqtype = scalar U32
+type u64 : eqtype = scalar U64
+type u128 : eqtype = scalar U128
+
+
+let core_isize_min : isize = isize_min
+let core_isize_max : isize = isize_max
+let core_i8_min : i8 = i8_min
+let core_i8_max : i8 = i8_max
+let core_i16_min : i16 = i16_min
+let core_i16_max : i16 = i16_max
+let core_i32_min : i32 = i32_min
+let core_i32_max : i32 = i32_max
+let core_i64_min : i64 = i64_min
+let core_i64_max : i64 = i64_max
+let core_i128_min : i128 = i128_min
+let core_i128_max : i128 = i128_max
+
+let core_usize_min : usize = usize_min
+let core_usize_max : usize = usize_max
+let core_u8_min : u8 = u8_min
+let core_u8_max : u8 = u8_max
+let core_u16_min : u16 = u16_min
+let core_u16_max : u16 = u16_max
+let core_u32_min : u32 = u32_min
+let core_u32_max : u32 = u32_max
+let core_u64_min : u64 = u64_min
+let core_u64_max : u64 = u64_max
+let core_u128_min : u128 = u128_min
+let core_u128_max : u128 = u128_max
+
+/// Negation
+let isize_neg = scalar_neg #Isize
+let i8_neg = scalar_neg #I8
+let i16_neg = scalar_neg #I16
+let i32_neg = scalar_neg #I32
+let i64_neg = scalar_neg #I64
+let i128_neg = scalar_neg #I128
+
+/// Division
+let isize_div = scalar_div #Isize
+let i8_div = scalar_div #I8
+let i16_div = scalar_div #I16
+let i32_div = scalar_div #I32
+let i64_div = scalar_div #I64
+let i128_div = scalar_div #I128
+let usize_div = scalar_div #Usize
+let u8_div = scalar_div #U8
+let u16_div = scalar_div #U16
+let u32_div = scalar_div #U32
+let u64_div = scalar_div #U64
+let u128_div = scalar_div #U128
+
+/// Remainder
+let isize_rem = scalar_rem #Isize
+let i8_rem = scalar_rem #I8
+let i16_rem = scalar_rem #I16
+let i32_rem = scalar_rem #I32
+let i64_rem = scalar_rem #I64
+let i128_rem = scalar_rem #I128
+let usize_rem = scalar_rem #Usize
+let u8_rem = scalar_rem #U8
+let u16_rem = scalar_rem #U16
+let u32_rem = scalar_rem #U32
+let u64_rem = scalar_rem #U64
+let u128_rem = scalar_rem #U128
+
+/// Addition
+let isize_add = scalar_add #Isize
+let i8_add = scalar_add #I8
+let i16_add = scalar_add #I16
+let i32_add = scalar_add #I32
+let i64_add = scalar_add #I64
+let i128_add = scalar_add #I128
+let usize_add = scalar_add #Usize
+let u8_add = scalar_add #U8
+let u16_add = scalar_add #U16
+let u32_add = scalar_add #U32
+let u64_add = scalar_add #U64
+let u128_add = scalar_add #U128
+
+/// Subtraction
+let isize_sub = scalar_sub #Isize
+let i8_sub = scalar_sub #I8
+let i16_sub = scalar_sub #I16
+let i32_sub = scalar_sub #I32
+let i64_sub = scalar_sub #I64
+let i128_sub = scalar_sub #I128
+let usize_sub = scalar_sub #Usize
+let u8_sub = scalar_sub #U8
+let u16_sub = scalar_sub #U16
+let u32_sub = scalar_sub #U32
+let u64_sub = scalar_sub #U64
+let u128_sub = scalar_sub #U128
+
+/// Multiplication
+let isize_mul = scalar_mul #Isize
+let i8_mul = scalar_mul #I8
+let i16_mul = scalar_mul #I16
+let i32_mul = scalar_mul #I32
+let i64_mul = scalar_mul #I64
+let i128_mul = scalar_mul #I128
+let usize_mul = scalar_mul #Usize
+let u8_mul = scalar_mul #U8
+let u16_mul = scalar_mul #U16
+let u32_mul = scalar_mul #U32
+let u64_mul = scalar_mul #U64
+let u128_mul = scalar_mul #U128
+
+/// Logical operators, defined for unsigned types only, so far
+let u8_xor = scalar_lxor #U8
+let u16_xor = scalar_lxor #U16
+let u32_xor = scalar_lxor #U32
+let u64_xor = scalar_lxor #U64
+let u128_xor = scalar_lxor #U128
+
+(*** core::ops *)
+
+// Trait declaration: [core::ops::index::Index]
+noeq type core_ops_index_Index (self idx : Type0) = {
+ output : Type0;
+ index : self → idx → result output
+}
+
+// Trait declaration: [core::ops::index::IndexMut]
+noeq type core_ops_index_IndexMut (self idx : Type0) = {
+ indexInst : core_ops_index_Index self idx;
+ index_mut : self → idx → result indexInst.output;
+ index_mut_back : self → idx → indexInst.output → result self;
+}
+
+// Trait declaration [core::ops::deref::Deref]
+noeq type core_ops_deref_Deref (self : Type0) = {
+ target : Type0;
+ deref : self → result target;
+}
+
+// Trait declaration [core::ops::deref::DerefMut]
+noeq type core_ops_deref_DerefMut (self : Type0) = {
+ derefInst : core_ops_deref_Deref self;
+ deref_mut : self → result derefInst.target;
+ deref_mut_back : self → derefInst.target → result self;
+}
+
+type core_ops_range_Range (a : Type0) = {
+ start : a;
+ end_ : a;
+}
+
+(*** [alloc] *)
+
+let alloc_boxed_Box_deref (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut (t : Type0) (x : t) : result t = Return x
+let alloc_boxed_Box_deref_mut_back (t : Type) (_ : t) (x : t) : result t = Return x
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefInst (self : Type0) : core_ops_deref_Deref self = {
+ target = self;
+ deref = alloc_boxed_Box_deref self;
+}
+
+// Trait instance
+let alloc_boxed_Box_coreOpsDerefMutInst (self : Type0) : core_ops_deref_DerefMut self = {
+ derefInst = alloc_boxed_Box_coreOpsDerefInst self;
+ deref_mut = alloc_boxed_Box_deref_mut self;
+ deref_mut_back = alloc_boxed_Box_deref_mut_back self;
+}
+
+(*** Array *)
+type array (a : Type0) (n : usize) = s:list a{length s = n}
+
+// We tried putting the normalize_term condition as a refinement on the list
+// but it didn't work. It works with the requires clause.
+let mk_array (a : Type0) (n : usize)
+ (l : list a) :
+ Pure (array a n)
+ (requires (normalize_term(FStar.List.Tot.length l) = n))
+ (ensures (fun _ -> True)) =
+ normalize_term_spec (FStar.List.Tot.length l);
+ l
+
+let array_index_usize (a : Type0) (n : usize) (x : array a n) (i : usize) : result a =
+ if i < length x then Return (index x i)
+ else Fail Failure
+
+let array_update_usize (a : Type0) (n : usize) (x : array a n) (i : usize) (nx : a) : result (array a n) =
+ if i < length x then Return (list_update x i nx)
+ else Fail Failure
+
+(*** Slice *)
+type slice (a : Type0) = s:list a{length s <= usize_max}
+
+let slice_len (a : Type0) (s : slice a) : usize = length s
+
+let slice_index_usize (a : Type0) (x : slice a) (i : usize) : result a =
+ if i < length x then Return (index x i)
+ else Fail Failure
+
+let slice_update_usize (a : Type0) (x : slice a) (i : usize) (nx : a) : result (slice a) =
+ if i < length x then Return (list_update x i nx)
+ else Fail Failure
+
+(*** Subslices *)
+
+let array_to_slice (a : Type0) (n : usize) (x : array a n) : result (slice a) = Return x
+let array_from_slice (a : Type0) (n : usize) (x : array a n) (s : slice a) : result (array a n) =
+ if length s = n then Return s
+ else Fail Failure
+
+// TODO: finish the definitions below (there lacks [List.drop] and [List.take] in the standard library *)
+let array_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) : result (slice a) =
+ admit()
+
+let array_update_subslice (a : Type0) (n : usize) (x : array a n) (r : core_ops_range_Range usize) (ns : slice a) : result (array a n) =
+ admit()
+
+let array_repeat (a : Type0) (n : usize) (x : a) : array a n =
+ admit()
+
+let slice_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) : result (slice a) =
+ admit()
+
+let slice_update_subslice (a : Type0) (x : slice a) (r : core_ops_range_Range usize) (ns : slice a) : result (slice a) =
+ admit()
+
+(*** Vector *)
+type alloc_vec_Vec (a : Type0) = v:list a{length v <= usize_max}
+
+let alloc_vec_Vec_new (a : Type0) : alloc_vec_Vec a = assert_norm(length #a [] == 0); []
+let alloc_vec_Vec_len (a : Type0) (v : alloc_vec_Vec a) : usize = length v
+
+// Helper
+let alloc_vec_Vec_index_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) : result a =
+ if i < length v then Return (index v i) else Fail Failure
+// Helper
+let alloc_vec_Vec_update_usize (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
+
+// The **forward** function shouldn't be used
+let alloc_vec_Vec_push_fwd (a : Type0) (v : alloc_vec_Vec a) (x : a) : unit = ()
+let alloc_vec_Vec_push (a : Type0) (v : alloc_vec_Vec a) (x : a) :
+ Pure (result (alloc_vec_Vec a))
+ (requires True)
+ (ensures (fun res ->
+ match res with
+ | Fail e -> e == Failure
+ | Return v' -> length v' = length v + 1)) =
+ if length v < usize_max then begin
+ (**) assert_norm(length [x] == 1);
+ (**) append_length v [x];
+ (**) assert(length (append v [x]) = length v + 1);
+ Return (append v [x])
+ end
+ else Fail Failure
+
+// The **forward** function shouldn't be used
+let alloc_vec_Vec_insert_fwd (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result unit =
+ if i < length v then Return () else Fail Failure
+let alloc_vec_Vec_insert (a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) : result (alloc_vec_Vec a) =
+ if i < length v then Return (list_update v i x) else Fail Failure
+
+// Trait declaration: [core::slice::index::private_slice_index::Sealed]
+type core_slice_index_private_slice_index_Sealed (self : Type0) = unit
+
+// Trait declaration: [core::slice::index::SliceIndex]
+noeq type core_slice_index_SliceIndex (self t : Type0) = {
+ sealedInst : core_slice_index_private_slice_index_Sealed self;
+ output : Type0;
+ get : self → t → result (option output);
+ get_mut : self → t → result (option output);
+ get_mut_back : self → t → option output → result t;
+ get_unchecked : self → const_raw_ptr t → result (const_raw_ptr output);
+ get_unchecked_mut : self → mut_raw_ptr t → result (mut_raw_ptr output);
+ index : self → t → result output;
+ index_mut : self → t → result output;
+ index_mut_back : self → t → output → result t;
+}
+
+// [core::slice::index::[T]::index]: forward function
+let core_slice_index_Slice_index
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (s : slice t) (i : idx) : result inst.output =
+ let* x = inst.get i s in
+ match x with
+ | None -> Fail Failure
+ | Some x -> Return x
+
+// [core::slice::index::Range:::get]: forward function
+let core_slice_index_Range_get (t : Type0) (i : core_ops_range_Range usize) (s : slice t) :
+ result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: forward function
+let core_slice_index_Range_get_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (option (slice t)) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_mut]: backward function 0
+let core_slice_index_Range_get_mut_back
+ (t : Type0) :
+ core_ops_range_Range usize → slice t → option (slice t) → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::get_unchecked]: forward function
+let core_slice_index_Range_get_unchecked
+ (t : Type0) :
+ core_ops_range_Range usize → const_raw_ptr (slice t) → result (const_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::get_unchecked_mut]: forward function
+let core_slice_index_Range_get_unchecked_mut
+ (t : Type0) :
+ core_ops_range_Range usize → mut_raw_ptr (slice t) → result (mut_raw_ptr (slice t)) =
+ // Don't know what the model should be - for now we always fail to make
+ // sure code which uses it fails
+ fun _ _ -> Fail Failure
+
+// [core::slice::index::Range::index]: forward function
+let core_slice_index_Range_index
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: forward function
+let core_slice_index_Range_index_mut
+ (t : Type0) : core_ops_range_Range usize → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::Range::index_mut]: backward function 0
+let core_slice_index_Range_index_mut_back
+ (t : Type0) : core_ops_range_Range usize → slice t → slice t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::[T]::index_mut]: forward function
+let core_slice_index_Slice_index_mut
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → result inst.output =
+ admit () //
+
+// [core::slice::index::[T]::index_mut]: backward function 0
+let core_slice_index_Slice_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t)) :
+ slice t → idx → inst.output → result (slice t) =
+ admit () // TODO
+
+// [core::array::[T; N]::index]: forward function
+let core_array_Array_index
+ (t idx : Type0) (n : usize) (inst : core_ops_index_Index (slice t) idx)
+ (a : array t n) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: forward function
+let core_array_Array_index_mut
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) : result inst.indexInst.output =
+ admit () // TODO
+
+// [core::array::[T; N]::index_mut]: backward function 0
+let core_array_Array_index_mut_back
+ (t idx : Type0) (n : usize) (inst : core_ops_index_IndexMut (slice t) idx)
+ (a : array t n) (i : idx) (x : inst.indexInst.output) : result (array t n) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (slice t) idx = {
+ output = inst.output;
+ index = core_slice_index_Slice_index t idx inst;
+}
+
+// Trait implementation: [core::slice::index::private_slice_index::Range]
+let core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) = ()
+
+// Trait implementation: [core::slice::index::Range]
+let core_slice_index_Range_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ output = slice t;
+ get = core_slice_index_Range_get t;
+ get_mut = core_slice_index_Range_get_mut t;
+ get_mut_back = core_slice_index_Range_get_mut_back t;
+ get_unchecked = core_slice_index_Range_get_unchecked t;
+ get_unchecked_mut = core_slice_index_Range_get_unchecked_mut t;
+ index = core_slice_index_Range_index t;
+ index_mut = core_slice_index_Range_index_mut t;
+ index_mut_back = core_slice_index_Range_index_mut_back t;
+}
+
+// Trait implementation: [core::slice::index::[T]]
+let core_slice_index_Slice_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (slice t) idx = {
+ indexInst = core_slice_index_Slice_coreopsindexIndexInst t idx inst;
+ index_mut = core_slice_index_Slice_index_mut t idx inst;
+ index_mut_back = core_slice_index_Slice_index_mut_back t idx inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_Index (slice t) idx) :
+ core_ops_index_Index (array t n) idx = {
+ output = inst.output;
+ index = core_array_Array_index t idx n inst;
+}
+
+// Trait implementation: [core::array::[T; N]]
+let core_array_Array_coreopsindexIndexMutInst (t idx : Type0) (n : usize)
+ (inst : core_ops_index_IndexMut (slice t) idx) :
+ core_ops_index_IndexMut (array t n) idx = {
+ indexInst = core_array_Array_coreopsindexIndexInst t idx n inst.indexInst;
+ index_mut = core_array_Array_index_mut t idx n inst;
+ index_mut_back = core_array_Array_index_mut_back t idx n inst;
+}
+
+// [core::slice::index::usize::get]: forward function
+let core_slice_index_usize_get
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: forward function
+let core_slice_index_usize_get_mut
+ (t : Type0) : usize → slice t → result (option t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_mut]: backward function 0
+let core_slice_index_usize_get_mut_back
+ (t : Type0) : usize → slice t → option t → result (slice t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked]: forward function
+let core_slice_index_usize_get_unchecked
+ (t : Type0) : usize → const_raw_ptr (slice t) → result (const_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::get_unchecked_mut]: forward function
+let core_slice_index_usize_get_unchecked_mut
+ (t : Type0) : usize → mut_raw_ptr (slice t) → result (mut_raw_ptr t) =
+ admit () // TODO
+
+// [core::slice::index::usize::index]: forward function
+let core_slice_index_usize_index (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: forward function
+let core_slice_index_usize_index_mut (t : Type0) : usize → slice t → result t =
+ admit () // TODO
+
+// [core::slice::index::usize::index_mut]: backward function 0
+let core_slice_index_usize_index_mut_back
+ (t : Type0) : usize → slice t → t → result (slice t) =
+ admit () // TODO
+
+// Trait implementation: [core::slice::index::private_slice_index::usize]
+let core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize = ()
+
+// Trait implementation: [core::slice::index::usize]
+let core_slice_index_usize_coresliceindexSliceIndexInst (t : Type0) :
+ core_slice_index_SliceIndex usize (slice t) = {
+ sealedInst = core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ output = t;
+ get = core_slice_index_usize_get t;
+ get_mut = core_slice_index_usize_get_mut t;
+ get_mut_back = core_slice_index_usize_get_mut_back t;
+ get_unchecked = core_slice_index_usize_get_unchecked t;
+ get_unchecked_mut = core_slice_index_usize_get_unchecked_mut t;
+ index = core_slice_index_usize_index t;
+ index_mut = core_slice_index_usize_index_mut t;
+ index_mut_back = core_slice_index_usize_index_mut_back t;
+}
+
+// [alloc::vec::Vec::index]: forward function
+let alloc_vec_Vec_index (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: forward function
+let alloc_vec_Vec_index_mut (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) : result inst.output =
+ admit () // TODO
+
+// [alloc::vec::Vec::index_mut]: backward function 0
+let alloc_vec_Vec_index_mut_back
+ (t idx : Type0) (inst : core_slice_index_SliceIndex idx (slice t))
+ (self : alloc_vec_Vec t) (i : idx) (x : inst.output) : result (alloc_vec_Vec t) =
+ admit () // TODO
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_Index (alloc_vec_Vec t) idx = {
+ output = inst.output;
+ index = alloc_vec_Vec_index t idx inst;
+}
+
+// Trait implementation: [alloc::vec::Vec]
+let alloc_vec_Vec_coreopsindexIndexMutInst (t idx : Type0)
+ (inst : core_slice_index_SliceIndex idx (slice t)) :
+ core_ops_index_IndexMut (alloc_vec_Vec t) idx = {
+ indexInst = alloc_vec_Vec_coreopsindexIndexInst t idx inst;
+ index_mut = alloc_vec_Vec_index_mut t idx inst;
+ index_mut_back = alloc_vec_Vec_index_mut_back t idx inst;
+}
+
+(*** Theorems *)
+
+let alloc_vec_Vec_index_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) :
+ Lemma (
+ alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i ==
+ alloc_vec_Vec_index_usize v i)
+ [SMTPat (alloc_vec_Vec_index_mut a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i)]
+ =
+ admit()
+
+let alloc_vec_Vec_index_mut_back_eq (#a : Type0) (v : alloc_vec_Vec a) (i : usize) (x : a) :
+ Lemma (
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x ==
+ alloc_vec_Vec_update_usize v i x)
+ [SMTPat (alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x)]
+ =
+ admit()
diff --git a/tests/fstar/traits/Traits.fst b/tests/fstar/traits/Traits.fst
new file mode 100644
index 00000000..318efa2b
--- /dev/null
+++ b/tests/fstar/traits/Traits.fst
@@ -0,0 +1,371 @@
+(** THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS *)
+(** [traits] *)
+module Traits
+open Primitives
+
+#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
+
+(** Trait declaration: [traits::BoolTrait] *)
+noeq type boolTrait_t (self : Type0) = { get_bool : self -> result bool; }
+
+(** [traits::Bool::{0}::get_bool]: forward function *)
+let bool_get_bool (self : bool) : result bool =
+ Return self
+
+(** Trait implementation: [traits::Bool::{0}] *)
+let bool_BoolTraitInst : boolTrait_t bool = { get_bool = bool_get_bool; }
+
+(** [traits::BoolTrait::ret_true]: forward function *)
+let boolTrait_ret_true
+ (#self : Type0) (self_clause : boolTrait_t self) (self0 : self) :
+ result bool
+ =
+ Return true
+
+(** [traits::test_bool_trait_bool]: forward function *)
+let test_bool_trait_bool (x : bool) : result bool =
+ let* b = bool_get_bool x in
+ if b then boolTrait_ret_true bool_BoolTraitInst x else Return false
+
+(** [traits::Option::{1}::get_bool]: forward function *)
+let option_get_bool (t : Type0) (self : option t) : result bool =
+ begin match self with | None -> Return false | Some x -> Return true end
+
+(** Trait implementation: [traits::Option::{1}] *)
+let option_BoolTraitInst (t : Type0) : boolTrait_t (option t) = {
+ get_bool = option_get_bool t;
+}
+
+(** [traits::test_bool_trait_option]: forward function *)
+let test_bool_trait_option (t : Type0) (x : option t) : result bool =
+ let* b = option_get_bool t x in
+ if b then boolTrait_ret_true (option_BoolTraitInst t) x else Return false
+
+(** [traits::test_bool_trait]: forward function *)
+let test_bool_trait (t : Type0) (inst : boolTrait_t t) (x : t) : result bool =
+ inst.get_bool x
+
+(** Trait declaration: [traits::ToU64] *)
+noeq type toU64_t (self : Type0) = { to_u64 : self -> result u64; }
+
+(** [traits::u64::{2}::to_u64]: forward function *)
+let u64_to_u64 (self : u64) : result u64 =
+ Return self
+
+(** Trait implementation: [traits::u64::{2}] *)
+let u64_ToU64Inst : toU64_t u64 = { to_u64 = u64_to_u64; }
+
+(** [traits::Tuple2::{3}::to_u64]: forward function *)
+let tuple2_to_u64
+ (a : Type0) (inst : toU64_t a) (self : (a & a)) : result u64 =
+ let (x, x0) = self in
+ let* i = inst.to_u64 x in
+ let* i0 = inst.to_u64 x0 in
+ u64_add i i0
+
+(** Trait implementation: [traits::Tuple2::{3}] *)
+let tuple2_ToU64Inst (a : Type0) (inst : toU64_t a) : toU64_t (a & a) = {
+ to_u64 = tuple2_to_u64 a inst;
+}
+
+(** [traits::f]: forward function *)
+let f (t : Type0) (inst : toU64_t t) (x : (t & t)) : result u64 =
+ tuple2_to_u64 t inst x
+
+(** [traits::g]: forward function *)
+let g (t : Type0) (inst : toU64_t (t & t)) (x : (t & t)) : result u64 =
+ inst.to_u64 x
+
+(** [traits::h0]: forward function *)
+let h0 (x : u64) : result u64 =
+ u64_to_u64 x
+
+(** [traits::Wrapper] *)
+type wrapper_t (t : Type0) = { x : t; }
+
+(** [traits::Wrapper::{4}::to_u64]: forward function *)
+let wrapper_to_u64
+ (t : Type0) (inst : toU64_t t) (self : wrapper_t t) : result u64 =
+ inst.to_u64 self.x
+
+(** Trait implementation: [traits::Wrapper::{4}] *)
+let wrapper_ToU64Inst (t : Type0) (inst : toU64_t t) : toU64_t (wrapper_t t)
+ = {
+ to_u64 = wrapper_to_u64 t inst;
+}
+
+(** [traits::h1]: forward function *)
+let h1 (x : wrapper_t u64) : result u64 =
+ wrapper_to_u64 u64 u64_ToU64Inst x
+
+(** [traits::h2]: forward function *)
+let h2 (t : Type0) (inst : toU64_t t) (x : wrapper_t t) : result u64 =
+ wrapper_to_u64 t inst x
+
+(** Trait declaration: [traits::ToType] *)
+noeq type toType_t (self t : Type0) = { to_type : self -> result t; }
+
+(** [traits::u64::{5}::to_type]: forward function *)
+let u64_to_type (self : u64) : result bool =
+ Return (self > 0)
+
+(** Trait implementation: [traits::u64::{5}] *)
+let u64_ToTypeInst : toType_t u64 bool = { to_type = u64_to_type; }
+
+(** Trait declaration: [traits::OfType] *)
+noeq type ofType_t (self : Type0) = {
+ of_type : (t : Type0) -> (inst : toType_t t self) -> t -> result self;
+}
+
+(** [traits::h3]: forward function *)
+let h3
+ (t1 t2 : Type0) (inst : ofType_t t1) (inst0 : toType_t t2 t1) (y : t2) :
+ result t1
+ =
+ inst.of_type t2 inst0 y
+
+(** Trait declaration: [traits::OfTypeBis] *)
+noeq type ofTypeBis_t (self t : Type0) = {
+ parent_clause_0 : toType_t t self;
+ of_type : t -> result self;
+}
+
+(** [traits::h4]: forward function *)
+let h4
+ (t1 t2 : Type0) (inst : ofTypeBis_t t1 t2) (inst0 : toType_t t2 t1)
+ (y : t2) :
+ result t1
+ =
+ inst.of_type y
+
+(** [traits::TestType] *)
+type testType_t (t : Type0) = { _0 : t; }
+
+(** [traits::TestType::{6}::test::TestType1] *)
+type testType_test_TestType1_t = { _0 : u64; }
+
+(** Trait declaration: [traits::TestType::{6}::test::TestTrait] *)
+noeq type testType_test_TestTrait_t (self : Type0) = {
+ test : self -> result bool;
+}
+
+(** [traits::TestType::{6}::test::TestType1::{0}::test]: forward function *)
+let testType_test_TestType1_test
+ (self : testType_test_TestType1_t) : result bool =
+ Return (self._0 > 1)
+
+(** Trait implementation: [traits::TestType::{6}::test::TestType1::{0}] *)
+let testType_test_TestType1_TestType_test_TestTraitInst :
+ testType_test_TestTrait_t testType_test_TestType1_t = {
+ test = testType_test_TestType1_test;
+}
+
+(** [traits::TestType::{6}::test]: forward function *)
+let testType_test
+ (t : Type0) (inst : toU64_t t) (self : testType_t t) (x : t) : result bool =
+ let* x0 = inst.to_u64 x in
+ if x0 > 0 then testType_test_TestType1_test { _0 = 0 } else Return false
+
+(** [traits::BoolWrapper] *)
+type boolWrapper_t = { _0 : bool; }
+
+(** [traits::BoolWrapper::{7}::to_type]: forward function *)
+let boolWrapper_to_type
+ (t : Type0) (inst : toType_t bool t) (self : boolWrapper_t) : result t =
+ inst.to_type self._0
+
+(** Trait implementation: [traits::BoolWrapper::{7}] *)
+let boolWrapper_ToTypeInst (t : Type0) (inst : toType_t bool t) : toType_t
+ boolWrapper_t t = {
+ to_type = boolWrapper_to_type t inst;
+}
+
+(** [traits::WithConstTy::LEN2] *)
+let with_const_ty_len2_body : result usize = Return 32
+let with_const_ty_len2_c : usize = eval_global with_const_ty_len2_body
+
+(** Trait declaration: [traits::WithConstTy] *)
+noeq type withConstTy_t (self : Type0) (len : usize) = {
+ cLEN1 : usize;
+ cLEN2 : usize;
+ tV : Type0;
+ tW : Type0;
+ tW_clause_0 : toU64_t tW;
+ f : tW -> array u8 len -> result tW;
+}
+
+(** [traits::Bool::{8}::LEN1] *)
+let bool_len1_body : result usize = Return 12
+let bool_len1_c : usize = eval_global bool_len1_body
+
+(** [traits::Bool::{8}::f]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+let bool_f (i : u64) (a : array u8 32) : result u64 =
+ Return i
+
+(** Trait implementation: [traits::Bool::{8}] *)
+let bool_WithConstTyInst : withConstTy_t bool 32 = {
+ cLEN1 = bool_len1_c;
+ cLEN2 = with_const_ty_len2_c;
+ tV = u8;
+ tW = u64;
+ tW_clause_0 = u64_ToU64Inst;
+ f = bool_f;
+}
+
+(** [traits::use_with_const_ty1]: forward function *)
+let use_with_const_ty1
+ (h : Type0) (len : usize) (inst : withConstTy_t h len) : result usize =
+ let i = inst.cLEN1 in Return i
+
+(** [traits::use_with_const_ty2]: forward function *)
+let use_with_const_ty2
+ (h : Type0) (len : usize) (inst : withConstTy_t h len) (w : inst.tW) :
+ result unit
+ =
+ Return ()
+
+(** [traits::use_with_const_ty3]: forward function *)
+let use_with_const_ty3
+ (h : Type0) (len : usize) (inst : withConstTy_t h len) (x : inst.tW) :
+ result u64
+ =
+ inst.tW_clause_0.to_u64 x
+
+(** [traits::test_where1]: forward function *)
+let test_where1 (t : Type0) (_x : t) : result unit =
+ Return ()
+
+(** [traits::test_where2]: forward function *)
+let test_where2
+ (t : Type0) (inst : withConstTy_t t 32) (_x : u32) : result unit =
+ Return ()
+
+(** [alloc::string::String] *)
+assume type alloc_string_String_t : Type0
+
+(** Trait declaration: [traits::ParentTrait0] *)
+noeq type parentTrait0_t (self : Type0) = {
+ tW : Type0;
+ get_name : self -> result alloc_string_String_t;
+ get_w : self -> result tW;
+}
+
+(** Trait declaration: [traits::ParentTrait1] *)
+type parentTrait1_t (self : Type0) = unit
+
+(** Trait declaration: [traits::ChildTrait] *)
+noeq type childTrait_t (self : Type0) = {
+ parent_clause_0 : parentTrait0_t self;
+ parent_clause_1 : parentTrait1_t self;
+}
+
+(** [traits::test_child_trait1]: forward function *)
+let test_child_trait1
+ (t : Type0) (inst : childTrait_t t) (x : t) : result alloc_string_String_t =
+ inst.parent_clause_0.get_name x
+
+(** [traits::test_child_trait2]: forward function *)
+let test_child_trait2
+ (t : Type0) (inst : childTrait_t t) (x : t) :
+ result inst.parent_clause_0.tW
+ =
+ inst.parent_clause_0.get_w x
+
+(** [traits::order1]: forward function *)
+let order1
+ (t u : Type0) (inst : parentTrait0_t t) (inst0 : parentTrait0_t u) :
+ result unit
+ =
+ Return ()
+
+(** Trait declaration: [traits::ChildTrait1] *)
+noeq type childTrait1_t (self : Type0) = {
+ parent_clause_0 : parentTrait1_t self;
+}
+
+(** Trait implementation: [traits::usize::{9}] *)
+let usize_ParentTrait1Inst : parentTrait1_t usize = ()
+
+(** Trait implementation: [traits::usize::{10}] *)
+let usize_ChildTrait1Inst : childTrait1_t usize = {
+ parent_clause_0 = usize_ParentTrait1Inst;
+}
+
+(** Trait declaration: [traits::Iterator] *)
+noeq type iterator_t (self : Type0) = { tItem : Type0; }
+
+(** Trait declaration: [traits::IntoIterator] *)
+noeq type intoIterator_t (self : Type0) = {
+ tItem : Type0;
+ tIntoIter : Type0;
+ tIntoIter_clause_0 : iterator_t tIntoIter;
+ into_iter : self -> result tIntoIter;
+}
+
+(** Trait declaration: [traits::FromResidual] *)
+type fromResidual_t (self t : Type0) = unit
+
+(** Trait declaration: [traits::Try] *)
+noeq type try_t (self : Type0) = {
+ tResidual : Type0;
+ parent_clause_0 : fromResidual_t self tResidual;
+}
+
+(** Trait declaration: [traits::WithTarget] *)
+noeq type withTarget_t (self : Type0) = { tTarget : Type0; }
+
+(** Trait declaration: [traits::ParentTrait2] *)
+noeq type parentTrait2_t (self : Type0) = {
+ tU : Type0;
+ tU_clause_0 : withTarget_t tU;
+}
+
+(** Trait declaration: [traits::ChildTrait2] *)
+noeq type childTrait2_t (self : Type0) = {
+ parent_clause_0 : parentTrait2_t self;
+ convert : parent_clause_0.tU -> result parent_clause_0.tU_clause_0.tTarget;
+}
+
+(** Trait implementation: [traits::u32::{11}] *)
+let u32_WithTargetInst : withTarget_t u32 = { tTarget = u32; }
+
+(** Trait implementation: [traits::u32::{12}] *)
+let u32_ParentTrait2Inst : parentTrait2_t u32 = {
+ tU = u32;
+ tU_clause_0 = u32_WithTargetInst;
+}
+
+(** [traits::u32::{13}::convert]: forward function *)
+let u32_convert (x : u32) : result u32 =
+ Return x
+
+(** Trait implementation: [traits::u32::{13}] *)
+let u32_ChildTrait2Inst : childTrait2_t u32 = {
+ parent_clause_0 = u32_ParentTrait2Inst;
+ convert = u32_convert;
+}
+
+(** [traits::incr_u32]: forward function *)
+let incr_u32 (x : u32) : result u32 =
+ u32_add x 1
+
+(** Trait declaration: [traits::CFnOnce] *)
+noeq type cFnOnce_t (self args : Type0) = {
+ tOutput : Type0;
+ call_once : self -> args -> result tOutput;
+}
+
+(** Trait declaration: [traits::CFnMut] *)
+noeq type cFnMut_t (self args : Type0) = {
+ parent_clause_0 : cFnOnce_t self args;
+ call_mut : self -> args -> result parent_clause_0.tOutput;
+ call_mut_back : self -> args -> parent_clause_0.tOutput -> result self;
+}
+
+(** Trait declaration: [traits::CFn] *)
+noeq type cFn_t (self args : Type0) = {
+ parent_clause_0 : cFnMut_t self args;
+ call_mut : self -> args -> result parent_clause_0.parent_clause_0.tOutput;
+}
+