summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/coq/array/Array.v470
-rw-r--r--tests/coq/array/Array_Funs.v467
-rw-r--r--tests/coq/array/Array_Types.v14
-rw-r--r--tests/coq/array/Primitives.v419
-rw-r--r--tests/coq/array/_CoqProject3
-rw-r--r--tests/coq/betree/BetreeMain_Funs.v1075
-rw-r--r--tests/coq/betree/BetreeMain_Opaque.v18
-rw-r--r--tests/coq/betree/BetreeMain_Types.v92
-rw-r--r--tests/coq/betree/Primitives.v419
-rw-r--r--tests/coq/hashmap/Hashmap_Funs.v520
-rw-r--r--tests/coq/hashmap/Hashmap_Types.v30
-rw-r--r--tests/coq/hashmap/Primitives.v419
-rw-r--r--tests/coq/hashmap_on_disk/HashmapMain_Funs.v610
-rw-r--r--tests/coq/hashmap_on_disk/HashmapMain_Opaque.v8
-rw-r--r--tests/coq/hashmap_on_disk/HashmapMain_Types.v32
-rw-r--r--tests/coq/hashmap_on_disk/Primitives.v419
-rw-r--r--tests/coq/misc/Constants.v66
-rw-r--r--tests/coq/misc/External_Funs.v39
-rw-r--r--tests/coq/misc/External_Opaque.v8
-rw-r--r--tests/coq/misc/External_Types.v2
-rw-r--r--tests/coq/misc/Loops.v412
-rw-r--r--tests/coq/misc/NoNestedBorrows.v319
-rw-r--r--tests/coq/misc/Paper.v67
-rw-r--r--tests/coq/misc/PoloniusList.v22
-rw-r--r--tests/coq/misc/Primitives.v419
-rw-r--r--tests/coq/traits/Makefile23
-rw-r--r--tests/coq/traits/Primitives.v822
-rw-r--r--tests/coq/traits/Traits.v520
-rw-r--r--tests/coq/traits/_CoqProject7
-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
-rw-r--r--tests/hol4/betree/betreeMain_FunsScript.sml12
-rw-r--r--tests/hol4/betree/betreeMain_FunsTheory.sig14
-rw-r--r--tests/hol4/hashmap/hashmap_FunsScript.sml10
-rw-r--r--tests/hol4/hashmap/hashmap_FunsTheory.sig12
-rw-r--r--tests/hol4/hashmap/hashmap_PropertiesScript.sml2
-rw-r--r--tests/hol4/hashmap_on_disk/hashmapMain_FunsScript.sml10
-rw-r--r--tests/hol4/hashmap_on_disk/hashmapMain_FunsTheory.sig12
-rw-r--r--tests/hol4/misc-constants/constantsScript.sml10
-rw-r--r--tests/hol4/misc-constants/constantsTheory.sig12
-rw-r--r--tests/lean/Array.lean436
-rw-r--r--tests/lean/Array/Funs.lean360
-rw-r--r--tests/lean/Array/Types.lean8
-rw-r--r--tests/lean/BetreeMain/Funs.lean88
-rw-r--r--tests/lean/Constants.lean43
-rw-r--r--tests/lean/External/Funs.lean16
-rw-r--r--tests/lean/Hashmap/Funs.lean223
-rw-r--r--tests/lean/Hashmap/Properties.lean17
-rw-r--r--tests/lean/Hashmap/Types.lean2
-rw-r--r--tests/lean/HashmapMain/Funs.lean232
-rw-r--r--tests/lean/HashmapMain/Types.lean2
-rw-r--r--tests/lean/Loops.lean630
-rw-r--r--tests/lean/Loops/Funs.lean612
-rw-r--r--tests/lean/Loops/Types.lean13
-rw-r--r--tests/lean/NoNestedBorrows.lean158
-rw-r--r--tests/lean/Paper.lean48
-rw-r--r--tests/lean/Traits.lean383
-rw-r--r--tests/lean/lakefile.lean1
101 files changed, 14519 insertions, 7681 deletions
diff --git a/tests/coq/array/Array.v b/tests/coq/array/Array.v
new file mode 100644
index 00000000..825f73e0
--- /dev/null
+++ b/tests/coq/array/Array.v
@@ -0,0 +1,470 @@
+(** THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS *)
+(** [array] *)
+Require Import Primitives.
+Import Primitives.
+Require Import Coq.ZArith.ZArith.
+Require Import List.
+Import ListNotations.
+Local Open Scope Primitives_scope.
+Module Array.
+
+(** [array::AB] *)
+Inductive AB_t := | AB_A : AB_t | AB_B : AB_t.
+
+(** [array::incr]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+Definition incr (x : u32) : result u32 :=
+ u32_add x 1%u32.
+
+(** [array::array_to_shared_slice_]: forward function *)
+Definition array_to_shared_slice_
+ (T : Type) (s : array T 32%usize) : result (slice T) :=
+ array_to_slice T 32%usize s
+.
+
+(** [array::array_to_mut_slice_]: forward function *)
+Definition array_to_mut_slice_
+ (T : Type) (s : array T 32%usize) : result (slice T) :=
+ array_to_slice T 32%usize s
+.
+
+(** [array::array_to_mut_slice_]: backward function 0 *)
+Definition array_to_mut_slice__back
+ (T : Type) (s : array T 32%usize) (ret : slice T) :
+ result (array T 32%usize)
+ :=
+ array_from_slice T 32%usize s ret
+.
+
+(** [array::array_len]: forward function *)
+Definition array_len (T : Type) (s : array T 32%usize) : result usize :=
+ s0 <- array_to_slice T 32%usize s; let i := slice_len T s0 in Return i
+.
+
+(** [array::shared_array_len]: forward function *)
+Definition shared_array_len (T : Type) (s : array T 32%usize) : result usize :=
+ s0 <- array_to_slice T 32%usize s; let i := slice_len T s0 in Return i
+.
+
+(** [array::shared_slice_len]: forward function *)
+Definition shared_slice_len (T : Type) (s : slice T) : result usize :=
+ let i := slice_len T s in Return i
+.
+
+(** [array::index_array_shared]: forward function *)
+Definition index_array_shared
+ (T : Type) (s : array T 32%usize) (i : usize) : result T :=
+ array_index_usize T 32%usize s i
+.
+
+(** [array::index_array_u32]: forward function *)
+Definition index_array_u32 (s : array u32 32%usize) (i : usize) : result u32 :=
+ array_index_usize u32 32%usize s i
+.
+
+(** [array::index_array_copy]: forward function *)
+Definition index_array_copy (x : array u32 32%usize) : result u32 :=
+ array_index_usize u32 32%usize x 0%usize
+.
+
+(** [array::index_mut_array]: forward function *)
+Definition index_mut_array
+ (T : Type) (s : array T 32%usize) (i : usize) : result T :=
+ array_index_usize T 32%usize s i
+.
+
+(** [array::index_mut_array]: backward function 0 *)
+Definition index_mut_array_back
+ (T : Type) (s : array T 32%usize) (i : usize) (ret : T) :
+ result (array T 32%usize)
+ :=
+ array_update_usize T 32%usize s i ret
+.
+
+(** [array::index_slice]: forward function *)
+Definition index_slice (T : Type) (s : slice T) (i : usize) : result T :=
+ slice_index_usize T s i
+.
+
+(** [array::index_mut_slice]: forward function *)
+Definition index_mut_slice (T : Type) (s : slice T) (i : usize) : result T :=
+ slice_index_usize T s i
+.
+
+(** [array::index_mut_slice]: backward function 0 *)
+Definition index_mut_slice_back
+ (T : Type) (s : slice T) (i : usize) (ret : T) : result (slice T) :=
+ slice_update_usize T s i ret
+.
+
+(** [array::slice_subslice_shared_]: forward function *)
+Definition slice_subslice_shared_
+ (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
+ core_slice_index_Slice_index u32 (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
+.
+
+(** [array::slice_subslice_mut_]: forward function *)
+Definition slice_subslice_mut_
+ (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
+ core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
+.
+
+(** [array::slice_subslice_mut_]: backward function 0 *)
+Definition slice_subslice_mut__back
+ (x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
+ result (slice u32)
+ :=
+ core_slice_index_Slice_index_mut_back u32 (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |} ret
+.
+
+(** [array::array_to_slice_shared_]: forward function *)
+Definition array_to_slice_shared_
+ (x : array u32 32%usize) : result (slice u32) :=
+ array_to_slice u32 32%usize x
+.
+
+(** [array::array_to_slice_mut_]: forward function *)
+Definition array_to_slice_mut_ (x : array u32 32%usize) : result (slice u32) :=
+ array_to_slice u32 32%usize x
+.
+
+(** [array::array_to_slice_mut_]: backward function 0 *)
+Definition array_to_slice_mut__back
+ (x : array u32 32%usize) (ret : slice u32) : result (array u32 32%usize) :=
+ array_from_slice u32 32%usize x ret
+.
+
+(** [array::array_subslice_shared_]: forward function *)
+Definition array_subslice_shared_
+ (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
+ core_array_Array_index u32 (core_ops_range_Range usize) 32%usize
+ (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
+.
+
+(** [array::array_subslice_mut_]: forward function *)
+Definition array_subslice_mut_
+ (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
+ core_array_Array_index_mut u32 (core_ops_range_Range usize) 32%usize
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
+.
+
+(** [array::array_subslice_mut_]: backward function 0 *)
+Definition array_subslice_mut__back
+ (x : array u32 32%usize) (y : usize) (z : usize) (ret : slice u32) :
+ result (array u32 32%usize)
+ :=
+ core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 32%usize
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |} ret
+.
+
+(** [array::index_slice_0]: forward function *)
+Definition index_slice_0 (T : Type) (s : slice T) : result T :=
+ slice_index_usize T s 0%usize
+.
+
+(** [array::index_array_0]: forward function *)
+Definition index_array_0 (T : Type) (s : array T 32%usize) : result T :=
+ array_index_usize T 32%usize s 0%usize
+.
+
+(** [array::index_index_array]: forward function *)
+Definition index_index_array
+ (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
+ result u32
+ :=
+ a <- array_index_usize (array u32 32%usize) 32%usize s i;
+ array_index_usize u32 32%usize a j
+.
+
+(** [array::update_update_array]: forward function *)
+Definition update_update_array
+ (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
+ result unit
+ :=
+ a <- array_index_usize (array u32 32%usize) 32%usize s i;
+ a0 <- array_update_usize u32 32%usize a j 0%u32;
+ _ <- array_update_usize (array u32 32%usize) 32%usize s i a0;
+ Return tt
+.
+
+(** [array::array_local_deep_copy]: forward function *)
+Definition array_local_deep_copy (x : array u32 32%usize) : result unit :=
+ Return tt
+.
+
+(** [array::take_array]: forward function *)
+Definition take_array (a : array u32 2%usize) : result unit :=
+ Return tt.
+
+(** [array::take_array_borrow]: forward function *)
+Definition take_array_borrow (a : array u32 2%usize) : result unit :=
+ Return tt
+.
+
+(** [array::take_slice]: forward function *)
+Definition take_slice (s : slice u32) : result unit :=
+ Return tt.
+
+(** [array::take_mut_slice]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+Definition take_mut_slice (s : slice u32) : result (slice u32) :=
+ Return s.
+
+(** [array::take_all]: forward function *)
+Definition take_all : result unit :=
+ _ <- take_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ _ <- take_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ _ <- take_slice s;
+ s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ s1 <- take_mut_slice s0;
+ _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
+ Return tt
+.
+
+(** [array::index_array]: forward function *)
+Definition index_array (x : array u32 2%usize) : result u32 :=
+ array_index_usize u32 2%usize x 0%usize
+.
+
+(** [array::index_array_borrow]: forward function *)
+Definition index_array_borrow (x : array u32 2%usize) : result u32 :=
+ array_index_usize u32 2%usize x 0%usize
+.
+
+(** [array::index_slice_u32_0]: forward function *)
+Definition index_slice_u32_0 (x : slice u32) : result u32 :=
+ slice_index_usize u32 x 0%usize
+.
+
+(** [array::index_mut_slice_u32_0]: forward function *)
+Definition index_mut_slice_u32_0 (x : slice u32) : result u32 :=
+ slice_index_usize u32 x 0%usize
+.
+
+(** [array::index_mut_slice_u32_0]: backward function 0 *)
+Definition index_mut_slice_u32_0_back (x : slice u32) : result (slice u32) :=
+ _ <- slice_index_usize u32 x 0%usize; Return x
+.
+
+(** [array::index_all]: forward function *)
+Definition index_all : result u32 :=
+ i <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ i0 <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ i1 <- u32_add i i0;
+ i2 <- index_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ i3 <- u32_add i1 i2;
+ s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ i4 <- index_slice_u32_0 s;
+ i5 <- u32_add i3 i4;
+ s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ i6 <- index_mut_slice_u32_0 s0;
+ i7 <- u32_add i5 i6;
+ s1 <- index_mut_slice_u32_0_back s0;
+ _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
+ Return i7
+.
+
+(** [array::update_array]: forward function *)
+Definition update_array (x : array u32 2%usize) : result unit :=
+ _ <- array_update_usize u32 2%usize x 0%usize 1%u32; Return tt
+.
+
+(** [array::update_array_mut_borrow]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+Definition update_array_mut_borrow
+ (x : array u32 2%usize) : result (array u32 2%usize) :=
+ array_update_usize u32 2%usize x 0%usize 1%u32
+.
+
+(** [array::update_mut_slice]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+Definition update_mut_slice (x : slice u32) : result (slice u32) :=
+ slice_update_usize u32 x 0%usize 1%u32
+.
+
+(** [array::update_all]: forward function *)
+Definition update_all : result unit :=
+ _ <- update_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ x <- update_array_mut_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ s <- array_to_slice u32 2%usize x;
+ s0 <- update_mut_slice s;
+ _ <- array_from_slice u32 2%usize x s0;
+ Return tt
+.
+
+(** [array::range_all]: forward function *)
+Definition range_all : result unit :=
+ s <-
+ core_array_Array_index_mut u32 (core_ops_range_Range usize) 4%usize
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32
+ (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+ (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ])
+ {|
+ core_ops_range_Range_start := 1%usize;
+ core_ops_range_Range_end_ := 3%usize
+ |};
+ s0 <- update_mut_slice s;
+ _ <-
+ core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 4%usize
+ (core_slice_index_Slice_coreopsindexIndexMutInst u32
+ (core_ops_range_Range usize)
+ (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+ (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ])
+ {|
+ core_ops_range_Range_start := 1%usize;
+ core_ops_range_Range_end_ := 3%usize
+ |} s0;
+ Return tt
+.
+
+(** [array::deref_array_borrow]: forward function *)
+Definition deref_array_borrow (x : array u32 2%usize) : result u32 :=
+ array_index_usize u32 2%usize x 0%usize
+.
+
+(** [array::deref_array_mut_borrow]: forward function *)
+Definition deref_array_mut_borrow (x : array u32 2%usize) : result u32 :=
+ array_index_usize u32 2%usize x 0%usize
+.
+
+(** [array::deref_array_mut_borrow]: backward function 0 *)
+Definition deref_array_mut_borrow_back
+ (x : array u32 2%usize) : result (array u32 2%usize) :=
+ _ <- array_index_usize u32 2%usize x 0%usize; Return x
+.
+
+(** [array::take_array_t]: forward function *)
+Definition take_array_t (a : array AB_t 2%usize) : result unit :=
+ Return tt.
+
+(** [array::non_copyable_array]: forward function *)
+Definition non_copyable_array : result unit :=
+ _ <- take_array_t (mk_array AB_t 2%usize [ AB_A; AB_B ]); Return tt
+.
+
+(** [array::sum]: loop 0: forward function *)
+Fixpoint sum_loop
+ (n : nat) (s : slice u32) (sum0 : u32) (i : usize) : result u32 :=
+ match n with
+ | O => Fail_ OutOfFuel
+ | S n0 =>
+ let i0 := slice_len u32 s in
+ if i s< i0
+ then (
+ i1 <- slice_index_usize u32 s i;
+ sum1 <- u32_add sum0 i1;
+ i2 <- usize_add i 1%usize;
+ sum_loop n0 s sum1 i2)
+ else Return sum0
+ end
+.
+
+(** [array::sum]: forward function *)
+Definition sum (n : nat) (s : slice u32) : result u32 :=
+ sum_loop n s 0%u32 0%usize
+.
+
+(** [array::sum2]: loop 0: forward function *)
+Fixpoint sum2_loop
+ (n : nat) (s : slice u32) (s2 : slice u32) (sum0 : u32) (i : usize) :
+ result u32
+ :=
+ match n with
+ | O => Fail_ OutOfFuel
+ | S n0 =>
+ let i0 := slice_len u32 s in
+ if i s< i0
+ then (
+ i1 <- slice_index_usize u32 s i;
+ i2 <- slice_index_usize u32 s2 i;
+ i3 <- u32_add i1 i2;
+ sum1 <- u32_add sum0 i3;
+ i4 <- usize_add i 1%usize;
+ sum2_loop n0 s s2 sum1 i4)
+ else Return sum0
+ end
+.
+
+(** [array::sum2]: forward function *)
+Definition sum2 (n : nat) (s : slice u32) (s2 : slice u32) : result u32 :=
+ let i := slice_len u32 s in
+ let i0 := slice_len u32 s2 in
+ if negb (i s= i0) then Fail_ Failure else sum2_loop n s s2 0%u32 0%usize
+.
+
+(** [array::f0]: forward function *)
+Definition f0 : result unit :=
+ s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
+ s0 <- slice_update_usize u32 s 0%usize 1%u32;
+ _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]) s0;
+ Return tt
+.
+
+(** [array::f1]: forward function *)
+Definition f1 : result unit :=
+ _ <-
+ array_update_usize u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
+ 0%usize 1%u32;
+ Return tt
+.
+
+(** [array::f2]: forward function *)
+Definition f2 (i : u32) : result unit :=
+ Return tt.
+
+(** [array::f4]: forward function *)
+Definition f4
+ (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
+ core_array_Array_index u32 (core_ops_range_Range usize) 32%usize
+ (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+ usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+ {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
+.
+
+(** [array::f3]: forward function *)
+Definition f3 (n : nat) : result u32 :=
+ i <-
+ array_index_usize u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
+ 0%usize;
+ _ <- f2 i;
+ let b := array_repeat u32 32%usize 0%u32 in
+ s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
+ s0 <- f4 b 16%usize 18%usize;
+ sum2 n s s0
+.
+
+(** [array::SZ] *)
+Definition sz_body : result usize := Return 32%usize.
+Definition sz_c : usize := sz_body%global.
+
+(** [array::f5]: forward function *)
+Definition f5 (x : array u32 32%usize) : result u32 :=
+ array_index_usize u32 32%usize x 0%usize
+.
+
+(** [array::ite]: forward function *)
+Definition ite : result unit :=
+ s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+ s1 <- index_mut_slice_u32_0_back s0;
+ _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
+ s2 <- index_mut_slice_u32_0_back s;
+ _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s2;
+ Return tt
+.
+
+End Array .
diff --git a/tests/coq/array/Array_Funs.v b/tests/coq/array/Array_Funs.v
deleted file mode 100644
index 6d791873..00000000
--- a/tests/coq/array/Array_Funs.v
+++ /dev/null
@@ -1,467 +0,0 @@
-(** THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS *)
-(** [array]: function definitions *)
-Require Import Primitives.
-Import Primitives.
-Require Import Coq.ZArith.ZArith.
-Require Import List.
-Import ListNotations.
-Local Open Scope Primitives_scope.
-Require Export Array_Types.
-Import Array_Types.
-Module Array_Funs.
-
-(** [array::array_to_shared_slice_]: forward function *)
-Definition array_to_shared_slice__fwd
- (T : Type) (s : array T 32%usize) : result (slice T) :=
- array_to_slice_shared T 32%usize s
-.
-
-(** [array::array_to_mut_slice_]: forward function *)
-Definition array_to_mut_slice__fwd
- (T : Type) (s : array T 32%usize) : result (slice T) :=
- array_to_slice_mut_fwd T 32%usize s
-.
-
-(** [array::array_to_mut_slice_]: backward function 0 *)
-Definition array_to_mut_slice__back
- (T : Type) (s : array T 32%usize) (ret : slice T) :
- result (array T 32%usize)
- :=
- array_to_slice_mut_back T 32%usize s ret
-.
-
-(** [array::array_len]: forward function *)
-Definition array_len_fwd (T : Type) (s : array T 32%usize) : result usize :=
- s0 <- array_to_slice_shared T 32%usize s; let i := slice_len T s0 in Return i
-.
-
-(** [array::shared_array_len]: forward function *)
-Definition shared_array_len_fwd
- (T : Type) (s : array T 32%usize) : result usize :=
- s0 <- array_to_slice_shared T 32%usize s; let i := slice_len T s0 in Return i
-.
-
-(** [array::shared_slice_len]: forward function *)
-Definition shared_slice_len_fwd (T : Type) (s : slice T) : result usize :=
- let i := slice_len T s in Return i
-.
-
-(** [array::index_array_shared]: forward function *)
-Definition index_array_shared_fwd
- (T : Type) (s : array T 32%usize) (i : usize) : result T :=
- array_index_shared T 32%usize s i
-.
-
-(** [array::index_array_u32]: forward function *)
-Definition index_array_u32_fwd
- (s : array u32 32%usize) (i : usize) : result u32 :=
- array_index_shared u32 32%usize s i
-.
-
-(** [array::index_array_generic]: forward function *)
-Definition 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 *)
-Definition index_array_generic_call_fwd
- (N : usize) (s : array u32 N) (i : usize) : result u32 :=
- index_array_generic_fwd N s i
-.
-
-(** [array::index_array_copy]: forward function *)
-Definition index_array_copy_fwd (x : array u32 32%usize) : result u32 :=
- array_index_shared u32 32%usize x 0%usize
-.
-
-(** [array::index_mut_array]: forward function *)
-Definition index_mut_array_fwd
- (T : Type) (s : array T 32%usize) (i : usize) : result T :=
- array_index_mut_fwd T 32%usize s i
-.
-
-(** [array::index_mut_array]: backward function 0 *)
-Definition index_mut_array_back
- (T : Type) (s : array T 32%usize) (i : usize) (ret : T) :
- result (array T 32%usize)
- :=
- array_index_mut_back T 32%usize s i ret
-.
-
-(** [array::index_slice]: forward function *)
-Definition index_slice_fwd (T : Type) (s : slice T) (i : usize) : result T :=
- slice_index_shared T s i
-.
-
-(** [array::index_mut_slice]: forward function *)
-Definition index_mut_slice_fwd
- (T : Type) (s : slice T) (i : usize) : result T :=
- slice_index_mut_fwd T s i
-.
-
-(** [array::index_mut_slice]: backward function 0 *)
-Definition index_mut_slice_back
- (T : Type) (s : slice T) (i : usize) (ret : T) : result (slice T) :=
- slice_index_mut_back T s i ret
-.
-
-(** [array::slice_subslice_shared_]: forward function *)
-Definition slice_subslice_shared__fwd
- (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
- slice_subslice_shared u32 x (mk_range y z)
-.
-
-(** [array::slice_subslice_mut_]: forward function *)
-Definition slice_subslice_mut__fwd
- (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
- slice_subslice_mut_fwd u32 x (mk_range y z)
-.
-
-(** [array::slice_subslice_mut_]: backward function 0 *)
-Definition slice_subslice_mut__back
- (x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
- result (slice u32)
- :=
- slice_subslice_mut_back u32 x (mk_range y z) ret
-.
-
-(** [array::array_to_slice_shared_]: forward function *)
-Definition array_to_slice_shared__fwd
- (x : array u32 32%usize) : result (slice u32) :=
- array_to_slice_shared u32 32%usize x
-.
-
-(** [array::array_to_slice_mut_]: forward function *)
-Definition array_to_slice_mut__fwd
- (x : array u32 32%usize) : result (slice u32) :=
- array_to_slice_mut_fwd u32 32%usize x
-.
-
-(** [array::array_to_slice_mut_]: backward function 0 *)
-Definition array_to_slice_mut__back
- (x : array u32 32%usize) (ret : slice u32) : result (array u32 32%usize) :=
- array_to_slice_mut_back u32 32%usize x ret
-.
-
-(** [array::array_subslice_shared_]: forward function *)
-Definition array_subslice_shared__fwd
- (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
- array_subslice_shared u32 32%usize x (mk_range y z)
-.
-
-(** [array::array_subslice_mut_]: forward function *)
-Definition array_subslice_mut__fwd
- (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
- array_subslice_mut_fwd u32 32%usize x (mk_range y z)
-.
-
-(** [array::array_subslice_mut_]: backward function 0 *)
-Definition array_subslice_mut__back
- (x : array u32 32%usize) (y : usize) (z : usize) (ret : slice u32) :
- result (array u32 32%usize)
- :=
- array_subslice_mut_back u32 32%usize x (mk_range y z) ret
-.
-
-(** [array::index_slice_0]: forward function *)
-Definition index_slice_0_fwd (T : Type) (s : slice T) : result T :=
- slice_index_shared T s 0%usize
-.
-
-(** [array::index_array_0]: forward function *)
-Definition index_array_0_fwd (T : Type) (s : array T 32%usize) : result T :=
- array_index_shared T 32%usize s 0%usize
-.
-
-(** [array::index_index_array]: forward function *)
-Definition index_index_array_fwd
- (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
- result u32
- :=
- a <- array_index_shared (array u32 32%usize) 32%usize s i;
- array_index_shared u32 32%usize a j
-.
-
-(** [array::update_update_array]: forward function *)
-Definition update_update_array_fwd
- (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
- result unit
- :=
- a <- array_index_mut_fwd (array u32 32%usize) 32%usize s i;
- a0 <- array_index_mut_back u32 32%usize a j 0%u32;
- _ <- array_index_mut_back (array u32 32%usize) 32%usize s i a0;
- Return tt
-.
-
-(** [array::array_local_deep_copy]: forward function *)
-Definition array_local_deep_copy_fwd (x : array u32 32%usize) : result unit :=
- Return tt
-.
-
-(** [array::take_array]: forward function *)
-Definition take_array_fwd (a : array u32 2%usize) : result unit :=
- Return tt.
-
-(** [array::take_array_borrow]: forward function *)
-Definition take_array_borrow_fwd (a : array u32 2%usize) : result unit :=
- Return tt
-.
-
-(** [array::take_slice]: forward function *)
-Definition take_slice_fwd (s : slice u32) : result unit :=
- Return tt.
-
-(** [array::take_mut_slice]: merged forward/backward function
- (there is a single backward function, and the forward function returns ()) *)
-Definition take_mut_slice_fwd_back (s : slice u32) : result (slice u32) :=
- Return s
-.
-
-(** [array::take_all]: forward function *)
-Definition take_all_fwd : result unit :=
- _ <- take_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- _ <- take_array_borrow_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- s <-
- array_to_slice_shared u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- _ <- take_slice_fwd s;
- s0 <-
- array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- s1 <- take_mut_slice_fwd_back s0;
- _ <-
- array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
- s1;
- Return tt
-.
-
-(** [array::index_array]: forward function *)
-Definition index_array_fwd (x : array u32 2%usize) : result u32 :=
- array_index_shared u32 2%usize x 0%usize
-.
-
-(** [array::index_array_borrow]: forward function *)
-Definition index_array_borrow_fwd (x : array u32 2%usize) : result u32 :=
- array_index_shared u32 2%usize x 0%usize
-.
-
-(** [array::index_slice_u32_0]: forward function *)
-Definition index_slice_u32_0_fwd (x : slice u32) : result u32 :=
- slice_index_shared u32 x 0%usize
-.
-
-(** [array::index_mut_slice_u32_0]: forward function *)
-Definition index_mut_slice_u32_0_fwd (x : slice u32) : result u32 :=
- slice_index_shared u32 x 0%usize
-.
-
-(** [array::index_mut_slice_u32_0]: backward function 0 *)
-Definition index_mut_slice_u32_0_back (x : slice u32) : result (slice u32) :=
- _ <- slice_index_shared u32 x 0%usize; Return x
-.
-
-(** [array::index_all]: forward function *)
-Definition index_all_fwd : result u32 :=
- i <- index_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- i0 <- index_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- i1 <- u32_add i i0;
- i2 <- index_array_borrow_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- i3 <- u32_add i1 i2;
- s <-
- array_to_slice_shared u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- i4 <- index_slice_u32_0_fwd s;
- i5 <- u32_add i3 i4;
- s0 <-
- array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- i6 <- index_mut_slice_u32_0_fwd s0;
- i7 <- u32_add i5 i6;
- s1 <- index_mut_slice_u32_0_back s0;
- _ <-
- array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
- s1;
- Return i7
-.
-
-(** [array::update_array]: forward function *)
-Definition update_array_fwd (x : array u32 2%usize) : result unit :=
- _ <- array_index_mut_back u32 2%usize x 0%usize 1%u32; Return tt
-.
-
-(** [array::update_array_mut_borrow]: merged forward/backward function
- (there is a single backward function, and the forward function returns ()) *)
-Definition update_array_mut_borrow_fwd_back
- (x : array u32 2%usize) : result (array u32 2%usize) :=
- array_index_mut_back u32 2%usize x 0%usize 1%u32
-.
-
-(** [array::update_mut_slice]: merged forward/backward function
- (there is a single backward function, and the forward function returns ()) *)
-Definition update_mut_slice_fwd_back (x : slice u32) : result (slice u32) :=
- slice_index_mut_back u32 x 0%usize 1%u32
-.
-
-(** [array::update_all]: forward function *)
-Definition update_all_fwd : result unit :=
- _ <- update_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- x <-
- update_array_mut_borrow_fwd_back (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- s <- array_to_slice_mut_fwd u32 2%usize x;
- s0 <- update_mut_slice_fwd_back s;
- _ <- array_to_slice_mut_back u32 2%usize x s0;
- Return tt
-.
-
-(** [array::range_all]: forward function *)
-Definition range_all_fwd : result unit :=
- s <-
- array_subslice_mut_fwd u32 4%usize
- (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ]) (mk_range 1%usize
- 3%usize);
- s0 <- update_mut_slice_fwd_back s;
- _ <-
- array_subslice_mut_back u32 4%usize
- (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ]) (mk_range 1%usize
- 3%usize) s0;
- Return tt
-.
-
-(** [array::deref_array_borrow]: forward function *)
-Definition deref_array_borrow_fwd (x : array u32 2%usize) : result u32 :=
- array_index_shared u32 2%usize x 0%usize
-.
-
-(** [array::deref_array_mut_borrow]: forward function *)
-Definition deref_array_mut_borrow_fwd (x : array u32 2%usize) : result u32 :=
- array_index_shared u32 2%usize x 0%usize
-.
-
-(** [array::deref_array_mut_borrow]: backward function 0 *)
-Definition deref_array_mut_borrow_back
- (x : array u32 2%usize) : result (array u32 2%usize) :=
- _ <- array_index_shared u32 2%usize x 0%usize; Return x
-.
-
-(** [array::take_array_t]: forward function *)
-Definition take_array_t_fwd (a : array T_t 2%usize) : result unit :=
- Return tt.
-
-(** [array::non_copyable_array]: forward function *)
-Definition non_copyable_array_fwd : result unit :=
- _ <- take_array_t_fwd (mk_array T_t 2%usize [ TA; TB ]); Return tt
-.
-
-(** [array::sum]: loop 0: forward function *)
-Fixpoint sum_loop_fwd
- (n : nat) (s : slice u32) (sum : u32) (i : usize) : result u32 :=
- match n with
- | O => Fail_ OutOfFuel
- | S n0 =>
- let i0 := slice_len u32 s in
- if i s< i0
- then (
- i1 <- slice_index_shared u32 s i;
- sum0 <- u32_add sum i1;
- i2 <- usize_add i 1%usize;
- sum_loop_fwd n0 s sum0 i2)
- else Return sum
- end
-.
-
-(** [array::sum]: forward function *)
-Definition sum_fwd (n : nat) (s : slice u32) : result u32 :=
- sum_loop_fwd n s 0%u32 0%usize
-.
-
-(** [array::sum2]: loop 0: forward function *)
-Fixpoint sum2_loop_fwd
- (n : nat) (s : slice u32) (s2 : slice u32) (sum : u32) (i : usize) :
- result u32
- :=
- match n with
- | O => Fail_ OutOfFuel
- | S n0 =>
- let i0 := slice_len u32 s in
- if i s< i0
- then (
- i1 <- slice_index_shared u32 s i;
- i2 <- slice_index_shared u32 s2 i;
- i3 <- u32_add i1 i2;
- sum0 <- u32_add sum i3;
- i4 <- usize_add i 1%usize;
- sum2_loop_fwd n0 s s2 sum0 i4)
- else Return sum
- end
-.
-
-(** [array::sum2]: forward function *)
-Definition sum2_fwd (n : nat) (s : slice u32) (s2 : slice u32) : result u32 :=
- let i := slice_len u32 s in
- let i0 := slice_len u32 s2 in
- if negb (i s= i0) then Fail_ Failure else sum2_loop_fwd n s s2 0%u32 0%usize
-.
-
-(** [array::f0]: forward function *)
-Definition f0_fwd : result unit :=
- s <-
- array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
- s0 <- slice_index_mut_back u32 s 0%usize 1%u32;
- _ <-
- array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
- s0;
- Return tt
-.
-
-(** [array::f1]: forward function *)
-Definition f1_fwd : result unit :=
- _ <-
- array_index_mut_back u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
- 0%usize 1%u32;
- Return tt
-.
-
-(** [array::f2]: forward function *)
-Definition f2_fwd (i : u32) : result unit :=
- Return tt.
-
-(** [array::f4]: forward function *)
-Definition f4_fwd
- (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
- array_subslice_shared u32 32%usize x (mk_range y z)
-.
-
-(** [array::f3]: forward function *)
-Definition f3_fwd (n : nat) : result u32 :=
- i <-
- array_index_shared u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
- 0%usize;
- _ <- f2_fwd i;
- s <-
- array_to_slice_shared u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
- s0 <-
- f4_fwd
- (mk_array u32 32%usize [
- 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32;
- 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32;
- 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32;
- 0%u32; 0%u32
- ]) 16%usize 18%usize;
- sum2_fwd n s s0
-.
-
-(** [array::ite]: forward function *)
-Definition ite_fwd : result unit :=
- s <-
- array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- s0 <-
- array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
- s1 <- index_mut_slice_u32_0_back s0;
- _ <-
- array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
- s1;
- s2 <- index_mut_slice_u32_0_back s;
- _ <-
- array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
- s2;
- Return tt
-.
-
-End Array_Funs .
diff --git a/tests/coq/array/Array_Types.v b/tests/coq/array/Array_Types.v
deleted file mode 100644
index 7be6dc9b..00000000
--- a/tests/coq/array/Array_Types.v
+++ /dev/null
@@ -1,14 +0,0 @@
-(** THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS *)
-(** [array]: type definitions *)
-Require Import Primitives.
-Import Primitives.
-Require Import Coq.ZArith.ZArith.
-Require Import List.
-Import ListNotations.
-Local Open Scope Primitives_scope.
-Module Array_Types.
-
-(** [array::T] *)
-Inductive T_t := | TA : T_t | TB : T_t.
-
-End Array_Types .
diff --git a/tests/coq/array/Primitives.v b/tests/coq/array/Primitives.v
index 71a2d9c3..85e38f01 100644
--- a/tests/coq/array/Primitives.v
+++ b/tests/coq/array/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
(*** Misc *)
-
Definition string := Coq.Strings.String.string.
Definition char := Coq.Strings.Ascii.ascii.
Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
(*** Scalars *)
@@ -394,12 +396,89 @@ Notation "x s< y" := (scalar_ltb x y) (at level 80) : Primitives_scope.
Notation "x s>= y" := (scalar_geb x y) (at level 80) : Primitives_scope.
Notation "x s> y" := (scalar_gtb x y) (at level 80) : Primitives_scope.
-(*** Range *)
-Record range (T : Type) := mk_range {
- start: T;
- end_: T;
+(** Constants *)
+Definition core_u8_max := u8_max %u32.
+Definition core_u16_max := u16_max %u32.
+Definition core_u32_max := u32_max %u32.
+Definition core_u64_max := u64_max %u64.
+Definition core_u128_max := u64_max %u128.
+Axiom core_usize_max : usize. (** TODO *)
+Definition core_i8_max := i8_max %i32.
+Definition core_i16_max := i16_max %i32.
+Definition core_i32_max := i32_max %i32.
+Definition core_i64_max := i64_max %i64.
+Definition core_i128_max := i64_max %i128.
+Axiom core_isize_max : isize. (** TODO *)
+
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+ core_ops_index_Index_Output : Type;
+ core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+ core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+ core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+ core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+ core_ops_deref_Deref_target : Type;
+ core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+ core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+ core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+ core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
}.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+ core_ops_range_Range_start : T;
+ core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+ core_ops_deref_Deref_target := Self;
+ core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+ core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+ core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+ core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
(*** Arrays *)
Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -419,51 +498,50 @@ Qed.
(* TODO: finish the definitions *)
Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
(*** Slice *)
Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
(*** Subslices *)
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
(*** Vectors *)
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
Proof.
- unfold vec_length, usize_min.
+ unfold alloc_vec_Vec_length, usize_min.
split.
- lia.
- apply (proj2_sig v).
Qed.
-Definition vec_len (T: Type) (v: vec T) : usize :=
- exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+ exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
: list A :=
@@ -474,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
| S m => x :: (list_update t m a)
end end.
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
- l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+ l <- f (alloc_vec_Vec_to_list v) ;
match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
| left H => Return (exist _ l (scalar_le_max_valid _ _ H))
| right _ => Fail_ Failure
end.
(* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
- vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
(* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+ if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l =>
if to_Z i <? Z.of_nat (length l)
then Return (list_update l (usize_to_nat i) x)
else Fail_ Failure).
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
- end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+ core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+ core_slice_index_SliceIndex_Output : Type;
+ core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+ core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+ (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+ x <- inst.(core_slice_index_SliceIndex_get) i s;
+ match x with
+ | None => Fail_ Failure
+ | Some x => Return x
end.
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
- if to_Z i <? Z.of_nat (length l)
- then Return (list_update l (usize_to_nat i) x)
- else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+ (T : Type) :
+ 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 *)
+Definition core_slice_index_Range_get_unchecked_mut
+ (T : Type) :
+ 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 *)
+Axiom core_slice_index_Range_index :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (slice T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := slice T;
+ core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (slice T) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_Index (slice T) Idx) :
+ core_ops_index_Index (array T N) Idx := {|
+ core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+ core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_IndexMut (slice T) Idx) :
+ core_ops_index_IndexMut (array T N) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+ core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+ core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+ forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+ forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+ forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+ forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex usize (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := T;
+ core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+ core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+ alloc_vec_Vec_update_usize v i x.
End Primitives.
diff --git a/tests/coq/array/_CoqProject b/tests/coq/array/_CoqProject
index f33cefe6..87d8fc3d 100644
--- a/tests/coq/array/_CoqProject
+++ b/tests/coq/array/_CoqProject
@@ -3,6 +3,5 @@
-arg -w
-arg all
-Array_Funs.v
Primitives.v
-Array_Types.v
+Array.v
diff --git a/tests/coq/betree/BetreeMain_Funs.v b/tests/coq/betree/BetreeMain_Funs.v
index 1e457433..261e8270 100644
--- a/tests/coq/betree/BetreeMain_Funs.v
+++ b/tests/coq/betree/BetreeMain_Funs.v
@@ -13,41 +13,41 @@ Import BetreeMain_Opaque.
Module BetreeMain_Funs.
(** [betree_main::betree::load_internal_node]: forward function *)
-Definition betree_load_internal_node_fwd
+Definition 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 *)
-Definition betree_store_internal_node_fwd
- (id : u64) (content : Betree_list_t (u64 * Betree_message_t)) (st : state) :
+Definition betree_store_internal_node
+ (id : u64) (content : betree_List_t (u64 * betree_Message_t)) (st : state) :
result (state * unit)
:=
- p <- betree_utils_store_internal_node_fwd id content st;
+ p <- betree_utils_store_internal_node id content st;
let (st0, _) := p in
Return (st0, tt)
.
(** [betree_main::betree::load_leaf_node]: forward function *)
-Definition betree_load_leaf_node_fwd
- (id : u64) (st : state) : result (state * (Betree_list_t (u64 * u64))) :=
- betree_utils_load_leaf_node_fwd id st
+Definition 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 *)
-Definition betree_store_leaf_node_fwd
- (id : u64) (content : Betree_list_t (u64 * u64)) (st : state) :
+Definition betree_store_leaf_node
+ (id : u64) (content : betree_List_t (u64 * u64)) (st : state) :
result (state * unit)
:=
- p <- betree_utils_store_leaf_node_fwd id content st;
+ p <- betree_utils_store_leaf_node id content st;
let (st0, _) := p in
Return (st0, tt)
.
(** [betree_main::betree::fresh_node_id]: forward function *)
-Definition betree_fresh_node_id_fwd (counter : u64) : result u64 :=
+Definition betree_fresh_node_id (counter : u64) : result u64 :=
_ <- u64_add counter 1%u64; Return counter
.
@@ -57,1142 +57,1121 @@ Definition betree_fresh_node_id_back (counter : u64) : result u64 :=
.
(** [betree_main::betree::NodeIdCounter::{0}::new]: forward function *)
-Definition betree_node_id_counter_new_fwd : result Betree_node_id_counter_t :=
- Return {| Betree_node_id_counter_next_node_id := 0%u64 |}
+Definition betree_NodeIdCounter_new : result betree_NodeIdCounter_t :=
+ Return {| betree_NodeIdCounter_next_node_id := 0%u64 |}
.
(** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: forward function *)
-Definition betree_node_id_counter_fresh_id_fwd
- (self : Betree_node_id_counter_t) : result u64 :=
- _ <- u64_add self.(Betree_node_id_counter_next_node_id) 1%u64;
- Return self.(Betree_node_id_counter_next_node_id)
+Definition betree_NodeIdCounter_fresh_id
+ (self : betree_NodeIdCounter_t) : result u64 :=
+ _ <- u64_add self.(betree_NodeIdCounter_next_node_id) 1%u64;
+ Return self.(betree_NodeIdCounter_next_node_id)
.
(** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: backward function 0 *)
-Definition betree_node_id_counter_fresh_id_back
- (self : Betree_node_id_counter_t) : result Betree_node_id_counter_t :=
- i <- u64_add self.(Betree_node_id_counter_next_node_id) 1%u64;
- Return {| Betree_node_id_counter_next_node_id := i |}
+Definition betree_NodeIdCounter_fresh_id_back
+ (self : betree_NodeIdCounter_t) : result betree_NodeIdCounter_t :=
+ i <- u64_add self.(betree_NodeIdCounter_next_node_id) 1%u64;
+ Return {| betree_NodeIdCounter_next_node_id := i |}
.
-(** [core::num::u64::{9}::MAX] *)
-Definition core_num_u64_max_body : result u64 :=
- Return 18446744073709551615%u64
-.
-Definition core_num_u64_max_c : u64 := core_num_u64_max_body%global.
-
(** [betree_main::betree::upsert_update]: forward function *)
-Definition betree_upsert_update_fwd
- (prev : option u64) (st : Betree_upsert_fun_state_t) : result u64 :=
+Definition betree_upsert_update
+ (prev : option u64) (st : betree_UpsertFunState_t) : result u64 :=
match prev with
| None =>
match st with
- | BetreeUpsertFunStateAdd v => Return v
- | BetreeUpsertFunStateSub i => Return 0%u64
+ | Betree_UpsertFunState_Add v => Return v
+ | Betree_UpsertFunState_Sub i => Return 0%u64
end
| Some prev0 =>
match st with
- | BetreeUpsertFunStateAdd v =>
- margin <- u64_sub core_num_u64_max_c prev0;
- if margin s>= v then u64_add prev0 v else Return core_num_u64_max_c
- | BetreeUpsertFunStateSub v =>
+ | Betree_UpsertFunState_Add v =>
+ margin <- u64_sub core_u64_max prev0;
+ if margin s>= v then u64_add prev0 v else Return core_u64_max
+ | Betree_UpsertFunState_Sub v =>
if prev0 s>= v then u64_sub prev0 v else Return 0%u64
end
end
.
(** [betree_main::betree::List::{1}::len]: forward function *)
-Fixpoint betree_list_len_fwd
- (T : Type) (n : nat) (self : Betree_list_t T) : result u64 :=
+Fixpoint betree_List_len
+ (T : Type) (n : nat) (self : betree_List_t T) : result u64 :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match self with
- | BetreeListCons t tl => i <- betree_list_len_fwd T n0 tl; u64_add 1%u64 i
- | BetreeListNil => Return 0%u64
+ | Betree_List_Cons t tl => i <- betree_List_len T n0 tl; u64_add 1%u64 i
+ | Betree_List_Nil => Return 0%u64
end
end
.
(** [betree_main::betree::List::{1}::split_at]: forward function *)
-Fixpoint betree_list_split_at_fwd
- (T : Type) (n : nat) (self : Betree_list_t T) (n0 : u64) :
- result ((Betree_list_t T) * (Betree_list_t T))
+Fixpoint betree_List_split_at
+ (T : Type) (n : nat) (self : betree_List_t T) (n0 : u64) :
+ result ((betree_List_t T) * (betree_List_t T))
:=
match n with
| O => Fail_ OutOfFuel
| S n1 =>
if n0 s= 0%u64
- then Return (BetreeListNil, self)
+ then Return (Betree_List_Nil, self)
else
match self with
- | BetreeListCons hd tl =>
+ | Betree_List_Cons hd tl =>
i <- u64_sub n0 1%u64;
- p <- betree_list_split_at_fwd T n1 tl i;
+ p <- betree_List_split_at T n1 tl i;
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
end
.
(** [betree_main::betree::List::{1}::push_front]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition betree_list_push_front_fwd_back
- (T : Type) (self : Betree_list_t T) (x : T) : result (Betree_list_t T) :=
- let tl := mem_replace_fwd (Betree_list_t T) self BetreeListNil in
+Definition betree_List_push_front
+ (T : Type) (self : betree_List_t T) (x : T) : result (betree_List_t T) :=
+ let tl := core_mem_replace (betree_List_t T) self Betree_List_Nil in
let l := tl in
- Return (BetreeListCons x l)
+ Return (Betree_List_Cons x l)
.
(** [betree_main::betree::List::{1}::pop_front]: forward function *)
-Definition betree_list_pop_front_fwd
- (T : Type) (self : Betree_list_t T) : result T :=
- let ls := mem_replace_fwd (Betree_list_t T) self BetreeListNil in
+Definition betree_List_pop_front
+ (T : Type) (self : betree_List_t T) : result T :=
+ let ls := core_mem_replace (betree_List_t T) self Betree_List_Nil in
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 *)
-Definition betree_list_pop_front_back
- (T : Type) (self : Betree_list_t T) : result (Betree_list_t T) :=
- let ls := mem_replace_fwd (Betree_list_t T) self BetreeListNil in
+Definition betree_List_pop_front_back
+ (T : Type) (self : betree_List_t T) : result (betree_List_t T) :=
+ let ls := core_mem_replace (betree_List_t T) self Betree_List_Nil in
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 *)
-Definition betree_list_hd_fwd (T : Type) (self : Betree_list_t T) : result T :=
+Definition betree_List_hd (T : Type) (self : betree_List_t T) : result T :=
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 *)
-Definition betree_list_head_has_key_fwd
- (T : Type) (self : Betree_list_t (u64 * T)) (key : u64) : result bool :=
+Definition betree_List_head_has_key
+ (T : Type) (self : betree_List_t (u64 * T)) (key : u64) : result bool :=
match self with
- | BetreeListCons hd l => let (i, _) := hd in Return (i s= key)
- | BetreeListNil => Return false
+ | Betree_List_Cons hd l => let (i, _) := hd in Return (i s= key)
+ | Betree_List_Nil => Return false
end
.
(** [betree_main::betree::List::{2}::partition_at_pivot]: forward function *)
-Fixpoint betree_list_partition_at_pivot_fwd
- (T : Type) (n : nat) (self : Betree_list_t (u64 * T)) (pivot : u64) :
- result ((Betree_list_t (u64 * T)) * (Betree_list_t (u64 * T)))
+Fixpoint betree_List_partition_at_pivot
+ (T : Type) (n : nat) (self : betree_List_t (u64 * T)) (pivot : u64) :
+ result ((betree_List_t (u64 * T)) * (betree_List_t (u64 * T)))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match self with
- | BetreeListCons hd tl =>
+ | Betree_List_Cons hd tl =>
let (i, t) := hd in
if i s>= pivot
- then Return (BetreeListNil, BetreeListCons (i, t) tl)
+ then Return (Betree_List_Nil, Betree_List_Cons (i, t) tl)
else (
- p <- betree_list_partition_at_pivot_fwd T n0 tl pivot;
+ p <- betree_List_partition_at_pivot T n0 tl pivot;
let (ls0, ls1) := p in
let l := ls0 in
- Return (BetreeListCons (i, t) l, ls1))
- | BetreeListNil => Return (BetreeListNil, BetreeListNil)
+ Return (Betree_List_Cons (i, t) l, ls1))
+ | Betree_List_Nil => Return (Betree_List_Nil, Betree_List_Nil)
end
end
.
(** [betree_main::betree::Leaf::{3}::split]: forward function *)
-Definition betree_leaf_split_fwd
- (n : nat) (self : Betree_leaf_t) (content : Betree_list_t (u64 * u64))
- (params : Betree_params_t) (node_id_cnt : Betree_node_id_counter_t)
+Definition betree_Leaf_split
+ (n : nat) (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)
:=
p <-
- betree_list_split_at_fwd (u64 * u64) n content
- params.(Betree_params_split_size);
+ betree_List_split_at (u64 * u64) n content
+ params.(betree_Params_split_size);
let (content0, content1) := p in
- p0 <- betree_list_hd_fwd (u64 * u64) content1;
+ p0 <- betree_List_hd (u64 * u64) content1;
let (pivot, _) := p0 in
- id0 <- betree_node_id_counter_fresh_id_fwd node_id_cnt;
- node_id_cnt0 <- betree_node_id_counter_fresh_id_back node_id_cnt;
- id1 <- betree_node_id_counter_fresh_id_fwd node_id_cnt0;
- p1 <- betree_store_leaf_node_fwd id0 content0 st;
+ id0 <- betree_NodeIdCounter_fresh_id node_id_cnt;
+ node_id_cnt0 <- betree_NodeIdCounter_fresh_id_back node_id_cnt;
+ id1 <- betree_NodeIdCounter_fresh_id node_id_cnt0;
+ p1 <- betree_store_leaf_node id0 content0 st;
let (st0, _) := p1 in
- p2 <- betree_store_leaf_node_fwd id1 content1 st0;
+ p2 <- betree_store_leaf_node id1 content1 st0;
let (st1, _) := p2 in
- let n0 := BetreeNodeLeaf
+ let n0 := Betree_Node_Leaf
{|
- Betree_leaf_id := id0;
- Betree_leaf_size := params.(Betree_params_split_size)
+ betree_Leaf_id := id0;
+ betree_Leaf_size := params.(betree_Params_split_size)
|} in
- let n1 := BetreeNodeLeaf
+ let n1 := Betree_Node_Leaf
{|
- Betree_leaf_id := id1;
- Betree_leaf_size := params.(Betree_params_split_size)
+ betree_Leaf_id := id1;
+ betree_Leaf_size := params.(betree_Params_split_size)
|} in
- Return (st1, mkBetree_internal_t self.(Betree_leaf_id) pivot n0 n1)
+ Return (st1, mkbetree_Internal_t self.(betree_Leaf_id) pivot n0 n1)
.
(** [betree_main::betree::Leaf::{3}::split]: backward function 2 *)
-Definition betree_leaf_split_back
- (n : nat) (self : Betree_leaf_t) (content : Betree_list_t (u64 * u64))
- (params : Betree_params_t) (node_id_cnt : Betree_node_id_counter_t)
+Definition betree_Leaf_split_back
+ (n : nat) (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
:=
p <-
- betree_list_split_at_fwd (u64 * u64) n content
- params.(Betree_params_split_size);
+ betree_List_split_at (u64 * u64) n content
+ params.(betree_Params_split_size);
let (content0, content1) := p in
- _ <- betree_list_hd_fwd (u64 * u64) content1;
- id0 <- betree_node_id_counter_fresh_id_fwd node_id_cnt;
- node_id_cnt0 <- betree_node_id_counter_fresh_id_back node_id_cnt;
- id1 <- betree_node_id_counter_fresh_id_fwd node_id_cnt0;
- p0 <- betree_store_leaf_node_fwd id0 content0 st;
+ _ <- betree_List_hd (u64 * u64) content1;
+ id0 <- betree_NodeIdCounter_fresh_id node_id_cnt;
+ node_id_cnt0 <- betree_NodeIdCounter_fresh_id_back node_id_cnt;
+ id1 <- betree_NodeIdCounter_fresh_id node_id_cnt0;
+ p0 <- betree_store_leaf_node id0 content0 st;
let (st0, _) := p0 in
- _ <- betree_store_leaf_node_fwd id1 content1 st0;
- betree_node_id_counter_fresh_id_back node_id_cnt0
+ _ <- betree_store_leaf_node id1 content1 st0;
+ betree_NodeIdCounter_fresh_id_back node_id_cnt0
.
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: forward function *)
-Fixpoint betree_node_lookup_first_message_for_key_fwd
- (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_for_key
+ (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match msgs with
- | BetreeListCons x next_msgs =>
+ | Betree_List_Cons x next_msgs =>
let (i, m) := x in
if i s>= key
- then Return (BetreeListCons (i, m) next_msgs)
- else betree_node_lookup_first_message_for_key_fwd n0 key next_msgs
- | BetreeListNil => Return BetreeListNil
+ then Return (Betree_List_Cons (i, m) next_msgs)
+ else betree_Node_lookup_first_message_for_key n0 key next_msgs
+ | Betree_List_Nil => Return Betree_List_Nil
end
end
.
(** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: backward function 0 *)
-Fixpoint betree_node_lookup_first_message_for_key_back
- (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t))
- (ret : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_for_key_back
+ (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t))
+ (ret : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match msgs with
- | BetreeListCons x next_msgs =>
+ | Betree_List_Cons x next_msgs =>
let (i, m) := x in
if i s>= key
then Return ret
else (
next_msgs0 <-
- betree_node_lookup_first_message_for_key_back n0 key next_msgs ret;
- Return (BetreeListCons (i, m) next_msgs0))
- | BetreeListNil => Return ret
+ betree_Node_lookup_first_message_for_key_back n0 key next_msgs ret;
+ Return (Betree_List_Cons (i, m) next_msgs0))
+ | Betree_List_Nil => Return ret
end
end
.
(** [betree_main::betree::Node::{5}::apply_upserts]: forward function *)
-Fixpoint betree_node_apply_upserts_fwd
- (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t)) (prev : option u64)
+Fixpoint betree_Node_apply_upserts
+ (n : nat) (msgs : betree_List_t (u64 * betree_Message_t)) (prev : option u64)
(key : u64) (st : state) :
result (state * u64)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- b <- betree_list_head_has_key_fwd Betree_message_t msgs key;
+ b <- betree_List_head_has_key betree_Message_t msgs key;
if b
then (
- msg <- betree_list_pop_front_fwd (u64 * Betree_message_t) msgs;
+ msg <- betree_List_pop_front (u64 * betree_Message_t) msgs;
let (_, m) := msg in
match m with
- | BetreeMessageInsert i => Fail_ Failure
- | BetreeMessageDelete => Fail_ Failure
- | BetreeMessageUpsert s =>
- v <- betree_upsert_update_fwd prev s;
- msgs0 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs;
- betree_node_apply_upserts_fwd n0 msgs0 (Some v) key st
+ | Betree_Message_Insert i => Fail_ Failure
+ | Betree_Message_Delete => Fail_ Failure
+ | Betree_Message_Upsert s =>
+ v <- betree_upsert_update prev s;
+ msgs0 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs;
+ betree_Node_apply_upserts n0 msgs0 (Some v) key st
end)
else (
- p <- core_option_option_unwrap_fwd u64 prev st;
+ p <- core_option_Option_unwrap u64 prev st;
let (st0, v) := p in
_ <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs (key,
- BetreeMessageInsert v);
+ betree_List_push_front (u64 * betree_Message_t) msgs (key,
+ Betree_Message_Insert v);
Return (st0, v))
end
.
(** [betree_main::betree::Node::{5}::apply_upserts]: backward function 0 *)
-Fixpoint betree_node_apply_upserts_back
- (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t)) (prev : option u64)
+Fixpoint betree_Node_apply_upserts_back
+ (n : nat) (msgs : betree_List_t (u64 * betree_Message_t)) (prev : option u64)
(key : u64) (st : state) :
- result (Betree_list_t (u64 * Betree_message_t))
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- b <- betree_list_head_has_key_fwd Betree_message_t msgs key;
+ b <- betree_List_head_has_key betree_Message_t msgs key;
if b
then (
- msg <- betree_list_pop_front_fwd (u64 * Betree_message_t) msgs;
+ msg <- betree_List_pop_front (u64 * betree_Message_t) msgs;
let (_, m) := msg in
match m with
- | BetreeMessageInsert i => Fail_ Failure
- | BetreeMessageDelete => Fail_ Failure
- | BetreeMessageUpsert s =>
- v <- betree_upsert_update_fwd prev s;
- msgs0 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs;
- betree_node_apply_upserts_back n0 msgs0 (Some v) key st
+ | Betree_Message_Insert i => Fail_ Failure
+ | Betree_Message_Delete => Fail_ Failure
+ | Betree_Message_Upsert s =>
+ v <- betree_upsert_update prev s;
+ msgs0 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs;
+ betree_Node_apply_upserts_back n0 msgs0 (Some v) key st
end)
else (
- p <- core_option_option_unwrap_fwd u64 prev st;
+ p <- core_option_Option_unwrap u64 prev st;
let (_, v) := p in
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs (key,
- BetreeMessageInsert v))
+ betree_List_push_front (u64 * betree_Message_t) msgs (key,
+ Betree_Message_Insert v))
end
.
(** [betree_main::betree::Node::{5}::lookup_in_bindings]: forward function *)
-Fixpoint betree_node_lookup_in_bindings_fwd
- (n : nat) (key : u64) (bindings : Betree_list_t (u64 * u64)) :
+Fixpoint betree_Node_lookup_in_bindings
+ (n : nat) (key : u64) (bindings : betree_List_t (u64 * u64)) :
result (option u64)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match bindings with
- | BetreeListCons hd tl =>
+ | Betree_List_Cons hd tl =>
let (i, i0) := hd in
if i s= key
then Return (Some i0)
else
if i s> key
then Return None
- else betree_node_lookup_in_bindings_fwd n0 key tl
- | BetreeListNil => Return None
+ else betree_Node_lookup_in_bindings n0 key tl
+ | Betree_List_Nil => Return None
end
end
.
(** [betree_main::betree::Internal::{4}::lookup_in_children]: forward function *)
-Fixpoint betree_internal_lookup_in_children_fwd
- (n : nat) (self : Betree_internal_t) (key : u64) (st : state) :
+Fixpoint betree_Internal_lookup_in_children
+ (n : nat) (self : betree_Internal_t) (key : u64) (st : state) :
result (state * (option u64))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- if key s< self.(Betree_internal_pivot)
- then betree_node_lookup_fwd n0 self.(Betree_internal_left) key st
- else betree_node_lookup_fwd n0 self.(Betree_internal_right) key st
+ if key s< self.(betree_Internal_pivot)
+ then betree_Node_lookup n0 self.(betree_Internal_left) key st
+ else betree_Node_lookup n0 self.(betree_Internal_right) key st
end
(** [betree_main::betree::Internal::{4}::lookup_in_children]: backward function 0 *)
-with betree_internal_lookup_in_children_back
- (n : nat) (self : Betree_internal_t) (key : u64) (st : state) :
- result Betree_internal_t
+with betree_Internal_lookup_in_children_back
+ (n : nat) (self : betree_Internal_t) (key : u64) (st : state) :
+ result betree_Internal_t
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- if key s< self.(Betree_internal_pivot)
+ if key s< self.(betree_Internal_pivot)
then (
- n1 <- betree_node_lookup_back n0 self.(Betree_internal_left) key st;
- Return (mkBetree_internal_t self.(Betree_internal_id)
- self.(Betree_internal_pivot) n1 self.(Betree_internal_right)))
+ n1 <- betree_Node_lookup_back n0 self.(betree_Internal_left) key st;
+ Return (mkbetree_Internal_t self.(betree_Internal_id)
+ self.(betree_Internal_pivot) n1 self.(betree_Internal_right)))
else (
- n1 <- betree_node_lookup_back n0 self.(Betree_internal_right) key st;
- Return (mkBetree_internal_t self.(Betree_internal_id)
- self.(Betree_internal_pivot) self.(Betree_internal_left) n1))
+ n1 <- betree_Node_lookup_back n0 self.(betree_Internal_right) key st;
+ Return (mkbetree_Internal_t self.(betree_Internal_id)
+ self.(betree_Internal_pivot) self.(betree_Internal_left) n1))
end
(** [betree_main::betree::Node::{5}::lookup]: forward function *)
-with betree_node_lookup_fwd
- (n : nat) (self : Betree_node_t) (key : u64) (st : state) :
+with betree_Node_lookup
+ (n : nat) (self : betree_Node_t) (key : u64) (st : state) :
result (state * (option u64))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match self with
- | BetreeNodeInternal node =>
- p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+ | Betree_Node_Internal node =>
+ p <- betree_load_internal_node node.(betree_Internal_id) st;
let (st0, msgs) := p in
- pending <- betree_node_lookup_first_message_for_key_fwd n0 key msgs;
+ pending <- betree_Node_lookup_first_message_for_key n0 key msgs;
match pending with
- | BetreeListCons p0 l =>
+ | Betree_List_Cons p0 l =>
let (k, msg) := p0 in
if k s<> key
then (
- p1 <- betree_internal_lookup_in_children_fwd n0 node key st0;
- let (st1, opt) := p1 in
+ p1 <- betree_Internal_lookup_in_children n0 node key st0;
+ let (st1, o) := p1 in
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- (BetreeListCons (k, msg) l);
- Return (st1, opt))
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ (Betree_List_Cons (k, msg) l);
+ Return (st1, o))
else
match msg with
- | BetreeMessageInsert v =>
+ | Betree_Message_Insert v =>
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- (BetreeListCons (k, BetreeMessageInsert v) l);
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ (Betree_List_Cons (k, Betree_Message_Insert v) l);
Return (st0, Some v)
- | BetreeMessageDelete =>
+ | Betree_Message_Delete =>
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- (BetreeListCons (k, BetreeMessageDelete) l);
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ (Betree_List_Cons (k, Betree_Message_Delete) l);
Return (st0, None)
- | BetreeMessageUpsert ufs =>
- p1 <- betree_internal_lookup_in_children_fwd n0 node key st0;
+ | Betree_Message_Upsert ufs =>
+ p1 <- betree_Internal_lookup_in_children n0 node key st0;
let (st1, v) := p1 in
p2 <-
- betree_node_apply_upserts_fwd n0 (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1;
+ betree_Node_apply_upserts n0 (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1;
let (st2, v0) := p2 in
- node0 <- betree_internal_lookup_in_children_back n0 node key st0;
+ node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
pending0 <-
- betree_node_apply_upserts_back n0 (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1;
+ betree_Node_apply_upserts_back n0 (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1;
msgs0 <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
pending0;
p3 <-
- betree_store_internal_node_fwd node0.(Betree_internal_id) msgs0
- st2;
+ betree_store_internal_node node0.(betree_Internal_id) msgs0 st2;
let (st3, _) := p3 in
Return (st3, Some v0)
end
- | BetreeListNil =>
- p0 <- betree_internal_lookup_in_children_fwd n0 node key st0;
- let (st1, opt) := p0 in
+ | Betree_List_Nil =>
+ p0 <- betree_Internal_lookup_in_children n0 node key st0;
+ let (st1, o) := p0 in
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- BetreeListNil;
- Return (st1, opt)
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ Betree_List_Nil;
+ Return (st1, o)
end
- | BetreeNodeLeaf node =>
- p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+ | Betree_Node_Leaf node =>
+ p <- betree_load_leaf_node node.(betree_Leaf_id) st;
let (st0, bindings) := p in
- opt <- betree_node_lookup_in_bindings_fwd n0 key bindings;
- Return (st0, opt)
+ o <- betree_Node_lookup_in_bindings n0 key bindings;
+ Return (st0, o)
end
end
(** [betree_main::betree::Node::{5}::lookup]: backward function 0 *)
-with betree_node_lookup_back
- (n : nat) (self : Betree_node_t) (key : u64) (st : state) :
- result Betree_node_t
+with betree_Node_lookup_back
+ (n : nat) (self : betree_Node_t) (key : u64) (st : state) :
+ result betree_Node_t
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match self with
- | BetreeNodeInternal node =>
- p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+ | Betree_Node_Internal node =>
+ p <- betree_load_internal_node node.(betree_Internal_id) st;
let (st0, msgs) := p in
- pending <- betree_node_lookup_first_message_for_key_fwd n0 key msgs;
+ pending <- betree_Node_lookup_first_message_for_key n0 key msgs;
match pending with
- | BetreeListCons p0 l =>
+ | Betree_List_Cons p0 l =>
let (k, msg) := p0 in
if k s<> key
then (
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- (BetreeListCons (k, msg) l);
- node0 <- betree_internal_lookup_in_children_back n0 node key st0;
- Return (BetreeNodeInternal node0))
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ (Betree_List_Cons (k, msg) l);
+ node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
+ Return (Betree_Node_Internal node0))
else
match msg with
- | BetreeMessageInsert v =>
+ | Betree_Message_Insert v =>
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- (BetreeListCons (k, BetreeMessageInsert v) l);
- Return (BetreeNodeInternal node)
- | BetreeMessageDelete =>
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ (Betree_List_Cons (k, Betree_Message_Insert v) l);
+ Return (Betree_Node_Internal node)
+ | Betree_Message_Delete =>
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- (BetreeListCons (k, BetreeMessageDelete) l);
- Return (BetreeNodeInternal node)
- | BetreeMessageUpsert ufs =>
- p1 <- betree_internal_lookup_in_children_fwd n0 node key st0;
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ (Betree_List_Cons (k, Betree_Message_Delete) l);
+ Return (Betree_Node_Internal node)
+ | Betree_Message_Upsert ufs =>
+ p1 <- betree_Internal_lookup_in_children n0 node key st0;
let (st1, v) := p1 in
p2 <-
- betree_node_apply_upserts_fwd n0 (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1;
+ betree_Node_apply_upserts n0 (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1;
let (st2, _) := p2 in
- node0 <- betree_internal_lookup_in_children_back n0 node key st0;
+ node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
pending0 <-
- betree_node_apply_upserts_back n0 (BetreeListCons (k,
- BetreeMessageUpsert ufs) l) v key st1;
+ betree_Node_apply_upserts_back n0 (Betree_List_Cons (k,
+ Betree_Message_Upsert ufs) l) v key st1;
msgs0 <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
pending0;
_ <-
- betree_store_internal_node_fwd node0.(Betree_internal_id) msgs0
- st2;
- Return (BetreeNodeInternal node0)
+ betree_store_internal_node node0.(betree_Internal_id) msgs0 st2;
+ Return (Betree_Node_Internal node0)
end
- | BetreeListNil =>
+ | Betree_List_Nil =>
_ <-
- betree_node_lookup_first_message_for_key_back n0 key msgs
- BetreeListNil;
- node0 <- betree_internal_lookup_in_children_back n0 node key st0;
- Return (BetreeNodeInternal node0)
+ betree_Node_lookup_first_message_for_key_back n0 key msgs
+ Betree_List_Nil;
+ node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
+ Return (Betree_Node_Internal node0)
end
- | BetreeNodeLeaf node =>
- p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+ | Betree_Node_Leaf node =>
+ p <- betree_load_leaf_node node.(betree_Leaf_id) st;
let (_, bindings) := p in
- _ <- betree_node_lookup_in_bindings_fwd n0 key bindings;
- Return (BetreeNodeLeaf node)
+ _ <- betree_Node_lookup_in_bindings n0 key bindings;
+ Return (Betree_Node_Leaf node)
end
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 ()) *)
-Fixpoint betree_node_filter_messages_for_key_fwd_back
- (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_filter_messages_for_key
+ (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match msgs with
- | BetreeListCons p l =>
+ | Betree_List_Cons p l =>
let (k, m) := p in
if k s= key
then (
msgs0 <-
- betree_list_pop_front_back (u64 * Betree_message_t) (BetreeListCons
+ betree_List_pop_front_back (u64 * betree_Message_t) (Betree_List_Cons
(k, m) l);
- betree_node_filter_messages_for_key_fwd_back n0 key msgs0)
- else Return (BetreeListCons (k, m) l)
- | BetreeListNil => Return BetreeListNil
+ betree_Node_filter_messages_for_key n0 key msgs0)
+ else Return (Betree_List_Cons (k, m) l)
+ | Betree_List_Nil => Return Betree_List_Nil
end
end
.
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: forward function *)
-Fixpoint betree_node_lookup_first_message_after_key_fwd
- (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_after_key
+ (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match msgs with
- | BetreeListCons p next_msgs =>
+ | Betree_List_Cons p next_msgs =>
let (k, m) := p in
if k s= key
- then betree_node_lookup_first_message_after_key_fwd n0 key next_msgs
- else Return (BetreeListCons (k, m) next_msgs)
- | BetreeListNil => Return BetreeListNil
+ then betree_Node_lookup_first_message_after_key n0 key next_msgs
+ else Return (Betree_List_Cons (k, m) next_msgs)
+ | Betree_List_Nil => Return Betree_List_Nil
end
end
.
(** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: backward function 0 *)
-Fixpoint betree_node_lookup_first_message_after_key_back
- (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t))
- (ret : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_after_key_back
+ (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t))
+ (ret : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match msgs with
- | BetreeListCons p next_msgs =>
+ | Betree_List_Cons p next_msgs =>
let (k, m) := p in
if k s= key
then (
next_msgs0 <-
- betree_node_lookup_first_message_after_key_back n0 key next_msgs ret;
- Return (BetreeListCons (k, m) next_msgs0))
+ betree_Node_lookup_first_message_after_key_back n0 key next_msgs ret;
+ Return (Betree_List_Cons (k, m) next_msgs0))
else Return ret
- | BetreeListNil => Return ret
+ | Betree_List_Nil => Return ret
end
end
.
(** [betree_main::betree::Node::{5}::apply_to_internal]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition betree_node_apply_to_internal_fwd_back
- (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t)) (key : u64)
- (new_msg : Betree_message_t) :
- result (Betree_list_t (u64 * Betree_message_t))
+Definition betree_Node_apply_to_internal
+ (n : nat) (msgs : betree_List_t (u64 * betree_Message_t)) (key : u64)
+ (new_msg : betree_Message_t) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
- msgs0 <- betree_node_lookup_first_message_for_key_fwd n key msgs;
- b <- betree_list_head_has_key_fwd Betree_message_t msgs0 key;
+ msgs0 <- betree_Node_lookup_first_message_for_key n key msgs;
+ b <- betree_List_head_has_key betree_Message_t msgs0 key;
if b
then
match new_msg with
- | BetreeMessageInsert i =>
- msgs1 <- betree_node_filter_messages_for_key_fwd_back n key msgs0;
+ | Betree_Message_Insert i =>
+ msgs1 <- betree_Node_filter_messages_for_key n key msgs0;
msgs2 <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
- BetreeMessageInsert i);
- betree_node_lookup_first_message_for_key_back n key msgs msgs2
- | BetreeMessageDelete =>
- msgs1 <- betree_node_filter_messages_for_key_fwd_back n key msgs0;
+ betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+ Betree_Message_Insert i);
+ betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+ | Betree_Message_Delete =>
+ msgs1 <- betree_Node_filter_messages_for_key n key msgs0;
msgs2 <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
- BetreeMessageDelete);
- betree_node_lookup_first_message_for_key_back n key msgs msgs2
- | BetreeMessageUpsert s =>
- p <- betree_list_hd_fwd (u64 * Betree_message_t) msgs0;
+ betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+ Betree_Message_Delete);
+ betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+ | Betree_Message_Upsert s =>
+ p <- betree_List_hd (u64 * betree_Message_t) msgs0;
let (_, m) := p in
match m with
- | BetreeMessageInsert prev =>
- v <- betree_upsert_update_fwd (Some prev) s;
- msgs1 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs0;
+ | Betree_Message_Insert prev =>
+ v <- betree_upsert_update (Some prev) s;
+ msgs1 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs0;
msgs2 <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
- BetreeMessageInsert v);
- betree_node_lookup_first_message_for_key_back n key msgs msgs2
- | BetreeMessageDelete =>
- v <- betree_upsert_update_fwd None s;
- 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);
+ betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+ | Betree_Message_Delete =>
+ v <- betree_upsert_update None s;
+ msgs1 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs0;
msgs2 <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
- BetreeMessageInsert v);
- betree_node_lookup_first_message_for_key_back n key msgs msgs2
- | BetreeMessageUpsert ufs =>
- msgs1 <- betree_node_lookup_first_message_after_key_fwd n key msgs0;
+ betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+ Betree_Message_Insert v);
+ betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+ | Betree_Message_Upsert ufs =>
+ msgs1 <- betree_Node_lookup_first_message_after_key n key msgs0;
msgs2 <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
- BetreeMessageUpsert s);
+ betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+ Betree_Message_Upsert s);
msgs3 <-
- betree_node_lookup_first_message_after_key_back n key msgs0 msgs2;
- betree_node_lookup_first_message_for_key_back n key msgs msgs3
+ betree_Node_lookup_first_message_after_key_back n key msgs0 msgs2;
+ betree_Node_lookup_first_message_for_key_back n key msgs msgs3
end
end
else (
msgs1 <-
- betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs0 (key,
- new_msg);
- betree_node_lookup_first_message_for_key_back n key msgs msgs1)
+ betree_List_push_front (u64 * betree_Message_t) msgs0 (key, new_msg);
+ betree_Node_lookup_first_message_for_key_back n 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 ()) *)
-Fixpoint betree_node_apply_messages_to_internal_fwd_back
- (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t))
- (new_msgs : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_apply_messages_to_internal
+ (n : nat) (msgs : betree_List_t (u64 * betree_Message_t))
+ (new_msgs : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * betree_Message_t))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match new_msgs with
- | BetreeListCons new_msg new_msgs_tl =>
+ | Betree_List_Cons new_msg new_msgs_tl =>
let (i, m) := new_msg in
- msgs0 <- betree_node_apply_to_internal_fwd_back n0 msgs i m;
- betree_node_apply_messages_to_internal_fwd_back n0 msgs0 new_msgs_tl
- | BetreeListNil => Return msgs
+ msgs0 <- betree_Node_apply_to_internal n0 msgs i m;
+ betree_Node_apply_messages_to_internal n0 msgs0 new_msgs_tl
+ | Betree_List_Nil => Return msgs
end
end
.
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: forward function *)
-Fixpoint betree_node_lookup_mut_in_bindings_fwd
- (n : nat) (key : u64) (bindings : Betree_list_t (u64 * u64)) :
- result (Betree_list_t (u64 * u64))
+Fixpoint betree_Node_lookup_mut_in_bindings
+ (n : nat) (key : u64) (bindings : betree_List_t (u64 * u64)) :
+ result (betree_List_t (u64 * u64))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match bindings with
- | BetreeListCons hd tl =>
+ | Betree_List_Cons hd tl =>
let (i, i0) := hd in
if i s>= key
- then Return (BetreeListCons (i, i0) tl)
- else betree_node_lookup_mut_in_bindings_fwd n0 key tl
- | BetreeListNil => Return BetreeListNil
+ then Return (Betree_List_Cons (i, i0) tl)
+ else betree_Node_lookup_mut_in_bindings n0 key tl
+ | Betree_List_Nil => Return Betree_List_Nil
end
end
.
(** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: backward function 0 *)
-Fixpoint betree_node_lookup_mut_in_bindings_back
- (n : nat) (key : u64) (bindings : Betree_list_t (u64 * u64))
- (ret : Betree_list_t (u64 * u64)) :
- result (Betree_list_t (u64 * u64))
+Fixpoint betree_Node_lookup_mut_in_bindings_back
+ (n : nat) (key : u64) (bindings : betree_List_t (u64 * u64))
+ (ret : betree_List_t (u64 * u64)) :
+ result (betree_List_t (u64 * u64))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match bindings with
- | BetreeListCons hd tl =>
+ | Betree_List_Cons hd tl =>
let (i, i0) := hd in
if i s>= key
then Return ret
else (
- tl0 <- betree_node_lookup_mut_in_bindings_back n0 key tl ret;
- Return (BetreeListCons (i, i0) tl0))
- | BetreeListNil => Return ret
+ tl0 <- betree_Node_lookup_mut_in_bindings_back n0 key tl ret;
+ Return (Betree_List_Cons (i, i0) tl0))
+ | Betree_List_Nil => Return ret
end
end
.
(** [betree_main::betree::Node::{5}::apply_to_leaf]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition betree_node_apply_to_leaf_fwd_back
- (n : nat) (bindings : Betree_list_t (u64 * u64)) (key : u64)
- (new_msg : Betree_message_t) :
- result (Betree_list_t (u64 * u64))
+Definition betree_Node_apply_to_leaf
+ (n : nat) (bindings : betree_List_t (u64 * u64)) (key : u64)
+ (new_msg : betree_Message_t) :
+ result (betree_List_t (u64 * u64))
:=
- bindings0 <- betree_node_lookup_mut_in_bindings_fwd n key bindings;
- b <- betree_list_head_has_key_fwd u64 bindings0 key;
+ bindings0 <- betree_Node_lookup_mut_in_bindings n key bindings;
+ b <- betree_List_head_has_key u64 bindings0 key;
if b
then (
- hd <- betree_list_pop_front_fwd (u64 * u64) bindings0;
+ hd <- betree_List_pop_front (u64 * u64) bindings0;
match new_msg with
- | BetreeMessageInsert v =>
- bindings1 <- betree_list_pop_front_back (u64 * u64) bindings0;
- bindings2 <-
- betree_list_push_front_fwd_back (u64 * u64) bindings1 (key, v);
- betree_node_lookup_mut_in_bindings_back n key bindings bindings2
- | BetreeMessageDelete =>
- bindings1 <- betree_list_pop_front_back (u64 * u64) bindings0;
- betree_node_lookup_mut_in_bindings_back n key bindings bindings1
- | BetreeMessageUpsert s =>
+ | Betree_Message_Insert v =>
+ bindings1 <- betree_List_pop_front_back (u64 * u64) bindings0;
+ bindings2 <- betree_List_push_front (u64 * u64) bindings1 (key, v);
+ betree_Node_lookup_mut_in_bindings_back n key bindings bindings2
+ | Betree_Message_Delete =>
+ bindings1 <- betree_List_pop_front_back (u64 * u64) bindings0;
+ betree_Node_lookup_mut_in_bindings_back n key bindings bindings1
+ | Betree_Message_Upsert s =>
let (_, i) := hd in
- v <- betree_upsert_update_fwd (Some i) s;
- bindings1 <- betree_list_pop_front_back (u64 * u64) bindings0;
- bindings2 <-
- betree_list_push_front_fwd_back (u64 * u64) bindings1 (key, v);
- betree_node_lookup_mut_in_bindings_back n key bindings bindings2
+ v <- betree_upsert_update (Some i) s;
+ bindings1 <- betree_List_pop_front_back (u64 * u64) bindings0;
+ bindings2 <- betree_List_push_front (u64 * u64) bindings1 (key, v);
+ betree_Node_lookup_mut_in_bindings_back n key bindings bindings2
end)
else
match new_msg with
- | BetreeMessageInsert v =>
- bindings1 <-
- betree_list_push_front_fwd_back (u64 * u64) bindings0 (key, v);
- betree_node_lookup_mut_in_bindings_back n key bindings bindings1
- | BetreeMessageDelete =>
- betree_node_lookup_mut_in_bindings_back n key bindings bindings0
- | BetreeMessageUpsert s =>
- v <- betree_upsert_update_fwd None s;
- bindings1 <-
- betree_list_push_front_fwd_back (u64 * u64) bindings0 (key, v);
- betree_node_lookup_mut_in_bindings_back n key bindings bindings1
+ | Betree_Message_Insert v =>
+ bindings1 <- betree_List_push_front (u64 * u64) bindings0 (key, v);
+ betree_Node_lookup_mut_in_bindings_back n key bindings bindings1
+ | Betree_Message_Delete =>
+ betree_Node_lookup_mut_in_bindings_back n key bindings bindings0
+ | Betree_Message_Upsert s =>
+ v <- betree_upsert_update None s;
+ bindings1 <- betree_List_push_front (u64 * u64) bindings0 (key, v);
+ betree_Node_lookup_mut_in_bindings_back n 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 ()) *)
-Fixpoint betree_node_apply_messages_to_leaf_fwd_back
- (n : nat) (bindings : Betree_list_t (u64 * u64))
- (new_msgs : Betree_list_t (u64 * Betree_message_t)) :
- result (Betree_list_t (u64 * u64))
+Fixpoint betree_Node_apply_messages_to_leaf
+ (n : nat) (bindings : betree_List_t (u64 * u64))
+ (new_msgs : betree_List_t (u64 * betree_Message_t)) :
+ result (betree_List_t (u64 * u64))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match new_msgs with
- | BetreeListCons new_msg new_msgs_tl =>
+ | Betree_List_Cons new_msg new_msgs_tl =>
let (i, m) := new_msg in
- bindings0 <- betree_node_apply_to_leaf_fwd_back n0 bindings i m;
- betree_node_apply_messages_to_leaf_fwd_back n0 bindings0 new_msgs_tl
- | BetreeListNil => Return bindings
+ bindings0 <- betree_Node_apply_to_leaf n0 bindings i m;
+ betree_Node_apply_messages_to_leaf n0 bindings0 new_msgs_tl
+ | Betree_List_Nil => Return bindings
end
end
.
(** [betree_main::betree::Internal::{4}::flush]: forward function *)
-Fixpoint betree_internal_flush_fwd
- (n : nat) (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) :
- result (state * (Betree_list_t (u64 * Betree_message_t)))
+Fixpoint betree_Internal_flush
+ (n : nat) (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 * betree_Message_t)) (st : state) :
+ result (state * (betree_List_t (u64 * betree_Message_t)))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
p <-
- betree_list_partition_at_pivot_fwd Betree_message_t n0 content
- self.(Betree_internal_pivot);
+ betree_List_partition_at_pivot betree_Message_t n0 content
+ self.(betree_Internal_pivot);
let (msgs_left, msgs_right) := p in
- len_left <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_left;
- if len_left s>= params.(Betree_params_min_flush_size)
+ len_left <- betree_List_len (u64 * betree_Message_t) n0 msgs_left;
+ if len_left s>= params.(betree_Params_min_flush_size)
then (
p0 <-
- betree_node_apply_messages_fwd n0 self.(Betree_internal_left) params
+ betree_Node_apply_messages n0 self.(betree_Internal_left) params
node_id_cnt msgs_left st;
let (st0, _) := p0 in
p1 <-
- betree_node_apply_messages_back n0 self.(Betree_internal_left) params
+ betree_Node_apply_messages_back n0 self.(betree_Internal_left) params
node_id_cnt msgs_left st;
let (_, node_id_cnt0) := p1 in
- len_right <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_right;
- if len_right s>= params.(Betree_params_min_flush_size)
+ len_right <- betree_List_len (u64 * betree_Message_t) n0 msgs_right;
+ if len_right s>= params.(betree_Params_min_flush_size)
then (
p2 <-
- betree_node_apply_messages_fwd n0 self.(Betree_internal_right) params
+ betree_Node_apply_messages n0 self.(betree_Internal_right) params
node_id_cnt0 msgs_right st0;
let (st1, _) := p2 in
_ <-
- betree_node_apply_messages_back n0 self.(Betree_internal_right)
+ betree_Node_apply_messages_back n0 self.(betree_Internal_right)
params node_id_cnt0 msgs_right st0;
- Return (st1, BetreeListNil))
+ Return (st1, Betree_List_Nil))
else Return (st0, msgs_right))
else (
p0 <-
- betree_node_apply_messages_fwd n0 self.(Betree_internal_right) params
+ betree_Node_apply_messages n0 self.(betree_Internal_right) params
node_id_cnt msgs_right st;
let (st0, _) := p0 in
_ <-
- betree_node_apply_messages_back n0 self.(Betree_internal_right) params
+ betree_Node_apply_messages_back n0 self.(betree_Internal_right) params
node_id_cnt msgs_right st;
Return (st0, msgs_left))
end
(** [betree_main::betree::Internal::{4}::flush]: backward function 0 *)
-with betree_internal_flush_back
- (n : nat) (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) :
- result (Betree_internal_t * Betree_node_id_counter_t)
+with betree_Internal_flush_back
+ (n : nat) (self : betree_Internal_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (content : betree_List_t (u64 * betree_Message_t)) (st : state) :
+ result (betree_Internal_t * betree_NodeIdCounter_t)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
p <-
- betree_list_partition_at_pivot_fwd Betree_message_t n0 content
- self.(Betree_internal_pivot);
+ betree_List_partition_at_pivot betree_Message_t n0 content
+ self.(betree_Internal_pivot);
let (msgs_left, msgs_right) := p in
- len_left <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_left;
- if len_left s>= params.(Betree_params_min_flush_size)
+ len_left <- betree_List_len (u64 * betree_Message_t) n0 msgs_left;
+ if len_left s>= params.(betree_Params_min_flush_size)
then (
p0 <-
- betree_node_apply_messages_fwd n0 self.(Betree_internal_left) params
+ betree_Node_apply_messages n0 self.(betree_Internal_left) params
node_id_cnt msgs_left st;
let (st0, _) := p0 in
p1 <-
- betree_node_apply_messages_back n0 self.(Betree_internal_left) params
+ betree_Node_apply_messages_back n0 self.(betree_Internal_left) params
node_id_cnt msgs_left st;
let (n1, node_id_cnt0) := p1 in
- len_right <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_right;
- if len_right s>= params.(Betree_params_min_flush_size)
+ len_right <- betree_List_len (u64 * betree_Message_t) n0 msgs_right;
+ if len_right s>= params.(betree_Params_min_flush_size)
then (
p2 <-
- betree_node_apply_messages_back n0 self.(Betree_internal_right)
+ betree_Node_apply_messages_back n0 self.(betree_Internal_right)
params node_id_cnt0 msgs_right st0;
let (n2, node_id_cnt1) := p2 in
- Return (mkBetree_internal_t self.(Betree_internal_id)
- self.(Betree_internal_pivot) n1 n2, node_id_cnt1))
+ Return (mkbetree_Internal_t self.(betree_Internal_id)
+ self.(betree_Internal_pivot) n1 n2, node_id_cnt1))
else
- Return (mkBetree_internal_t self.(Betree_internal_id)
- self.(Betree_internal_pivot) n1 self.(Betree_internal_right),
+ Return (mkbetree_Internal_t self.(betree_Internal_id)
+ self.(betree_Internal_pivot) n1 self.(betree_Internal_right),
node_id_cnt0))
else (
p0 <-
- betree_node_apply_messages_back n0 self.(Betree_internal_right) params
+ betree_Node_apply_messages_back n0 self.(betree_Internal_right) params
node_id_cnt msgs_right st;
let (n1, node_id_cnt0) := p0 in
- Return (mkBetree_internal_t self.(Betree_internal_id)
- self.(Betree_internal_pivot) self.(Betree_internal_left) n1,
+ Return (mkbetree_Internal_t self.(betree_Internal_id)
+ self.(betree_Internal_pivot) self.(betree_Internal_left) n1,
node_id_cnt0))
end
(** [betree_main::betree::Node::{5}::apply_messages]: forward function *)
-with betree_node_apply_messages_fwd
- (n : nat) (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) :
+with betree_Node_apply_messages
+ (n : nat) (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 * betree_Message_t)) (st : state) :
result (state * unit)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match self with
- | BetreeNodeInternal node =>
- p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+ | Betree_Node_Internal node =>
+ p <- betree_load_internal_node node.(betree_Internal_id) st;
let (st0, content) := p in
- content0 <-
- betree_node_apply_messages_to_internal_fwd_back n0 content msgs;
- num_msgs <- betree_list_len_fwd (u64 * Betree_message_t) n0 content0;
- if num_msgs s>= params.(Betree_params_min_flush_size)
+ content0 <- betree_Node_apply_messages_to_internal n0 content msgs;
+ num_msgs <- betree_List_len (u64 * betree_Message_t) n0 content0;
+ if num_msgs s>= params.(betree_Params_min_flush_size)
then (
- p0 <-
- betree_internal_flush_fwd n0 node params node_id_cnt content0 st0;
+ p0 <- betree_Internal_flush n0 node params node_id_cnt content0 st0;
let (st1, content1) := p0 in
p1 <-
- betree_internal_flush_back n0 node params node_id_cnt content0 st0;
+ betree_Internal_flush_back n0 node params node_id_cnt content0 st0;
let (node0, _) := p1 in
p2 <-
- betree_store_internal_node_fwd node0.(Betree_internal_id) content1
- st1;
+ betree_store_internal_node node0.(betree_Internal_id) content1 st1;
let (st2, _) := p2 in
Return (st2, tt))
else (
p0 <-
- betree_store_internal_node_fwd node.(Betree_internal_id) content0 st0;
+ betree_store_internal_node node.(betree_Internal_id) content0 st0;
let (st1, _) := p0 in
Return (st1, tt))
- | BetreeNodeLeaf node =>
- p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+ | Betree_Node_Leaf node =>
+ p <- betree_load_leaf_node node.(betree_Leaf_id) st;
let (st0, content) := p in
- content0 <- betree_node_apply_messages_to_leaf_fwd_back n0 content msgs;
- len <- betree_list_len_fwd (u64 * u64) n0 content0;
- i <- u64_mul 2%u64 params.(Betree_params_split_size);
+ content0 <- betree_Node_apply_messages_to_leaf n0 content msgs;
+ len <- betree_List_len (u64 * u64) n0 content0;
+ i <- u64_mul 2%u64 params.(betree_Params_split_size);
if len s>= i
then (
- p0 <- betree_leaf_split_fwd n0 node content0 params node_id_cnt st0;
+ p0 <- betree_Leaf_split n0 node content0 params node_id_cnt st0;
let (st1, _) := p0 in
- p1 <-
- betree_store_leaf_node_fwd node.(Betree_leaf_id) BetreeListNil st1;
+ p1 <- betree_store_leaf_node node.(betree_Leaf_id) Betree_List_Nil st1;
let (st2, _) := p1 in
Return (st2, tt))
else (
- p0 <- betree_store_leaf_node_fwd node.(Betree_leaf_id) content0 st0;
+ p0 <- betree_store_leaf_node node.(betree_Leaf_id) content0 st0;
let (st1, _) := p0 in
Return (st1, tt))
end
end
(** [betree_main::betree::Node::{5}::apply_messages]: backward function 0 *)
-with betree_node_apply_messages_back
- (n : nat) (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) :
- result (Betree_node_t * Betree_node_id_counter_t)
+with betree_Node_apply_messages_back
+ (n : nat) (self : betree_Node_t) (params : betree_Params_t)
+ (node_id_cnt : betree_NodeIdCounter_t)
+ (msgs : betree_List_t (u64 * betree_Message_t)) (st : state) :
+ result (betree_Node_t * betree_NodeIdCounter_t)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match self with
- | BetreeNodeInternal node =>
- p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+ | Betree_Node_Internal node =>
+ p <- betree_load_internal_node node.(betree_Internal_id) st;
let (st0, content) := p in
- content0 <-
- betree_node_apply_messages_to_internal_fwd_back n0 content msgs;
- num_msgs <- betree_list_len_fwd (u64 * Betree_message_t) n0 content0;
- if num_msgs s>= params.(Betree_params_min_flush_size)
+ content0 <- betree_Node_apply_messages_to_internal n0 content msgs;
+ num_msgs <- betree_List_len (u64 * betree_Message_t) n0 content0;
+ if num_msgs s>= params.(betree_Params_min_flush_size)
then (
- p0 <-
- betree_internal_flush_fwd n0 node params node_id_cnt content0 st0;
+ p0 <- betree_Internal_flush n0 node params node_id_cnt content0 st0;
let (st1, content1) := p0 in
p1 <-
- betree_internal_flush_back n0 node params node_id_cnt content0 st0;
+ betree_Internal_flush_back n0 node params node_id_cnt content0 st0;
let (node0, node_id_cnt0) := p1 in
_ <-
- betree_store_internal_node_fwd node0.(Betree_internal_id) content1
- st1;
- Return (BetreeNodeInternal node0, node_id_cnt0))
+ betree_store_internal_node node0.(betree_Internal_id) content1 st1;
+ Return (Betree_Node_Internal node0, node_id_cnt0))
else (
- _ <-
- betree_store_internal_node_fwd node.(Betree_internal_id) content0 st0;
- Return (BetreeNodeInternal node, node_id_cnt))
- | BetreeNodeLeaf node =>
- p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+ _ <- betree_store_internal_node node.(betree_Internal_id) content0 st0;
+ Return (Betree_Node_Internal node, node_id_cnt))
+ | Betree_Node_Leaf node =>
+ p <- betree_load_leaf_node node.(betree_Leaf_id) st;
let (st0, content) := p in
- content0 <- betree_node_apply_messages_to_leaf_fwd_back n0 content msgs;
- len <- betree_list_len_fwd (u64 * u64) n0 content0;
- i <- u64_mul 2%u64 params.(Betree_params_split_size);
+ content0 <- betree_Node_apply_messages_to_leaf n0 content msgs;
+ len <- betree_List_len (u64 * u64) n0 content0;
+ i <- u64_mul 2%u64 params.(betree_Params_split_size);
if len s>= i
then (
- p0 <- betree_leaf_split_fwd n0 node content0 params node_id_cnt st0;
+ p0 <- betree_Leaf_split n0 node content0 params node_id_cnt st0;
let (st1, new_node) := p0 in
- _ <-
- betree_store_leaf_node_fwd node.(Betree_leaf_id) BetreeListNil st1;
+ _ <- betree_store_leaf_node node.(betree_Leaf_id) Betree_List_Nil st1;
node_id_cnt0 <-
- betree_leaf_split_back n0 node content0 params node_id_cnt st0;
- Return (BetreeNodeInternal new_node, node_id_cnt0))
+ betree_Leaf_split_back n0 node content0 params node_id_cnt st0;
+ Return (Betree_Node_Internal new_node, node_id_cnt0))
else (
- _ <- betree_store_leaf_node_fwd node.(Betree_leaf_id) content0 st0;
- Return (BetreeNodeLeaf
- {| Betree_leaf_id := node.(Betree_leaf_id); Betree_leaf_size := len
+ _ <- betree_store_leaf_node node.(betree_Leaf_id) content0 st0;
+ Return (Betree_Node_Leaf
+ {| betree_Leaf_id := node.(betree_Leaf_id); betree_Leaf_size := len
|}, node_id_cnt))
end
end
.
(** [betree_main::betree::Node::{5}::apply]: forward function *)
-Definition betree_node_apply_fwd
- (n : nat) (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) :
+Definition betree_Node_apply
+ (n : nat) (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
p <-
- betree_node_apply_messages_fwd n self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages n self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st;
let (st0, _) := p in
_ <-
- betree_node_apply_messages_back n self params node_id_cnt (BetreeListCons
+ betree_Node_apply_messages_back n self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st;
Return (st0, tt)
.
(** [betree_main::betree::Node::{5}::apply]: backward function 0 *)
-Definition betree_node_apply_back
- (n : nat) (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)
+Definition betree_Node_apply_back
+ (n : nat) (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 n self params node_id_cnt (BetreeListCons
+ let l := Betree_List_Nil in
+ betree_Node_apply_messages_back n self params node_id_cnt (Betree_List_Cons
(key, new_msg) l) st
.
(** [betree_main::betree::BeTree::{6}::new]: forward function *)
-Definition betree_be_tree_new_fwd
+Definition betree_BeTree_new
(min_flush_size : u64) (split_size : u64) (st : state) :
- result (state * Betree_be_tree_t)
+ result (state * betree_BeTree_t)
:=
- node_id_cnt <- betree_node_id_counter_new_fwd;
- id <- betree_node_id_counter_fresh_id_fwd node_id_cnt;
- p <- betree_store_leaf_node_fwd id BetreeListNil st;
+ node_id_cnt <- betree_NodeIdCounter_new;
+ id <- betree_NodeIdCounter_fresh_id node_id_cnt;
+ p <- betree_store_leaf_node id Betree_List_Nil st;
let (st0, _) := p in
- node_id_cnt0 <- betree_node_id_counter_fresh_id_back node_id_cnt;
+ node_id_cnt0 <- betree_NodeIdCounter_fresh_id_back node_id_cnt;
Return (st0,
{|
- Betree_be_tree_params :=
+ betree_BeTree_params :=
{|
- Betree_params_min_flush_size := min_flush_size;
- Betree_params_split_size := split_size
+ 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%u64 |})
+ betree_BeTree_node_id_cnt := node_id_cnt0;
+ betree_BeTree_root :=
+ (Betree_Node_Leaf
+ {| betree_Leaf_id := id; betree_Leaf_size := 0%u64 |})
|})
.
(** [betree_main::betree::BeTree::{6}::apply]: forward function *)
-Definition betree_be_tree_apply_fwd
- (n : nat) (self : Betree_be_tree_t) (key : u64) (msg : Betree_message_t)
+Definition betree_BeTree_apply
+ (n : nat) (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t)
(st : state) :
result (state * unit)
:=
p <-
- betree_node_apply_fwd n self.(Betree_be_tree_root)
- self.(Betree_be_tree_params) self.(Betree_be_tree_node_id_cnt) key msg st;
+ betree_Node_apply n self.(betree_BeTree_root) self.(betree_BeTree_params)
+ self.(betree_BeTree_node_id_cnt) key msg st;
let (st0, _) := p in
_ <-
- betree_node_apply_back n self.(Betree_be_tree_root)
- self.(Betree_be_tree_params) self.(Betree_be_tree_node_id_cnt) key msg st;
+ betree_Node_apply_back n self.(betree_BeTree_root)
+ self.(betree_BeTree_params) self.(betree_BeTree_node_id_cnt) key msg st;
Return (st0, tt)
.
(** [betree_main::betree::BeTree::{6}::apply]: backward function 0 *)
-Definition betree_be_tree_apply_back
- (n : nat) (self : Betree_be_tree_t) (key : u64) (msg : Betree_message_t)
+Definition betree_BeTree_apply_back
+ (n : nat) (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t)
(st : state) :
- result Betree_be_tree_t
+ result betree_BeTree_t
:=
p <-
- betree_node_apply_back n self.(Betree_be_tree_root)
- self.(Betree_be_tree_params) self.(Betree_be_tree_node_id_cnt) key msg st;
+ betree_Node_apply_back n self.(betree_BeTree_root)
+ self.(betree_BeTree_params) self.(betree_BeTree_node_id_cnt) key msg st;
let (n0, nic) := p in
Return
{|
- Betree_be_tree_params := self.(Betree_be_tree_params);
- Betree_be_tree_node_id_cnt := nic;
- Betree_be_tree_root := n0
+ betree_BeTree_params := self.(betree_BeTree_params);
+ betree_BeTree_node_id_cnt := nic;
+ betree_BeTree_root := n0
|}
.
(** [betree_main::betree::BeTree::{6}::insert]: forward function *)
-Definition betree_be_tree_insert_fwd
- (n : nat) (self : Betree_be_tree_t) (key : u64) (value : u64) (st : state) :
+Definition betree_BeTree_insert
+ (n : nat) (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
result (state * unit)
:=
- p <- betree_be_tree_apply_fwd n self key (BetreeMessageInsert value) st;
+ p <- betree_BeTree_apply n self key (Betree_Message_Insert value) st;
let (st0, _) := p in
- _ <- betree_be_tree_apply_back n self key (BetreeMessageInsert value) st;
+ _ <- betree_BeTree_apply_back n self key (Betree_Message_Insert value) st;
Return (st0, tt)
.
(** [betree_main::betree::BeTree::{6}::insert]: backward function 0 *)
-Definition betree_be_tree_insert_back
- (n : nat) (self : Betree_be_tree_t) (key : u64) (value : u64) (st : state) :
- result Betree_be_tree_t
+Definition betree_BeTree_insert_back
+ (n : nat) (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
+ result betree_BeTree_t
:=
- betree_be_tree_apply_back n self key (BetreeMessageInsert value) st
+ betree_BeTree_apply_back n self key (Betree_Message_Insert value) st
.
(** [betree_main::betree::BeTree::{6}::delete]: forward function *)
-Definition betree_be_tree_delete_fwd
- (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
+Definition betree_BeTree_delete
+ (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
result (state * unit)
:=
- p <- betree_be_tree_apply_fwd n self key BetreeMessageDelete st;
+ p <- betree_BeTree_apply n self key Betree_Message_Delete st;
let (st0, _) := p in
- _ <- betree_be_tree_apply_back n self key BetreeMessageDelete st;
+ _ <- betree_BeTree_apply_back n self key Betree_Message_Delete st;
Return (st0, tt)
.
(** [betree_main::betree::BeTree::{6}::delete]: backward function 0 *)
-Definition betree_be_tree_delete_back
- (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
- result Betree_be_tree_t
+Definition betree_BeTree_delete_back
+ (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
+ result betree_BeTree_t
:=
- betree_be_tree_apply_back n self key BetreeMessageDelete st
+ betree_BeTree_apply_back n self key Betree_Message_Delete st
.
(** [betree_main::betree::BeTree::{6}::upsert]: forward function *)
-Definition betree_be_tree_upsert_fwd
- (n : nat) (self : Betree_be_tree_t) (key : u64)
- (upd : Betree_upsert_fun_state_t) (st : state) :
+Definition betree_BeTree_upsert
+ (n : nat) (self : betree_BeTree_t) (key : u64)
+ (upd : betree_UpsertFunState_t) (st : state) :
result (state * unit)
:=
- p <- betree_be_tree_apply_fwd n self key (BetreeMessageUpsert upd) st;
+ p <- betree_BeTree_apply n self key (Betree_Message_Upsert upd) st;
let (st0, _) := p in
- _ <- betree_be_tree_apply_back n self key (BetreeMessageUpsert upd) st;
+ _ <- betree_BeTree_apply_back n self key (Betree_Message_Upsert upd) st;
Return (st0, tt)
.
(** [betree_main::betree::BeTree::{6}::upsert]: backward function 0 *)
-Definition betree_be_tree_upsert_back
- (n : nat) (self : Betree_be_tree_t) (key : u64)
- (upd : Betree_upsert_fun_state_t) (st : state) :
- result Betree_be_tree_t
+Definition betree_BeTree_upsert_back
+ (n : nat) (self : betree_BeTree_t) (key : u64)
+ (upd : betree_UpsertFunState_t) (st : state) :
+ result betree_BeTree_t
:=
- betree_be_tree_apply_back n self key (BetreeMessageUpsert upd) st
+ betree_BeTree_apply_back n self key (Betree_Message_Upsert upd) st
.
(** [betree_main::betree::BeTree::{6}::lookup]: forward function *)
-Definition betree_be_tree_lookup_fwd
- (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
+Definition betree_BeTree_lookup
+ (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
result (state * (option u64))
:=
- betree_node_lookup_fwd n self.(Betree_be_tree_root) key st
+ betree_Node_lookup n self.(betree_BeTree_root) key st
.
(** [betree_main::betree::BeTree::{6}::lookup]: backward function 0 *)
-Definition betree_be_tree_lookup_back
- (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
- result Betree_be_tree_t
+Definition betree_BeTree_lookup_back
+ (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
+ result betree_BeTree_t
:=
- n0 <- betree_node_lookup_back n self.(Betree_be_tree_root) key st;
+ n0 <- betree_Node_lookup_back n self.(betree_BeTree_root) key st;
Return
{|
- Betree_be_tree_params := self.(Betree_be_tree_params);
- Betree_be_tree_node_id_cnt := self.(Betree_be_tree_node_id_cnt);
- Betree_be_tree_root := n0
+ betree_BeTree_params := self.(betree_BeTree_params);
+ betree_BeTree_node_id_cnt := self.(betree_BeTree_node_id_cnt);
+ betree_BeTree_root := n0
|}
.
(** [betree_main::main]: forward function *)
-Definition main_fwd : result unit :=
+Definition main : result unit :=
Return tt.
(** Unit test for [betree_main::main] *)
-Check (main_fwd )%return.
+Check (main )%return.
End BetreeMain_Funs .
diff --git a/tests/coq/betree/BetreeMain_Opaque.v b/tests/coq/betree/BetreeMain_Opaque.v
index ecd81b9d..eade90de 100644
--- a/tests/coq/betree/BetreeMain_Opaque.v
+++ b/tests/coq/betree/BetreeMain_Opaque.v
@@ -11,29 +11,29 @@ Import BetreeMain_Types.
Module BetreeMain_Opaque.
(** [betree_main::betree_utils::load_internal_node]: forward function *)
-Axiom betree_utils_load_internal_node_fwd
- : u64 -> state -> result (state * (Betree_list_t (u64 * Betree_message_t)))
+Axiom 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 *)
-Axiom betree_utils_store_internal_node_fwd
+Axiom 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 *)
-Axiom betree_utils_load_leaf_node_fwd
- : u64 -> state -> result (state * (Betree_list_t (u64 * u64)))
+Axiom betree_utils_load_leaf_node
+ : u64 -> state -> result (state * (betree_List_t (u64 * u64)))
.
(** [betree_main::betree_utils::store_leaf_node]: forward function *)
-Axiom betree_utils_store_leaf_node_fwd
- : u64 -> Betree_list_t (u64 * u64) -> state -> result (state * unit)
+Axiom betree_utils_store_leaf_node
+ : u64 -> betree_List_t (u64 * u64) -> state -> result (state * unit)
.
(** [core::option::Option::{0}::unwrap]: forward function *)
-Axiom core_option_option_unwrap_fwd :
+Axiom core_option_Option_unwrap :
forall(T : Type), option T -> state -> result (state * T)
.
diff --git a/tests/coq/betree/BetreeMain_Types.v b/tests/coq/betree/BetreeMain_Types.v
index 4a4e75aa..933a670c 100644
--- a/tests/coq/betree/BetreeMain_Types.v
+++ b/tests/coq/betree/BetreeMain_Types.v
@@ -9,98 +9,98 @@ Local Open Scope Primitives_scope.
Module BetreeMain_Types.
(** [betree_main::betree::List] *)
-Inductive Betree_list_t (T : Type) :=
-| BetreeListCons : T -> Betree_list_t T -> Betree_list_t T
-| BetreeListNil : Betree_list_t T
+Inductive betree_List_t (T : Type) :=
+| Betree_List_Cons : T -> betree_List_t T -> betree_List_t T
+| Betree_List_Nil : betree_List_t T
.
-Arguments BetreeListCons {T} _ _.
-Arguments BetreeListNil {T}.
+Arguments Betree_List_Cons { _ }.
+Arguments Betree_List_Nil { _ }.
(** [betree_main::betree::UpsertFunState] *)
-Inductive Betree_upsert_fun_state_t :=
-| BetreeUpsertFunStateAdd : u64 -> Betree_upsert_fun_state_t
-| BetreeUpsertFunStateSub : u64 -> Betree_upsert_fun_state_t
+Inductive betree_UpsertFunState_t :=
+| Betree_UpsertFunState_Add : u64 -> betree_UpsertFunState_t
+| Betree_UpsertFunState_Sub : u64 -> betree_UpsertFunState_t
.
(** [betree_main::betree::Message] *)
-Inductive Betree_message_t :=
-| BetreeMessageInsert : u64 -> Betree_message_t
-| BetreeMessageDelete : Betree_message_t
-| BetreeMessageUpsert : Betree_upsert_fun_state_t -> Betree_message_t
+Inductive 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] *)
-Record Betree_leaf_t :=
-mkBetree_leaf_t {
- Betree_leaf_id : u64; Betree_leaf_size : u64;
+Record betree_Leaf_t :=
+mkbetree_Leaf_t {
+ betree_Leaf_id : u64; betree_Leaf_size : u64;
}
.
(** [betree_main::betree::Internal] *)
-Inductive Betree_internal_t :=
-| mkBetree_internal_t :
+Inductive betree_Internal_t :=
+| mkbetree_Internal_t :
u64 ->
u64 ->
- Betree_node_t ->
- Betree_node_t ->
- Betree_internal_t
+ betree_Node_t ->
+ betree_Node_t ->
+ betree_Internal_t
(** [betree_main::betree::Node] *)
-with Betree_node_t :=
-| BetreeNodeInternal : Betree_internal_t -> Betree_node_t
-| BetreeNodeLeaf : Betree_leaf_t -> Betree_node_t
+with betree_Node_t :=
+| Betree_Node_Internal : betree_Internal_t -> betree_Node_t
+| Betree_Node_Leaf : betree_Leaf_t -> betree_Node_t
.
-Definition Betree_internal_id (x : Betree_internal_t) :=
- match x with | mkBetree_internal_t x0 _ _ _ => x0 end
+Definition betree_Internal_id (x : betree_Internal_t) :=
+ match x with | mkbetree_Internal_t x0 _ _ _ => x0 end
.
-Notation "x1 .(Betree_internal_id)" := (Betree_internal_id x1) (at level 9).
+Notation "x1 .(betree_Internal_id)" := (betree_Internal_id x1) (at level 9).
-Definition Betree_internal_pivot (x : Betree_internal_t) :=
- match x with | mkBetree_internal_t _ x0 _ _ => x0 end
+Definition betree_Internal_pivot (x : betree_Internal_t) :=
+ match x with | mkbetree_Internal_t _ x0 _ _ => x0 end
.
-Notation "x1 .(Betree_internal_pivot)" := (Betree_internal_pivot x1)
+Notation "x1 .(betree_Internal_pivot)" := (betree_Internal_pivot x1)
(at level 9)
.
-Definition Betree_internal_left (x : Betree_internal_t) :=
- match x with | mkBetree_internal_t _ _ x0 _ => x0 end
+Definition betree_Internal_left (x : betree_Internal_t) :=
+ match x with | mkbetree_Internal_t _ _ x0 _ => x0 end
.
-Notation "x1 .(Betree_internal_left)" := (Betree_internal_left x1) (at level 9)
+Notation "x1 .(betree_Internal_left)" := (betree_Internal_left x1) (at level 9)
.
-Definition Betree_internal_right (x : Betree_internal_t) :=
- match x with | mkBetree_internal_t _ _ _ x0 => x0 end
+Definition betree_Internal_right (x : betree_Internal_t) :=
+ match x with | mkbetree_Internal_t _ _ _ x0 => x0 end
.
-Notation "x1 .(Betree_internal_right)" := (Betree_internal_right x1)
+Notation "x1 .(betree_Internal_right)" := (betree_Internal_right x1)
(at level 9)
.
(** [betree_main::betree::Params] *)
-Record Betree_params_t :=
-mkBetree_params_t {
- Betree_params_min_flush_size : u64; Betree_params_split_size : u64;
+Record betree_Params_t :=
+mkbetree_Params_t {
+ betree_Params_min_flush_size : u64; betree_Params_split_size : u64;
}
.
(** [betree_main::betree::NodeIdCounter] *)
-Record Betree_node_id_counter_t :=
-mkBetree_node_id_counter_t {
- Betree_node_id_counter_next_node_id : u64;
+Record betree_NodeIdCounter_t :=
+mkbetree_NodeIdCounter_t {
+ betree_NodeIdCounter_next_node_id : u64;
}
.
(** [betree_main::betree::BeTree] *)
-Record Betree_be_tree_t :=
-mkBetree_be_tree_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;
+Record betree_BeTree_t :=
+mkbetree_BeTree_t {
+ betree_BeTree_params : betree_Params_t;
+ betree_BeTree_node_id_cnt : betree_NodeIdCounter_t;
+ betree_BeTree_root : betree_Node_t;
}
.
diff --git a/tests/coq/betree/Primitives.v b/tests/coq/betree/Primitives.v
index 71a2d9c3..85e38f01 100644
--- a/tests/coq/betree/Primitives.v
+++ b/tests/coq/betree/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
(*** Misc *)
-
Definition string := Coq.Strings.String.string.
Definition char := Coq.Strings.Ascii.ascii.
Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
(*** Scalars *)
@@ -394,12 +396,89 @@ Notation "x s< y" := (scalar_ltb x y) (at level 80) : Primitives_scope.
Notation "x s>= y" := (scalar_geb x y) (at level 80) : Primitives_scope.
Notation "x s> y" := (scalar_gtb x y) (at level 80) : Primitives_scope.
-(*** Range *)
-Record range (T : Type) := mk_range {
- start: T;
- end_: T;
+(** Constants *)
+Definition core_u8_max := u8_max %u32.
+Definition core_u16_max := u16_max %u32.
+Definition core_u32_max := u32_max %u32.
+Definition core_u64_max := u64_max %u64.
+Definition core_u128_max := u64_max %u128.
+Axiom core_usize_max : usize. (** TODO *)
+Definition core_i8_max := i8_max %i32.
+Definition core_i16_max := i16_max %i32.
+Definition core_i32_max := i32_max %i32.
+Definition core_i64_max := i64_max %i64.
+Definition core_i128_max := i64_max %i128.
+Axiom core_isize_max : isize. (** TODO *)
+
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+ core_ops_index_Index_Output : Type;
+ core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+ core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+ core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+ core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+ core_ops_deref_Deref_target : Type;
+ core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+ core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+ core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+ core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
}.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+ core_ops_range_Range_start : T;
+ core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+ core_ops_deref_Deref_target := Self;
+ core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+ core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+ core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+ core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
(*** Arrays *)
Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -419,51 +498,50 @@ Qed.
(* TODO: finish the definitions *)
Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
(*** Slice *)
Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
(*** Subslices *)
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
(*** Vectors *)
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
Proof.
- unfold vec_length, usize_min.
+ unfold alloc_vec_Vec_length, usize_min.
split.
- lia.
- apply (proj2_sig v).
Qed.
-Definition vec_len (T: Type) (v: vec T) : usize :=
- exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+ exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
: list A :=
@@ -474,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
| S m => x :: (list_update t m a)
end end.
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
- l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+ l <- f (alloc_vec_Vec_to_list v) ;
match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
| left H => Return (exist _ l (scalar_le_max_valid _ _ H))
| right _ => Fail_ Failure
end.
(* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
- vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
(* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+ if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l =>
if to_Z i <? Z.of_nat (length l)
then Return (list_update l (usize_to_nat i) x)
else Fail_ Failure).
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
- end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+ core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+ core_slice_index_SliceIndex_Output : Type;
+ core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+ core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+ (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+ x <- inst.(core_slice_index_SliceIndex_get) i s;
+ match x with
+ | None => Fail_ Failure
+ | Some x => Return x
end.
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
- if to_Z i <? Z.of_nat (length l)
- then Return (list_update l (usize_to_nat i) x)
- else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+ (T : Type) :
+ 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 *)
+Definition core_slice_index_Range_get_unchecked_mut
+ (T : Type) :
+ 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 *)
+Axiom core_slice_index_Range_index :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (slice T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := slice T;
+ core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (slice T) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_Index (slice T) Idx) :
+ core_ops_index_Index (array T N) Idx := {|
+ core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+ core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_IndexMut (slice T) Idx) :
+ core_ops_index_IndexMut (array T N) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+ core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+ core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+ forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+ forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+ forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+ forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex usize (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := T;
+ core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+ core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+ alloc_vec_Vec_update_usize v i x.
End Primitives.
diff --git a/tests/coq/hashmap/Hashmap_Funs.v b/tests/coq/hashmap/Hashmap_Funs.v
index e950ba0b..3ca52a9f 100644
--- a/tests/coq/hashmap/Hashmap_Funs.v
+++ b/tests/coq/hashmap/Hashmap_Funs.v
@@ -11,98 +11,101 @@ Import Hashmap_Types.
Module Hashmap_Funs.
(** [hashmap::hash_key]: forward function *)
-Definition hash_key_fwd (k : usize) : result usize :=
+Definition hash_key (k : usize) : result usize :=
Return k.
(** [hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function *)
-Fixpoint hash_map_allocate_slots_loop_fwd
- (T : Type) (n : nat) (slots : vec (List_t T)) (n0 : usize) :
- result (vec (List_t T))
+Fixpoint hashMap_allocate_slots_loop
+ (T : Type) (n : nat) (slots : alloc_vec_Vec (List_t T)) (n0 : usize) :
+ result (alloc_vec_Vec (List_t T))
:=
match n with
| O => Fail_ OutOfFuel
| S n1 =>
if n0 s> 0%usize
then (
- slots0 <- vec_push_back (List_t T) slots ListNil;
+ slots0 <- alloc_vec_Vec_push (List_t T) slots List_Nil;
n2 <- usize_sub n0 1%usize;
- hash_map_allocate_slots_loop_fwd T n1 slots0 n2)
+ hashMap_allocate_slots_loop T n1 slots0 n2)
else Return slots
end
.
(** [hashmap::HashMap::{0}::allocate_slots]: forward function *)
-Definition hash_map_allocate_slots_fwd
- (T : Type) (n : nat) (slots : vec (List_t T)) (n0 : usize) :
- result (vec (List_t T))
+Definition hashMap_allocate_slots
+ (T : Type) (n : nat) (slots : alloc_vec_Vec (List_t T)) (n0 : usize) :
+ result (alloc_vec_Vec (List_t T))
:=
- hash_map_allocate_slots_loop_fwd T n slots n0
+ hashMap_allocate_slots_loop T n slots n0
.
(** [hashmap::HashMap::{0}::new_with_capacity]: forward function *)
-Definition hash_map_new_with_capacity_fwd
+Definition hashMap_new_with_capacity
(T : Type) (n : nat) (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
- slots <- hash_map_allocate_slots_fwd T n v capacity;
+ let v := alloc_vec_Vec_new (List_t T) in
+ slots <- hashMap_allocate_slots T n v capacity;
i <- usize_mul capacity max_load_dividend;
i0 <- usize_div i max_load_divisor;
Return
{|
- Hash_map_num_entries := 0%usize;
- Hash_map_max_load_factor := (max_load_dividend, max_load_divisor);
- Hash_map_max_load := i0;
- Hash_map_slots := slots
+ hashMap_num_entries := 0%usize;
+ hashMap_max_load_factor := (max_load_dividend, max_load_divisor);
+ hashMap_max_load := i0;
+ hashMap_slots := slots
|}
.
(** [hashmap::HashMap::{0}::new]: forward function *)
-Definition hash_map_new_fwd (T : Type) (n : nat) : result (Hash_map_t T) :=
- hash_map_new_with_capacity_fwd T n 32%usize 4%usize 5%usize
+Definition hashMap_new (T : Type) (n : nat) : result (HashMap_t T) :=
+ hashMap_new_with_capacity T n 32%usize 4%usize 5%usize
.
(** [hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Fixpoint hash_map_clear_loop_fwd_back
- (T : Type) (n : nat) (slots : vec (List_t T)) (i : usize) :
- result (vec (List_t T))
+Fixpoint hashMap_clear_loop
+ (T : Type) (n : nat) (slots : alloc_vec_Vec (List_t T)) (i : usize) :
+ result (alloc_vec_Vec (List_t T))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- let i0 := vec_len (List_t T) slots in
+ let i0 := alloc_vec_Vec_len (List_t T) slots in
if i s< i0
then (
i1 <- usize_add i 1%usize;
- slots0 <- vec_index_mut_back (List_t T) slots i ListNil;
- hash_map_clear_loop_fwd_back T n0 slots0 i1)
+ slots0 <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ slots i List_Nil;
+ hashMap_clear_loop T n0 slots0 i1)
else Return slots
end
.
(** [hashmap::HashMap::{0}::clear]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_clear_fwd_back
- (T : Type) (n : nat) (self : Hash_map_t T) : result (Hash_map_t T) :=
- v <- hash_map_clear_loop_fwd_back T n self.(Hash_map_slots) 0%usize;
+Definition hashMap_clear
+ (T : Type) (n : nat) (self : HashMap_t T) : result (HashMap_t T) :=
+ v <- hashMap_clear_loop T n self.(hashMap_slots) 0%usize;
Return
{|
- Hash_map_num_entries := 0%usize;
- Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := v
+ hashMap_num_entries := 0%usize;
+ hashMap_max_load_factor := self.(hashMap_max_load_factor);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := v
|}
.
(** [hashmap::HashMap::{0}::len]: forward function *)
-Definition hash_map_len_fwd (T : Type) (self : Hash_map_t T) : result usize :=
- Return self.(Hash_map_num_entries)
+Definition hashMap_len (T : Type) (self : HashMap_t T) : result usize :=
+ Return self.(hashMap_num_entries)
.
(** [hashmap::HashMap::{0}::insert_in_list]: loop 0: forward function *)
-Fixpoint hash_map_insert_in_list_loop_fwd
+Fixpoint hashMap_insert_in_list_loop
(T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
result bool
:=
@@ -110,25 +113,25 @@ Fixpoint hash_map_insert_in_list_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey cvalue tl =>
+ | List_Cons ckey cvalue tl =>
if ckey s= key
then Return false
- else hash_map_insert_in_list_loop_fwd T n0 key value tl
- | ListNil => Return true
+ else hashMap_insert_in_list_loop T n0 key value tl
+ | List_Nil => Return true
end
end
.
(** [hashmap::HashMap::{0}::insert_in_list]: forward function *)
-Definition hash_map_insert_in_list_fwd
+Definition hashMap_insert_in_list
(T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
result bool
:=
- hash_map_insert_in_list_loop_fwd T n key value ls
+ hashMap_insert_in_list_loop T n key value ls
.
(** [hashmap::HashMap::{0}::insert_in_list]: loop 0: backward function 0 *)
-Fixpoint hash_map_insert_in_list_loop_back
+Fixpoint hashMap_insert_in_list_loop_back
(T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
result (List_t T)
:=
@@ -136,259 +139,275 @@ Fixpoint hash_map_insert_in_list_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey cvalue tl =>
+ | List_Cons ckey cvalue tl =>
if ckey s= key
- then Return (ListCons ckey value tl)
+ then Return (List_Cons ckey value tl)
else (
- tl0 <- hash_map_insert_in_list_loop_back T n0 key value tl;
- Return (ListCons ckey cvalue tl0))
- | ListNil => let l := ListNil in Return (ListCons key value l)
+ tl0 <- hashMap_insert_in_list_loop_back T n0 key value tl;
+ Return (List_Cons ckey cvalue tl0))
+ | List_Nil => let l := List_Nil in Return (List_Cons key value l)
end
end
.
(** [hashmap::HashMap::{0}::insert_in_list]: backward function 0 *)
-Definition hash_map_insert_in_list_back
+Definition hashMap_insert_in_list_back
(T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
result (List_t T)
:=
- hash_map_insert_in_list_loop_back T n key value ls
+ hashMap_insert_in_list_loop_back T n key value ls
.
(** [hashmap::HashMap::{0}::insert_no_resize]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_insert_no_resize_fwd_back
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) (value : T) :
- result (Hash_map_t T)
+Definition hashMap_insert_no_resize
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) (value : T) :
+ result (HashMap_t T)
:=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- inserted <- hash_map_insert_in_list_fwd T n key value l;
+ l <-
+ alloc_vec_Vec_index_mut (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ inserted <- hashMap_insert_in_list T n key value l;
if inserted
then (
- i0 <- usize_add self.(Hash_map_num_entries) 1%usize;
- l0 <- hash_map_insert_in_list_back T n key value l;
- v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+ i0 <- usize_add self.(hashMap_num_entries) 1%usize;
+ l0 <- hashMap_insert_in_list_back T n key value l;
+ v <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod l0;
Return
{|
- Hash_map_num_entries := i0;
- Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := v
+ hashMap_num_entries := i0;
+ hashMap_max_load_factor := self.(hashMap_max_load_factor);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := v
|})
else (
- l0 <- hash_map_insert_in_list_back T n key value l;
- v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+ l0 <- hashMap_insert_in_list_back T n key value l;
+ v <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod l0;
Return
{|
- Hash_map_num_entries := self.(Hash_map_num_entries);
- Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := v
+ hashMap_num_entries := self.(hashMap_num_entries);
+ hashMap_max_load_factor := self.(hashMap_max_load_factor);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := v
|})
.
-(** [core::num::u32::{8}::MAX] *)
-Definition core_num_u32_max_body : result u32 := Return 4294967295%u32.
-Definition core_num_u32_max_c : u32 := core_num_u32_max_body%global.
-
(** [hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Fixpoint hash_map_move_elements_from_list_loop_fwd_back
- (T : Type) (n : nat) (ntable : Hash_map_t T) (ls : List_t T) :
- result (Hash_map_t T)
+Fixpoint hashMap_move_elements_from_list_loop
+ (T : Type) (n : nat) (ntable : HashMap_t T) (ls : List_t T) :
+ result (HashMap_t T)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons k v tl =>
- ntable0 <- hash_map_insert_no_resize_fwd_back T n0 ntable k v;
- hash_map_move_elements_from_list_loop_fwd_back T n0 ntable0 tl
- | ListNil => Return ntable
+ | List_Cons k v tl =>
+ ntable0 <- hashMap_insert_no_resize T n0 ntable k v;
+ hashMap_move_elements_from_list_loop T n0 ntable0 tl
+ | List_Nil => Return ntable
end
end
.
(** [hashmap::HashMap::{0}::move_elements_from_list]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_move_elements_from_list_fwd_back
- (T : Type) (n : nat) (ntable : Hash_map_t T) (ls : List_t T) :
- result (Hash_map_t T)
+Definition hashMap_move_elements_from_list
+ (T : Type) (n : nat) (ntable : HashMap_t T) (ls : List_t T) :
+ result (HashMap_t T)
:=
- hash_map_move_elements_from_list_loop_fwd_back T n ntable ls
+ hashMap_move_elements_from_list_loop T n ntable ls
.
(** [hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Fixpoint hash_map_move_elements_loop_fwd_back
- (T : Type) (n : nat) (ntable : Hash_map_t T) (slots : vec (List_t T))
- (i : usize) :
- result ((Hash_map_t T) * (vec (List_t T)))
+Fixpoint hashMap_move_elements_loop
+ (T : Type) (n : nat) (ntable : HashMap_t T)
+ (slots : alloc_vec_Vec (List_t T)) (i : usize) :
+ result ((HashMap_t T) * (alloc_vec_Vec (List_t T)))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- let i0 := vec_len (List_t T) slots in
+ let i0 := alloc_vec_Vec_len (List_t T) slots in
if i s< i0
then (
- l <- vec_index_mut_fwd (List_t T) slots i;
- let ls := mem_replace_fwd (List_t T) l ListNil in
- ntable0 <- hash_map_move_elements_from_list_fwd_back T n0 ntable ls;
+ l <-
+ alloc_vec_Vec_index_mut (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ slots i;
+ let ls := core_mem_replace (List_t T) l List_Nil in
+ ntable0 <- hashMap_move_elements_from_list T n0 ntable ls;
i1 <- usize_add i 1%usize;
- let l0 := mem_replace_back (List_t T) l ListNil in
- slots0 <- vec_index_mut_back (List_t T) slots i l0;
- hash_map_move_elements_loop_fwd_back T n0 ntable0 slots0 i1)
+ let l0 := core_mem_replace_back (List_t T) l List_Nil in
+ slots0 <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ slots i l0;
+ hashMap_move_elements_loop T n0 ntable0 slots0 i1)
else Return (ntable, slots)
end
.
(** [hashmap::HashMap::{0}::move_elements]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_move_elements_fwd_back
- (T : Type) (n : nat) (ntable : Hash_map_t T) (slots : vec (List_t T))
- (i : usize) :
- result ((Hash_map_t T) * (vec (List_t T)))
+Definition hashMap_move_elements
+ (T : Type) (n : nat) (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 n ntable slots i
+ hashMap_move_elements_loop T n ntable slots i
.
(** [hashmap::HashMap::{0}::try_resize]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_try_resize_fwd_back
- (T : Type) (n : nat) (self : Hash_map_t T) : result (Hash_map_t T) :=
- max_usize <- scalar_cast U32 Usize core_num_u32_max_c;
- let capacity := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_try_resize
+ (T : Type) (n : nat) (self : HashMap_t T) : result (HashMap_t T) :=
+ max_usize <- scalar_cast U32 Usize core_u32_max;
+ let capacity := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
n1 <- usize_div max_usize 2%usize;
- let (i, i0) := self.(Hash_map_max_load_factor) in
+ let (i, i0) := self.(hashMap_max_load_factor) in
i1 <- usize_div n1 i;
if capacity s<= i1
then (
i2 <- usize_mul capacity 2%usize;
- ntable <- hash_map_new_with_capacity_fwd T n i2 i i0;
- p <-
- hash_map_move_elements_fwd_back T n ntable self.(Hash_map_slots) 0%usize;
+ ntable <- hashMap_new_with_capacity T n i2 i i0;
+ p <- hashMap_move_elements T n ntable self.(hashMap_slots) 0%usize;
let (ntable0, _) := p in
Return
{|
- Hash_map_num_entries := self.(Hash_map_num_entries);
- Hash_map_max_load_factor := (i, i0);
- Hash_map_max_load := ntable0.(Hash_map_max_load);
- Hash_map_slots := ntable0.(Hash_map_slots)
+ hashMap_num_entries := self.(hashMap_num_entries);
+ hashMap_max_load_factor := (i, i0);
+ hashMap_max_load := ntable0.(hashMap_max_load);
+ hashMap_slots := ntable0.(hashMap_slots)
|})
else
Return
{|
- Hash_map_num_entries := self.(Hash_map_num_entries);
- Hash_map_max_load_factor := (i, i0);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := self.(Hash_map_slots)
+ hashMap_num_entries := self.(hashMap_num_entries);
+ hashMap_max_load_factor := (i, i0);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := self.(hashMap_slots)
|}
.
(** [hashmap::HashMap::{0}::insert]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_insert_fwd_back
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) (value : T) :
- result (Hash_map_t T)
+Definition hashMap_insert
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) (value : T) :
+ result (HashMap_t T)
:=
- self0 <- hash_map_insert_no_resize_fwd_back T n self key value;
- i <- hash_map_len_fwd T self0;
- if i s> self0.(Hash_map_max_load)
- then hash_map_try_resize_fwd_back T n self0
+ self0 <- hashMap_insert_no_resize T n self key value;
+ i <- hashMap_len T self0;
+ if i s> self0.(hashMap_max_load)
+ then hashMap_try_resize T n self0
else Return self0
.
(** [hashmap::HashMap::{0}::contains_key_in_list]: loop 0: forward function *)
-Fixpoint hash_map_contains_key_in_list_loop_fwd
+Fixpoint hashMap_contains_key_in_list_loop
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result bool :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey t tl =>
+ | List_Cons ckey t tl =>
if ckey s= key
then Return true
- else hash_map_contains_key_in_list_loop_fwd T n0 key tl
- | ListNil => Return false
+ else hashMap_contains_key_in_list_loop T n0 key tl
+ | List_Nil => Return false
end
end
.
(** [hashmap::HashMap::{0}::contains_key_in_list]: forward function *)
-Definition hash_map_contains_key_in_list_fwd
+Definition hashMap_contains_key_in_list
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result bool :=
- hash_map_contains_key_in_list_loop_fwd T n key ls
+ hashMap_contains_key_in_list_loop T n key ls
.
(** [hashmap::HashMap::{0}::contains_key]: forward function *)
-Definition hash_map_contains_key_fwd
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) : result bool :=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_contains_key
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) : result bool :=
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- hash_map_contains_key_in_list_fwd T n key l
+ l <-
+ alloc_vec_Vec_index (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ hashMap_contains_key_in_list T n key l
.
(** [hashmap::HashMap::{0}::get_in_list]: loop 0: forward function *)
-Fixpoint hash_map_get_in_list_loop_fwd
+Fixpoint hashMap_get_in_list_loop
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey cvalue tl =>
+ | List_Cons ckey cvalue tl =>
if ckey s= key
then Return cvalue
- else hash_map_get_in_list_loop_fwd T n0 key tl
- | ListNil => Fail_ Failure
+ else hashMap_get_in_list_loop T n0 key tl
+ | List_Nil => Fail_ Failure
end
end
.
(** [hashmap::HashMap::{0}::get_in_list]: forward function *)
-Definition hash_map_get_in_list_fwd
+Definition hashMap_get_in_list
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result T :=
- hash_map_get_in_list_loop_fwd T n key ls
+ hashMap_get_in_list_loop T n key ls
.
(** [hashmap::HashMap::{0}::get]: forward function *)
-Definition hash_map_get_fwd
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) : result T :=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_get
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) : result T :=
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- hash_map_get_in_list_fwd T n key l
+ l <-
+ alloc_vec_Vec_index (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ hashMap_get_in_list T n key l
.
(** [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function *)
-Fixpoint hash_map_get_mut_in_list_loop_fwd
+Fixpoint hashMap_get_mut_in_list_loop
(T : Type) (n : nat) (ls : List_t T) (key : usize) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey cvalue tl =>
+ | List_Cons ckey cvalue tl =>
if ckey s= key
then Return cvalue
- else hash_map_get_mut_in_list_loop_fwd T n0 tl key
- | ListNil => Fail_ Failure
+ else hashMap_get_mut_in_list_loop T n0 tl key
+ | List_Nil => Fail_ Failure
end
end
.
(** [hashmap::HashMap::{0}::get_mut_in_list]: forward function *)
-Definition hash_map_get_mut_in_list_fwd
+Definition hashMap_get_mut_in_list
(T : Type) (n : nat) (ls : List_t T) (key : usize) : result T :=
- hash_map_get_mut_in_list_loop_fwd T n ls key
+ hashMap_get_mut_in_list_loop T n ls key
.
(** [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: backward function 0 *)
-Fixpoint hash_map_get_mut_in_list_loop_back
+Fixpoint hashMap_get_mut_in_list_loop_back
(T : Type) (n : nat) (ls : List_t T) (key : usize) (ret : T) :
result (List_t T)
:=
@@ -396,196 +415,219 @@ Fixpoint hash_map_get_mut_in_list_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey cvalue tl =>
+ | List_Cons ckey cvalue tl =>
if ckey s= key
- then Return (ListCons ckey ret tl)
+ then Return (List_Cons ckey ret tl)
else (
- tl0 <- hash_map_get_mut_in_list_loop_back T n0 tl key ret;
- Return (ListCons ckey cvalue tl0))
- | ListNil => Fail_ Failure
+ tl0 <- hashMap_get_mut_in_list_loop_back T n0 tl key ret;
+ Return (List_Cons ckey cvalue tl0))
+ | List_Nil => Fail_ Failure
end
end
.
(** [hashmap::HashMap::{0}::get_mut_in_list]: backward function 0 *)
-Definition hash_map_get_mut_in_list_back
+Definition hashMap_get_mut_in_list_back
(T : Type) (n : nat) (ls : List_t T) (key : usize) (ret : T) :
result (List_t T)
:=
- hash_map_get_mut_in_list_loop_back T n ls key ret
+ hashMap_get_mut_in_list_loop_back T n ls key ret
.
(** [hashmap::HashMap::{0}::get_mut]: forward function *)
-Definition hash_map_get_mut_fwd
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) : result T :=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_get_mut
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) : result T :=
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- hash_map_get_mut_in_list_fwd T n l key
+ l <-
+ alloc_vec_Vec_index_mut (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ hashMap_get_mut_in_list T n l key
.
(** [hashmap::HashMap::{0}::get_mut]: backward function 0 *)
-Definition hash_map_get_mut_back
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) (ret : T) :
- result (Hash_map_t T)
+Definition hashMap_get_mut_back
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) (ret : T) :
+ result (HashMap_t T)
:=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- l0 <- hash_map_get_mut_in_list_back T n l key ret;
- v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+ l <-
+ alloc_vec_Vec_index_mut (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ l0 <- hashMap_get_mut_in_list_back T n l key ret;
+ v <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod l0;
Return
{|
- Hash_map_num_entries := self.(Hash_map_num_entries);
- Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := v
+ hashMap_num_entries := self.(hashMap_num_entries);
+ hashMap_max_load_factor := self.(hashMap_max_load_factor);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := v
|}
.
(** [hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function *)
-Fixpoint hash_map_remove_from_list_loop_fwd
+Fixpoint hashMap_remove_from_list_loop
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result (option T) :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey t tl =>
+ | List_Cons ckey t tl =>
if ckey s= key
then
- let mv_ls := mem_replace_fwd (List_t T) (ListCons ckey t tl) ListNil in
+ let mv_ls := core_mem_replace (List_t T) (List_Cons ckey t tl) List_Nil
+ in
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 n0 key tl
- | ListNil => Return None
+ else hashMap_remove_from_list_loop T n0 key tl
+ | List_Nil => Return None
end
end
.
(** [hashmap::HashMap::{0}::remove_from_list]: forward function *)
-Definition hash_map_remove_from_list_fwd
+Definition hashMap_remove_from_list
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result (option T) :=
- hash_map_remove_from_list_loop_fwd T n key ls
+ hashMap_remove_from_list_loop T n key ls
.
(** [hashmap::HashMap::{0}::remove_from_list]: loop 0: backward function 1 *)
-Fixpoint hash_map_remove_from_list_loop_back
+Fixpoint hashMap_remove_from_list_loop_back
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result (List_t T) :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons ckey t tl =>
+ | List_Cons ckey t tl =>
if ckey s= key
then
- let mv_ls := mem_replace_fwd (List_t T) (ListCons ckey t tl) ListNil in
+ let mv_ls := core_mem_replace (List_t T) (List_Cons ckey t tl) List_Nil
+ in
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 (
- tl0 <- hash_map_remove_from_list_loop_back T n0 key tl;
- Return (ListCons ckey t tl0))
- | ListNil => Return ListNil
+ tl0 <- hashMap_remove_from_list_loop_back T n0 key tl;
+ Return (List_Cons ckey t tl0))
+ | List_Nil => Return List_Nil
end
end
.
(** [hashmap::HashMap::{0}::remove_from_list]: backward function 1 *)
-Definition hash_map_remove_from_list_back
+Definition hashMap_remove_from_list_back
(T : Type) (n : nat) (key : usize) (ls : List_t T) : result (List_t T) :=
- hash_map_remove_from_list_loop_back T n key ls
+ hashMap_remove_from_list_loop_back T n key ls
.
(** [hashmap::HashMap::{0}::remove]: forward function *)
-Definition hash_map_remove_fwd
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) :
+Definition hashMap_remove
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) :
result (option T)
:=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- x <- hash_map_remove_from_list_fwd T n key l;
+ l <-
+ alloc_vec_Vec_index_mut (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ x <- hashMap_remove_from_list T n key l;
match x with
| None => Return None
| Some x0 =>
- _ <- usize_sub self.(Hash_map_num_entries) 1%usize; Return (Some x0)
+ _ <- usize_sub self.(hashMap_num_entries) 1%usize; Return (Some x0)
end
.
(** [hashmap::HashMap::{0}::remove]: backward function 0 *)
-Definition hash_map_remove_back
- (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) :
- result (Hash_map_t T)
+Definition hashMap_remove_back
+ (T : Type) (n : nat) (self : HashMap_t T) (key : usize) :
+ result (HashMap_t T)
:=
- hash <- hash_key_fwd key;
- let i := vec_len (List_t T) self.(Hash_map_slots) in
+ hash <- hash_key key;
+ let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
- x <- hash_map_remove_from_list_fwd T n key l;
+ l <-
+ alloc_vec_Vec_index_mut (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod;
+ x <- hashMap_remove_from_list T n key l;
match x with
| None =>
- l0 <- hash_map_remove_from_list_back T n key l;
- v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+ l0 <- hashMap_remove_from_list_back T n key l;
+ v <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod l0;
Return
{|
- Hash_map_num_entries := self.(Hash_map_num_entries);
- Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := v
+ hashMap_num_entries := self.(hashMap_num_entries);
+ hashMap_max_load_factor := self.(hashMap_max_load_factor);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := v
|}
| Some x0 =>
- i0 <- usize_sub self.(Hash_map_num_entries) 1%usize;
- l0 <- hash_map_remove_from_list_back T n key l;
- v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+ i0 <- usize_sub self.(hashMap_num_entries) 1%usize;
+ l0 <- hashMap_remove_from_list_back T n key l;
+ v <-
+ alloc_vec_Vec_index_mut_back (List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+ self.(hashMap_slots) hash_mod l0;
Return
{|
- Hash_map_num_entries := i0;
- Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
- Hash_map_max_load := self.(Hash_map_max_load);
- Hash_map_slots := v
+ hashMap_num_entries := i0;
+ hashMap_max_load_factor := self.(hashMap_max_load_factor);
+ hashMap_max_load := self.(hashMap_max_load);
+ hashMap_slots := v
|}
end
.
(** [hashmap::test1]: forward function *)
-Definition test1_fwd (n : nat) : result unit :=
- hm <- hash_map_new_fwd u64 n;
- hm0 <- hash_map_insert_fwd_back u64 n hm 0%usize 42%u64;
- hm1 <- hash_map_insert_fwd_back u64 n hm0 128%usize 18%u64;
- hm2 <- hash_map_insert_fwd_back u64 n hm1 1024%usize 138%u64;
- hm3 <- hash_map_insert_fwd_back u64 n hm2 1056%usize 256%u64;
- i <- hash_map_get_fwd u64 n hm3 128%usize;
+Definition test1 (n : nat) : result unit :=
+ hm <- hashMap_new u64 n;
+ hm0 <- hashMap_insert u64 n hm 0%usize 42%u64;
+ hm1 <- hashMap_insert u64 n hm0 128%usize 18%u64;
+ hm2 <- hashMap_insert u64 n hm1 1024%usize 138%u64;
+ hm3 <- hashMap_insert u64 n hm2 1056%usize 256%u64;
+ i <- hashMap_get u64 n hm3 128%usize;
if negb (i s= 18%u64)
then Fail_ Failure
else (
- hm4 <- hash_map_get_mut_back u64 n hm3 1024%usize 56%u64;
- i0 <- hash_map_get_fwd u64 n hm4 1024%usize;
+ hm4 <- hashMap_get_mut_back u64 n hm3 1024%usize 56%u64;
+ i0 <- hashMap_get u64 n hm4 1024%usize;
if negb (i0 s= 56%u64)
then Fail_ Failure
else (
- x <- hash_map_remove_fwd u64 n hm4 1024%usize;
+ x <- hashMap_remove u64 n hm4 1024%usize;
match x with
| None => Fail_ Failure
| Some x0 =>
if negb (x0 s= 56%u64)
then Fail_ Failure
else (
- hm5 <- hash_map_remove_back u64 n hm4 1024%usize;
- i1 <- hash_map_get_fwd u64 n hm5 0%usize;
+ hm5 <- hashMap_remove_back u64 n hm4 1024%usize;
+ i1 <- hashMap_get u64 n hm5 0%usize;
if negb (i1 s= 42%u64)
then Fail_ Failure
else (
- i2 <- hash_map_get_fwd u64 n hm5 128%usize;
+ i2 <- hashMap_get u64 n hm5 128%usize;
if negb (i2 s= 18%u64)
then Fail_ Failure
else (
- i3 <- hash_map_get_fwd u64 n hm5 1056%usize;
+ i3 <- hashMap_get u64 n hm5 1056%usize;
if negb (i3 s= 256%u64) then Fail_ Failure else Return tt)))
end))
.
diff --git a/tests/coq/hashmap/Hashmap_Types.v b/tests/coq/hashmap/Hashmap_Types.v
index dbde6be9..8529803d 100644
--- a/tests/coq/hashmap/Hashmap_Types.v
+++ b/tests/coq/hashmap/Hashmap_Types.v
@@ -10,27 +10,27 @@ Module Hashmap_Types.
(** [hashmap::List] *)
Inductive List_t (T : Type) :=
-| 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
.
-Arguments ListCons {T} _ _ _.
-Arguments ListNil {T}.
+Arguments List_Cons { _ }.
+Arguments List_Nil { _ }.
(** [hashmap::HashMap] *)
-Record Hash_map_t (T : Type) :=
-mkHash_map_t {
- Hash_map_num_entries : usize;
- Hash_map_max_load_factor : (usize * usize);
- Hash_map_max_load : usize;
- Hash_map_slots : vec (List_t T);
+Record HashMap_t (T : Type) :=
+mkHashMap_t {
+ hashMap_num_entries : usize;
+ hashMap_max_load_factor : (usize * usize);
+ hashMap_max_load : usize;
+ hashMap_slots : alloc_vec_Vec (List_t T);
}
.
-Arguments mkHash_map_t {T} _ _ _ _.
-Arguments Hash_map_num_entries {T}.
-Arguments Hash_map_max_load_factor {T}.
-Arguments Hash_map_max_load {T}.
-Arguments Hash_map_slots {T}.
+Arguments mkHashMap_t { _ }.
+Arguments hashMap_num_entries { _ }.
+Arguments hashMap_max_load_factor { _ }.
+Arguments hashMap_max_load { _ }.
+Arguments hashMap_slots { _ }.
End Hashmap_Types .
diff --git a/tests/coq/hashmap/Primitives.v b/tests/coq/hashmap/Primitives.v
index 71a2d9c3..85e38f01 100644
--- a/tests/coq/hashmap/Primitives.v
+++ b/tests/coq/hashmap/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
(*** Misc *)
-
Definition string := Coq.Strings.String.string.
Definition char := Coq.Strings.Ascii.ascii.
Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
(*** Scalars *)
@@ -394,12 +396,89 @@ Notation "x s< y" := (scalar_ltb x y) (at level 80) : Primitives_scope.
Notation "x s>= y" := (scalar_geb x y) (at level 80) : Primitives_scope.
Notation "x s> y" := (scalar_gtb x y) (at level 80) : Primitives_scope.
-(*** Range *)
-Record range (T : Type) := mk_range {
- start: T;
- end_: T;
+(** Constants *)
+Definition core_u8_max := u8_max %u32.
+Definition core_u16_max := u16_max %u32.
+Definition core_u32_max := u32_max %u32.
+Definition core_u64_max := u64_max %u64.
+Definition core_u128_max := u64_max %u128.
+Axiom core_usize_max : usize. (** TODO *)
+Definition core_i8_max := i8_max %i32.
+Definition core_i16_max := i16_max %i32.
+Definition core_i32_max := i32_max %i32.
+Definition core_i64_max := i64_max %i64.
+Definition core_i128_max := i64_max %i128.
+Axiom core_isize_max : isize. (** TODO *)
+
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+ core_ops_index_Index_Output : Type;
+ core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+ core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+ core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+ core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+ core_ops_deref_Deref_target : Type;
+ core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+ core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+ core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+ core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
}.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+ core_ops_range_Range_start : T;
+ core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+ core_ops_deref_Deref_target := Self;
+ core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+ core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+ core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+ core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
(*** Arrays *)
Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -419,51 +498,50 @@ Qed.
(* TODO: finish the definitions *)
Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
(*** Slice *)
Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
(*** Subslices *)
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
(*** Vectors *)
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
Proof.
- unfold vec_length, usize_min.
+ unfold alloc_vec_Vec_length, usize_min.
split.
- lia.
- apply (proj2_sig v).
Qed.
-Definition vec_len (T: Type) (v: vec T) : usize :=
- exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+ exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
: list A :=
@@ -474,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
| S m => x :: (list_update t m a)
end end.
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
- l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+ l <- f (alloc_vec_Vec_to_list v) ;
match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
| left H => Return (exist _ l (scalar_le_max_valid _ _ H))
| right _ => Fail_ Failure
end.
(* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
- vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
(* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+ if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l =>
if to_Z i <? Z.of_nat (length l)
then Return (list_update l (usize_to_nat i) x)
else Fail_ Failure).
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
- end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+ core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+ core_slice_index_SliceIndex_Output : Type;
+ core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+ core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+ (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+ x <- inst.(core_slice_index_SliceIndex_get) i s;
+ match x with
+ | None => Fail_ Failure
+ | Some x => Return x
end.
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
- if to_Z i <? Z.of_nat (length l)
- then Return (list_update l (usize_to_nat i) x)
- else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+ (T : Type) :
+ 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 *)
+Definition core_slice_index_Range_get_unchecked_mut
+ (T : Type) :
+ 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 *)
+Axiom core_slice_index_Range_index :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (slice T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := slice T;
+ core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (slice T) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_Index (slice T) Idx) :
+ core_ops_index_Index (array T N) Idx := {|
+ core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+ core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_IndexMut (slice T) Idx) :
+ core_ops_index_IndexMut (array T N) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+ core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+ core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+ forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+ forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+ forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+ forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex usize (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := T;
+ core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+ core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+ alloc_vec_Vec_update_usize v i x.
End Primitives.
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Funs.v b/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
index 657d5590..eac78186 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
@@ -13,656 +13,668 @@ Import HashmapMain_Opaque.
Module HashmapMain_Funs.
(** [hashmap_main::hashmap::hash_key]: forward function *)
-Definition hashmap_hash_key_fwd (k : usize) : result usize :=
+Definition hashmap_hash_key (k : usize) : result usize :=
Return k.
(** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_allocate_slots_loop_fwd
- (T : Type) (n : nat) (slots : vec (Hashmap_list_t T)) (n0 : usize) :
- result (vec (Hashmap_list_t T))
+Fixpoint hashmap_HashMap_allocate_slots_loop
+ (T : Type) (n : nat) (slots : alloc_vec_Vec (hashmap_List_t T)) (n0 : usize)
+ :
+ result (alloc_vec_Vec (hashmap_List_t T))
:=
match n with
| O => Fail_ OutOfFuel
| S n1 =>
if n0 s> 0%usize
then (
- slots0 <- vec_push_back (Hashmap_list_t T) slots HashmapListNil;
+ slots0 <- alloc_vec_Vec_push (hashmap_List_t T) slots Hashmap_List_Nil;
n2 <- usize_sub n0 1%usize;
- hashmap_hash_map_allocate_slots_loop_fwd T n1 slots0 n2)
+ hashmap_HashMap_allocate_slots_loop T n1 slots0 n2)
else Return slots
end
.
(** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: forward function *)
-Definition hashmap_hash_map_allocate_slots_fwd
- (T : Type) (n : nat) (slots : vec (Hashmap_list_t T)) (n0 : usize) :
- result (vec (Hashmap_list_t T))
+Definition hashmap_HashMap_allocate_slots
+ (T : Type) (n : nat) (slots : alloc_vec_Vec (hashmap_List_t T)) (n0 : usize)
+ :
+ result (alloc_vec_Vec (hashmap_List_t T))
:=
- hashmap_hash_map_allocate_slots_loop_fwd T n slots n0
+ hashmap_HashMap_allocate_slots_loop T n slots n0
.
(** [hashmap_main::hashmap::HashMap::{0}::new_with_capacity]: forward function *)
-Definition hashmap_hash_map_new_with_capacity_fwd
+Definition hashmap_HashMap_new_with_capacity
(T : Type) (n : nat) (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
- slots <- hashmap_hash_map_allocate_slots_fwd T n v capacity;
+ let v := alloc_vec_Vec_new (hashmap_List_t T) in
+ slots <- hashmap_HashMap_allocate_slots T n v capacity;
i <- usize_mul capacity max_load_dividend;
i0 <- usize_div i max_load_divisor;
Return
{|
- Hashmap_hash_map_num_entries := 0%usize;
- Hashmap_hash_map_max_load_factor := (max_load_dividend, max_load_divisor);
- Hashmap_hash_map_max_load := i0;
- Hashmap_hash_map_slots := slots
+ hashmap_HashMap_num_entries := 0%usize;
+ hashmap_HashMap_max_load_factor := (max_load_dividend, max_load_divisor);
+ hashmap_HashMap_max_load := i0;
+ hashmap_HashMap_slots := slots
|}
.
(** [hashmap_main::hashmap::HashMap::{0}::new]: forward function *)
-Definition hashmap_hash_map_new_fwd
- (T : Type) (n : nat) : result (Hashmap_hash_map_t T) :=
- hashmap_hash_map_new_with_capacity_fwd T n 32%usize 4%usize 5%usize
+Definition hashmap_HashMap_new
+ (T : Type) (n : nat) : result (hashmap_HashMap_t T) :=
+ hashmap_HashMap_new_with_capacity T n 32%usize 4%usize 5%usize
.
(** [hashmap_main::hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Fixpoint hashmap_hash_map_clear_loop_fwd_back
- (T : Type) (n : nat) (slots : vec (Hashmap_list_t T)) (i : usize) :
- result (vec (Hashmap_list_t T))
+Fixpoint hashmap_HashMap_clear_loop
+ (T : Type) (n : nat) (slots : alloc_vec_Vec (hashmap_List_t T)) (i : usize) :
+ result (alloc_vec_Vec (hashmap_List_t T))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- let i0 := vec_len (Hashmap_list_t T) slots in
+ let i0 := alloc_vec_Vec_len (hashmap_List_t T) slots in
if i s< i0
then (
i1 <- usize_add i 1%usize;
- slots0 <- vec_index_mut_back (Hashmap_list_t T) slots i HashmapListNil;
- hashmap_hash_map_clear_loop_fwd_back T n0 slots0 i1)
+ 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;
+ hashmap_HashMap_clear_loop T n0 slots0 i1)
else Return slots
end
.
(** [hashmap_main::hashmap::HashMap::{0}::clear]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_clear_fwd_back
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_clear
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) :
+ result (hashmap_HashMap_t T)
:=
- v <-
- hashmap_hash_map_clear_loop_fwd_back T n self.(Hashmap_hash_map_slots)
- 0%usize;
+ v <- hashmap_HashMap_clear_loop T n self.(hashmap_HashMap_slots) 0%usize;
Return
{|
- Hashmap_hash_map_num_entries := 0%usize;
- Hashmap_hash_map_max_load_factor :=
- self.(Hashmap_hash_map_max_load_factor);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := v
+ hashmap_HashMap_num_entries := 0%usize;
+ hashmap_HashMap_max_load_factor := self.(hashmap_HashMap_max_load_factor);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := v
|}
.
(** [hashmap_main::hashmap::HashMap::{0}::len]: forward function *)
-Definition hashmap_hash_map_len_fwd
- (T : Type) (self : Hashmap_hash_map_t T) : result usize :=
- Return self.(Hashmap_hash_map_num_entries)
+Definition hashmap_HashMap_len
+ (T : Type) (self : hashmap_HashMap_t T) : result usize :=
+ Return self.(hashmap_HashMap_num_entries)
.
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_insert_in_list_loop_fwd
- (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
+Fixpoint hashmap_HashMap_insert_in_list_loop
+ (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
result bool
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey cvalue tl =>
+ | Hashmap_List_Cons ckey cvalue tl =>
if ckey s= key
then Return false
- else hashmap_hash_map_insert_in_list_loop_fwd T n0 key value tl
- | HashmapListNil => Return true
+ else hashmap_HashMap_insert_in_list_loop T n0 key value tl
+ | Hashmap_List_Nil => Return true
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: forward function *)
-Definition hashmap_hash_map_insert_in_list_fwd
- (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
+Definition hashmap_HashMap_insert_in_list
+ (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
result bool
:=
- hashmap_hash_map_insert_in_list_loop_fwd T n key value ls
+ hashmap_HashMap_insert_in_list_loop T n key value ls
.
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: loop 0: backward function 0 *)
-Fixpoint hashmap_hash_map_insert_in_list_loop_back
- (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
- result (Hashmap_list_t T)
+Fixpoint hashmap_HashMap_insert_in_list_loop_back
+ (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
+ result (hashmap_List_t T)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey cvalue tl =>
+ | Hashmap_List_Cons ckey cvalue tl =>
if ckey s= key
- then Return (HashmapListCons ckey value tl)
+ then Return (Hashmap_List_Cons ckey value tl)
else (
- tl0 <- hashmap_hash_map_insert_in_list_loop_back T n0 key value tl;
- Return (HashmapListCons ckey cvalue tl0))
- | HashmapListNil =>
- let l := HashmapListNil in Return (HashmapListCons key value l)
+ tl0 <- hashmap_HashMap_insert_in_list_loop_back T n0 key value tl;
+ Return (Hashmap_List_Cons ckey cvalue tl0))
+ | Hashmap_List_Nil =>
+ let l := Hashmap_List_Nil in Return (Hashmap_List_Cons key value l)
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: backward function 0 *)
-Definition hashmap_hash_map_insert_in_list_back
- (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
- result (Hashmap_list_t T)
+Definition hashmap_HashMap_insert_in_list_back
+ (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
+ result (hashmap_List_t T)
:=
- hashmap_hash_map_insert_in_list_loop_back T n key value ls
+ hashmap_HashMap_insert_in_list_loop_back T n 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 ()) *)
-Definition hashmap_hash_map_insert_no_resize_fwd_back
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) (value : T)
- :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_insert_no_resize
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) (value : T) :
+ result (hashmap_HashMap_t T)
:=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
l <-
- vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- inserted <- hashmap_hash_map_insert_in_list_fwd T n key value l;
+ alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ inserted <- hashmap_HashMap_insert_in_list T n key value l;
if inserted
then (
- i0 <- usize_add self.(Hashmap_hash_map_num_entries) 1%usize;
- l0 <- hashmap_hash_map_insert_in_list_back T n key value l;
+ i0 <- usize_add self.(hashmap_HashMap_num_entries) 1%usize;
+ l0 <- hashmap_HashMap_insert_in_list_back T n key value l;
v <-
- vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
- hash_mod l0;
+ alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ T)) self.(hashmap_HashMap_slots) hash_mod l0;
Return
{|
- Hashmap_hash_map_num_entries := i0;
- Hashmap_hash_map_max_load_factor :=
- self.(Hashmap_hash_map_max_load_factor);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := v
+ hashmap_HashMap_num_entries := i0;
+ hashmap_HashMap_max_load_factor :=
+ self.(hashmap_HashMap_max_load_factor);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := v
|})
else (
- l0 <- hashmap_hash_map_insert_in_list_back T n key value l;
+ l0 <- hashmap_HashMap_insert_in_list_back T n key value l;
v <-
- vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
- hash_mod l0;
+ alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ T)) self.(hashmap_HashMap_slots) hash_mod l0;
Return
{|
- Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
- Hashmap_hash_map_max_load_factor :=
- self.(Hashmap_hash_map_max_load_factor);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := v
+ hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+ hashmap_HashMap_max_load_factor :=
+ self.(hashmap_HashMap_max_load_factor);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := v
|})
.
-(** [core::num::u32::{8}::MAX] *)
-Definition core_num_u32_max_body : result u32 := Return 4294967295%u32.
-Definition core_num_u32_max_c : u32 := core_num_u32_max_body%global.
-
(** [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 ()) *)
-Fixpoint hashmap_hash_map_move_elements_from_list_loop_fwd_back
- (T : Type) (n : nat) (ntable : Hashmap_hash_map_t T) (ls : Hashmap_list_t T)
- :
- result (Hashmap_hash_map_t T)
+Fixpoint hashmap_HashMap_move_elements_from_list_loop
+ (T : Type) (n : nat) (ntable : hashmap_HashMap_t T) (ls : hashmap_List_t T) :
+ result (hashmap_HashMap_t T)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons k v tl =>
- ntable0 <- hashmap_hash_map_insert_no_resize_fwd_back T n0 ntable k v;
- hashmap_hash_map_move_elements_from_list_loop_fwd_back T n0 ntable0 tl
- | HashmapListNil => Return ntable
+ | Hashmap_List_Cons k v tl =>
+ ntable0 <- hashmap_HashMap_insert_no_resize T n0 ntable k v;
+ hashmap_HashMap_move_elements_from_list_loop T n0 ntable0 tl
+ | Hashmap_List_Nil => Return ntable
end
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 ()) *)
-Definition hashmap_hash_map_move_elements_from_list_fwd_back
- (T : Type) (n : nat) (ntable : Hashmap_hash_map_t T) (ls : Hashmap_list_t T)
- :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_move_elements_from_list
+ (T : Type) (n : nat) (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 n ntable ls
+ hashmap_HashMap_move_elements_from_list_loop T n 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 ()) *)
-Fixpoint hashmap_hash_map_move_elements_loop_fwd_back
- (T : Type) (n : nat) (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)))
+Fixpoint hashmap_HashMap_move_elements_loop
+ (T : Type) (n : nat) (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)))
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- let i0 := vec_len (Hashmap_list_t T) slots in
+ let i0 := alloc_vec_Vec_len (hashmap_List_t T) slots in
if i s< i0
then (
- l <- vec_index_mut_fwd (Hashmap_list_t T) slots i;
- let ls := mem_replace_fwd (Hashmap_list_t T) l HashmapListNil in
- ntable0 <-
- hashmap_hash_map_move_elements_from_list_fwd_back T n0 ntable ls;
+ l <-
+ alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ T)) slots i;
+ let ls := core_mem_replace (hashmap_List_t T) l Hashmap_List_Nil in
+ ntable0 <- hashmap_HashMap_move_elements_from_list T n0 ntable ls;
i1 <- usize_add i 1%usize;
- let l0 := mem_replace_back (Hashmap_list_t T) l HashmapListNil in
- slots0 <- vec_index_mut_back (Hashmap_list_t T) slots i l0;
- hashmap_hash_map_move_elements_loop_fwd_back T n0 ntable0 slots0 i1)
+ let l0 := core_mem_replace_back (hashmap_List_t T) l Hashmap_List_Nil in
+ slots0 <-
+ alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ T)) slots i l0;
+ hashmap_HashMap_move_elements_loop T n0 ntable0 slots0 i1)
else Return (ntable, slots)
end
.
(** [hashmap_main::hashmap::HashMap::{0}::move_elements]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_move_elements_fwd_back
- (T : Type) (n : nat) (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)))
+Definition hashmap_HashMap_move_elements
+ (T : Type) (n : nat) (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 n ntable slots i
+ hashmap_HashMap_move_elements_loop T n 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 ()) *)
-Definition hashmap_hash_map_try_resize_fwd_back
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_try_resize
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) :
+ result (hashmap_HashMap_t T)
:=
- max_usize <- scalar_cast U32 Usize core_num_u32_max_c;
- let capacity := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+ max_usize <- scalar_cast U32 Usize core_u32_max;
+ let capacity :=
+ alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
n1 <- usize_div max_usize 2%usize;
- let (i, i0) := self.(Hashmap_hash_map_max_load_factor) in
+ let (i, i0) := self.(hashmap_HashMap_max_load_factor) in
i1 <- usize_div n1 i;
if capacity s<= i1
then (
i2 <- usize_mul capacity 2%usize;
- ntable <- hashmap_hash_map_new_with_capacity_fwd T n i2 i i0;
+ ntable <- hashmap_HashMap_new_with_capacity T n i2 i i0;
p <-
- hashmap_hash_map_move_elements_fwd_back T n ntable
- self.(Hashmap_hash_map_slots) 0%usize;
+ hashmap_HashMap_move_elements T n ntable self.(hashmap_HashMap_slots)
+ 0%usize;
let (ntable0, _) := p in
Return
{|
- Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
- Hashmap_hash_map_max_load_factor := (i, i0);
- Hashmap_hash_map_max_load := ntable0.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := ntable0.(Hashmap_hash_map_slots)
+ hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+ hashmap_HashMap_max_load_factor := (i, i0);
+ hashmap_HashMap_max_load := ntable0.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := ntable0.(hashmap_HashMap_slots)
|})
else
Return
{|
- Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
- Hashmap_hash_map_max_load_factor := (i, i0);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := self.(Hashmap_hash_map_slots)
+ hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+ hashmap_HashMap_max_load_factor := (i, i0);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := self.(hashmap_HashMap_slots)
|}
.
(** [hashmap_main::hashmap::HashMap::{0}::insert]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_insert_fwd_back
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) (value : T)
- :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_insert
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) (value : T) :
+ result (hashmap_HashMap_t T)
:=
- self0 <- hashmap_hash_map_insert_no_resize_fwd_back T n self key value;
- i <- hashmap_hash_map_len_fwd T self0;
- if i s> self0.(Hashmap_hash_map_max_load)
- then hashmap_hash_map_try_resize_fwd_back T n self0
+ self0 <- hashmap_HashMap_insert_no_resize T n self key value;
+ i <- hashmap_HashMap_len T self0;
+ if i s> self0.(hashmap_HashMap_max_load)
+ then hashmap_HashMap_try_resize T n self0
else Return self0
.
(** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_contains_key_in_list_loop_fwd
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result bool :=
+Fixpoint hashmap_HashMap_contains_key_in_list_loop
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result bool :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey t tl =>
+ | Hashmap_List_Cons ckey t tl =>
if ckey s= key
then Return true
- else hashmap_hash_map_contains_key_in_list_loop_fwd T n0 key tl
- | HashmapListNil => Return false
+ else hashmap_HashMap_contains_key_in_list_loop T n0 key tl
+ | Hashmap_List_Nil => Return false
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: forward function *)
-Definition hashmap_hash_map_contains_key_in_list_fwd
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result bool :=
- hashmap_hash_map_contains_key_in_list_loop_fwd T n key ls
+Definition hashmap_HashMap_contains_key_in_list
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result bool :=
+ hashmap_HashMap_contains_key_in_list_loop T n key ls
.
(** [hashmap_main::hashmap::HashMap::{0}::contains_key]: forward function *)
-Definition hashmap_hash_map_contains_key_fwd
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
+Definition hashmap_HashMap_contains_key
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) :
result bool
:=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- hashmap_hash_map_contains_key_in_list_fwd T n key l
+ l <-
+ alloc_vec_Vec_index (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ hashmap_HashMap_contains_key_in_list T n key l
.
(** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_get_in_list_loop_fwd
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result T :=
+Fixpoint hashmap_HashMap_get_in_list_loop
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey cvalue tl =>
+ | Hashmap_List_Cons ckey cvalue tl =>
if ckey s= key
then Return cvalue
- else hashmap_hash_map_get_in_list_loop_fwd T n0 key tl
- | HashmapListNil => Fail_ Failure
+ else hashmap_HashMap_get_in_list_loop T n0 key tl
+ | Hashmap_List_Nil => Fail_ Failure
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: forward function *)
-Definition hashmap_hash_map_get_in_list_fwd
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result T :=
- hashmap_hash_map_get_in_list_loop_fwd T n key ls
+Definition hashmap_HashMap_get_in_list
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result T :=
+ hashmap_HashMap_get_in_list_loop T n key ls
.
(** [hashmap_main::hashmap::HashMap::{0}::get]: forward function *)
-Definition hashmap_hash_map_get_fwd
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
- result T
- :=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+Definition hashmap_HashMap_get
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) : result T :=
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
- l <- vec_index_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- hashmap_hash_map_get_in_list_fwd T n key l
+ l <-
+ alloc_vec_Vec_index (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ hashmap_HashMap_get_in_list T n key l
.
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_get_mut_in_list_loop_fwd
- (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) : result T :=
+Fixpoint hashmap_HashMap_get_mut_in_list_loop
+ (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey cvalue tl =>
+ | Hashmap_List_Cons ckey cvalue tl =>
if ckey s= key
then Return cvalue
- else hashmap_hash_map_get_mut_in_list_loop_fwd T n0 tl key
- | HashmapListNil => Fail_ Failure
+ else hashmap_HashMap_get_mut_in_list_loop T n0 tl key
+ | Hashmap_List_Nil => Fail_ Failure
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: forward function *)
-Definition hashmap_hash_map_get_mut_in_list_fwd
- (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) : result T :=
- hashmap_hash_map_get_mut_in_list_loop_fwd T n ls key
+Definition hashmap_HashMap_get_mut_in_list
+ (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) : result T :=
+ hashmap_HashMap_get_mut_in_list_loop T n ls key
.
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: backward function 0 *)
-Fixpoint hashmap_hash_map_get_mut_in_list_loop_back
- (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) (ret : T) :
- result (Hashmap_list_t T)
+Fixpoint hashmap_HashMap_get_mut_in_list_loop_back
+ (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) (ret : T) :
+ result (hashmap_List_t T)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey cvalue tl =>
+ | Hashmap_List_Cons ckey cvalue tl =>
if ckey s= key
- then Return (HashmapListCons ckey ret tl)
+ then Return (Hashmap_List_Cons ckey ret tl)
else (
- tl0 <- hashmap_hash_map_get_mut_in_list_loop_back T n0 tl key ret;
- Return (HashmapListCons ckey cvalue tl0))
- | HashmapListNil => Fail_ Failure
+ tl0 <- hashmap_HashMap_get_mut_in_list_loop_back T n0 tl key ret;
+ Return (Hashmap_List_Cons ckey cvalue tl0))
+ | Hashmap_List_Nil => Fail_ Failure
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: backward function 0 *)
-Definition hashmap_hash_map_get_mut_in_list_back
- (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) (ret : T) :
- result (Hashmap_list_t T)
+Definition hashmap_HashMap_get_mut_in_list_back
+ (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) (ret : T) :
+ result (hashmap_List_t T)
:=
- hashmap_hash_map_get_mut_in_list_loop_back T n ls key ret
+ hashmap_HashMap_get_mut_in_list_loop_back T n ls key ret
.
(** [hashmap_main::hashmap::HashMap::{0}::get_mut]: forward function *)
-Definition hashmap_hash_map_get_mut_fwd
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
- result T
- :=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+Definition hashmap_HashMap_get_mut
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) : result T :=
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
l <-
- vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- hashmap_hash_map_get_mut_in_list_fwd T n l key
+ alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ hashmap_HashMap_get_mut_in_list T n l key
.
(** [hashmap_main::hashmap::HashMap::{0}::get_mut]: backward function 0 *)
-Definition hashmap_hash_map_get_mut_back
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) (ret : T) :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_get_mut_back
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) (ret : T) :
+ result (hashmap_HashMap_t T)
:=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
l <-
- vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- l0 <- hashmap_hash_map_get_mut_in_list_back T n l key ret;
+ alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ l0 <- hashmap_HashMap_get_mut_in_list_back T n l key ret;
v <-
- vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
- hash_mod l0;
+ alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod l0;
Return
{|
- Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
- Hashmap_hash_map_max_load_factor :=
- self.(Hashmap_hash_map_max_load_factor);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := v
+ hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+ hashmap_HashMap_max_load_factor := self.(hashmap_HashMap_max_load_factor);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := v
|}
.
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_remove_from_list_loop_fwd
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
+Fixpoint hashmap_HashMap_remove_from_list_loop
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
result (option T)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey t tl =>
+ | Hashmap_List_Cons ckey t tl =>
if ckey s= key
then
let mv_ls :=
- mem_replace_fwd (Hashmap_list_t T) (HashmapListCons ckey t tl)
- HashmapListNil in
+ core_mem_replace (hashmap_List_t T) (Hashmap_List_Cons ckey t tl)
+ Hashmap_List_Nil in
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 n0 key tl
- | HashmapListNil => Return None
+ else hashmap_HashMap_remove_from_list_loop T n0 key tl
+ | Hashmap_List_Nil => Return None
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: forward function *)
-Definition hashmap_hash_map_remove_from_list_fwd
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
+Definition hashmap_HashMap_remove_from_list
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
result (option T)
:=
- hashmap_hash_map_remove_from_list_loop_fwd T n key ls
+ hashmap_HashMap_remove_from_list_loop T n key ls
.
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: backward function 1 *)
-Fixpoint hashmap_hash_map_remove_from_list_loop_back
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
- result (Hashmap_list_t T)
+Fixpoint hashmap_HashMap_remove_from_list_loop_back
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
+ result (hashmap_List_t T)
:=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | HashmapListCons ckey t tl =>
+ | Hashmap_List_Cons ckey t tl =>
if ckey s= key
then
let mv_ls :=
- mem_replace_fwd (Hashmap_list_t T) (HashmapListCons ckey t tl)
- HashmapListNil in
+ core_mem_replace (hashmap_List_t T) (Hashmap_List_Cons ckey t tl)
+ Hashmap_List_Nil in
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 (
- tl0 <- hashmap_hash_map_remove_from_list_loop_back T n0 key tl;
- Return (HashmapListCons ckey t tl0))
- | HashmapListNil => Return HashmapListNil
+ tl0 <- hashmap_HashMap_remove_from_list_loop_back T n0 key tl;
+ Return (Hashmap_List_Cons ckey t tl0))
+ | Hashmap_List_Nil => Return Hashmap_List_Nil
end
end
.
(** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: backward function 1 *)
-Definition hashmap_hash_map_remove_from_list_back
- (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
- result (Hashmap_list_t T)
+Definition hashmap_HashMap_remove_from_list_back
+ (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
+ result (hashmap_List_t T)
:=
- hashmap_hash_map_remove_from_list_loop_back T n key ls
+ hashmap_HashMap_remove_from_list_loop_back T n key ls
.
(** [hashmap_main::hashmap::HashMap::{0}::remove]: forward function *)
-Definition hashmap_hash_map_remove_fwd
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
+Definition hashmap_HashMap_remove
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) :
result (option T)
:=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
l <-
- vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- x <- hashmap_hash_map_remove_from_list_fwd T n key l;
+ alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ x <- hashmap_HashMap_remove_from_list T n key l;
match x with
| None => Return None
| Some x0 =>
- _ <- usize_sub self.(Hashmap_hash_map_num_entries) 1%usize;
- Return (Some x0)
+ _ <- usize_sub self.(hashmap_HashMap_num_entries) 1%usize; Return (Some x0)
end
.
(** [hashmap_main::hashmap::HashMap::{0}::remove]: backward function 0 *)
-Definition hashmap_hash_map_remove_back
- (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
- result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_remove_back
+ (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) :
+ result (hashmap_HashMap_t T)
:=
- hash <- hashmap_hash_key_fwd key;
- let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+ hash <- hashmap_hash_key key;
+ let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
hash_mod <- usize_rem hash i;
l <-
- vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
- x <- hashmap_hash_map_remove_from_list_fwd T n key l;
+ alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+ self.(hashmap_HashMap_slots) hash_mod;
+ x <- hashmap_HashMap_remove_from_list T n key l;
match x with
| None =>
- l0 <- hashmap_hash_map_remove_from_list_back T n key l;
+ l0 <- hashmap_HashMap_remove_from_list_back T n key l;
v <-
- vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
- hash_mod l0;
+ alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ T)) self.(hashmap_HashMap_slots) hash_mod l0;
Return
{|
- Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
- Hashmap_hash_map_max_load_factor :=
- self.(Hashmap_hash_map_max_load_factor);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := v
+ hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+ hashmap_HashMap_max_load_factor :=
+ self.(hashmap_HashMap_max_load_factor);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := v
|}
| Some x0 =>
- i0 <- usize_sub self.(Hashmap_hash_map_num_entries) 1%usize;
- l0 <- hashmap_hash_map_remove_from_list_back T n key l;
+ i0 <- usize_sub self.(hashmap_HashMap_num_entries) 1%usize;
+ l0 <- hashmap_HashMap_remove_from_list_back T n key l;
v <-
- vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
- hash_mod l0;
+ alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+ T)) self.(hashmap_HashMap_slots) hash_mod l0;
Return
{|
- Hashmap_hash_map_num_entries := i0;
- Hashmap_hash_map_max_load_factor :=
- self.(Hashmap_hash_map_max_load_factor);
- Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
- Hashmap_hash_map_slots := v
+ hashmap_HashMap_num_entries := i0;
+ hashmap_HashMap_max_load_factor :=
+ self.(hashmap_HashMap_max_load_factor);
+ hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+ hashmap_HashMap_slots := v
|}
end
.
(** [hashmap_main::hashmap::test1]: forward function *)
-Definition hashmap_test1_fwd (n : nat) : result unit :=
- hm <- hashmap_hash_map_new_fwd u64 n;
- hm0 <- hashmap_hash_map_insert_fwd_back u64 n hm 0%usize 42%u64;
- hm1 <- hashmap_hash_map_insert_fwd_back u64 n hm0 128%usize 18%u64;
- hm2 <- hashmap_hash_map_insert_fwd_back u64 n hm1 1024%usize 138%u64;
- hm3 <- hashmap_hash_map_insert_fwd_back u64 n hm2 1056%usize 256%u64;
- i <- hashmap_hash_map_get_fwd u64 n hm3 128%usize;
+Definition hashmap_test1 (n : nat) : result unit :=
+ hm <- hashmap_HashMap_new u64 n;
+ hm0 <- hashmap_HashMap_insert u64 n hm 0%usize 42%u64;
+ hm1 <- hashmap_HashMap_insert u64 n hm0 128%usize 18%u64;
+ hm2 <- hashmap_HashMap_insert u64 n hm1 1024%usize 138%u64;
+ hm3 <- hashmap_HashMap_insert u64 n hm2 1056%usize 256%u64;
+ i <- hashmap_HashMap_get u64 n hm3 128%usize;
if negb (i s= 18%u64)
then Fail_ Failure
else (
- hm4 <- hashmap_hash_map_get_mut_back u64 n hm3 1024%usize 56%u64;
- i0 <- hashmap_hash_map_get_fwd u64 n hm4 1024%usize;
+ hm4 <- hashmap_HashMap_get_mut_back u64 n hm3 1024%usize 56%u64;
+ i0 <- hashmap_HashMap_get u64 n hm4 1024%usize;
if negb (i0 s= 56%u64)
then Fail_ Failure
else (
- x <- hashmap_hash_map_remove_fwd u64 n hm4 1024%usize;
+ x <- hashmap_HashMap_remove u64 n hm4 1024%usize;
match x with
| None => Fail_ Failure
| Some x0 =>
if negb (x0 s= 56%u64)
then Fail_ Failure
else (
- hm5 <- hashmap_hash_map_remove_back u64 n hm4 1024%usize;
- i1 <- hashmap_hash_map_get_fwd u64 n hm5 0%usize;
+ hm5 <- hashmap_HashMap_remove_back u64 n hm4 1024%usize;
+ i1 <- hashmap_HashMap_get u64 n hm5 0%usize;
if negb (i1 s= 42%u64)
then Fail_ Failure
else (
- i2 <- hashmap_hash_map_get_fwd u64 n hm5 128%usize;
+ i2 <- hashmap_HashMap_get u64 n hm5 128%usize;
if negb (i2 s= 18%u64)
then Fail_ Failure
else (
- i3 <- hashmap_hash_map_get_fwd u64 n hm5 1056%usize;
+ i3 <- hashmap_HashMap_get u64 n hm5 1056%usize;
if negb (i3 s= 256%u64) then Fail_ Failure else Return tt)))
end))
.
(** [hashmap_main::insert_on_disk]: forward function *)
-Definition insert_on_disk_fwd
+Definition insert_on_disk
(n : nat) (key : usize) (value : u64) (st : state) : result (state * unit) :=
- p <- hashmap_utils_deserialize_fwd st;
+ p <- hashmap_utils_deserialize st;
let (st0, hm) := p in
- hm0 <- hashmap_hash_map_insert_fwd_back u64 n hm key value;
- p0 <- hashmap_utils_serialize_fwd hm0 st0;
+ hm0 <- hashmap_HashMap_insert u64 n hm key value;
+ p0 <- hashmap_utils_serialize hm0 st0;
let (st1, _) := p0 in
Return (st1, tt)
.
(** [hashmap_main::main]: forward function *)
-Definition main_fwd : result unit :=
+Definition main : result unit :=
Return tt.
-(** Unit test for [hashmap_main::main] *)
-Check (main_fwd )%return.
-
End HashmapMain_Funs .
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v b/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v
index 2d17cc29..5e376239 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v
@@ -11,13 +11,13 @@ Import HashmapMain_Types.
Module HashmapMain_Opaque.
(** [hashmap_main::hashmap_utils::deserialize]: forward function *)
-Axiom hashmap_utils_deserialize_fwd
- : state -> result (state * (Hashmap_hash_map_t u64))
+Axiom hashmap_utils_deserialize
+ : state -> result (state * (hashmap_HashMap_t u64))
.
(** [hashmap_main::hashmap_utils::serialize]: forward function *)
-Axiom hashmap_utils_serialize_fwd
- : Hashmap_hash_map_t u64 -> state -> result (state * unit)
+Axiom hashmap_utils_serialize
+ : hashmap_HashMap_t u64 -> state -> result (state * unit)
.
End HashmapMain_Opaque .
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Types.v b/tests/coq/hashmap_on_disk/HashmapMain_Types.v
index 36aaaf25..95e5f35b 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Types.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Types.v
@@ -9,29 +9,29 @@ Local Open Scope Primitives_scope.
Module HashmapMain_Types.
(** [hashmap_main::hashmap::List] *)
-Inductive Hashmap_list_t (T : Type) :=
-| HashmapListCons : usize -> T -> Hashmap_list_t T -> Hashmap_list_t T
-| HashmapListNil : Hashmap_list_t T
+Inductive hashmap_List_t (T : Type) :=
+| Hashmap_List_Cons : usize -> T -> hashmap_List_t T -> hashmap_List_t T
+| Hashmap_List_Nil : hashmap_List_t T
.
-Arguments HashmapListCons {T} _ _ _.
-Arguments HashmapListNil {T}.
+Arguments Hashmap_List_Cons { _ }.
+Arguments Hashmap_List_Nil { _ }.
(** [hashmap_main::hashmap::HashMap] *)
-Record Hashmap_hash_map_t (T : Type) :=
-mkHashmap_hash_map_t {
- 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);
+Record hashmap_HashMap_t (T : Type) :=
+mkhashmap_HashMap_t {
+ hashmap_HashMap_num_entries : usize;
+ hashmap_HashMap_max_load_factor : (usize * usize);
+ hashmap_HashMap_max_load : usize;
+ hashmap_HashMap_slots : alloc_vec_Vec (hashmap_List_t T);
}
.
-Arguments mkHashmap_hash_map_t {T} _ _ _ _.
-Arguments Hashmap_hash_map_num_entries {T}.
-Arguments Hashmap_hash_map_max_load_factor {T}.
-Arguments Hashmap_hash_map_max_load {T}.
-Arguments Hashmap_hash_map_slots {T}.
+Arguments mkhashmap_HashMap_t { _ }.
+Arguments hashmap_HashMap_num_entries { _ }.
+Arguments hashmap_HashMap_max_load_factor { _ }.
+Arguments hashmap_HashMap_max_load { _ }.
+Arguments hashmap_HashMap_slots { _ }.
(** The state type used in the state-error monad *)
Axiom state : Type.
diff --git a/tests/coq/hashmap_on_disk/Primitives.v b/tests/coq/hashmap_on_disk/Primitives.v
index 71a2d9c3..85e38f01 100644
--- a/tests/coq/hashmap_on_disk/Primitives.v
+++ b/tests/coq/hashmap_on_disk/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
(*** Misc *)
-
Definition string := Coq.Strings.String.string.
Definition char := Coq.Strings.Ascii.ascii.
Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
(*** Scalars *)
@@ -394,12 +396,89 @@ Notation "x s< y" := (scalar_ltb x y) (at level 80) : Primitives_scope.
Notation "x s>= y" := (scalar_geb x y) (at level 80) : Primitives_scope.
Notation "x s> y" := (scalar_gtb x y) (at level 80) : Primitives_scope.
-(*** Range *)
-Record range (T : Type) := mk_range {
- start: T;
- end_: T;
+(** Constants *)
+Definition core_u8_max := u8_max %u32.
+Definition core_u16_max := u16_max %u32.
+Definition core_u32_max := u32_max %u32.
+Definition core_u64_max := u64_max %u64.
+Definition core_u128_max := u64_max %u128.
+Axiom core_usize_max : usize. (** TODO *)
+Definition core_i8_max := i8_max %i32.
+Definition core_i16_max := i16_max %i32.
+Definition core_i32_max := i32_max %i32.
+Definition core_i64_max := i64_max %i64.
+Definition core_i128_max := i64_max %i128.
+Axiom core_isize_max : isize. (** TODO *)
+
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+ core_ops_index_Index_Output : Type;
+ core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+ core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+ core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+ core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+ core_ops_deref_Deref_target : Type;
+ core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+ core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+ core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+ core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
}.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+ core_ops_range_Range_start : T;
+ core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+ core_ops_deref_Deref_target := Self;
+ core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+ core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+ core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+ core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
(*** Arrays *)
Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -419,51 +498,50 @@ Qed.
(* TODO: finish the definitions *)
Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
(*** Slice *)
Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
(*** Subslices *)
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
(*** Vectors *)
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
Proof.
- unfold vec_length, usize_min.
+ unfold alloc_vec_Vec_length, usize_min.
split.
- lia.
- apply (proj2_sig v).
Qed.
-Definition vec_len (T: Type) (v: vec T) : usize :=
- exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+ exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
: list A :=
@@ -474,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
| S m => x :: (list_update t m a)
end end.
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
- l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+ l <- f (alloc_vec_Vec_to_list v) ;
match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
| left H => Return (exist _ l (scalar_le_max_valid _ _ H))
| right _ => Fail_ Failure
end.
(* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
- vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
(* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+ if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l =>
if to_Z i <? Z.of_nat (length l)
then Return (list_update l (usize_to_nat i) x)
else Fail_ Failure).
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
- end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+ core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+ core_slice_index_SliceIndex_Output : Type;
+ core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+ core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+ (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+ x <- inst.(core_slice_index_SliceIndex_get) i s;
+ match x with
+ | None => Fail_ Failure
+ | Some x => Return x
end.
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
- if to_Z i <? Z.of_nat (length l)
- then Return (list_update l (usize_to_nat i) x)
- else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+ (T : Type) :
+ 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 *)
+Definition core_slice_index_Range_get_unchecked_mut
+ (T : Type) :
+ 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 *)
+Axiom core_slice_index_Range_index :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (slice T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := slice T;
+ core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (slice T) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_Index (slice T) Idx) :
+ core_ops_index_Index (array T N) Idx := {|
+ core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+ core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_IndexMut (slice T) Idx) :
+ core_ops_index_IndexMut (array T N) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+ core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+ core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+ forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+ forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+ forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+ forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex usize (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := T;
+ core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+ core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+ alloc_vec_Vec_update_usize v i x.
End Primitives.
diff --git a/tests/coq/misc/Constants.v b/tests/coq/misc/Constants.v
index f1c32730..03653f69 100644
--- a/tests/coq/misc/Constants.v
+++ b/tests/coq/misc/Constants.v
@@ -12,12 +12,8 @@ Module Constants.
Definition x0_body : result u32 := Return 0%u32.
Definition x0_c : u32 := x0_body%global.
-(** [core::num::u32::{8}::MAX] *)
-Definition core_num_u32_max_body : result u32 := Return 4294967295%u32.
-Definition core_num_u32_max_c : u32 := core_num_u32_max_body%global.
-
(** [constants::X1] *)
-Definition x1_body : result u32 := Return core_num_u32_max_c.
+Definition x1_body : result u32 := Return core_u32_max.
Definition x1_c : u32 := x1_body%global.
(** [constants::X2] *)
@@ -25,36 +21,35 @@ Definition x2_body : result u32 := Return 3%u32.
Definition x2_c : u32 := x2_body%global.
(** [constants::incr]: forward function *)
-Definition incr_fwd (n : u32) : result u32 :=
+Definition incr (n : u32) : result u32 :=
u32_add n 1%u32.
(** [constants::X3] *)
-Definition x3_body : result u32 := incr_fwd 32%u32.
+Definition x3_body : result u32 := incr 32%u32.
Definition x3_c : u32 := x3_body%global.
(** [constants::mk_pair0]: forward function *)
-Definition mk_pair0_fwd (x : u32) (y : u32) : result (u32 * u32) :=
- Return (x, y)
-.
+Definition mk_pair0 (x : u32) (y : u32) : result (u32 * u32) :=
+ Return (x, y).
(** [constants::Pair] *)
-Record Pair_t (T1 T2 : Type) := mkPair_t { Pair_x : T1; Pair_y : T2; }.
+Record Pair_t (T1 T2 : Type) := mkPair_t { pair_x : T1; pair_y : T2; }.
-Arguments mkPair_t {T1} {T2} _ _.
-Arguments Pair_x {T1} {T2}.
-Arguments Pair_y {T1} {T2}.
+Arguments mkPair_t { _ _ }.
+Arguments pair_x { _ _ }.
+Arguments pair_y { _ _ }.
(** [constants::mk_pair1]: forward function *)
-Definition mk_pair1_fwd (x : u32) (y : u32) : result (Pair_t u32 u32) :=
- Return {| Pair_x := x; Pair_y := y |}
+Definition mk_pair1 (x : u32) (y : u32) : result (Pair_t u32 u32) :=
+ Return {| pair_x := x; pair_y := y |}
.
(** [constants::P0] *)
-Definition p0_body : result (u32 * u32) := mk_pair0_fwd 0%u32 1%u32.
+Definition p0_body : result (u32 * u32) := mk_pair0 0%u32 1%u32.
Definition p0_c : (u32 * u32) := p0_body%global.
(** [constants::P1] *)
-Definition p1_body : result (Pair_t u32 u32) := mk_pair1_fwd 0%u32 1%u32.
+Definition p1_body : result (Pair_t u32 u32) := mk_pair1 0%u32 1%u32.
Definition p1_c : Pair_t u32 u32 := p1_body%global.
(** [constants::P2] *)
@@ -63,31 +58,31 @@ Definition p2_c : (u32 * u32) := p2_body%global.
(** [constants::P3] *)
Definition p3_body : result (Pair_t u32 u32) :=
- Return {| Pair_x := 0%u32; Pair_y := 1%u32 |}
+ Return {| pair_x := 0%u32; pair_y := 1%u32 |}
.
Definition p3_c : Pair_t u32 u32 := p3_body%global.
(** [constants::Wrap] *)
-Record Wrap_t (T : Type) := mkWrap_t { Wrap_val : T; }.
+Record Wrap_t (T : Type) := mkWrap_t { wrap_value : T; }.
-Arguments mkWrap_t {T} _.
-Arguments Wrap_val {T}.
+Arguments mkWrap_t { _ }.
+Arguments wrap_value { _ }.
(** [constants::Wrap::{0}::new]: forward function *)
-Definition wrap_new_fwd (T : Type) (val : T) : result (Wrap_t T) :=
- Return {| Wrap_val := val |}
+Definition wrap_new (T : Type) (value : T) : result (Wrap_t T) :=
+ Return {| wrap_value := value |}
.
(** [constants::Y] *)
-Definition y_body : result (Wrap_t i32) := wrap_new_fwd i32 2%i32.
+Definition y_body : result (Wrap_t i32) := wrap_new i32 2%i32.
Definition y_c : Wrap_t i32 := y_body%global.
(** [constants::unwrap_y]: forward function *)
-Definition unwrap_y_fwd : result i32 :=
- Return y_c.(Wrap_val).
+Definition unwrap_y : result i32 :=
+ Return y_c.(wrap_value).
(** [constants::YVAL] *)
-Definition yval_body : result i32 := unwrap_y_fwd.
+Definition yval_body : result i32 := unwrap_y.
Definition yval_c : i32 := yval_body%global.
(** [constants::get_z1::Z1] *)
@@ -95,11 +90,11 @@ Definition get_z1_z1_body : result i32 := Return 3%i32.
Definition get_z1_z1_c : i32 := get_z1_z1_body%global.
(** [constants::get_z1]: forward function *)
-Definition get_z1_fwd : result i32 :=
+Definition get_z1 : result i32 :=
Return get_z1_z1_c.
(** [constants::add]: forward function *)
-Definition add_fwd (a : i32) (b : i32) : result i32 :=
+Definition add (a : i32) (b : i32) : result i32 :=
i32_add a b.
(** [constants::Q1] *)
@@ -111,20 +106,19 @@ Definition q2_body : result i32 := Return q1_c.
Definition q2_c : i32 := q2_body%global.
(** [constants::Q3] *)
-Definition q3_body : result i32 := add_fwd q2_c 3%i32.
+Definition q3_body : result i32 := add q2_c 3%i32.
Definition q3_c : i32 := q3_body%global.
(** [constants::get_z2]: forward function *)
-Definition get_z2_fwd : result i32 :=
- i <- get_z1_fwd; i0 <- add_fwd i q3_c; add_fwd q1_c i0
-.
+Definition get_z2 : result i32 :=
+ i <- get_z1; i0 <- add i q3_c; add q1_c i0.
(** [constants::S1] *)
Definition s1_body : result u32 := Return 6%u32.
Definition s1_c : u32 := s1_body%global.
(** [constants::S2] *)
-Definition s2_body : result u32 := incr_fwd s1_c.
+Definition s2_body : result u32 := incr s1_c.
Definition s2_c : u32 := s2_body%global.
(** [constants::S3] *)
@@ -132,7 +126,7 @@ Definition s3_body : result (Pair_t u32 u32) := Return p3_c.
Definition s3_c : Pair_t u32 u32 := s3_body%global.
(** [constants::S4] *)
-Definition s4_body : result (Pair_t u32 u32) := mk_pair1_fwd 7%u32 8%u32.
+Definition s4_body : result (Pair_t u32 u32) := mk_pair1 7%u32 8%u32.
Definition s4_c : Pair_t u32 u32 := s4_body%global.
End Constants .
diff --git a/tests/coq/misc/External_Funs.v b/tests/coq/misc/External_Funs.v
index 28370b2b..018ce13c 100644
--- a/tests/coq/misc/External_Funs.v
+++ b/tests/coq/misc/External_Funs.v
@@ -13,9 +13,9 @@ Import External_Opaque.
Module External_Funs.
(** [external::swap]: forward function *)
-Definition swap_fwd
+Definition swap
(T : Type) (x : T) (y : T) (st : state) : result (state * unit) :=
- p <- core_mem_swap_fwd T x y st;
+ p <- core_mem_swap T x y st;
let (st0, _) := p in
p0 <- core_mem_swap_back0 T x y st st0;
let (st1, _) := p0 in
@@ -29,7 +29,7 @@ Definition swap_back
(T : Type) (x : T) (y : T) (st : state) (st0 : state) :
result (state * (T * T))
:=
- p <- core_mem_swap_fwd T x y st;
+ p <- core_mem_swap T x y st;
let (st1, _) := p in
p0 <- core_mem_swap_back0 T x y st st1;
let (st2, x0) := p0 in
@@ -39,25 +39,27 @@ Definition swap_back
.
(** [external::test_new_non_zero_u32]: forward function *)
-Definition test_new_non_zero_u32_fwd
- (x : u32) (st : state) : result (state * Core_num_nonzero_non_zero_u32_t) :=
- p <- core_num_nonzero_non_zero_u32_new_fwd x st;
- let (st0, opt) := p in
- core_option_option_unwrap_fwd Core_num_nonzero_non_zero_u32_t opt st0
+Definition test_new_non_zero_u32
+ (x : u32) (st : state) : result (state * core_num_nonzero_NonZeroU32_t) :=
+ p <- core_num_nonzero_NonZeroU32_new x st;
+ let (st0, o) := p in
+ core_option_Option_unwrap core_num_nonzero_NonZeroU32_t o st0
.
(** [external::test_vec]: forward function *)
-Definition test_vec_fwd : result unit :=
- let v := vec_new u32 in _ <- vec_push_back u32 v 0%u32; Return tt
+Definition test_vec : result unit :=
+ let v := alloc_vec_Vec_new u32 in
+ _ <- alloc_vec_Vec_push u32 v 0%u32;
+ Return tt
.
(** Unit test for [external::test_vec] *)
-Check (test_vec_fwd )%return.
+Check (test_vec )%return.
(** [external::custom_swap]: forward function *)
-Definition custom_swap_fwd
+Definition custom_swap
(T : Type) (x : T) (y : T) (st : state) : result (state * T) :=
- p <- core_mem_swap_fwd T x y st;
+ p <- core_mem_swap T x y st;
let (st0, _) := p in
p0 <- core_mem_swap_back0 T x y st st0;
let (st1, x0) := p0 in
@@ -71,7 +73,7 @@ Definition custom_swap_back
(T : Type) (x : T) (y : T) (st : state) (ret : T) (st0 : state) :
result (state * (T * T))
:=
- p <- core_mem_swap_fwd T x y st;
+ p <- core_mem_swap T x y st;
let (st1, _) := p in
p0 <- core_mem_swap_back0 T x y st st1;
let (st2, _) := p0 in
@@ -81,9 +83,9 @@ Definition custom_swap_back
.
(** [external::test_custom_swap]: forward function *)
-Definition test_custom_swap_fwd
+Definition test_custom_swap
(x : u32) (y : u32) (st : state) : result (state * unit) :=
- p <- custom_swap_fwd u32 x y st; let (st0, _) := p in Return (st0, tt)
+ p <- custom_swap u32 x y st; let (st0, _) := p in Return (st0, tt)
.
(** [external::test_custom_swap]: backward function 0 *)
@@ -95,9 +97,8 @@ Definition test_custom_swap_back
.
(** [external::test_swap_non_zero]: forward function *)
-Definition test_swap_non_zero_fwd
- (x : u32) (st : state) : result (state * u32) :=
- p <- swap_fwd u32 x 0%u32 st;
+Definition test_swap_non_zero (x : u32) (st : state) : result (state * u32) :=
+ p <- swap u32 x 0%u32 st;
let (st0, _) := p in
p0 <- swap_back u32 x 0%u32 st st0;
let (st1, p1) := p0 in
diff --git a/tests/coq/misc/External_Opaque.v b/tests/coq/misc/External_Opaque.v
index d2ee42d4..80be37e7 100644
--- a/tests/coq/misc/External_Opaque.v
+++ b/tests/coq/misc/External_Opaque.v
@@ -11,7 +11,7 @@ Import External_Types.
Module External_Opaque.
(** [core::mem::swap]: forward function *)
-Axiom core_mem_swap_fwd :
+Axiom core_mem_swap :
forall(T : Type), T -> T -> state -> result (state * unit)
.
@@ -26,12 +26,12 @@ Axiom core_mem_swap_back1 :
.
(** [core::num::nonzero::NonZeroU32::{14}::new]: forward function *)
-Axiom core_num_nonzero_non_zero_u32_new_fwd
- : u32 -> state -> result (state * (option Core_num_nonzero_non_zero_u32_t))
+Axiom core_num_nonzero_NonZeroU32_new
+ : u32 -> state -> result (state * (option core_num_nonzero_NonZeroU32_t))
.
(** [core::option::Option::{0}::unwrap]: forward function *)
-Axiom core_option_option_unwrap_fwd :
+Axiom core_option_Option_unwrap :
forall(T : Type), option T -> state -> result (state * T)
.
diff --git a/tests/coq/misc/External_Types.v b/tests/coq/misc/External_Types.v
index 1883fa6c..9e49ca41 100644
--- a/tests/coq/misc/External_Types.v
+++ b/tests/coq/misc/External_Types.v
@@ -9,7 +9,7 @@ Local Open Scope Primitives_scope.
Module External_Types.
(** [core::num::nonzero::NonZeroU32] *)
-Axiom Core_num_nonzero_non_zero_u32_t : Type.
+Axiom core_num_nonzero_NonZeroU32_t : Type.
(** The state type used in the state-error monad *)
Axiom state : Type.
diff --git a/tests/coq/misc/Loops.v b/tests/coq/misc/Loops.v
index 82e57576..1c0eab17 100644
--- a/tests/coq/misc/Loops.v
+++ b/tests/coq/misc/Loops.v
@@ -9,23 +9,23 @@ Local Open Scope Primitives_scope.
Module Loops.
(** [loops::sum]: loop 0: forward function *)
-Fixpoint sum_loop_fwd (n : nat) (max : u32) (i : u32) (s : u32) : result u32 :=
+Fixpoint sum_loop (n : nat) (max : u32) (i : u32) (s : u32) : result u32 :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
if i s< max
- then (s0 <- u32_add s i; i0 <- u32_add i 1%u32; sum_loop_fwd n0 max i0 s0)
+ then (s0 <- u32_add s i; i0 <- u32_add i 1%u32; sum_loop n0 max i0 s0)
else u32_mul s 2%u32
end
.
(** [loops::sum]: forward function *)
-Definition sum_fwd (n : nat) (max : u32) : result u32 :=
- sum_loop_fwd n max 0%u32 0%u32
+Definition sum (n : nat) (max : u32) : result u32 :=
+ sum_loop n max 0%u32 0%u32
.
(** [loops::sum_with_mut_borrows]: loop 0: forward function *)
-Fixpoint sum_with_mut_borrows_loop_fwd
+Fixpoint sum_with_mut_borrows_loop
(n : nat) (max : u32) (mi : u32) (ms : u32) : result u32 :=
match n with
| O => Fail_ OutOfFuel
@@ -34,18 +34,18 @@ Fixpoint sum_with_mut_borrows_loop_fwd
then (
ms0 <- u32_add ms mi;
mi0 <- u32_add mi 1%u32;
- sum_with_mut_borrows_loop_fwd n0 max mi0 ms0)
+ sum_with_mut_borrows_loop n0 max mi0 ms0)
else u32_mul ms 2%u32
end
.
(** [loops::sum_with_mut_borrows]: forward function *)
-Definition sum_with_mut_borrows_fwd (n : nat) (max : u32) : result u32 :=
- sum_with_mut_borrows_loop_fwd n max 0%u32 0%u32
+Definition sum_with_mut_borrows (n : nat) (max : u32) : result u32 :=
+ sum_with_mut_borrows_loop n max 0%u32 0%u32
.
(** [loops::sum_with_shared_borrows]: loop 0: forward function *)
-Fixpoint sum_with_shared_borrows_loop_fwd
+Fixpoint sum_with_shared_borrows_loop
(n : nat) (max : u32) (i : u32) (s : u32) : result u32 :=
match n with
| O => Fail_ OutOfFuel
@@ -54,87 +54,88 @@ Fixpoint sum_with_shared_borrows_loop_fwd
then (
i0 <- u32_add i 1%u32;
s0 <- u32_add s i0;
- sum_with_shared_borrows_loop_fwd n0 max i0 s0)
+ sum_with_shared_borrows_loop n0 max i0 s0)
else u32_mul s 2%u32
end
.
(** [loops::sum_with_shared_borrows]: forward function *)
-Definition sum_with_shared_borrows_fwd (n : nat) (max : u32) : result u32 :=
- sum_with_shared_borrows_loop_fwd n max 0%u32 0%u32
+Definition sum_with_shared_borrows (n : nat) (max : u32) : result u32 :=
+ sum_with_shared_borrows_loop n max 0%u32 0%u32
.
(** [loops::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Fixpoint clear_loop_fwd_back
- (n : nat) (v : vec u32) (i : usize) : result (vec u32) :=
+Fixpoint clear_loop
+ (n : nat) (v : alloc_vec_Vec u32) (i : usize) : result (alloc_vec_Vec u32) :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
- let i0 := vec_len u32 v in
+ let i0 := alloc_vec_Vec_len u32 v in
if i s< i0
then (
i1 <- usize_add i 1%usize;
- v0 <- vec_index_mut_back u32 v i 0%u32;
- clear_loop_fwd_back n0 v0 i1)
+ v0 <-
+ alloc_vec_Vec_index_mut_back u32 usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst u32) v i 0%u32;
+ clear_loop n0 v0 i1)
else Return v
end
.
(** [loops::clear]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition clear_fwd_back (n : nat) (v : vec u32) : result (vec u32) :=
- clear_loop_fwd_back n v 0%usize
+Definition clear
+ (n : nat) (v : alloc_vec_Vec u32) : result (alloc_vec_Vec u32) :=
+ clear_loop n v 0%usize
.
(** [loops::List] *)
Inductive List_t (T : Type) :=
-| 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
.
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons { _ }.
+Arguments List_Nil { _ }.
(** [loops::list_mem]: loop 0: forward function *)
-Fixpoint list_mem_loop_fwd
- (n : nat) (x : u32) (ls : List_t u32) : result bool :=
+Fixpoint list_mem_loop (n : nat) (x : u32) (ls : List_t u32) : result bool :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons y tl =>
- if y s= x then Return true else list_mem_loop_fwd n0 x tl
- | ListNil => Return false
+ | List_Cons y tl => if y s= x then Return true else list_mem_loop n0 x tl
+ | List_Nil => Return false
end
end
.
(** [loops::list_mem]: forward function *)
-Definition list_mem_fwd (n : nat) (x : u32) (ls : List_t u32) : result bool :=
- list_mem_loop_fwd n x ls
+Definition list_mem (n : nat) (x : u32) (ls : List_t u32) : result bool :=
+ list_mem_loop n x ls
.
(** [loops::list_nth_mut_loop]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_loop_fwd
+Fixpoint list_nth_mut_loop_loop
(T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
- else (i0 <- u32_sub i 1%u32; list_nth_mut_loop_loop_fwd T n0 tl i0)
- | ListNil => Fail_ Failure
+ else (i0 <- u32_sub i 1%u32; list_nth_mut_loop_loop T n0 tl i0)
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_mut_loop]: forward function *)
-Definition list_nth_mut_loop_fwd
+Definition list_nth_mut_loop
(T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
- list_nth_mut_loop_loop_fwd T n ls i
+ list_nth_mut_loop_loop T n ls i
.
(** [loops::list_nth_mut_loop]: loop 0: backward function 0 *)
@@ -146,14 +147,14 @@ Fixpoint list_nth_mut_loop_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else (
i0 <- u32_sub i 1%u32;
tl0 <- list_nth_mut_loop_loop_back T n0 tl i0 ret;
- Return (ListCons x tl0))
- | ListNil => Fail_ Failure
+ Return (List_Cons x tl0))
+ | List_Nil => Fail_ Failure
end
end
.
@@ -167,46 +168,50 @@ Definition list_nth_mut_loop_back
.
(** [loops::list_nth_shared_loop]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_loop_fwd
+Fixpoint list_nth_shared_loop_loop
(T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
- else (i0 <- u32_sub i 1%u32; list_nth_shared_loop_loop_fwd T n0 tl i0)
- | ListNil => Fail_ Failure
+ else (i0 <- u32_sub i 1%u32; list_nth_shared_loop_loop T n0 tl i0)
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_shared_loop]: forward function *)
-Definition list_nth_shared_loop_fwd
+Definition list_nth_shared_loop
(T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
- list_nth_shared_loop_loop_fwd T n ls i
+ list_nth_shared_loop_loop T n ls i
.
(** [loops::get_elem_mut]: loop 0: forward function *)
-Fixpoint get_elem_mut_loop_fwd
+Fixpoint get_elem_mut_loop
(n : nat) (x : usize) (ls : List_t usize) : result usize :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons y tl =>
- if y s= x then Return y else get_elem_mut_loop_fwd n0 x tl
- | ListNil => Fail_ Failure
+ | List_Cons y tl => if y s= x then Return y else get_elem_mut_loop n0 x tl
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::get_elem_mut]: forward function *)
-Definition get_elem_mut_fwd
- (n : nat) (slots : vec (List_t usize)) (x : usize) : result usize :=
- l <- vec_index_mut_fwd (List_t usize) slots 0%usize;
- get_elem_mut_loop_fwd n x l
+Definition get_elem_mut
+ (n : nat) (slots : alloc_vec_Vec (List_t usize)) (x : usize) :
+ result usize
+ :=
+ l <-
+ alloc_vec_Vec_index_mut (List_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize))
+ slots 0%usize;
+ get_elem_mut_loop n x l
.
(** [loops::get_elem_mut]: loop 0: backward function 0 *)
@@ -218,50 +223,60 @@ Fixpoint get_elem_mut_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons y tl =>
+ | List_Cons y tl =>
if y s= x
- then Return (ListCons ret tl)
- else (tl0 <- get_elem_mut_loop_back n0 x tl ret; Return (ListCons y tl0))
- | ListNil => Fail_ Failure
+ then Return (List_Cons ret tl)
+ else (
+ tl0 <- get_elem_mut_loop_back n0 x tl ret; Return (List_Cons y tl0))
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::get_elem_mut]: backward function 0 *)
Definition get_elem_mut_back
- (n : nat) (slots : vec (List_t usize)) (x : usize) (ret : usize) :
- result (vec (List_t usize))
+ (n : nat) (slots : alloc_vec_Vec (List_t usize)) (x : usize) (ret : usize) :
+ result (alloc_vec_Vec (List_t usize))
:=
- l <- vec_index_mut_fwd (List_t usize) slots 0%usize;
+ l <-
+ alloc_vec_Vec_index_mut (List_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize))
+ slots 0%usize;
l0 <- get_elem_mut_loop_back n x l ret;
- vec_index_mut_back (List_t usize) slots 0%usize l0
+ alloc_vec_Vec_index_mut_back (List_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize)) slots
+ 0%usize l0
.
(** [loops::get_elem_shared]: loop 0: forward function *)
-Fixpoint get_elem_shared_loop_fwd
+Fixpoint get_elem_shared_loop
(n : nat) (x : usize) (ls : List_t usize) : result usize :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons y tl =>
- if y s= x then Return y else get_elem_shared_loop_fwd n0 x tl
- | ListNil => Fail_ Failure
+ | List_Cons y tl =>
+ if y s= x then Return y else get_elem_shared_loop n0 x tl
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::get_elem_shared]: forward function *)
-Definition get_elem_shared_fwd
- (n : nat) (slots : vec (List_t usize)) (x : usize) : result usize :=
- l <- vec_index_fwd (List_t usize) slots 0%usize;
- get_elem_shared_loop_fwd n x l
+Definition get_elem_shared
+ (n : nat) (slots : alloc_vec_Vec (List_t usize)) (x : usize) :
+ result usize
+ :=
+ l <-
+ alloc_vec_Vec_index (List_t usize) usize
+ (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize))
+ slots 0%usize;
+ get_elem_shared_loop n x l
.
(** [loops::id_mut]: forward function *)
-Definition id_mut_fwd (T : Type) (ls : List_t T) : result (List_t T) :=
- Return ls
-.
+Definition id_mut (T : Type) (ls : List_t T) : result (List_t T) :=
+ Return ls.
(** [loops::id_mut]: backward function 0 *)
Definition id_mut_back
@@ -270,31 +285,30 @@ Definition id_mut_back
.
(** [loops::id_shared]: forward function *)
-Definition id_shared_fwd (T : Type) (ls : List_t T) : result (List_t T) :=
+Definition id_shared (T : Type) (ls : List_t T) : result (List_t T) :=
Return ls
.
(** [loops::list_nth_mut_loop_with_id]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_with_id_loop_fwd
+Fixpoint list_nth_mut_loop_with_id_loop
(T : Type) (n : nat) (i : u32) (ls : List_t T) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
- else (
- i0 <- u32_sub i 1%u32; list_nth_mut_loop_with_id_loop_fwd T n0 i0 tl)
- | ListNil => Fail_ Failure
+ else (i0 <- u32_sub i 1%u32; list_nth_mut_loop_with_id_loop T n0 i0 tl)
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_mut_loop_with_id]: forward function *)
-Definition list_nth_mut_loop_with_id_fwd
+Definition list_nth_mut_loop_with_id
(T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
- ls0 <- id_mut_fwd T ls; list_nth_mut_loop_with_id_loop_fwd T n i ls0
+ ls0 <- id_mut T ls; list_nth_mut_loop_with_id_loop T n i ls0
.
(** [loops::list_nth_mut_loop_with_id]: loop 0: backward function 0 *)
@@ -306,14 +320,14 @@ Fixpoint list_nth_mut_loop_with_id_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else (
i0 <- u32_sub i 1%u32;
tl0 <- list_nth_mut_loop_with_id_loop_back T n0 i0 tl ret;
- Return (ListCons x tl0))
- | ListNil => Fail_ Failure
+ Return (List_Cons x tl0))
+ | List_Nil => Fail_ Failure
end
end
.
@@ -323,36 +337,36 @@ Definition list_nth_mut_loop_with_id_back
(T : Type) (n : nat) (ls : List_t T) (i : u32) (ret : T) :
result (List_t T)
:=
- ls0 <- id_mut_fwd T ls;
+ ls0 <- id_mut T ls;
l <- list_nth_mut_loop_with_id_loop_back T n i ls0 ret;
id_mut_back T ls l
.
(** [loops::list_nth_shared_loop_with_id]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_with_id_loop_fwd
+Fixpoint list_nth_shared_loop_with_id_loop
(T : Type) (n : nat) (i : u32) (ls : List_t T) : result T :=
match n with
| O => Fail_ OutOfFuel
| S n0 =>
match ls with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
else (
- i0 <- u32_sub i 1%u32; list_nth_shared_loop_with_id_loop_fwd T n0 i0 tl)
- | ListNil => Fail_ Failure
+ i0 <- u32_sub i 1%u32; list_nth_shared_loop_with_id_loop T n0 i0 tl)
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_shared_loop_with_id]: forward function *)
-Definition list_nth_shared_loop_with_id_fwd
+Definition list_nth_shared_loop_with_id
(T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
- ls0 <- id_shared_fwd T ls; list_nth_shared_loop_with_id_loop_fwd T n i ls0
+ ls0 <- id_shared T ls; list_nth_shared_loop_with_id_loop T n i ls0
.
(** [loops::list_nth_mut_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_pair_loop_fwd
+Fixpoint list_nth_mut_loop_pair_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -360,27 +374,26 @@ Fixpoint list_nth_mut_loop_pair_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
- i0 <- u32_sub i 1%u32;
- list_nth_mut_loop_pair_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ i0 <- u32_sub i 1%u32; list_nth_mut_loop_pair_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_mut_loop_pair]: forward function *)
-Definition list_nth_mut_loop_pair_fwd
+Definition list_nth_mut_loop_pair
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_mut_loop_pair_loop_fwd T n ls0 ls1 i
+ list_nth_mut_loop_pair_loop T n ls0 ls1 i
.
(** [loops::list_nth_mut_loop_pair]: loop 0: backward function 0 *)
@@ -392,18 +405,18 @@ Fixpoint list_nth_mut_loop_pair_loop_back'a
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then Return (ListCons ret tl0)
+ then Return (List_Cons ret tl0)
else (
i0 <- u32_sub i 1%u32;
tl00 <- list_nth_mut_loop_pair_loop_back'a T n0 tl0 tl1 i0 ret;
- 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
end
.
@@ -425,18 +438,18 @@ Fixpoint list_nth_mut_loop_pair_loop_back'b
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then Return (ListCons ret tl1)
+ then Return (List_Cons ret tl1)
else (
i0 <- u32_sub i 1%u32;
tl10 <- list_nth_mut_loop_pair_loop_back'b T n0 tl0 tl1 i0 ret;
- 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
end
.
@@ -450,7 +463,7 @@ Definition list_nth_mut_loop_pair_back'b
.
(** [loops::list_nth_shared_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_pair_loop_fwd
+Fixpoint list_nth_shared_loop_pair_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -458,31 +471,30 @@ Fixpoint list_nth_shared_loop_pair_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
- i0 <- u32_sub i 1%u32;
- list_nth_shared_loop_pair_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ i0 <- u32_sub i 1%u32; list_nth_shared_loop_pair_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_shared_loop_pair]: forward function *)
-Definition list_nth_shared_loop_pair_fwd
+Definition list_nth_shared_loop_pair
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_shared_loop_pair_loop_fwd T n ls0 ls1 i
+ list_nth_shared_loop_pair_loop T n ls0 ls1 i
.
(** [loops::list_nth_mut_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_pair_merge_loop_fwd
+Fixpoint list_nth_mut_loop_pair_merge_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -490,27 +502,27 @@ Fixpoint list_nth_mut_loop_pair_merge_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
i0 <- u32_sub i 1%u32;
- list_nth_mut_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ list_nth_mut_loop_pair_merge_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_mut_loop_pair_merge]: forward function *)
-Definition list_nth_mut_loop_pair_merge_fwd
+Definition list_nth_mut_loop_pair_merge
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_mut_loop_pair_merge_loop_fwd T n ls0 ls1 i
+ list_nth_mut_loop_pair_merge_loop T n ls0 ls1 i
.
(** [loops::list_nth_mut_loop_pair_merge]: loop 0: backward function 0 *)
@@ -523,19 +535,19 @@ Fixpoint list_nth_mut_loop_pair_merge_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then let (t, t0) := ret in Return (ListCons t tl0, ListCons t0 tl1)
+ then let (t, t0) := ret in Return (List_Cons t tl0, List_Cons t0 tl1)
else (
i0 <- u32_sub i 1%u32;
p <- list_nth_mut_loop_pair_merge_loop_back T n0 tl0 tl1 i0 ret;
let (tl00, tl10) := p 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
end
.
@@ -550,7 +562,7 @@ Definition list_nth_mut_loop_pair_merge_back
.
(** [loops::list_nth_shared_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_pair_merge_loop_fwd
+Fixpoint list_nth_shared_loop_pair_merge_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -558,31 +570,31 @@ Fixpoint list_nth_shared_loop_pair_merge_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
i0 <- u32_sub i 1%u32;
- list_nth_shared_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ list_nth_shared_loop_pair_merge_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_shared_loop_pair_merge]: forward function *)
-Definition list_nth_shared_loop_pair_merge_fwd
+Definition list_nth_shared_loop_pair_merge
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_shared_loop_pair_merge_loop_fwd T n ls0 ls1 i
+ list_nth_shared_loop_pair_merge_loop T n ls0 ls1 i
.
(** [loops::list_nth_mut_shared_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_mut_shared_loop_pair_loop_fwd
+Fixpoint list_nth_mut_shared_loop_pair_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -590,27 +602,27 @@ Fixpoint list_nth_mut_shared_loop_pair_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
i0 <- u32_sub i 1%u32;
- list_nth_mut_shared_loop_pair_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ list_nth_mut_shared_loop_pair_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_mut_shared_loop_pair]: forward function *)
-Definition list_nth_mut_shared_loop_pair_fwd
+Definition list_nth_mut_shared_loop_pair
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_mut_shared_loop_pair_loop_fwd T n ls0 ls1 i
+ list_nth_mut_shared_loop_pair_loop T n ls0 ls1 i
.
(** [loops::list_nth_mut_shared_loop_pair]: loop 0: backward function 0 *)
@@ -622,18 +634,18 @@ Fixpoint list_nth_mut_shared_loop_pair_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then Return (ListCons ret tl0)
+ then Return (List_Cons ret tl0)
else (
i0 <- u32_sub i 1%u32;
tl00 <- list_nth_mut_shared_loop_pair_loop_back T n0 tl0 tl1 i0 ret;
- 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
end
.
@@ -647,7 +659,7 @@ Definition list_nth_mut_shared_loop_pair_back
.
(** [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_mut_shared_loop_pair_merge_loop_fwd
+Fixpoint list_nth_mut_shared_loop_pair_merge_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -655,27 +667,27 @@ Fixpoint list_nth_mut_shared_loop_pair_merge_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
i0 <- u32_sub i 1%u32;
- list_nth_mut_shared_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ list_nth_mut_shared_loop_pair_merge_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_mut_shared_loop_pair_merge]: forward function *)
-Definition list_nth_mut_shared_loop_pair_merge_fwd
+Definition list_nth_mut_shared_loop_pair_merge
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_mut_shared_loop_pair_merge_loop_fwd T n ls0 ls1 i
+ list_nth_mut_shared_loop_pair_merge_loop T n ls0 ls1 i
.
(** [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: backward function 0 *)
@@ -687,19 +699,19 @@ Fixpoint list_nth_mut_shared_loop_pair_merge_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then Return (ListCons ret tl0)
+ then Return (List_Cons ret tl0)
else (
i0 <- u32_sub i 1%u32;
tl00 <-
list_nth_mut_shared_loop_pair_merge_loop_back T n0 tl0 tl1 i0 ret;
- 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
end
.
@@ -713,7 +725,7 @@ Definition list_nth_mut_shared_loop_pair_merge_back
.
(** [loops::list_nth_shared_mut_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_shared_mut_loop_pair_loop_fwd
+Fixpoint list_nth_shared_mut_loop_pair_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -721,27 +733,27 @@ Fixpoint list_nth_shared_mut_loop_pair_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
i0 <- u32_sub i 1%u32;
- list_nth_shared_mut_loop_pair_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ list_nth_shared_mut_loop_pair_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_shared_mut_loop_pair]: forward function *)
-Definition list_nth_shared_mut_loop_pair_fwd
+Definition list_nth_shared_mut_loop_pair
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_shared_mut_loop_pair_loop_fwd T n ls0 ls1 i
+ list_nth_shared_mut_loop_pair_loop T n ls0 ls1 i
.
(** [loops::list_nth_shared_mut_loop_pair]: loop 0: backward function 1 *)
@@ -753,18 +765,18 @@ Fixpoint list_nth_shared_mut_loop_pair_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then Return (ListCons ret tl1)
+ then Return (List_Cons ret tl1)
else (
i0 <- u32_sub i 1%u32;
tl10 <- list_nth_shared_mut_loop_pair_loop_back T n0 tl0 tl1 i0 ret;
- 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
end
.
@@ -778,7 +790,7 @@ Definition list_nth_shared_mut_loop_pair_back
.
(** [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_shared_mut_loop_pair_merge_loop_fwd
+Fixpoint list_nth_shared_mut_loop_pair_merge_loop
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
@@ -786,27 +798,27 @@ Fixpoint list_nth_shared_mut_loop_pair_merge_loop_fwd
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
then Return (x0, x1)
else (
i0 <- u32_sub i 1%u32;
- list_nth_shared_mut_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
- | ListNil => Fail_ Failure
+ list_nth_shared_mut_loop_pair_merge_loop T n0 tl0 tl1 i0)
+ | List_Nil => Fail_ Failure
end
- | ListNil => Fail_ Failure
+ | List_Nil => Fail_ Failure
end
end
.
(** [loops::list_nth_shared_mut_loop_pair_merge]: forward function *)
-Definition list_nth_shared_mut_loop_pair_merge_fwd
+Definition list_nth_shared_mut_loop_pair_merge
(T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
result (T * T)
:=
- list_nth_shared_mut_loop_pair_merge_loop_fwd T n ls0 ls1 i
+ list_nth_shared_mut_loop_pair_merge_loop T n ls0 ls1 i
.
(** [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: backward function 0 *)
@@ -818,19 +830,19 @@ Fixpoint list_nth_shared_mut_loop_pair_merge_loop_back
| O => Fail_ OutOfFuel
| S n0 =>
match ls0 with
- | ListCons x0 tl0 =>
+ | List_Cons x0 tl0 =>
match ls1 with
- | ListCons x1 tl1 =>
+ | List_Cons x1 tl1 =>
if i s= 0%u32
- then Return (ListCons ret tl1)
+ then Return (List_Cons ret tl1)
else (
i0 <- u32_sub i 1%u32;
tl10 <-
list_nth_shared_mut_loop_pair_merge_loop_back T n0 tl0 tl1 i0 ret;
- 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
end
.
diff --git a/tests/coq/misc/NoNestedBorrows.v b/tests/coq/misc/NoNestedBorrows.v
index c1c24e00..c7af496f 100644
--- a/tests/coq/misc/NoNestedBorrows.v
+++ b/tests/coq/misc/NoNestedBorrows.v
@@ -9,113 +9,125 @@ Local Open Scope Primitives_scope.
Module NoNestedBorrows.
(** [no_nested_borrows::Pair] *)
-Record Pair_t (T1 T2 : Type) := mkPair_t { Pair_x : T1; Pair_y : T2; }.
+Record Pair_t (T1 T2 : Type) := mkPair_t { pair_x : T1; pair_y : T2; }.
-Arguments mkPair_t {T1} {T2} _ _.
-Arguments Pair_x {T1} {T2}.
-Arguments Pair_y {T1} {T2}.
+Arguments mkPair_t { _ _ }.
+Arguments pair_x { _ _ }.
+Arguments pair_y { _ _ }.
(** [no_nested_borrows::List] *)
Inductive List_t (T : Type) :=
-| 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
.
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons { _ }.
+Arguments List_Nil { _ }.
(** [no_nested_borrows::One] *)
-Inductive One_t (T1 : Type) := | OneOne : T1 -> One_t T1.
+Inductive One_t (T1 : Type) := | One_One : T1 -> One_t T1.
-Arguments OneOne {T1} _.
+Arguments One_One { _ }.
(** [no_nested_borrows::EmptyEnum] *)
-Inductive Empty_enum_t := | EmptyEnumEmpty : Empty_enum_t.
+Inductive EmptyEnum_t := | EmptyEnum_Empty : EmptyEnum_t.
(** [no_nested_borrows::Enum] *)
-Inductive Enum_t := | EnumVariant1 : Enum_t | EnumVariant2 : Enum_t.
+Inductive Enum_t := | Enum_Variant1 : Enum_t | Enum_Variant2 : Enum_t.
(** [no_nested_borrows::EmptyStruct] *)
-Record Empty_struct_t := mkEmpty_struct_t { }.
+Record EmptyStruct_t := mkEmptyStruct_t { }.
(** [no_nested_borrows::Sum] *)
Inductive Sum_t (T1 T2 : Type) :=
-| 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
.
-Arguments SumLeft {T1} {T2} _.
-Arguments SumRight {T1} {T2} _.
+Arguments Sum_Left { _ _ }.
+Arguments Sum_Right { _ _ }.
(** [no_nested_borrows::neg_test]: forward function *)
-Definition neg_test_fwd (x : i32) : result i32 :=
+Definition neg_test (x : i32) : result i32 :=
i32_neg x.
(** [no_nested_borrows::add_test]: forward function *)
-Definition add_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition add_test (x : u32) (y : u32) : result u32 :=
u32_add x y.
(** [no_nested_borrows::subs_test]: forward function *)
-Definition subs_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition subs_test (x : u32) (y : u32) : result u32 :=
u32_sub x y.
(** [no_nested_borrows::div_test]: forward function *)
-Definition div_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition div_test (x : u32) (y : u32) : result u32 :=
u32_div x y.
(** [no_nested_borrows::div_test1]: forward function *)
-Definition div_test1_fwd (x : u32) : result u32 :=
+Definition div_test1 (x : u32) : result u32 :=
u32_div x 2%u32.
(** [no_nested_borrows::rem_test]: forward function *)
-Definition rem_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition rem_test (x : u32) (y : u32) : result u32 :=
u32_rem x y.
+(** [no_nested_borrows::mul_test]: forward function *)
+Definition mul_test (x : u32) (y : u32) : result u32 :=
+ u32_mul x y.
+
+(** [no_nested_borrows::CONST0] *)
+Definition const0_body : result usize := usize_add 1%usize 1%usize.
+Definition const0_c : usize := const0_body%global.
+
+(** [no_nested_borrows::CONST1] *)
+Definition const1_body : result usize := usize_mul 2%usize 2%usize.
+Definition const1_c : usize := const1_body%global.
+
(** [no_nested_borrows::cast_test]: forward function *)
-Definition cast_test_fwd (x : u32) : result i32 :=
+Definition cast_test (x : u32) : result i32 :=
scalar_cast U32 I32 x.
(** [no_nested_borrows::test2]: forward function *)
-Definition test2_fwd : result unit :=
+Definition test2 : result unit :=
_ <- u32_add 23%u32 44%u32; Return tt.
(** Unit test for [no_nested_borrows::test2] *)
-Check (test2_fwd )%return.
+Check (test2 )%return.
(** [no_nested_borrows::get_max]: forward function *)
-Definition get_max_fwd (x : u32) (y : u32) : result u32 :=
+Definition get_max (x : u32) (y : u32) : result u32 :=
if x s>= y then Return x else Return y
.
(** [no_nested_borrows::test3]: forward function *)
-Definition test3_fwd : result unit :=
- x <- get_max_fwd 4%u32 3%u32;
- y <- get_max_fwd 10%u32 11%u32;
+Definition test3 : result unit :=
+ x <- get_max 4%u32 3%u32;
+ y <- get_max 10%u32 11%u32;
z <- u32_add x y;
if negb (z s= 15%u32) then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::test3] *)
-Check (test3_fwd )%return.
+Check (test3 )%return.
(** [no_nested_borrows::test_neg1]: forward function *)
-Definition test_neg1_fwd : result unit :=
+Definition test_neg1 : result unit :=
y <- i32_neg 3%i32; if negb (y s= (-3)%i32) then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::test_neg1] *)
-Check (test_neg1_fwd )%return.
+Check (test_neg1 )%return.
(** [no_nested_borrows::refs_test1]: forward function *)
-Definition refs_test1_fwd : result unit :=
+Definition refs_test1 : result unit :=
if negb (1%i32 s= 1%i32) then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::refs_test1] *)
-Check (refs_test1_fwd )%return.
+Check (refs_test1 )%return.
(** [no_nested_borrows::refs_test2]: forward function *)
-Definition refs_test2_fwd : result unit :=
+Definition refs_test2 : result unit :=
if negb (2%i32 s= 2%i32)
then Fail_ Failure
else
@@ -128,85 +140,83 @@ Definition refs_test2_fwd : result unit :=
.
(** Unit test for [no_nested_borrows::refs_test2] *)
-Check (refs_test2_fwd )%return.
+Check (refs_test2 )%return.
(** [no_nested_borrows::test_list1]: forward function *)
-Definition test_list1_fwd : result unit :=
+Definition test_list1 : result unit :=
Return tt.
(** Unit test for [no_nested_borrows::test_list1] *)
-Check (test_list1_fwd )%return.
+Check (test_list1 )%return.
(** [no_nested_borrows::test_box1]: forward function *)
-Definition test_box1_fwd : result unit :=
+Definition test_box1 : result unit :=
let b := 1%i32 in
let x := b in
if negb (x s= 1%i32) then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::test_box1] *)
-Check (test_box1_fwd )%return.
+Check (test_box1 )%return.
(** [no_nested_borrows::copy_int]: forward function *)
-Definition copy_int_fwd (x : i32) : result i32 :=
+Definition copy_int (x : i32) : result i32 :=
Return x.
(** [no_nested_borrows::test_unreachable]: forward function *)
-Definition test_unreachable_fwd (b : bool) : result unit :=
+Definition test_unreachable (b : bool) : result unit :=
if b then Fail_ Failure else Return tt
.
(** [no_nested_borrows::test_panic]: forward function *)
-Definition test_panic_fwd (b : bool) : result unit :=
+Definition test_panic (b : bool) : result unit :=
if b then Fail_ Failure else Return tt
.
(** [no_nested_borrows::test_copy_int]: forward function *)
-Definition test_copy_int_fwd : result unit :=
- y <- copy_int_fwd 0%i32;
- if negb (0%i32 s= y) then Fail_ Failure else Return tt
+Definition test_copy_int : result unit :=
+ y <- copy_int 0%i32; if negb (0%i32 s= y) then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::test_copy_int] *)
-Check (test_copy_int_fwd )%return.
+Check (test_copy_int )%return.
(** [no_nested_borrows::is_cons]: forward function *)
-Definition is_cons_fwd (T : Type) (l : List_t T) : result bool :=
- match l with | ListCons t l0 => Return true | ListNil => Return false end
+Definition is_cons (T : Type) (l : List_t T) : result bool :=
+ match l with | List_Cons t l0 => Return true | List_Nil => Return false end
.
(** [no_nested_borrows::test_is_cons]: forward function *)
-Definition test_is_cons_fwd : result unit :=
- let l := ListNil in
- b <- is_cons_fwd i32 (ListCons 0%i32 l);
+Definition test_is_cons : result unit :=
+ let l := List_Nil in
+ b <- is_cons i32 (List_Cons 0%i32 l);
if negb b then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::test_is_cons] *)
-Check (test_is_cons_fwd )%return.
+Check (test_is_cons )%return.
(** [no_nested_borrows::split_list]: forward function *)
-Definition split_list_fwd
- (T : Type) (l : List_t T) : result (T * (List_t T)) :=
+Definition split_list (T : Type) (l : List_t T) : result (T * (List_t T)) :=
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 *)
-Definition test_split_list_fwd : result unit :=
- let l := ListNil in
- p <- split_list_fwd i32 (ListCons 0%i32 l);
+Definition test_split_list : result unit :=
+ let l := List_Nil in
+ p <- split_list i32 (List_Cons 0%i32 l);
let (hd, _) := p in
if negb (hd s= 0%i32) then Fail_ Failure else Return tt
.
(** Unit test for [no_nested_borrows::test_split_list] *)
-Check (test_split_list_fwd )%return.
+Check (test_split_list )%return.
(** [no_nested_borrows::choose]: forward function *)
-Definition choose_fwd (T : Type) (b : bool) (x : T) (y : T) : result T :=
+Definition choose (T : Type) (b : bool) (x : T) (y : T) : result T :=
if b then Return x else Return y
.
@@ -217,8 +227,8 @@ Definition choose_back
.
(** [no_nested_borrows::choose_test]: forward function *)
-Definition choose_test_fwd : result unit :=
- z <- choose_fwd i32 true 0%i32 0%i32;
+Definition choose_test : result unit :=
+ z <- choose i32 true 0%i32 0%i32;
z0 <- i32_add z 1%i32;
if negb (z0 s= 1%i32)
then Fail_ Failure
@@ -231,57 +241,56 @@ Definition choose_test_fwd : result unit :=
.
(** Unit test for [no_nested_borrows::choose_test] *)
-Check (choose_test_fwd )%return.
+Check (choose_test )%return.
(** [no_nested_borrows::test_char]: forward function *)
-Definition test_char_fwd : result char :=
- Return (char_of_byte Coq.Init.Byte.x61)
-.
+Definition test_char : result char :=
+ Return (char_of_byte Coq.Init.Byte.x61).
(** [no_nested_borrows::Tree] *)
Inductive Tree_t (T : Type) :=
-| 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] *)
-with Node_elem_t (T : Type) :=
-| NodeElemCons : Tree_t T -> Node_elem_t T -> Node_elem_t T
-| NodeElemNil : Node_elem_t T
+with NodeElem_t (T : Type) :=
+| NodeElem_Cons : Tree_t T -> NodeElem_t T -> NodeElem_t T
+| NodeElem_Nil : NodeElem_t T
.
-Arguments TreeLeaf {T} _.
-Arguments TreeNode {T} _ _ _.
+Arguments Tree_Leaf { _ }.
+Arguments Tree_Node { _ }.
-Arguments NodeElemCons {T} _ _.
-Arguments NodeElemNil {T}.
+Arguments NodeElem_Cons { _ }.
+Arguments NodeElem_Nil { _ }.
(** [no_nested_borrows::list_length]: forward function *)
-Fixpoint list_length_fwd (T : Type) (l : List_t T) : result u32 :=
+Fixpoint list_length (T : Type) (l : List_t T) : result u32 :=
match l with
- | ListCons t l1 => i <- list_length_fwd T l1; u32_add 1%u32 i
- | ListNil => Return 0%u32
+ | List_Cons t l1 => i <- list_length T l1; u32_add 1%u32 i
+ | List_Nil => Return 0%u32
end
.
(** [no_nested_borrows::list_nth_shared]: forward function *)
-Fixpoint list_nth_shared_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
+Fixpoint list_nth_shared (T : Type) (l : List_t T) (i : u32) : result T :=
match l with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
- else (i0 <- u32_sub i 1%u32; list_nth_shared_fwd T tl i0)
- | ListNil => Fail_ Failure
+ else (i0 <- u32_sub i 1%u32; list_nth_shared T tl i0)
+ | List_Nil => Fail_ Failure
end
.
(** [no_nested_borrows::list_nth_mut]: forward function *)
-Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
+Fixpoint list_nth_mut (T : Type) (l : List_t T) (i : u32) : result T :=
match l with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
- else (i0 <- u32_sub i 1%u32; list_nth_mut_fwd T tl i0)
- | ListNil => Fail_ Failure
+ else (i0 <- u32_sub i 1%u32; list_nth_mut T tl i0)
+ | List_Nil => Fail_ Failure
end
.
@@ -289,73 +298,72 @@ Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
Fixpoint list_nth_mut_back
(T : Type) (l : List_t T) (i : u32) (ret : T) : result (List_t T) :=
match l with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else (
i0 <- u32_sub i 1%u32;
tl0 <- list_nth_mut_back T tl i0 ret;
- 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 *)
-Fixpoint list_rev_aux_fwd
+Fixpoint list_rev_aux
(T : Type) (li : List_t T) (lo : List_t T) : result (List_t T) :=
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 ()) *)
-Definition list_rev_fwd_back (T : Type) (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
+Definition list_rev (T : Type) (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 *)
-Definition test_list_functions_fwd : result unit :=
- let l := ListNil in
- let l0 := ListCons 2%i32 l in
- let l1 := ListCons 1%i32 l0 in
- i <- list_length_fwd i32 (ListCons 0%i32 l1);
+Definition test_list_functions : result unit :=
+ let l := List_Nil in
+ let l0 := List_Cons 2%i32 l in
+ let l1 := List_Cons 1%i32 l0 in
+ i <- list_length i32 (List_Cons 0%i32 l1);
if negb (i s= 3%u32)
then Fail_ Failure
else (
- i0 <- list_nth_shared_fwd i32 (ListCons 0%i32 l1) 0%u32;
+ i0 <- list_nth_shared i32 (List_Cons 0%i32 l1) 0%u32;
if negb (i0 s= 0%i32)
then Fail_ Failure
else (
- i1 <- list_nth_shared_fwd i32 (ListCons 0%i32 l1) 1%u32;
+ i1 <- list_nth_shared i32 (List_Cons 0%i32 l1) 1%u32;
if negb (i1 s= 1%i32)
then Fail_ Failure
else (
- i2 <- list_nth_shared_fwd i32 (ListCons 0%i32 l1) 2%u32;
+ i2 <- list_nth_shared i32 (List_Cons 0%i32 l1) 2%u32;
if negb (i2 s= 2%i32)
then Fail_ Failure
else (
- ls <- list_nth_mut_back i32 (ListCons 0%i32 l1) 1%u32 3%i32;
- i3 <- list_nth_shared_fwd i32 ls 0%u32;
+ ls <- list_nth_mut_back i32 (List_Cons 0%i32 l1) 1%u32 3%i32;
+ i3 <- list_nth_shared i32 ls 0%u32;
if negb (i3 s= 0%i32)
then Fail_ Failure
else (
- i4 <- list_nth_shared_fwd i32 ls 1%u32;
+ i4 <- list_nth_shared i32 ls 1%u32;
if negb (i4 s= 3%i32)
then Fail_ Failure
else (
- i5 <- list_nth_shared_fwd i32 ls 2%u32;
+ i5 <- list_nth_shared i32 ls 2%u32;
if negb (i5 s= 2%i32) then Fail_ Failure else Return tt))))))
.
(** Unit test for [no_nested_borrows::test_list_functions] *)
-Check (test_list_functions_fwd )%return.
+Check (test_list_functions )%return.
(** [no_nested_borrows::id_mut_pair1]: forward function *)
-Definition id_mut_pair1_fwd
- (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
+Definition id_mut_pair1 (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
Return (x, y)
.
@@ -366,8 +374,7 @@ Definition id_mut_pair1_back
.
(** [no_nested_borrows::id_mut_pair2]: forward function *)
-Definition id_mut_pair2_fwd
- (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
+Definition id_mut_pair2 (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
let (t, t0) := p in Return (t, t0)
.
@@ -378,8 +385,7 @@ Definition id_mut_pair2_back
.
(** [no_nested_borrows::id_mut_pair3]: forward function *)
-Definition id_mut_pair3_fwd
- (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
+Definition id_mut_pair3 (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
Return (x, y)
.
@@ -396,8 +402,7 @@ Definition id_mut_pair3_back'b
.
(** [no_nested_borrows::id_mut_pair4]: forward function *)
-Definition id_mut_pair4_fwd
- (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
+Definition id_mut_pair4 (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
let (t, t0) := p in Return (t, t0)
.
@@ -414,101 +419,101 @@ Definition id_mut_pair4_back'b
.
(** [no_nested_borrows::StructWithTuple] *)
-Record Struct_with_tuple_t (T1 T2 : Type) :=
-mkStruct_with_tuple_t {
- Struct_with_tuple_p : (T1 * T2);
+Record StructWithTuple_t (T1 T2 : Type) :=
+mkStructWithTuple_t {
+ structWithTuple_p : (T1 * T2);
}
.
-Arguments mkStruct_with_tuple_t {T1} {T2} _.
-Arguments Struct_with_tuple_p {T1} {T2}.
+Arguments mkStructWithTuple_t { _ _ }.
+Arguments structWithTuple_p { _ _ }.
(** [no_nested_borrows::new_tuple1]: forward function *)
-Definition new_tuple1_fwd : result (Struct_with_tuple_t u32 u32) :=
- Return {| Struct_with_tuple_p := (1%u32, 2%u32) |}
+Definition new_tuple1 : result (StructWithTuple_t u32 u32) :=
+ Return {| structWithTuple_p := (1%u32, 2%u32) |}
.
(** [no_nested_borrows::new_tuple2]: forward function *)
-Definition new_tuple2_fwd : result (Struct_with_tuple_t i16 i16) :=
- Return {| Struct_with_tuple_p := (1%i16, 2%i16) |}
+Definition new_tuple2 : result (StructWithTuple_t i16 i16) :=
+ Return {| structWithTuple_p := (1%i16, 2%i16) |}
.
(** [no_nested_borrows::new_tuple3]: forward function *)
-Definition new_tuple3_fwd : result (Struct_with_tuple_t u64 i64) :=
- Return {| Struct_with_tuple_p := (1%u64, 2%i64) |}
+Definition new_tuple3 : result (StructWithTuple_t u64 i64) :=
+ Return {| structWithTuple_p := (1%u64, 2%i64) |}
.
(** [no_nested_borrows::StructWithPair] *)
-Record Struct_with_pair_t (T1 T2 : Type) :=
-mkStruct_with_pair_t {
- Struct_with_pair_p : Pair_t T1 T2;
+Record StructWithPair_t (T1 T2 : Type) :=
+mkStructWithPair_t {
+ structWithPair_p : Pair_t T1 T2;
}
.
-Arguments mkStruct_with_pair_t {T1} {T2} _.
-Arguments Struct_with_pair_p {T1} {T2}.
+Arguments mkStructWithPair_t { _ _ }.
+Arguments structWithPair_p { _ _ }.
(** [no_nested_borrows::new_pair1]: forward function *)
-Definition new_pair1_fwd : result (Struct_with_pair_t u32 u32) :=
- Return {| Struct_with_pair_p := {| Pair_x := 1%u32; Pair_y := 2%u32 |} |}
+Definition new_pair1 : result (StructWithPair_t u32 u32) :=
+ Return {| structWithPair_p := {| pair_x := 1%u32; pair_y := 2%u32 |} |}
.
(** [no_nested_borrows::test_constants]: forward function *)
-Definition test_constants_fwd : result unit :=
- swt <- new_tuple1_fwd;
- let (i, _) := swt.(Struct_with_tuple_p) in
+Definition test_constants : result unit :=
+ swt <- new_tuple1;
+ let (i, _) := swt.(structWithTuple_p) in
if negb (i s= 1%u32)
then Fail_ Failure
else (
- swt0 <- new_tuple2_fwd;
- let (i0, _) := swt0.(Struct_with_tuple_p) in
+ swt0 <- new_tuple2;
+ let (i0, _) := swt0.(structWithTuple_p) in
if negb (i0 s= 1%i16)
then Fail_ Failure
else (
- swt1 <- new_tuple3_fwd;
- let (i1, _) := swt1.(Struct_with_tuple_p) in
+ swt1 <- new_tuple3;
+ let (i1, _) := swt1.(structWithTuple_p) in
if negb (i1 s= 1%u64)
then Fail_ Failure
else (
- swp <- new_pair1_fwd;
- if negb (swp.(Struct_with_pair_p).(Pair_x) s= 1%u32)
+ swp <- new_pair1;
+ if negb (swp.(structWithPair_p).(pair_x) s= 1%u32)
then Fail_ Failure
else Return tt)))
.
(** Unit test for [no_nested_borrows::test_constants] *)
-Check (test_constants_fwd )%return.
+Check (test_constants )%return.
(** [no_nested_borrows::test_weird_borrows1]: forward function *)
-Definition test_weird_borrows1_fwd : result unit :=
+Definition test_weird_borrows1 : result unit :=
Return tt.
(** Unit test for [no_nested_borrows::test_weird_borrows1] *)
-Check (test_weird_borrows1_fwd )%return.
+Check (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 ()) *)
-Definition test_mem_replace_fwd_back (px : u32) : result u32 :=
- let y := mem_replace_fwd u32 px 1%u32 in
+Definition test_mem_replace (px : u32) : result u32 :=
+ let y := core_mem_replace u32 px 1%u32 in
if negb (y s= 0%u32) then Fail_ Failure else Return 2%u32
.
(** [no_nested_borrows::test_shared_borrow_bool1]: forward function *)
-Definition test_shared_borrow_bool1_fwd (b : bool) : result u32 :=
+Definition test_shared_borrow_bool1 (b : bool) : result u32 :=
if b then Return 0%u32 else Return 1%u32
.
(** [no_nested_borrows::test_shared_borrow_bool2]: forward function *)
-Definition test_shared_borrow_bool2_fwd : result u32 :=
+Definition test_shared_borrow_bool2 : result u32 :=
Return 0%u32.
(** [no_nested_borrows::test_shared_borrow_enum1]: forward function *)
-Definition test_shared_borrow_enum1_fwd (l : List_t u32) : result u32 :=
- match l with | ListCons i l0 => Return 1%u32 | ListNil => Return 0%u32 end
+Definition test_shared_borrow_enum1 (l : List_t u32) : result u32 :=
+ match l with | List_Cons i l0 => Return 1%u32 | List_Nil => Return 0%u32 end
.
(** [no_nested_borrows::test_shared_borrow_enum2]: forward function *)
-Definition test_shared_borrow_enum2_fwd : result u32 :=
+Definition test_shared_borrow_enum2 : result u32 :=
Return 0%u32.
End NoNestedBorrows .
diff --git a/tests/coq/misc/Paper.v b/tests/coq/misc/Paper.v
index 175a523d..d3852e6b 100644
--- a/tests/coq/misc/Paper.v
+++ b/tests/coq/misc/Paper.v
@@ -10,20 +10,19 @@ Module Paper.
(** [paper::ref_incr]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
-Definition ref_incr_fwd_back (x : i32) : result i32 :=
+Definition ref_incr (x : i32) : result i32 :=
i32_add x 1%i32.
(** [paper::test_incr]: forward function *)
-Definition test_incr_fwd : result unit :=
- x <- ref_incr_fwd_back 0%i32;
- if negb (x s= 1%i32) then Fail_ Failure else Return tt
+Definition test_incr : result unit :=
+ x <- ref_incr 0%i32; if negb (x s= 1%i32) then Fail_ Failure else Return tt
.
(** Unit test for [paper::test_incr] *)
-Check (test_incr_fwd )%return.
+Check (test_incr )%return.
(** [paper::choose]: forward function *)
-Definition choose_fwd (T : Type) (b : bool) (x : T) (y : T) : result T :=
+Definition choose (T : Type) (b : bool) (x : T) (y : T) : result T :=
if b then Return x else Return y
.
@@ -34,8 +33,8 @@ Definition choose_back
.
(** [paper::test_choose]: forward function *)
-Definition test_choose_fwd : result unit :=
- z <- choose_fwd i32 true 0%i32 0%i32;
+Definition test_choose : result unit :=
+ z <- choose i32 true 0%i32 0%i32;
z0 <- i32_add z 1%i32;
if negb (z0 s= 1%i32)
then Fail_ Failure
@@ -48,25 +47,25 @@ Definition test_choose_fwd : result unit :=
.
(** Unit test for [paper::test_choose] *)
-Check (test_choose_fwd )%return.
+Check (test_choose )%return.
(** [paper::List] *)
Inductive List_t (T : Type) :=
-| 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
.
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons { _ }.
+Arguments List_Nil { _ }.
(** [paper::list_nth_mut]: forward function *)
-Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
+Fixpoint list_nth_mut (T : Type) (l : List_t T) (i : u32) : result T :=
match l with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
then Return x
- else (i0 <- u32_sub i 1%u32; list_nth_mut_fwd T tl i0)
- | ListNil => Fail_ Failure
+ else (i0 <- u32_sub i 1%u32; list_nth_mut T tl i0)
+ | List_Nil => Fail_ Failure
end
.
@@ -74,44 +73,44 @@ Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
Fixpoint list_nth_mut_back
(T : Type) (l : List_t T) (i : u32) (ret : T) : result (List_t T) :=
match l with
- | ListCons x tl =>
+ | List_Cons x tl =>
if i s= 0%u32
- then Return (ListCons ret tl)
+ then Return (List_Cons ret tl)
else (
i0 <- u32_sub i 1%u32;
tl0 <- list_nth_mut_back T tl i0 ret;
- Return (ListCons x tl0))
- | ListNil => Fail_ Failure
+ Return (List_Cons x tl0))
+ | List_Nil => Fail_ Failure
end
.
(** [paper::sum]: forward function *)
-Fixpoint sum_fwd (l : List_t i32) : result i32 :=
+Fixpoint sum (l : List_t i32) : result i32 :=
match l with
- | ListCons x tl => i <- sum_fwd tl; i32_add x i
- | ListNil => Return 0%i32
+ | List_Cons x tl => i <- sum tl; i32_add x i
+ | List_Nil => Return 0%i32
end
.
(** [paper::test_nth]: forward function *)
-Definition test_nth_fwd : result unit :=
- let l := ListNil in
- let l0 := ListCons 3%i32 l in
- let l1 := ListCons 2%i32 l0 in
- x <- list_nth_mut_fwd i32 (ListCons 1%i32 l1) 2%u32;
+Definition test_nth : result unit :=
+ let l := List_Nil in
+ let l0 := List_Cons 3%i32 l in
+ let l1 := List_Cons 2%i32 l0 in
+ x <- list_nth_mut i32 (List_Cons 1%i32 l1) 2%u32;
x0 <- i32_add x 1%i32;
- l2 <- list_nth_mut_back i32 (ListCons 1%i32 l1) 2%u32 x0;
- i <- sum_fwd l2;
+ l2 <- list_nth_mut_back i32 (List_Cons 1%i32 l1) 2%u32 x0;
+ i <- sum l2;
if negb (i s= 7%i32) then Fail_ Failure else Return tt
.
(** Unit test for [paper::test_nth] *)
-Check (test_nth_fwd )%return.
+Check (test_nth )%return.
(** [paper::call_choose]: forward function *)
-Definition call_choose_fwd (p : (u32 * u32)) : result u32 :=
+Definition call_choose (p : (u32 * u32)) : result u32 :=
let (px, py) := p in
- pz <- choose_fwd u32 true px py;
+ pz <- choose u32 true px py;
pz0 <- u32_add pz 1%u32;
p0 <- choose_back u32 true px py pz0;
let (px0, _) := p0 in
diff --git a/tests/coq/misc/PoloniusList.v b/tests/coq/misc/PoloniusList.v
index 54021bdf..4848444f 100644
--- a/tests/coq/misc/PoloniusList.v
+++ b/tests/coq/misc/PoloniusList.v
@@ -10,19 +10,19 @@ Module PoloniusList.
(** [polonius_list::List] *)
Inductive List_t (T : Type) :=
-| 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
.
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons { _ }.
+Arguments List_Nil { _ }.
(** [polonius_list::get_list_at_x]: forward function *)
-Fixpoint get_list_at_x_fwd (ls : List_t u32) (x : u32) : result (List_t u32) :=
+Fixpoint get_list_at_x (ls : List_t u32) (x : u32) : result (List_t u32) :=
match ls with
- | ListCons hd tl =>
- if hd s= x then Return (ListCons hd tl) else get_list_at_x_fwd tl x
- | ListNil => Return ListNil
+ | List_Cons hd tl =>
+ if hd s= x then Return (List_Cons hd tl) else get_list_at_x tl x
+ | List_Nil => Return List_Nil
end
.
@@ -30,11 +30,11 @@ Fixpoint get_list_at_x_fwd (ls : List_t u32) (x : u32) : result (List_t u32) :=
Fixpoint get_list_at_x_back
(ls : List_t u32) (x : u32) (ret : List_t u32) : result (List_t u32) :=
match ls with
- | ListCons hd tl =>
+ | List_Cons hd tl =>
if hd s= x
then Return ret
- else (tl0 <- get_list_at_x_back tl x ret; Return (ListCons hd tl0))
- | ListNil => Return ret
+ else (tl0 <- get_list_at_x_back tl x ret; Return (List_Cons hd tl0))
+ | List_Nil => Return ret
end
.
diff --git a/tests/coq/misc/Primitives.v b/tests/coq/misc/Primitives.v
index 71a2d9c3..85e38f01 100644
--- a/tests/coq/misc/Primitives.v
+++ b/tests/coq/misc/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
(*** Misc *)
-
Definition string := Coq.Strings.String.string.
Definition char := Coq.Strings.Ascii.ascii.
Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
(*** Scalars *)
@@ -394,12 +396,89 @@ Notation "x s< y" := (scalar_ltb x y) (at level 80) : Primitives_scope.
Notation "x s>= y" := (scalar_geb x y) (at level 80) : Primitives_scope.
Notation "x s> y" := (scalar_gtb x y) (at level 80) : Primitives_scope.
-(*** Range *)
-Record range (T : Type) := mk_range {
- start: T;
- end_: T;
+(** Constants *)
+Definition core_u8_max := u8_max %u32.
+Definition core_u16_max := u16_max %u32.
+Definition core_u32_max := u32_max %u32.
+Definition core_u64_max := u64_max %u64.
+Definition core_u128_max := u64_max %u128.
+Axiom core_usize_max : usize. (** TODO *)
+Definition core_i8_max := i8_max %i32.
+Definition core_i16_max := i16_max %i32.
+Definition core_i32_max := i32_max %i32.
+Definition core_i64_max := i64_max %i64.
+Definition core_i128_max := i64_max %i128.
+Axiom core_isize_max : isize. (** TODO *)
+
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+ core_ops_index_Index_Output : Type;
+ core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+ core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+ core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+ core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+ core_ops_deref_Deref_target : Type;
+ core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+ core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+ core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+ core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
}.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+ core_ops_range_Range_start : T;
+ core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+ core_ops_deref_Deref_target := Self;
+ core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+ core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+ core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+ core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
(*** Arrays *)
Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -419,51 +498,50 @@ Qed.
(* TODO: finish the definitions *)
Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
(*** Slice *)
Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
(*** Subslices *)
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
(*** Vectors *)
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
Proof.
- unfold vec_length, usize_min.
+ unfold alloc_vec_Vec_length, usize_min.
split.
- lia.
- apply (proj2_sig v).
Qed.
-Definition vec_len (T: Type) (v: vec T) : usize :=
- exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+ exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
: list A :=
@@ -474,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
| S m => x :: (list_update t m a)
end end.
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
- l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+ l <- f (alloc_vec_Vec_to_list v) ;
match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
| left H => Return (exist _ l (scalar_le_max_valid _ _ H))
| right _ => Fail_ Failure
end.
(* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
- vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
(* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+ if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l =>
if to_Z i <? Z.of_nat (length l)
then Return (list_update l (usize_to_nat i) x)
else Fail_ Failure).
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
- end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
- if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
- match nth_error (vec_to_list v) (usize_to_nat i) with
- | Some n => Return n
- | None => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+ core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+ core_slice_index_SliceIndex_Output : Type;
+ core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+ core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+ (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+ x <- inst.(core_slice_index_SliceIndex_get) i s;
+ match x with
+ | None => Fail_ Failure
+ | Some x => Return x
end.
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
- vec_bind v (fun l =>
- if to_Z i <? Z.of_nat (length l)
- then Return (list_update l (usize_to_nat i) x)
- else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+ (T : Type) :
+ 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 *)
+Definition core_slice_index_Range_get_unchecked_mut
+ (T : Type) :
+ 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 *)
+Axiom core_slice_index_Range_index :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (slice T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := slice T;
+ core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (slice T) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_Index (slice T) Idx) :
+ core_ops_index_Index (array T N) Idx := {|
+ core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+ core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_IndexMut (slice T) Idx) :
+ core_ops_index_IndexMut (array T N) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+ core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+ core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+ forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+ forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+ forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+ forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex usize (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := T;
+ core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+ core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+ alloc_vec_Vec_update_usize v i x.
End Primitives.
diff --git a/tests/coq/traits/Makefile b/tests/coq/traits/Makefile
new file mode 100644
index 00000000..1a5aee4a
--- /dev/null
+++ b/tests/coq/traits/Makefile
@@ -0,0 +1,23 @@
+# This file was automatically generated - modify ../Makefile.template instead
+# Makefile originally taken from coq-club
+
+%: Makefile.coq phony
+ +make -f Makefile.coq $@
+
+all: Makefile.coq
+ +make -f Makefile.coq all
+
+clean: Makefile.coq
+ +make -f Makefile.coq clean
+ rm -f Makefile.coq
+
+Makefile.coq: _CoqProject Makefile
+ coq_makefile -f _CoqProject | sed 's/$$(COQCHK) $$(COQCHKFLAGS) $$(COQLIBS)/$$(COQCHK) $$(COQCHKFLAGS) $$(subst -Q,-R,$$(COQLIBS))/' > Makefile.coq
+
+_CoqProject: ;
+
+Makefile: ;
+
+phony: ;
+
+.PHONY: all clean phony
diff --git a/tests/coq/traits/Primitives.v b/tests/coq/traits/Primitives.v
new file mode 100644
index 00000000..85e38f01
--- /dev/null
+++ b/tests/coq/traits/Primitives.v
@@ -0,0 +1,822 @@
+Require Import Lia.
+Require Coq.Strings.Ascii.
+Require Coq.Strings.String.
+Require Import Coq.Program.Equality.
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.ZArith.Znat.
+Require Import List.
+Import ListNotations.
+
+Module Primitives.
+
+ (* TODO: use more *)
+Declare Scope Primitives_scope.
+
+(*** Result *)
+
+Inductive error :=
+ | Failure
+ | OutOfFuel.
+
+Inductive result A :=
+ | Return : A -> result A
+ | Fail_ : error -> result A.
+
+Arguments Return {_} a.
+Arguments Fail_ {_}.
+
+Definition bind {A B} (m: result A) (f: A -> result B) : result B :=
+ match m with
+ | Fail_ e => Fail_ e
+ | Return x => f x
+ end.
+
+Definition return_ {A: Type} (x: A) : result A := Return x.
+Definition fail_ {A: Type} (e: error) : result A := Fail_ e.
+
+Notation "x <- c1 ; c2" := (bind c1 (fun x => c2))
+ (at level 61, c1 at next level, right associativity).
+
+(** Monadic assert *)
+Definition massert (b: bool) : result unit :=
+ if b then Return tt else Fail_ Failure.
+
+(** Normalize and unwrap a successful result (used for globals) *)
+Definition eval_result_refl {A} {x} (a: result A) (p: a = Return x) : A :=
+ match a as r return (r = Return x -> A) with
+ | Return a' => fun _ => a'
+ | Fail_ e => fun p' =>
+ False_rect _ (eq_ind (Fail_ e)
+ (fun e : result A =>
+ match e with
+ | Return _ => False
+ | Fail_ e => True
+ end)
+ I (Return x) p')
+ end p.
+
+Notation "x %global" := (eval_result_refl x eq_refl) (at level 40).
+Notation "x %return" := (eval_result_refl x eq_refl) (at level 40).
+
+(* Sanity check *)
+Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
+
+(*** Misc *)
+
+Definition string := Coq.Strings.String.string.
+Definition char := Coq.Strings.Ascii.ascii.
+Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
+
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
+
+(*** Scalars *)
+
+Definition i8_min : Z := -128%Z.
+Definition i8_max : Z := 127%Z.
+Definition i16_min : Z := -32768%Z.
+Definition i16_max : Z := 32767%Z.
+Definition i32_min : Z := -2147483648%Z.
+Definition i32_max : Z := 2147483647%Z.
+Definition i64_min : Z := -9223372036854775808%Z.
+Definition i64_max : Z := 9223372036854775807%Z.
+Definition i128_min : Z := -170141183460469231731687303715884105728%Z.
+Definition i128_max : Z := 170141183460469231731687303715884105727%Z.
+Definition u8_min : Z := 0%Z.
+Definition u8_max : Z := 255%Z.
+Definition u16_min : Z := 0%Z.
+Definition u16_max : Z := 65535%Z.
+Definition u32_min : Z := 0%Z.
+Definition u32_max : Z := 4294967295%Z.
+Definition u64_min : Z := 0%Z.
+Definition u64_max : Z := 18446744073709551615%Z.
+Definition u128_min : Z := 0%Z.
+Definition u128_max : Z := 340282366920938463463374607431768211455%Z.
+
+(** The bounds of [isize] and [usize] vary with the architecture. *)
+Axiom isize_min : Z.
+Axiom isize_max : Z.
+Definition usize_min : Z := 0%Z.
+Axiom usize_max : Z.
+
+Open Scope Z_scope.
+
+(** We provide those lemmas to reason about the bounds of [isize] and [usize] *)
+Axiom isize_min_bound : isize_min <= i32_min.
+Axiom isize_max_bound : i32_max <= isize_max.
+Axiom usize_max_bound : u32_max <= usize_max.
+
+Inductive scalar_ty :=
+ | Isize
+ | I8
+ | I16
+ | I32
+ | I64
+ | I128
+ | Usize
+ | U8
+ | U16
+ | U32
+ | U64
+ | U128
+.
+
+Definition scalar_min (ty: scalar_ty) : Z :=
+ 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
+end.
+
+Definition scalar_max (ty: scalar_ty) : Z :=
+ 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
+end.
+
+(** We use the following conservative bounds to make sure we can compute bound
+ checks in most situations *)
+Definition scalar_min_cons (ty: scalar_ty) : Z :=
+ match ty with
+ | Isize => i32_min
+ | Usize => u32_min
+ | _ => scalar_min ty
+end.
+
+Definition scalar_max_cons (ty: scalar_ty) : Z :=
+ match ty with
+ | Isize => i32_max
+ | Usize => u32_max
+ | _ => scalar_max ty
+end.
+
+Lemma scalar_min_cons_valid : forall ty, scalar_min ty <= scalar_min_cons ty .
+Proof.
+ destruct ty; unfold scalar_min_cons, scalar_min; try lia.
+ - pose isize_min_bound; lia.
+ - apply Z.le_refl.
+Qed.
+
+Lemma scalar_max_cons_valid : forall ty, scalar_max ty >= scalar_max_cons ty .
+Proof.
+ destruct ty; unfold scalar_max_cons, scalar_max; try lia.
+ - pose isize_max_bound; lia.
+ - pose usize_max_bound. lia.
+Qed.
+
+Definition scalar (ty: scalar_ty) : Type :=
+ { x: Z | scalar_min ty <= x <= scalar_max ty }.
+
+Definition to_Z {ty} (x: scalar ty) : Z := proj1_sig x.
+
+(** Bounds checks: we start by using the conservative bounds, to make sure we
+ can compute in most situations, then we use the real bounds (for [isize]
+ and [usize]). *)
+Definition scalar_ge_min (ty: scalar_ty) (x: Z) : bool :=
+ Z.leb (scalar_min_cons ty) x || Z.leb (scalar_min ty) x.
+
+Definition scalar_le_max (ty: scalar_ty) (x: Z) : bool :=
+ Z.leb x (scalar_max_cons ty) || Z.leb x (scalar_max ty).
+
+Lemma scalar_ge_min_valid (ty: scalar_ty) (x: Z) :
+ scalar_ge_min ty x = true -> scalar_min ty <= x .
+Proof.
+ unfold scalar_ge_min.
+ pose (scalar_min_cons_valid ty).
+ lia.
+Qed.
+
+Lemma scalar_le_max_valid (ty: scalar_ty) (x: Z) :
+ scalar_le_max ty x = true -> x <= scalar_max ty .
+Proof.
+ unfold scalar_le_max.
+ pose (scalar_max_cons_valid ty).
+ lia.
+Qed.
+
+Definition scalar_in_bounds (ty: scalar_ty) (x: Z) : bool :=
+ scalar_ge_min ty x && scalar_le_max ty x .
+
+Lemma scalar_in_bounds_valid (ty: scalar_ty) (x: Z) :
+ scalar_in_bounds ty x = true -> scalar_min ty <= x <= scalar_max ty .
+Proof.
+ unfold scalar_in_bounds.
+ intros H.
+ destruct (scalar_ge_min ty x) eqn:Hmin.
+ - destruct (scalar_le_max ty x) eqn:Hmax.
+ + pose (scalar_ge_min_valid ty x Hmin).
+ pose (scalar_le_max_valid ty x Hmax).
+ lia.
+ + inversion H.
+ - inversion H.
+Qed.
+
+Import Sumbool.
+
+Definition mk_scalar (ty: scalar_ty) (x: Z) : result (scalar ty) :=
+ match sumbool_of_bool (scalar_in_bounds ty x) with
+ | left H => Return (exist _ x (scalar_in_bounds_valid _ _ H))
+ | right _ => Fail_ Failure
+ end.
+
+Definition scalar_add {ty} (x y: scalar ty) : result (scalar ty) := mk_scalar ty (to_Z x + to_Z y).
+
+Definition scalar_sub {ty} (x y: scalar ty) : result (scalar ty) := mk_scalar ty (to_Z x - to_Z y).
+
+Definition scalar_mul {ty} (x y: scalar ty) : result (scalar ty) := mk_scalar ty (to_Z x * to_Z y).
+
+Definition scalar_div {ty} (x y: scalar ty) : result (scalar ty) :=
+ if to_Z y =? 0 then Fail_ Failure else
+ mk_scalar ty (to_Z x / to_Z y).
+
+Definition scalar_rem {ty} (x y: scalar ty) : result (scalar ty) := mk_scalar ty (Z.rem (to_Z x) (to_Z y)).
+
+Definition scalar_neg {ty} (x: scalar ty) : result (scalar ty) := mk_scalar ty (-(to_Z x)).
+
+(** Cast an integer from a [src_ty] to a [tgt_ty] *)
+(* TODO: check the semantics of casts in Rust *)
+Definition scalar_cast (src_ty tgt_ty : scalar_ty) (x : scalar src_ty) : result (scalar tgt_ty) :=
+ mk_scalar tgt_ty (to_Z x).
+
+(** Comparisons *)
+Definition scalar_leb {ty : scalar_ty} (x : scalar ty) (y : scalar ty) : bool :=
+ Z.leb (to_Z x) (to_Z y) .
+
+Definition scalar_ltb {ty : scalar_ty} (x : scalar ty) (y : scalar ty) : bool :=
+ Z.ltb (to_Z x) (to_Z y) .
+
+Definition scalar_geb {ty : scalar_ty} (x : scalar ty) (y : scalar ty) : bool :=
+ Z.geb (to_Z x) (to_Z y) .
+
+Definition scalar_gtb {ty : scalar_ty} (x : scalar ty) (y : scalar ty) : bool :=
+ Z.gtb (to_Z x) (to_Z y) .
+
+Definition scalar_eqb {ty : scalar_ty} (x : scalar ty) (y : scalar ty) : bool :=
+ Z.eqb (to_Z x) (to_Z y) .
+
+Definition scalar_neqb {ty : scalar_ty} (x : scalar ty) (y : scalar ty) : bool :=
+ negb (Z.eqb (to_Z x) (to_Z y)) .
+
+
+(** The scalar types *)
+Definition isize := scalar Isize.
+Definition i8 := scalar I8.
+Definition i16 := scalar I16.
+Definition i32 := scalar I32.
+Definition i64 := scalar I64.
+Definition i128 := scalar I128.
+Definition usize := scalar Usize.
+Definition u8 := scalar U8.
+Definition u16 := scalar U16.
+Definition u32 := scalar U32.
+Definition u64 := scalar U64.
+Definition u128 := scalar U128.
+
+(** Negaion *)
+Definition isize_neg := @scalar_neg Isize.
+Definition i8_neg := @scalar_neg I8.
+Definition i16_neg := @scalar_neg I16.
+Definition i32_neg := @scalar_neg I32.
+Definition i64_neg := @scalar_neg I64.
+Definition i128_neg := @scalar_neg I128.
+
+(** Division *)
+Definition isize_div := @scalar_div Isize.
+Definition i8_div := @scalar_div I8.
+Definition i16_div := @scalar_div I16.
+Definition i32_div := @scalar_div I32.
+Definition i64_div := @scalar_div I64.
+Definition i128_div := @scalar_div I128.
+Definition usize_div := @scalar_div Usize.
+Definition u8_div := @scalar_div U8.
+Definition u16_div := @scalar_div U16.
+Definition u32_div := @scalar_div U32.
+Definition u64_div := @scalar_div U64.
+Definition u128_div := @scalar_div U128.
+
+(** Remainder *)
+Definition isize_rem := @scalar_rem Isize.
+Definition i8_rem := @scalar_rem I8.
+Definition i16_rem := @scalar_rem I16.
+Definition i32_rem := @scalar_rem I32.
+Definition i64_rem := @scalar_rem I64.
+Definition i128_rem := @scalar_rem I128.
+Definition usize_rem := @scalar_rem Usize.
+Definition u8_rem := @scalar_rem U8.
+Definition u16_rem := @scalar_rem U16.
+Definition u32_rem := @scalar_rem U32.
+Definition u64_rem := @scalar_rem U64.
+Definition u128_rem := @scalar_rem U128.
+
+(** Addition *)
+Definition isize_add := @scalar_add Isize.
+Definition i8_add := @scalar_add I8.
+Definition i16_add := @scalar_add I16.
+Definition i32_add := @scalar_add I32.
+Definition i64_add := @scalar_add I64.
+Definition i128_add := @scalar_add I128.
+Definition usize_add := @scalar_add Usize.
+Definition u8_add := @scalar_add U8.
+Definition u16_add := @scalar_add U16.
+Definition u32_add := @scalar_add U32.
+Definition u64_add := @scalar_add U64.
+Definition u128_add := @scalar_add U128.
+
+(** Substraction *)
+Definition isize_sub := @scalar_sub Isize.
+Definition i8_sub := @scalar_sub I8.
+Definition i16_sub := @scalar_sub I16.
+Definition i32_sub := @scalar_sub I32.
+Definition i64_sub := @scalar_sub I64.
+Definition i128_sub := @scalar_sub I128.
+Definition usize_sub := @scalar_sub Usize.
+Definition u8_sub := @scalar_sub U8.
+Definition u16_sub := @scalar_sub U16.
+Definition u32_sub := @scalar_sub U32.
+Definition u64_sub := @scalar_sub U64.
+Definition u128_sub := @scalar_sub U128.
+
+(** Multiplication *)
+Definition isize_mul := @scalar_mul Isize.
+Definition i8_mul := @scalar_mul I8.
+Definition i16_mul := @scalar_mul I16.
+Definition i32_mul := @scalar_mul I32.
+Definition i64_mul := @scalar_mul I64.
+Definition i128_mul := @scalar_mul I128.
+Definition usize_mul := @scalar_mul Usize.
+Definition u8_mul := @scalar_mul U8.
+Definition u16_mul := @scalar_mul U16.
+Definition u32_mul := @scalar_mul U32.
+Definition u64_mul := @scalar_mul U64.
+Definition u128_mul := @scalar_mul U128.
+
+(** Small utility *)
+Definition usize_to_nat (x: usize) : nat := Z.to_nat (to_Z x).
+
+(** Notations *)
+Notation "x %isize" := ((mk_scalar Isize x)%return) (at level 9).
+Notation "x %i8" := ((mk_scalar I8 x)%return) (at level 9).
+Notation "x %i16" := ((mk_scalar I16 x)%return) (at level 9).
+Notation "x %i32" := ((mk_scalar I32 x)%return) (at level 9).
+Notation "x %i64" := ((mk_scalar I64 x)%return) (at level 9).
+Notation "x %i128" := ((mk_scalar I128 x)%return) (at level 9).
+Notation "x %usize" := ((mk_scalar Usize x)%return) (at level 9).
+Notation "x %u8" := ((mk_scalar U8 x)%return) (at level 9).
+Notation "x %u16" := ((mk_scalar U16 x)%return) (at level 9).
+Notation "x %u32" := ((mk_scalar U32 x)%return) (at level 9).
+Notation "x %u64" := ((mk_scalar U64 x)%return) (at level 9).
+Notation "x %u128" := ((mk_scalar U128 x)%return) (at level 9).
+
+Notation "x s= y" := (scalar_eqb x y) (at level 80) : Primitives_scope.
+Notation "x s<> y" := (scalar_neqb x y) (at level 80) : Primitives_scope.
+Notation "x s<= y" := (scalar_leb x y) (at level 80) : Primitives_scope.
+Notation "x s< y" := (scalar_ltb x y) (at level 80) : Primitives_scope.
+Notation "x s>= y" := (scalar_geb x y) (at level 80) : Primitives_scope.
+Notation "x s> y" := (scalar_gtb x y) (at level 80) : Primitives_scope.
+
+(** Constants *)
+Definition core_u8_max := u8_max %u32.
+Definition core_u16_max := u16_max %u32.
+Definition core_u32_max := u32_max %u32.
+Definition core_u64_max := u64_max %u64.
+Definition core_u128_max := u64_max %u128.
+Axiom core_usize_max : usize. (** TODO *)
+Definition core_i8_max := i8_max %i32.
+Definition core_i16_max := i16_max %i32.
+Definition core_i32_max := i32_max %i32.
+Definition core_i64_max := i64_max %i64.
+Definition core_i128_max := i64_max %i128.
+Axiom core_isize_max : isize. (** TODO *)
+
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+ core_ops_index_Index_Output : Type;
+ core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+ core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+ core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+ core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+ core_ops_deref_Deref_target : Type;
+ core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+ core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+ core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+ core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
+}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+ core_ops_range_Range_start : T;
+ core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+ core_ops_deref_Deref_target := Self;
+ core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+ core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+ core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+ core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
+
+(*** Arrays *)
+Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
+
+Lemma le_0_usize_max : 0 <= usize_max.
+Proof.
+ pose (H := usize_max_bound).
+ unfold u32_max in H.
+ lia.
+Qed.
+
+Lemma eqb_imp_eq (x y : Z) : Z.eqb x y = true -> x = y.
+Proof.
+ lia.
+Qed.
+
+(* TODO: finish the definitions *)
+Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
+
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+
+(*** Slice *)
+Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
+
+Axiom slice_len : forall (T : Type) (s : slice T), usize.
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+
+(*** Subslices *)
+
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
+
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
+
+(*** Vectors *)
+
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
+
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
+
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
+
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
+Proof.
+ unfold alloc_vec_Vec_length, usize_min.
+ split.
+ - lia.
+ - apply (proj2_sig v).
+Qed.
+
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+ exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
+
+Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
+ : list A :=
+ match l with
+ | [] => []
+ | x :: t => match n with
+ | 0%nat => a :: t
+ | S m => x :: (list_update t m a)
+end end.
+
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+ l <- f (alloc_vec_Vec_to_list v) ;
+ match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
+ | left H => Return (exist _ l (scalar_le_max_valid _ _ H))
+ | right _ => Fail_ Failure
+ end.
+
+(* The **forward** function shouldn't be used *)
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
+
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
+
+(* The **forward** function shouldn't be used *)
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+ if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
+
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+ alloc_vec_Vec_bind v (fun l =>
+ if to_Z i <? Z.of_nat (length l)
+ then Return (list_update l (usize_to_nat i) x)
+ else Fail_ Failure).
+
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+ core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+ core_slice_index_SliceIndex_Output : Type;
+ core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+ core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+ core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+ core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+ (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+ x <- inst.(core_slice_index_SliceIndex_get) i s;
+ match x with
+ | None => Fail_ Failure
+ | Some x => Return x
+ end.
+
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+ (T : Type) :
+ 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 *)
+Definition core_slice_index_Range_get_unchecked_mut
+ (T : Type) :
+ 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 *)
+Axiom core_slice_index_Range_index :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+ forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+ slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+ forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+ (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (slice T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := slice T;
+ core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (slice T) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_Index (slice T) Idx) :
+ core_ops_index_Index (array T N) Idx := {|
+ core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+ core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+ (inst : core_ops_index_IndexMut (slice T) Idx) :
+ core_ops_index_IndexMut (array T N) Idx := {|
+ core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+ core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+ core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+ forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+ forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+ forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+ forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+ : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+ core_slice_index_SliceIndex usize (slice T) := {|
+ core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+ core_slice_index_SliceIndex_Output := T;
+ core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+ core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+ core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+ core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+ core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+ core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+ core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+ core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+ forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+ (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+ core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+ core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+ (inst : core_slice_index_SliceIndex Idx (slice T)) :
+ core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+ core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+ core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+ core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+ alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+ alloc_vec_Vec_update_usize v i x.
+
+End Primitives.
diff --git a/tests/coq/traits/Traits.v b/tests/coq/traits/Traits.v
new file mode 100644
index 00000000..e104fb66
--- /dev/null
+++ b/tests/coq/traits/Traits.v
@@ -0,0 +1,520 @@
+(** THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS *)
+(** [traits] *)
+Require Import Primitives.
+Import Primitives.
+Require Import Coq.ZArith.ZArith.
+Require Import List.
+Import ListNotations.
+Local Open Scope Primitives_scope.
+Module Traits.
+
+(** Trait declaration: [traits::BoolTrait] *)
+Record BoolTrait_t (Self : Type) := mkBoolTrait_t {
+ BoolTrait_t_get_bool : Self -> result bool;
+}.
+
+Arguments mkBoolTrait_t { _ }.
+Arguments BoolTrait_t_get_bool { _ }.
+
+(** [traits::Bool::{0}::get_bool]: forward function *)
+Definition bool_get_bool (self : bool) : result bool :=
+ Return self.
+
+(** Trait implementation: [traits::Bool::{0}] *)
+Definition Bool_BoolTraitInst : BoolTrait_t bool := {|
+ BoolTrait_t_get_bool := bool_get_bool;
+|}.
+
+(** [traits::BoolTrait::ret_true]: forward function *)
+Definition boolTrait_ret_true
+ {Self : Type} (self_clause : BoolTrait_t Self) (self : Self) : result bool :=
+ Return true
+.
+
+(** [traits::test_bool_trait_bool]: forward function *)
+Definition test_bool_trait_bool (x : bool) : result bool :=
+ b <- bool_get_bool x;
+ if b then boolTrait_ret_true Bool_BoolTraitInst x else Return false
+.
+
+(** [traits::Option::{1}::get_bool]: forward function *)
+Definition option_get_bool (T : Type) (self : option T) : result bool :=
+ match self with | None => Return false | Some t => Return true end
+.
+
+(** Trait implementation: [traits::Option::{1}] *)
+Definition Option_BoolTraitInst (T : Type) : BoolTrait_t (option T) := {|
+ BoolTrait_t_get_bool := option_get_bool T;
+|}.
+
+(** [traits::test_bool_trait_option]: forward function *)
+Definition test_bool_trait_option (T : Type) (x : option T) : result bool :=
+ b <- option_get_bool T x;
+ if b then boolTrait_ret_true (Option_BoolTraitInst T) x else Return false
+.
+
+(** [traits::test_bool_trait]: forward function *)
+Definition test_bool_trait
+ (T : Type) (inst : BoolTrait_t T) (x : T) : result bool :=
+ inst.(BoolTrait_t_get_bool) x
+.
+
+(** Trait declaration: [traits::ToU64] *)
+Record ToU64_t (Self : Type) := mkToU64_t {
+ ToU64_t_to_u64 : Self -> result u64;
+}.
+
+Arguments mkToU64_t { _ }.
+Arguments ToU64_t_to_u64 { _ }.
+
+(** [traits::u64::{2}::to_u64]: forward function *)
+Definition u64_to_u64 (self : u64) : result u64 :=
+ Return self.
+
+(** Trait implementation: [traits::u64::{2}] *)
+Definition u64_ToU64Inst : ToU64_t u64 := {| ToU64_t_to_u64 := u64_to_u64; |}.
+
+(** [traits::Tuple2::{3}::to_u64]: forward function *)
+Definition tuple2_to_u64
+ (A : Type) (inst : ToU64_t A) (self : (A * A)) : result u64 :=
+ let (t, t0) := self in
+ i <- inst.(ToU64_t_to_u64) t;
+ i0 <- inst.(ToU64_t_to_u64) t0;
+ u64_add i i0
+.
+
+(** Trait implementation: [traits::Tuple2::{3}] *)
+Definition Tuple2_ToU64Inst (A : Type) (inst : ToU64_t A) : ToU64_t (A * A)
+ := {|
+ ToU64_t_to_u64 := tuple2_to_u64 A inst;
+|}.
+
+(** [traits::f]: forward function *)
+Definition f (T : Type) (inst : ToU64_t T) (x : (T * T)) : result u64 :=
+ tuple2_to_u64 T inst x
+.
+
+(** [traits::g]: forward function *)
+Definition g (T : Type) (inst : ToU64_t (T * T)) (x : (T * T)) : result u64 :=
+ inst.(ToU64_t_to_u64) x
+.
+
+(** [traits::h0]: forward function *)
+Definition h0 (x : u64) : result u64 :=
+ u64_to_u64 x.
+
+(** [traits::Wrapper] *)
+Record Wrapper_t (T : Type) := mkWrapper_t { wrapper_x : T; }.
+
+Arguments mkWrapper_t { _ }.
+Arguments wrapper_x { _ }.
+
+(** [traits::Wrapper::{4}::to_u64]: forward function *)
+Definition wrapper_to_u64
+ (T : Type) (inst : ToU64_t T) (self : Wrapper_t T) : result u64 :=
+ inst.(ToU64_t_to_u64) self.(wrapper_x)
+.
+
+(** Trait implementation: [traits::Wrapper::{4}] *)
+Definition Wrapper_ToU64Inst (T : Type) (inst : ToU64_t T) : ToU64_t (Wrapper_t
+ T) := {|
+ ToU64_t_to_u64 := wrapper_to_u64 T inst;
+|}.
+
+(** [traits::h1]: forward function *)
+Definition h1 (x : Wrapper_t u64) : result u64 :=
+ wrapper_to_u64 u64 u64_ToU64Inst x
+.
+
+(** [traits::h2]: forward function *)
+Definition h2 (T : Type) (inst : ToU64_t T) (x : Wrapper_t T) : result u64 :=
+ wrapper_to_u64 T inst x
+.
+
+(** Trait declaration: [traits::ToType] *)
+Record ToType_t (Self T : Type) := mkToType_t {
+ ToType_t_to_type : Self -> result T;
+}.
+
+Arguments mkToType_t { _ _ }.
+Arguments ToType_t_to_type { _ _ }.
+
+(** [traits::u64::{5}::to_type]: forward function *)
+Definition u64_to_type (self : u64) : result bool :=
+ Return (self s> 0%u64).
+
+(** Trait implementation: [traits::u64::{5}] *)
+Definition u64_ToTypeInst : ToType_t u64 bool := {|
+ ToType_t_to_type := u64_to_type;
+|}.
+
+(** Trait declaration: [traits::OfType] *)
+Record OfType_t (Self : Type) := mkOfType_t {
+ OfType_t_of_type : forall (T : Type) (inst : ToType_t T Self), T -> result
+ Self;
+}.
+
+Arguments mkOfType_t { _ }.
+Arguments OfType_t_of_type { _ }.
+
+(** [traits::h3]: forward function *)
+Definition h3
+ (T1 T2 : Type) (inst : OfType_t T1) (inst0 : ToType_t T2 T1) (y : T2) :
+ result T1
+ :=
+ inst.(OfType_t_of_type) T2 inst0 y
+.
+
+(** Trait declaration: [traits::OfTypeBis] *)
+Record OfTypeBis_t (Self T : Type) := mkOfTypeBis_t {
+ OfTypeBis_tOfTypeBis_t_parent_clause_0 : ToType_t T Self;
+ OfTypeBis_t_of_type : T -> result Self;
+}.
+
+Arguments mkOfTypeBis_t { _ _ }.
+Arguments OfTypeBis_tOfTypeBis_t_parent_clause_0 { _ _ }.
+Arguments OfTypeBis_t_of_type { _ _ }.
+
+(** [traits::h4]: forward function *)
+Definition h4
+ (T1 T2 : Type) (inst : OfTypeBis_t T1 T2) (inst0 : ToType_t T2 T1) (y : T2) :
+ result T1
+ :=
+ inst.(OfTypeBis_t_of_type) y
+.
+
+(** [traits::TestType] *)
+Record TestType_t (T : Type) := mkTestType_t { testType_0 : T; }.
+
+Arguments mkTestType_t { _ }.
+Arguments testType_0 { _ }.
+
+(** [traits::TestType::{6}::test::TestType1] *)
+Record TestType_test_TestType1_t :=
+mkTestType_test_TestType1_t {
+ testType_test_TestType1_0 : u64;
+}
+.
+
+(** Trait declaration: [traits::TestType::{6}::test::TestTrait] *)
+Record TestType_test_TestTrait_t (Self : Type) := mkTestType_test_TestTrait_t {
+ TestType_test_TestTrait_t_test : Self -> result bool;
+}.
+
+Arguments mkTestType_test_TestTrait_t { _ }.
+Arguments TestType_test_TestTrait_t_test { _ }.
+
+(** [traits::TestType::{6}::test::TestType1::{0}::test]: forward function *)
+Definition testType_test_TestType1_test
+ (self : TestType_test_TestType1_t) : result bool :=
+ Return (self.(testType_test_TestType1_0) s> 1%u64)
+.
+
+(** Trait implementation: [traits::TestType::{6}::test::TestType1::{0}] *)
+Definition TestType_test_TestType1_TestType_test_TestTraitInst :
+ TestType_test_TestTrait_t TestType_test_TestType1_t := {|
+ TestType_test_TestTrait_t_test := testType_test_TestType1_test;
+|}.
+
+(** [traits::TestType::{6}::test]: forward function *)
+Definition testType_test
+ (T : Type) (inst : ToU64_t T) (self : TestType_t T) (x : T) : result bool :=
+ x0 <- inst.(ToU64_t_to_u64) x;
+ if x0 s> 0%u64
+ then testType_test_TestType1_test {| testType_test_TestType1_0 := 0%u64 |}
+ else Return false
+.
+
+(** [traits::BoolWrapper] *)
+Record BoolWrapper_t := mkBoolWrapper_t { boolWrapper_0 : bool; }.
+
+(** [traits::BoolWrapper::{7}::to_type]: forward function *)
+Definition boolWrapper_to_type
+ (T : Type) (inst : ToType_t bool T) (self : BoolWrapper_t) : result T :=
+ inst.(ToType_t_to_type) self.(boolWrapper_0)
+.
+
+(** Trait implementation: [traits::BoolWrapper::{7}] *)
+Definition BoolWrapper_ToTypeInst (T : Type) (inst : ToType_t bool T) :
+ ToType_t BoolWrapper_t T := {|
+ ToType_t_to_type := boolWrapper_to_type T inst;
+|}.
+
+(** [traits::WithConstTy::LEN2] *)
+Definition with_const_ty_len2_body : result usize := Return 32%usize.
+Definition with_const_ty_len2_c : usize := with_const_ty_len2_body%global.
+
+(** Trait declaration: [traits::WithConstTy] *)
+Record WithConstTy_t (Self : Type) (LEN : usize) := mkWithConstTy_t {
+ WithConstTy_tWithConstTy_t_LEN1 : usize;
+ WithConstTy_tWithConstTy_t_LEN2 : usize;
+ WithConstTy_tWithConstTy_t_V : Type;
+ WithConstTy_tWithConstTy_t_W : Type;
+ WithConstTy_tWithConstTy_t_W_clause_0 : ToU64_t WithConstTy_tWithConstTy_t_W;
+ WithConstTy_t_f : WithConstTy_tWithConstTy_t_W -> array u8 LEN -> result
+ WithConstTy_tWithConstTy_t_W;
+}.
+
+Arguments mkWithConstTy_t { _ _ }.
+Arguments WithConstTy_tWithConstTy_t_LEN1 { _ _ }.
+Arguments WithConstTy_tWithConstTy_t_LEN2 { _ _ }.
+Arguments WithConstTy_tWithConstTy_t_V { _ _ }.
+Arguments WithConstTy_tWithConstTy_t_W { _ _ }.
+Arguments WithConstTy_tWithConstTy_t_W_clause_0 { _ _ }.
+Arguments WithConstTy_t_f { _ _ }.
+
+(** [traits::Bool::{8}::LEN1] *)
+Definition bool_len1_body : result usize := Return 12%usize.
+Definition bool_len1_c : usize := bool_len1_body%global.
+
+(** [traits::Bool::{8}::f]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) *)
+Definition bool_f (i : u64) (a : array u8 32%usize) : result u64 :=
+ Return i.
+
+(** Trait implementation: [traits::Bool::{8}] *)
+Definition Bool_WithConstTyInst : WithConstTy_t bool 32%usize := {|
+ WithConstTy_tWithConstTy_t_LEN1 := bool_len1_c;
+ WithConstTy_tWithConstTy_t_LEN2 := with_const_ty_len2_c;
+ WithConstTy_tWithConstTy_t_V := u8;
+ WithConstTy_tWithConstTy_t_W := u64;
+ WithConstTy_tWithConstTy_t_W_clause_0 := u64_ToU64Inst;
+ WithConstTy_t_f := bool_f;
+|}.
+
+(** [traits::use_with_const_ty1]: forward function *)
+Definition use_with_const_ty1
+ (H : Type) (LEN : usize) (inst : WithConstTy_t H LEN) : result usize :=
+ let i := inst.(WithConstTy_tWithConstTy_t_LEN1) in Return i
+.
+
+(** [traits::use_with_const_ty2]: forward function *)
+Definition use_with_const_ty2
+ (H : Type) (LEN : usize) (inst : WithConstTy_t H LEN)
+ (w : inst.(WithConstTy_tWithConstTy_t_W)) :
+ result unit
+ :=
+ Return tt
+.
+
+(** [traits::use_with_const_ty3]: forward function *)
+Definition use_with_const_ty3
+ (H : Type) (LEN : usize) (inst : WithConstTy_t H LEN)
+ (x : inst.(WithConstTy_tWithConstTy_t_W)) :
+ result u64
+ :=
+ inst.(WithConstTy_tWithConstTy_t_W_clause_0).(ToU64_t_to_u64) x
+.
+
+(** [traits::test_where1]: forward function *)
+Definition test_where1 (T : Type) (_x : T) : result unit :=
+ Return tt.
+
+(** [traits::test_where2]: forward function *)
+Definition test_where2
+ (T : Type) (inst : WithConstTy_t T 32%usize) (_x : u32) : result unit :=
+ Return tt
+.
+
+(** [alloc::string::String] *)
+Axiom alloc_string_String_t : Type.
+
+(** Trait declaration: [traits::ParentTrait0] *)
+Record ParentTrait0_t (Self : Type) := mkParentTrait0_t {
+ ParentTrait0_tParentTrait0_t_W : Type;
+ ParentTrait0_t_get_name : Self -> result alloc_string_String_t;
+ ParentTrait0_t_get_w : Self -> result ParentTrait0_tParentTrait0_t_W;
+}.
+
+Arguments mkParentTrait0_t { _ }.
+Arguments ParentTrait0_tParentTrait0_t_W { _ }.
+Arguments ParentTrait0_t_get_name { _ }.
+Arguments ParentTrait0_t_get_w { _ }.
+
+(** Trait declaration: [traits::ParentTrait1] *)
+Record ParentTrait1_t (Self : Type) := mkParentTrait1_t{}.
+
+Arguments mkParentTrait1_t { _ }.
+
+(** Trait declaration: [traits::ChildTrait] *)
+Record ChildTrait_t (Self : Type) := mkChildTrait_t {
+ ChildTrait_tChildTrait_t_parent_clause_0 : ParentTrait0_t Self;
+ ChildTrait_tChildTrait_t_parent_clause_1 : ParentTrait1_t Self;
+}.
+
+Arguments mkChildTrait_t { _ }.
+Arguments ChildTrait_tChildTrait_t_parent_clause_0 { _ }.
+Arguments ChildTrait_tChildTrait_t_parent_clause_1 { _ }.
+
+(** [traits::test_child_trait1]: forward function *)
+Definition test_child_trait1
+ (T : Type) (inst : ChildTrait_t T) (x : T) : result alloc_string_String_t :=
+ inst.(ChildTrait_tChildTrait_t_parent_clause_0).(ParentTrait0_t_get_name) x
+.
+
+(** [traits::test_child_trait2]: forward function *)
+Definition test_child_trait2
+ (T : Type) (inst : ChildTrait_t T) (x : T) :
+ result
+ inst.(ChildTrait_tChildTrait_t_parent_clause_0).(ParentTrait0_tParentTrait0_t_W)
+ :=
+ inst.(ChildTrait_tChildTrait_t_parent_clause_0).(ParentTrait0_t_get_w) x
+.
+
+(** [traits::order1]: forward function *)
+Definition order1
+ (T U : Type) (inst : ParentTrait0_t T) (inst0 : ParentTrait0_t U) :
+ result unit
+ :=
+ Return tt
+.
+
+(** Trait declaration: [traits::ChildTrait1] *)
+Record ChildTrait1_t (Self : Type) := mkChildTrait1_t {
+ ChildTrait1_tChildTrait1_t_parent_clause_0 : ParentTrait1_t Self;
+}.
+
+Arguments mkChildTrait1_t { _ }.
+Arguments ChildTrait1_tChildTrait1_t_parent_clause_0 { _ }.
+
+(** Trait implementation: [traits::usize::{9}] *)
+Definition usize_ParentTrait1Inst : ParentTrait1_t usize := mkParentTrait1_t.
+
+(** Trait implementation: [traits::usize::{10}] *)
+Definition usize_ChildTrait1Inst : ChildTrait1_t usize := {|
+ ChildTrait1_tChildTrait1_t_parent_clause_0 := usize_ParentTrait1Inst;
+|}.
+
+(** Trait declaration: [traits::Iterator] *)
+Record Iterator_t (Self : Type) := mkIterator_t {
+ Iterator_tIterator_t_Item : Type;
+}.
+
+Arguments mkIterator_t { _ }.
+Arguments Iterator_tIterator_t_Item { _ }.
+
+(** Trait declaration: [traits::IntoIterator] *)
+Record IntoIterator_t (Self : Type) := mkIntoIterator_t {
+ IntoIterator_tIntoIterator_t_Item : Type;
+ IntoIterator_tIntoIterator_t_IntoIter : Type;
+ IntoIterator_tIntoIterator_t_IntoIter_clause_0 : Iterator_t
+ IntoIterator_tIntoIterator_t_IntoIter;
+ IntoIterator_t_into_iter : Self -> result
+ IntoIterator_tIntoIterator_t_IntoIter;
+}.
+
+Arguments mkIntoIterator_t { _ }.
+Arguments IntoIterator_tIntoIterator_t_Item { _ }.
+Arguments IntoIterator_tIntoIterator_t_IntoIter { _ }.
+Arguments IntoIterator_tIntoIterator_t_IntoIter_clause_0 { _ }.
+Arguments IntoIterator_t_into_iter { _ }.
+
+(** Trait declaration: [traits::FromResidual] *)
+Record FromResidual_t (Self T : Type) := mkFromResidual_t{}.
+
+Arguments mkFromResidual_t { _ _ }.
+
+(** Trait declaration: [traits::Try] *)
+Record Try_t (Self : Type) := mkTry_t {
+ Try_tTry_t_Residual : Type;
+ Try_tTry_t_parent_clause_0 : FromResidual_t Self Try_tTry_t_Residual;
+}.
+
+Arguments mkTry_t { _ }.
+Arguments Try_tTry_t_Residual { _ }.
+Arguments Try_tTry_t_parent_clause_0 { _ }.
+
+(** Trait declaration: [traits::WithTarget] *)
+Record WithTarget_t (Self : Type) := mkWithTarget_t {
+ WithTarget_tWithTarget_t_Target : Type;
+}.
+
+Arguments mkWithTarget_t { _ }.
+Arguments WithTarget_tWithTarget_t_Target { _ }.
+
+(** Trait declaration: [traits::ParentTrait2] *)
+Record ParentTrait2_t (Self : Type) := mkParentTrait2_t {
+ ParentTrait2_tParentTrait2_t_U : Type;
+ ParentTrait2_tParentTrait2_t_U_clause_0 : WithTarget_t
+ ParentTrait2_tParentTrait2_t_U;
+}.
+
+Arguments mkParentTrait2_t { _ }.
+Arguments ParentTrait2_tParentTrait2_t_U { _ }.
+Arguments ParentTrait2_tParentTrait2_t_U_clause_0 { _ }.
+
+(** Trait declaration: [traits::ChildTrait2] *)
+Record ChildTrait2_t (Self : Type) := mkChildTrait2_t {
+ ChildTrait2_tChildTrait2_t_parent_clause_0 : ParentTrait2_t Self;
+ ChildTrait2_t_convert :
+ (ChildTrait2_tChildTrait2_t_parent_clause_0).(ParentTrait2_tParentTrait2_t_U)
+ -> result
+ (ChildTrait2_tChildTrait2_t_parent_clause_0).(ParentTrait2_tParentTrait2_t_U_clause_0).(WithTarget_tWithTarget_t_Target);
+}.
+
+Arguments mkChildTrait2_t { _ }.
+Arguments ChildTrait2_tChildTrait2_t_parent_clause_0 { _ }.
+Arguments ChildTrait2_t_convert { _ }.
+
+(** Trait implementation: [traits::u32::{11}] *)
+Definition u32_WithTargetInst : WithTarget_t u32 := {|
+ WithTarget_tWithTarget_t_Target := u32;
+|}.
+
+(** Trait implementation: [traits::u32::{12}] *)
+Definition u32_ParentTrait2Inst : ParentTrait2_t u32 := {|
+ ParentTrait2_tParentTrait2_t_U := u32;
+ ParentTrait2_tParentTrait2_t_U_clause_0 := u32_WithTargetInst;
+|}.
+
+(** [traits::u32::{13}::convert]: forward function *)
+Definition u32_convert (x : u32) : result u32 :=
+ Return x.
+
+(** Trait implementation: [traits::u32::{13}] *)
+Definition u32_ChildTrait2Inst : ChildTrait2_t u32 := {|
+ ChildTrait2_tChildTrait2_t_parent_clause_0 := u32_ParentTrait2Inst;
+ ChildTrait2_t_convert := u32_convert;
+|}.
+
+(** [traits::incr_u32]: forward function *)
+Definition incr_u32 (x : u32) : result u32 :=
+ u32_add x 1%u32.
+
+(** Trait declaration: [traits::CFnOnce] *)
+Record CFnOnce_t (Self Args : Type) := mkCFnOnce_t {
+ CFnOnce_tCFnOnce_t_Output : Type;
+ CFnOnce_t_call_once : Self -> Args -> result CFnOnce_tCFnOnce_t_Output;
+}.
+
+Arguments mkCFnOnce_t { _ _ }.
+Arguments CFnOnce_tCFnOnce_t_Output { _ _ }.
+Arguments CFnOnce_t_call_once { _ _ }.
+
+(** Trait declaration: [traits::CFnMut] *)
+Record CFnMut_t (Self Args : Type) := mkCFnMut_t {
+ CFnMut_tCFnMut_t_parent_clause_0 : CFnOnce_t Self Args;
+ CFnMut_t_call_mut : Self -> Args -> result
+ (CFnMut_tCFnMut_t_parent_clause_0).(CFnOnce_tCFnOnce_t_Output);
+ CFnMut_t_call_mut_back : Self -> Args ->
+ (CFnMut_tCFnMut_t_parent_clause_0).(CFnOnce_tCFnOnce_t_Output) -> result
+ Self;
+}.
+
+Arguments mkCFnMut_t { _ _ }.
+Arguments CFnMut_tCFnMut_t_parent_clause_0 { _ _ }.
+Arguments CFnMut_t_call_mut { _ _ }.
+Arguments CFnMut_t_call_mut_back { _ _ }.
+
+(** Trait declaration: [traits::CFn] *)
+Record CFn_t (Self Args : Type) := mkCFn_t {
+ CFn_tCFn_t_parent_clause_0 : CFnMut_t Self Args;
+ CFn_t_call_mut : Self -> Args -> result
+ (CFn_tCFn_t_parent_clause_0).(CFnMut_tCFnMut_t_parent_clause_0).(CFnOnce_tCFnOnce_t_Output);
+}.
+
+Arguments mkCFn_t { _ _ }.
+Arguments CFn_tCFn_t_parent_clause_0 { _ _ }.
+Arguments CFn_t_call_mut { _ _ }.
+
+End Traits .
diff --git a/tests/coq/traits/_CoqProject b/tests/coq/traits/_CoqProject
new file mode 100644
index 00000000..5b6199fc
--- /dev/null
+++ b/tests/coq/traits/_CoqProject
@@ -0,0 +1,7 @@
+# This file was automatically generated - see ../Makefile
+-R . Lib
+-arg -w
+-arg all
+
+Traits.v
+Primitives.v
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;
+}
+
diff --git a/tests/hol4/betree/betreeMain_FunsScript.sml b/tests/hol4/betree/betreeMain_FunsScript.sml
index 5e604f8c..bd16c16c 100644
--- a/tests/hol4/betree/betreeMain_FunsScript.sml
+++ b/tests/hol4/betree/betreeMain_FunsScript.sml
@@ -88,14 +88,6 @@ val betree_node_id_counter_fresh_id_back_def = Define ‘
od
-(** [core::num::u64::{9}::MAX] *)
-Definition core_num_u64_max_body_def:
- core_num_u64_max_body : u64 result = Return (int_to_u64 18446744073709551615)
-End
-Definition core_num_u64_max_c_def:
- core_num_u64_max_c : u64 = get_return_value core_num_u64_max_body
-End
-
val betree_upsert_update_fwd_def = Define ‘
(** [betree_main::betree::upsert_update]: forward function *)
betree_upsert_update_fwd
@@ -109,8 +101,8 @@ val betree_upsert_update_fwd_def = Define ‘
(case st of
| BetreeUpsertFunStateAdd v =>
do
- margin <- u64_sub core_num_u64_max_c prev0;
- if u64_ge margin v then u64_add prev0 v else Return core_num_u64_max_c
+ margin <- u64_sub core_u64_max prev0;
+ if u64_ge margin v then u64_add prev0 v else Return core_u64_max
od
| BetreeUpsertFunStateSub v =>
if u64_ge prev0 v then u64_sub prev0 v else Return (int_to_u64 0)))
diff --git a/tests/hol4/betree/betreeMain_FunsTheory.sig b/tests/hol4/betree/betreeMain_FunsTheory.sig
index 6c249f70..c922ca9f 100644
--- a/tests/hol4/betree/betreeMain_FunsTheory.sig
+++ b/tests/hol4/betree/betreeMain_FunsTheory.sig
@@ -58,8 +58,6 @@ sig
val betree_store_internal_node_fwd_def : thm
val betree_store_leaf_node_fwd_def : thm
val betree_upsert_update_fwd_def : thm
- val core_num_u64_max_body_def : thm
- val core_num_u64_max_c_def : thm
val main_fwd_def : thm
val betreeMain_Funs_grammars : type_grammar.grammar * term_grammar.grammar
@@ -1215,22 +1213,14 @@ sig
case st of
BetreeUpsertFunStateAdd v =>
do
- margin <- u64_sub core_num_u64_max_c prev0;
+ margin <- u64_sub core_u64_max prev0;
if u64_ge margin v then u64_add prev0 v
- else Return core_num_u64_max_c
+ else Return core_u64_max
od
| BetreeUpsertFunStateSub v' =>
if u64_ge prev0 v' then u64_sub prev0 v'
else Return (int_to_u64 0)
- [core_num_u64_max_body_def] Definition
-
- ⊢ core_num_u64_max_body = Return (int_to_u64 18446744073709551615)
-
- [core_num_u64_max_c_def] Definition
-
- ⊢ core_num_u64_max_c = get_return_value core_num_u64_max_body
-
[main_fwd_def] Definition
⊢ main_fwd = Return ()
diff --git a/tests/hol4/hashmap/hashmap_FunsScript.sml b/tests/hol4/hashmap/hashmap_FunsScript.sml
index e3c3d2a5..682c5760 100644
--- a/tests/hol4/hashmap/hashmap_FunsScript.sml
+++ b/tests/hol4/hashmap/hashmap_FunsScript.sml
@@ -170,14 +170,6 @@ val hash_map_insert_no_resize_fwd_back_def = Define ‘
od
-(** [core::num::u32::{8}::MAX] *)
-Definition core_num_u32_max_body_def:
- core_num_u32_max_body : u32 result = Return (int_to_u32 4294967295)
-End
-Definition core_num_u32_max_c_def:
- core_num_u32_max_c : u32 = get_return_value core_num_u32_max_body
-End
-
val [hash_map_move_elements_from_list_loop_fwd_back_def] = DefineDiv ‘
(** [hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) *)
@@ -241,7 +233,7 @@ val hash_map_try_resize_fwd_back_def = Define ‘
(there is a single backward function, and the forward function returns ()) *)
hash_map_try_resize_fwd_back (self : 't hash_map_t) : 't hash_map_t result =
do
- max_usize <- mk_usize (u32_to_int core_num_u32_max_c);
+ max_usize <- mk_usize (u32_to_int core_u32_max);
let capacity = vec_len self.hash_map_slots in
do
n1 <- usize_div max_usize (int_to_usize 2);
diff --git a/tests/hol4/hashmap/hashmap_FunsTheory.sig b/tests/hol4/hashmap/hashmap_FunsTheory.sig
index 50482547..bb3e192b 100644
--- a/tests/hol4/hashmap/hashmap_FunsTheory.sig
+++ b/tests/hol4/hashmap/hashmap_FunsTheory.sig
@@ -3,8 +3,6 @@ sig
type thm = Thm.thm
(* Definitions *)
- val core_num_u32_max_body_def : thm
- val core_num_u32_max_c_def : thm
val hash_key_fwd_def : thm
val hash_map_allocate_slots_fwd_def : thm
val hash_map_allocate_slots_loop_fwd_def : thm
@@ -48,14 +46,6 @@ sig
(*
[hashmap_Types] Parent theory of "hashmap_Funs"
- [core_num_u32_max_body_def] Definition
-
- ⊢ core_num_u32_max_body = Return (int_to_u32 4294967295)
-
- [core_num_u32_max_c_def] Definition
-
- ⊢ core_num_u32_max_c = get_return_value core_num_u32_max_body
-
[hash_key_fwd_def] Definition
⊢ ∀k. hash_key_fwd k = Return k
@@ -472,7 +462,7 @@ sig
⊢ ∀self.
hash_map_try_resize_fwd_back self =
do
- max_usize <- mk_usize (u32_to_int core_num_u32_max_c);
+ max_usize <- mk_usize (u32_to_int core_u32_max);
capacity <<- vec_len self.hash_map_slots;
n1 <- usize_div max_usize (int_to_usize 2);
(i,i0) <<- self.hash_map_max_load_factor;
diff --git a/tests/hol4/hashmap/hashmap_PropertiesScript.sml b/tests/hol4/hashmap/hashmap_PropertiesScript.sml
index 7259f2f5..8bc12fa5 100644
--- a/tests/hol4/hashmap/hashmap_PropertiesScript.sml
+++ b/tests/hol4/hashmap/hashmap_PropertiesScript.sml
@@ -1296,7 +1296,7 @@ Proof
rw [hash_map_try_resize_fwd_back_def] >>
(* “_ <-- mk_usize (u32_to_int core_num_u32_max_c)” *)
assume_tac usize_u32_bounds >>
- fs [core_num_u32_max_c_def, core_num_u32_max_body_def, get_return_value_def, u32_max_def] >>
+ fs [core_u32_max_def, u32_max_def] >>
massage >> fs [mk_usize_def, u32_max_def] >>
(* / 2 *)
progress >>
diff --git a/tests/hol4/hashmap_on_disk/hashmapMain_FunsScript.sml b/tests/hol4/hashmap_on_disk/hashmapMain_FunsScript.sml
index b21c4f58..c1e30aa6 100644
--- a/tests/hol4/hashmap_on_disk/hashmapMain_FunsScript.sml
+++ b/tests/hol4/hashmap_on_disk/hashmapMain_FunsScript.sml
@@ -193,14 +193,6 @@ val hashmap_hash_map_insert_no_resize_fwd_back_def = Define ‘
od
-(** [core::num::u32::{8}::MAX] *)
-Definition core_num_u32_max_body_def:
- core_num_u32_max_body : u32 result = Return (int_to_u32 4294967295)
-End
-Definition core_num_u32_max_c_def:
- core_num_u32_max_c : u32 = get_return_value core_num_u32_max_body
-End
-
val [hashmap_hash_map_move_elements_from_list_loop_fwd_back_def] = DefineDiv ‘
(** [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 ()) *)
@@ -271,7 +263,7 @@ val hashmap_hash_map_try_resize_fwd_back_def = Define ‘
hashmap_hash_map_try_resize_fwd_back
(self : 't hashmap_hash_map_t) : 't hashmap_hash_map_t result =
do
- max_usize <- mk_usize (u32_to_int core_num_u32_max_c);
+ max_usize <- mk_usize (u32_to_int core_u32_max);
let capacity = vec_len self.hashmap_hash_map_slots in
do
n1 <- usize_div max_usize (int_to_usize 2);
diff --git a/tests/hol4/hashmap_on_disk/hashmapMain_FunsTheory.sig b/tests/hol4/hashmap_on_disk/hashmapMain_FunsTheory.sig
index 1d24cb26..d4e43d9a 100644
--- a/tests/hol4/hashmap_on_disk/hashmapMain_FunsTheory.sig
+++ b/tests/hol4/hashmap_on_disk/hashmapMain_FunsTheory.sig
@@ -3,8 +3,6 @@ sig
type thm = Thm.thm
(* Definitions *)
- val core_num_u32_max_body_def : thm
- val core_num_u32_max_c_def : thm
val hashmap_hash_key_fwd_def : thm
val hashmap_hash_map_allocate_slots_fwd_def : thm
val hashmap_hash_map_allocate_slots_loop_fwd_def : thm
@@ -50,14 +48,6 @@ sig
(*
[hashmapMain_Opaque] Parent theory of "hashmapMain_Funs"
- [core_num_u32_max_body_def] Definition
-
- ⊢ core_num_u32_max_body = Return (int_to_u32 4294967295)
-
- [core_num_u32_max_c_def] Definition
-
- ⊢ core_num_u32_max_c = get_return_value core_num_u32_max_body
-
[hashmap_hash_key_fwd_def] Definition
⊢ ∀k. hashmap_hash_key_fwd k = Return k
@@ -506,7 +496,7 @@ sig
⊢ ∀self.
hashmap_hash_map_try_resize_fwd_back self =
do
- max_usize <- mk_usize (u32_to_int core_num_u32_max_c);
+ max_usize <- mk_usize (u32_to_int core_u32_max);
capacity <<- vec_len self.hashmap_hash_map_slots;
n1 <- usize_div max_usize (int_to_usize 2);
(i,i0) <<- self.hashmap_hash_map_max_load_factor;
diff --git a/tests/hol4/misc-constants/constantsScript.sml b/tests/hol4/misc-constants/constantsScript.sml
index d589d348..40a319c6 100644
--- a/tests/hol4/misc-constants/constantsScript.sml
+++ b/tests/hol4/misc-constants/constantsScript.sml
@@ -13,17 +13,9 @@ Definition x0_c_def:
x0_c : u32 = get_return_value x0_body
End
-(** [core::num::u32::{8}::MAX] *)
-Definition core_num_u32_max_body_def:
- core_num_u32_max_body : u32 result = Return (int_to_u32 4294967295)
-End
-Definition core_num_u32_max_c_def:
- core_num_u32_max_c : u32 = get_return_value core_num_u32_max_body
-End
-
(** [constants::X1] *)
Definition x1_body_def:
- x1_body : u32 result = Return core_num_u32_max_c
+ x1_body : u32 result = Return core_u32_max
End
Definition x1_c_def:
x1_c : u32 = get_return_value x1_body
diff --git a/tests/hol4/misc-constants/constantsTheory.sig b/tests/hol4/misc-constants/constantsTheory.sig
index 149d7e22..287ad5f5 100644
--- a/tests/hol4/misc-constants/constantsTheory.sig
+++ b/tests/hol4/misc-constants/constantsTheory.sig
@@ -4,8 +4,6 @@ sig
(* Definitions *)
val add_fwd_def : thm
- val core_num_u32_max_body_def : thm
- val core_num_u32_max_c_def : thm
val get_z1_fwd_def : thm
val get_z1_z1_body_def : thm
val get_z1_z1_c_def : thm
@@ -110,14 +108,6 @@ sig
⊢ ∀a b. add_fwd a b = i32_add a b
- [core_num_u32_max_body_def] Definition
-
- ⊢ core_num_u32_max_body = Return (int_to_u32 4294967295)
-
- [core_num_u32_max_c_def] Definition
-
- ⊢ core_num_u32_max_c = get_return_value core_num_u32_max_body
-
[get_z1_fwd_def] Definition
⊢ get_z1_fwd = Return get_z1_z1_c
@@ -321,7 +311,7 @@ sig
[x1_body_def] Definition
- ⊢ x1_body = Return core_num_u32_max_c
+ ⊢ x1_body = Return core_u32_max
[x1_c_def] Definition
diff --git a/tests/lean/Array.lean b/tests/lean/Array.lean
index 277b63d9..20f02e97 100644
--- a/tests/lean/Array.lean
+++ b/tests/lean/Array.lean
@@ -1 +1,435 @@
-import Array.Funs
+-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
+-- [array]
+import Base
+open Primitives
+
+namespace array
+
+/- [array::AB] -/
+inductive AB :=
+| A : AB
+| B : AB
+
+/- [array::incr]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def incr (x : U32) : Result U32 :=
+ x + 1#u32
+
+/- [array::array_to_shared_slice_]: forward function -/
+def array_to_shared_slice_
+ (T : Type) (s : Array T 32#usize) : Result (Slice T) :=
+ Array.to_slice T 32#usize s
+
+/- [array::array_to_mut_slice_]: forward function -/
+def array_to_mut_slice_ (T : Type) (s : Array T 32#usize) : Result (Slice T) :=
+ Array.to_slice T 32#usize s
+
+/- [array::array_to_mut_slice_]: backward function 0 -/
+def array_to_mut_slice__back
+ (T : Type) (s : Array T 32#usize) (ret0 : Slice T) :
+ Result (Array T 32#usize)
+ :=
+ Array.from_slice T 32#usize s ret0
+
+/- [array::array_len]: forward function -/
+def array_len (T : Type) (s : Array T 32#usize) : Result Usize :=
+ do
+ let s0 ← Array.to_slice T 32#usize s
+ let i := Slice.len T s0
+ Result.ret i
+
+/- [array::shared_array_len]: forward function -/
+def shared_array_len (T : Type) (s : Array T 32#usize) : Result Usize :=
+ do
+ let s0 ← Array.to_slice T 32#usize s
+ let i := Slice.len T s0
+ Result.ret i
+
+/- [array::shared_slice_len]: forward function -/
+def shared_slice_len (T : Type) (s : Slice T) : Result Usize :=
+ let i := Slice.len T s
+ Result.ret i
+
+/- [array::index_array_shared]: forward function -/
+def index_array_shared
+ (T : Type) (s : Array T 32#usize) (i : Usize) : Result T :=
+ Array.index_usize T 32#usize s i
+
+/- [array::index_array_u32]: forward function -/
+def index_array_u32 (s : Array U32 32#usize) (i : Usize) : Result U32 :=
+ Array.index_usize U32 32#usize s i
+
+/- [array::index_array_copy]: forward function -/
+def index_array_copy (x : Array U32 32#usize) : Result U32 :=
+ Array.index_usize U32 32#usize x 0#usize
+
+/- [array::index_mut_array]: forward function -/
+def index_mut_array (T : Type) (s : Array T 32#usize) (i : Usize) : Result T :=
+ Array.index_usize T 32#usize s i
+
+/- [array::index_mut_array]: backward function 0 -/
+def index_mut_array_back
+ (T : Type) (s : Array T 32#usize) (i : Usize) (ret0 : T) :
+ Result (Array T 32#usize)
+ :=
+ Array.update_usize T 32#usize s i ret0
+
+/- [array::index_slice]: forward function -/
+def index_slice (T : Type) (s : Slice T) (i : Usize) : Result T :=
+ Slice.index_usize T s i
+
+/- [array::index_mut_slice]: forward function -/
+def index_mut_slice (T : Type) (s : Slice T) (i : Usize) : Result T :=
+ Slice.index_usize T s i
+
+/- [array::index_mut_slice]: backward function 0 -/
+def index_mut_slice_back
+ (T : Type) (s : Slice T) (i : Usize) (ret0 : T) : Result (Slice T) :=
+ Slice.update_usize T s i ret0
+
+/- [array::slice_subslice_shared_]: forward function -/
+def slice_subslice_shared_
+ (x : Slice U32) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ 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 -/
+def slice_subslice_mut_
+ (x : Slice U32) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.slice.index.Slice.index_mut U32 (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32) x
+ { start := y, end_ := z }
+
+/- [array::slice_subslice_mut_]: backward function 0 -/
+def slice_subslice_mut__back
+ (x : Slice U32) (y : Usize) (z : Usize) (ret0 : Slice U32) :
+ Result (Slice U32)
+ :=
+ core.slice.index.Slice.index_mut_back U32 (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32) x
+ { start := y, end_ := z } ret0
+
+/- [array::array_to_slice_shared_]: forward function -/
+def array_to_slice_shared_ (x : Array U32 32#usize) : Result (Slice U32) :=
+ Array.to_slice U32 32#usize x
+
+/- [array::array_to_slice_mut_]: forward function -/
+def array_to_slice_mut_ (x : Array U32 32#usize) : Result (Slice U32) :=
+ Array.to_slice U32 32#usize x
+
+/- [array::array_to_slice_mut_]: backward function 0 -/
+def array_to_slice_mut__back
+ (x : Array U32 32#usize) (ret0 : Slice U32) : Result (Array U32 32#usize) :=
+ Array.from_slice U32 32#usize x ret0
+
+/- [array::array_subslice_shared_]: forward function -/
+def array_subslice_shared_
+ (x : Array U32 32#usize) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.array.Array.index U32 (core.ops.range.Range Usize) 32#usize
+ (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 -/
+def array_subslice_mut_
+ (x : Array U32 32#usize) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.array.Array.index_mut U32 (core.ops.range.Range Usize) 32#usize
+ (core.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 -/
+def array_subslice_mut__back
+ (x : Array U32 32#usize) (y : Usize) (z : Usize) (ret0 : Slice U32) :
+ Result (Array U32 32#usize)
+ :=
+ core.array.Array.index_mut_back U32 (core.ops.range.Range Usize) 32#usize
+ (core.slice.index.Slice.coreopsindexIndexMutInst U32 (core.ops.range.Range
+ Usize) (core.slice.index.Range.coresliceindexSliceIndexInst U32)) x
+ { start := y, end_ := z } ret0
+
+/- [array::index_slice_0]: forward function -/
+def index_slice_0 (T : Type) (s : Slice T) : Result T :=
+ Slice.index_usize T s 0#usize
+
+/- [array::index_array_0]: forward function -/
+def index_array_0 (T : Type) (s : Array T 32#usize) : Result T :=
+ Array.index_usize T 32#usize s 0#usize
+
+/- [array::index_index_array]: forward function -/
+def index_index_array
+ (s : Array (Array U32 32#usize) 32#usize) (i : Usize) (j : Usize) :
+ Result U32
+ :=
+ do
+ let a ← Array.index_usize (Array U32 32#usize) 32#usize s i
+ Array.index_usize U32 32#usize a j
+
+/- [array::update_update_array]: forward function -/
+def update_update_array
+ (s : Array (Array U32 32#usize) 32#usize) (i : Usize) (j : Usize) :
+ Result Unit
+ :=
+ do
+ let a ← Array.index_usize (Array U32 32#usize) 32#usize s i
+ let a0 ← Array.update_usize U32 32#usize a j 0#u32
+ let _ ← Array.update_usize (Array U32 32#usize) 32#usize s i a0
+ Result.ret ()
+
+/- [array::array_local_deep_copy]: forward function -/
+def array_local_deep_copy (x : Array U32 32#usize) : Result Unit :=
+ Result.ret ()
+
+/- [array::take_array]: forward function -/
+def take_array (a : Array U32 2#usize) : Result Unit :=
+ Result.ret ()
+
+/- [array::take_array_borrow]: forward function -/
+def take_array_borrow (a : Array U32 2#usize) : Result Unit :=
+ Result.ret ()
+
+/- [array::take_slice]: forward function -/
+def take_slice (s : Slice U32) : Result Unit :=
+ Result.ret ()
+
+/- [array::take_mut_slice]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def take_mut_slice (s : Slice U32) : Result (Slice U32) :=
+ Result.ret s
+
+/- [array::take_all]: forward function -/
+def take_all : Result Unit :=
+ do
+ let _ ← take_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let _ ← take_array_borrow (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let s ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let _ ← take_slice s
+ let s0 ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let s1 ← take_mut_slice s0
+ let _ ←
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s1
+ Result.ret ()
+
+/- [array::index_array]: forward function -/
+def index_array (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
+
+/- [array::index_array_borrow]: forward function -/
+def index_array_borrow (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
+
+/- [array::index_slice_u32_0]: forward function -/
+def index_slice_u32_0 (x : Slice U32) : Result U32 :=
+ Slice.index_usize U32 x 0#usize
+
+/- [array::index_mut_slice_u32_0]: forward function -/
+def index_mut_slice_u32_0 (x : Slice U32) : Result U32 :=
+ Slice.index_usize U32 x 0#usize
+
+/- [array::index_mut_slice_u32_0]: backward function 0 -/
+def index_mut_slice_u32_0_back (x : Slice U32) : Result (Slice U32) :=
+ do
+ let _ ← Slice.index_usize U32 x 0#usize
+ Result.ret x
+
+/- [array::index_all]: forward function -/
+def index_all : Result U32 :=
+ do
+ let i ← index_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let i0 ← index_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let i1 ← i + i0
+ let i2 ← index_array_borrow (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let i3 ← i1 + i2
+ let s ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let i4 ← index_slice_u32_0 s
+ let i5 ← i3 + i4
+ let s0 ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let i6 ← index_mut_slice_u32_0 s0
+ let i7 ← i5 + i6
+ let s1 ← index_mut_slice_u32_0_back s0
+ let _ ←
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s1
+ Result.ret i7
+
+/- [array::update_array]: forward function -/
+def update_array (x : Array U32 2#usize) : Result Unit :=
+ do
+ let _ ← Array.update_usize U32 2#usize x 0#usize 1#u32
+ Result.ret ()
+
+/- [array::update_array_mut_borrow]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def update_array_mut_borrow
+ (x : Array U32 2#usize) : Result (Array U32 2#usize) :=
+ Array.update_usize U32 2#usize x 0#usize 1#u32
+
+/- [array::update_mut_slice]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def update_mut_slice (x : Slice U32) : Result (Slice U32) :=
+ Slice.update_usize U32 x 0#usize 1#u32
+
+/- [array::update_all]: forward function -/
+def update_all : Result Unit :=
+ do
+ let _ ← update_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let x ← update_array_mut_borrow (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let s ← Array.to_slice U32 2#usize x
+ let s0 ← update_mut_slice s
+ let _ ← Array.from_slice U32 2#usize x s0
+ Result.ret ()
+
+/- [array::range_all]: forward function -/
+def range_all : Result Unit :=
+ do
+ let s ←
+ core.array.Array.index_mut U32 (core.ops.range.Range Usize) 4#usize
+ (core.slice.index.Slice.coreopsindexIndexMutInst U32
+ (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32))
+ (Array.make U32 4#usize [ 0#u32, 0#u32, 0#u32, 0#u32 ])
+ { start := 1#usize, end_ := 3#usize }
+ let s0 ← update_mut_slice s
+ let _ ←
+ core.array.Array.index_mut_back U32 (core.ops.range.Range Usize) 4#usize
+ (core.slice.index.Slice.coreopsindexIndexMutInst U32
+ (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32))
+ (Array.make U32 4#usize [ 0#u32, 0#u32, 0#u32, 0#u32 ])
+ { start := 1#usize, end_ := 3#usize } s0
+ Result.ret ()
+
+/- [array::deref_array_borrow]: forward function -/
+def deref_array_borrow (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
+
+/- [array::deref_array_mut_borrow]: forward function -/
+def deref_array_mut_borrow (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
+
+/- [array::deref_array_mut_borrow]: backward function 0 -/
+def deref_array_mut_borrow_back
+ (x : Array U32 2#usize) : Result (Array U32 2#usize) :=
+ do
+ let _ ← Array.index_usize U32 2#usize x 0#usize
+ Result.ret x
+
+/- [array::take_array_t]: forward function -/
+def take_array_t (a : Array AB 2#usize) : Result Unit :=
+ Result.ret ()
+
+/- [array::non_copyable_array]: forward function -/
+def non_copyable_array : Result Unit :=
+ do
+ let _ ← take_array_t (Array.make AB 2#usize [ AB.A, AB.B ])
+ Result.ret ()
+
+/- [array::sum]: loop 0: forward function -/
+divergent def sum_loop (s : Slice U32) (sum0 : U32) (i : Usize) : Result U32 :=
+ let i0 := Slice.len U32 s
+ if i < i0
+ then
+ do
+ let i1 ← Slice.index_usize U32 s i
+ let sum1 ← sum0 + i1
+ let i2 ← i + 1#usize
+ sum_loop s sum1 i2
+ else Result.ret sum0
+
+/- [array::sum]: forward function -/
+def sum (s : Slice U32) : Result U32 :=
+ sum_loop s 0#u32 0#usize
+
+/- [array::sum2]: loop 0: forward function -/
+divergent def sum2_loop
+ (s : Slice U32) (s2 : Slice U32) (sum0 : U32) (i : Usize) : Result U32 :=
+ let i0 := Slice.len U32 s
+ if i < i0
+ then
+ do
+ let i1 ← Slice.index_usize U32 s i
+ let i2 ← Slice.index_usize U32 s2 i
+ let i3 ← i1 + i2
+ let sum1 ← sum0 + i3
+ let i4 ← i + 1#usize
+ sum2_loop s s2 sum1 i4
+ else Result.ret sum0
+
+/- [array::sum2]: forward function -/
+def sum2 (s : Slice U32) (s2 : Slice U32) : Result U32 :=
+ let i := Slice.len U32 s
+ let i0 := Slice.len U32 s2
+ if not (i = i0)
+ then Result.fail Error.panic
+ else sum2_loop s s2 0#u32 0#usize
+
+/- [array::f0]: forward function -/
+def f0 : Result Unit :=
+ do
+ let s ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ let s0 ← Slice.update_usize U32 s 0#usize 1#u32
+ let _ ←
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ]) s0
+ Result.ret ()
+
+/- [array::f1]: forward function -/
+def f1 : Result Unit :=
+ do
+ let _ ←
+ Array.update_usize U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ 0#usize 1#u32
+ Result.ret ()
+
+/- [array::f2]: forward function -/
+def f2 (i : U32) : Result Unit :=
+ Result.ret ()
+
+/- [array::f4]: forward function -/
+def f4 (x : Array U32 32#usize) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.array.Array.index U32 (core.ops.range.Range Usize) 32#usize
+ (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 -/
+def f3 : Result U32 :=
+ do
+ let i ←
+ Array.index_usize U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ 0#usize
+ let _ ← f2 i
+ let b := Array.repeat U32 32#usize 0#u32
+ let s ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ let s0 ← f4 b 16#usize 18#usize
+ sum2 s s0
+
+/- [array::SZ] -/
+def sz_body : Result Usize := Result.ret 32#usize
+def sz_c : Usize := eval_global sz_body (by simp)
+
+/- [array::f5]: forward function -/
+def f5 (x : Array U32 32#usize) : Result U32 :=
+ Array.index_usize U32 32#usize x 0#usize
+
+/- [array::ite]: forward function -/
+def ite : Result Unit :=
+ do
+ let s ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let s0 ←
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let s1 ← index_mut_slice_u32_0_back s0
+ let _ ←
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s1
+ let s2 ← index_mut_slice_u32_0_back s
+ let _ ←
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s2
+ Result.ret ()
+
+end array
diff --git a/tests/lean/Array/Funs.lean b/tests/lean/Array/Funs.lean
index ad737dca..32ae6248 100644
--- a/tests/lean/Array/Funs.lean
+++ b/tests/lean/Array/Funs.lean
@@ -6,189 +6,183 @@ open Primitives
namespace array
+/- [array::incr]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def incr (x : U32) : Result U32 :=
+ x + 1#u32
+
/- [array::array_to_shared_slice_]: forward function -/
def array_to_shared_slice_
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) : Result (Slice T0) :=
- Array.to_slice_shared T0 (Usize.ofInt 32) s
+ (T : Type) (s : Array T 32#usize) : Result (Slice T) :=
+ Array.to_slice T 32#usize s
/- [array::array_to_mut_slice_]: forward function -/
-def array_to_mut_slice_
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) : Result (Slice T0) :=
- Array.to_slice_mut T0 (Usize.ofInt 32) s
+def array_to_mut_slice_ (T : Type) (s : Array T 32#usize) : Result (Slice T) :=
+ Array.to_slice T 32#usize s
/- [array::array_to_mut_slice_]: backward function 0 -/
def array_to_mut_slice__back
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) (ret0 : Slice T0) :
- Result (Array T0 (Usize.ofInt 32))
+ (T : Type) (s : Array T 32#usize) (ret0 : Slice T) :
+ Result (Array T 32#usize)
:=
- Array.to_slice_mut_back T0 (Usize.ofInt 32) s ret0
+ Array.from_slice T 32#usize s ret0
/- [array::array_len]: forward function -/
-def array_len (T0 : Type) (s : Array T0 (Usize.ofInt 32)) : Result Usize :=
+def array_len (T : Type) (s : Array T 32#usize) : Result Usize :=
do
- let s0 ← Array.to_slice_shared T0 (Usize.ofInt 32) s
- let i := Slice.len T0 s0
+ let s0 ← Array.to_slice T 32#usize s
+ let i := Slice.len T s0
Result.ret i
/- [array::shared_array_len]: forward function -/
-def shared_array_len
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) : Result Usize :=
+def shared_array_len (T : Type) (s : Array T 32#usize) : Result Usize :=
do
- let s0 ← Array.to_slice_shared T0 (Usize.ofInt 32) s
- let i := Slice.len T0 s0
+ let s0 ← Array.to_slice T 32#usize s
+ let i := Slice.len T s0
Result.ret i
/- [array::shared_slice_len]: forward function -/
-def shared_slice_len (T0 : Type) (s : Slice T0) : Result Usize :=
- let i := Slice.len T0 s
+def shared_slice_len (T : Type) (s : Slice T) : Result Usize :=
+ let i := Slice.len T s
Result.ret i
/- [array::index_array_shared]: forward function -/
def index_array_shared
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) (i : Usize) : Result T0 :=
- Array.index_shared T0 (Usize.ofInt 32) s i
+ (T : Type) (s : Array T 32#usize) (i : Usize) : Result T :=
+ Array.index_usize T 32#usize s i
/- [array::index_array_u32]: forward function -/
-def index_array_u32
- (s : Array U32 (Usize.ofInt 32)) (i : Usize) : Result U32 :=
- Array.index_shared U32 (Usize.ofInt 32) s i
-
-/- [array::index_array_generic]: forward function -/
-def index_array_generic
- (N : Usize) (s : Array U32 N) (i : Usize) : Result U32 :=
- Array.index_shared U32 N s i
-
-/- [array::index_array_generic_call]: forward function -/
-def index_array_generic_call
- (N : Usize) (s : Array U32 N) (i : Usize) : Result U32 :=
- index_array_generic N s i
+def index_array_u32 (s : Array U32 32#usize) (i : Usize) : Result U32 :=
+ Array.index_usize U32 32#usize s i
/- [array::index_array_copy]: forward function -/
-def index_array_copy (x : Array U32 (Usize.ofInt 32)) : Result U32 :=
- Array.index_shared U32 (Usize.ofInt 32) x (Usize.ofInt 0)
+def index_array_copy (x : Array U32 32#usize) : Result U32 :=
+ Array.index_usize U32 32#usize x 0#usize
/- [array::index_mut_array]: forward function -/
-def index_mut_array
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) (i : Usize) : Result T0 :=
- Array.index_mut T0 (Usize.ofInt 32) s i
+def index_mut_array (T : Type) (s : Array T 32#usize) (i : Usize) : Result T :=
+ Array.index_usize T 32#usize s i
/- [array::index_mut_array]: backward function 0 -/
def index_mut_array_back
- (T0 : Type) (s : Array T0 (Usize.ofInt 32)) (i : Usize) (ret0 : T0) :
- Result (Array T0 (Usize.ofInt 32))
+ (T : Type) (s : Array T 32#usize) (i : Usize) (ret0 : T) :
+ Result (Array T 32#usize)
:=
- Array.index_mut_back T0 (Usize.ofInt 32) s i ret0
+ Array.update_usize T 32#usize s i ret0
/- [array::index_slice]: forward function -/
-def index_slice (T0 : Type) (s : Slice T0) (i : Usize) : Result T0 :=
- Slice.index_shared T0 s i
+def index_slice (T : Type) (s : Slice T) (i : Usize) : Result T :=
+ Slice.index_usize T s i
/- [array::index_mut_slice]: forward function -/
-def index_mut_slice (T0 : Type) (s : Slice T0) (i : Usize) : Result T0 :=
- Slice.index_mut T0 s i
+def index_mut_slice (T : Type) (s : Slice T) (i : Usize) : Result T :=
+ Slice.index_usize T s i
/- [array::index_mut_slice]: backward function 0 -/
def index_mut_slice_back
- (T0 : Type) (s : Slice T0) (i : Usize) (ret0 : T0) : Result (Slice T0) :=
- Slice.index_mut_back T0 s i ret0
+ (T : Type) (s : Slice T) (i : Usize) (ret0 : T) : Result (Slice T) :=
+ Slice.update_usize T s i ret0
/- [array::slice_subslice_shared_]: forward function -/
def slice_subslice_shared_
(x : Slice U32) (y : Usize) (z : Usize) : Result (Slice U32) :=
- Slice.subslice_shared U32 x (Range.mk 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 -/
def slice_subslice_mut_
(x : Slice U32) (y : Usize) (z : Usize) : Result (Slice U32) :=
- Slice.subslice_mut U32 x (Range.mk 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 -/
def slice_subslice_mut__back
(x : Slice U32) (y : Usize) (z : Usize) (ret0 : Slice U32) :
Result (Slice U32)
:=
- Slice.subslice_mut_back U32 x (Range.mk y z) ret0
+ core.slice.index.Slice.index_mut_back U32 (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32) x
+ { start := y, end_ := z } ret0
/- [array::array_to_slice_shared_]: forward function -/
-def array_to_slice_shared_
- (x : Array U32 (Usize.ofInt 32)) : Result (Slice U32) :=
- Array.to_slice_shared U32 (Usize.ofInt 32) x
+def array_to_slice_shared_ (x : Array U32 32#usize) : Result (Slice U32) :=
+ Array.to_slice U32 32#usize x
/- [array::array_to_slice_mut_]: forward function -/
-def array_to_slice_mut_
- (x : Array U32 (Usize.ofInt 32)) : Result (Slice U32) :=
- Array.to_slice_mut U32 (Usize.ofInt 32) x
+def array_to_slice_mut_ (x : Array U32 32#usize) : Result (Slice U32) :=
+ Array.to_slice U32 32#usize x
/- [array::array_to_slice_mut_]: backward function 0 -/
def array_to_slice_mut__back
- (x : Array U32 (Usize.ofInt 32)) (ret0 : Slice U32) :
- Result (Array U32 (Usize.ofInt 32))
- :=
- Array.to_slice_mut_back U32 (Usize.ofInt 32) x ret0
+ (x : Array U32 32#usize) (ret0 : Slice U32) : Result (Array U32 32#usize) :=
+ Array.from_slice U32 32#usize x ret0
/- [array::array_subslice_shared_]: forward function -/
def array_subslice_shared_
- (x : Array U32 (Usize.ofInt 32)) (y : Usize) (z : Usize) :
- Result (Slice U32)
- :=
- Array.subslice_shared U32 (Usize.ofInt 32) x (Range.mk y z)
+ (x : Array U32 32#usize) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.array.Array.index U32 (core.ops.range.Range Usize) 32#usize
+ (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 -/
def array_subslice_mut_
- (x : Array U32 (Usize.ofInt 32)) (y : Usize) (z : Usize) :
- Result (Slice U32)
- :=
- Array.subslice_mut U32 (Usize.ofInt 32) x (Range.mk y z)
+ (x : Array U32 32#usize) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.array.Array.index_mut U32 (core.ops.range.Range Usize) 32#usize
+ (core.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 -/
def array_subslice_mut__back
- (x : Array U32 (Usize.ofInt 32)) (y : Usize) (z : Usize) (ret0 : Slice U32) :
- Result (Array U32 (Usize.ofInt 32))
+ (x : Array U32 32#usize) (y : Usize) (z : Usize) (ret0 : Slice U32) :
+ Result (Array U32 32#usize)
:=
- Array.subslice_mut_back U32 (Usize.ofInt 32) x (Range.mk y z) ret0
+ core.array.Array.index_mut_back U32 (core.ops.range.Range Usize) 32#usize
+ (core.slice.index.Slice.coreopsindexIndexMutInst U32 (core.ops.range.Range
+ Usize) (core.slice.index.Range.coresliceindexSliceIndexInst U32)) x
+ { start := y, end_ := z } ret0
/- [array::index_slice_0]: forward function -/
-def index_slice_0 (T0 : Type) (s : Slice T0) : Result T0 :=
- Slice.index_shared T0 s (Usize.ofInt 0)
+def index_slice_0 (T : Type) (s : Slice T) : Result T :=
+ Slice.index_usize T s 0#usize
/- [array::index_array_0]: forward function -/
-def index_array_0 (T0 : Type) (s : Array T0 (Usize.ofInt 32)) : Result T0 :=
- Array.index_shared T0 (Usize.ofInt 32) s (Usize.ofInt 0)
+def index_array_0 (T : Type) (s : Array T 32#usize) : Result T :=
+ Array.index_usize T 32#usize s 0#usize
/- [array::index_index_array]: forward function -/
def index_index_array
- (s : Array (Array U32 (Usize.ofInt 32)) (Usize.ofInt 32)) (i : Usize)
- (j : Usize) :
+ (s : Array (Array U32 32#usize) 32#usize) (i : Usize) (j : Usize) :
Result U32
:=
do
- let a ←
- Array.index_shared (Array U32 (Usize.ofInt 32)) (Usize.ofInt 32) s i
- Array.index_shared U32 (Usize.ofInt 32) a j
+ let a ← Array.index_usize (Array U32 32#usize) 32#usize s i
+ Array.index_usize U32 32#usize a j
/- [array::update_update_array]: forward function -/
def update_update_array
- (s : Array (Array U32 (Usize.ofInt 32)) (Usize.ofInt 32)) (i : Usize)
- (j : Usize) :
+ (s : Array (Array U32 32#usize) 32#usize) (i : Usize) (j : Usize) :
Result Unit
:=
do
- let a ← Array.index_mut (Array U32 (Usize.ofInt 32)) (Usize.ofInt 32) s i
- let a0 ← Array.index_mut_back U32 (Usize.ofInt 32) a j (U32.ofInt 0)
- let _ ←
- Array.index_mut_back (Array U32 (Usize.ofInt 32)) (Usize.ofInt 32) s i a0
+ let a ← Array.index_usize (Array U32 32#usize) 32#usize s i
+ let a0 ← Array.update_usize U32 32#usize a j 0#u32
+ let _ ← Array.update_usize (Array U32 32#usize) 32#usize s i a0
Result.ret ()
/- [array::array_local_deep_copy]: forward function -/
-def array_local_deep_copy (x : Array U32 (Usize.ofInt 32)) : Result Unit :=
+def array_local_deep_copy (x : Array U32 32#usize) : Result Unit :=
Result.ret ()
/- [array::take_array]: forward function -/
-def take_array (a : Array U32 (Usize.ofInt 2)) : Result Unit :=
+def take_array (a : Array U32 2#usize) : Result Unit :=
Result.ret ()
/- [array::take_array_borrow]: forward function -/
-def take_array_borrow (a : Array U32 (Usize.ofInt 2)) : Result Unit :=
+def take_array_borrow (a : Array U32 2#usize) : Result Unit :=
Result.ret ()
/- [array::take_slice]: forward function -/
@@ -203,148 +197,131 @@ def take_mut_slice (s : Slice U32) : Result (Slice U32) :=
/- [array::take_all]: forward function -/
def take_all : Result Unit :=
do
- let _ ←
- take_array
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
- let _ ←
- take_array_borrow
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ let _ ← take_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let _ ← take_array_borrow (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let s ←
- Array.to_slice_shared U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let _ ← take_slice s
let s0 ←
- Array.to_slice_mut U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let s1 ← take_mut_slice s0
let _ ←
- Array.to_slice_mut_back U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ]) s1
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s1
Result.ret ()
/- [array::index_array]: forward function -/
-def index_array (x : Array U32 (Usize.ofInt 2)) : Result U32 :=
- Array.index_shared U32 (Usize.ofInt 2) x (Usize.ofInt 0)
+def index_array (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
/- [array::index_array_borrow]: forward function -/
-def index_array_borrow (x : Array U32 (Usize.ofInt 2)) : Result U32 :=
- Array.index_shared U32 (Usize.ofInt 2) x (Usize.ofInt 0)
+def index_array_borrow (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
/- [array::index_slice_u32_0]: forward function -/
def index_slice_u32_0 (x : Slice U32) : Result U32 :=
- Slice.index_shared U32 x (Usize.ofInt 0)
+ Slice.index_usize U32 x 0#usize
/- [array::index_mut_slice_u32_0]: forward function -/
def index_mut_slice_u32_0 (x : Slice U32) : Result U32 :=
- Slice.index_shared U32 x (Usize.ofInt 0)
+ Slice.index_usize U32 x 0#usize
/- [array::index_mut_slice_u32_0]: backward function 0 -/
def index_mut_slice_u32_0_back (x : Slice U32) : Result (Slice U32) :=
do
- let _ ← Slice.index_shared U32 x (Usize.ofInt 0)
+ let _ ← Slice.index_usize U32 x 0#usize
Result.ret x
/- [array::index_all]: forward function -/
def index_all : Result U32 :=
do
- let i ←
- index_array
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
- let i0 ←
- index_array
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ let i ← index_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let i0 ← index_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let i1 ← i + i0
- let i2 ←
- index_array_borrow
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ let i2 ← index_array_borrow (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let i3 ← i1 + i2
let s ←
- Array.to_slice_shared U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let i4 ← index_slice_u32_0 s
let i5 ← i3 + i4
let s0 ←
- Array.to_slice_mut U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let i6 ← index_mut_slice_u32_0 s0
let i7 ← i5 + i6
let s1 ← index_mut_slice_u32_0_back s0
let _ ←
- Array.to_slice_mut_back U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ]) s1
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s1
Result.ret i7
/- [array::update_array]: forward function -/
-def update_array (x : Array U32 (Usize.ofInt 2)) : Result Unit :=
+def update_array (x : Array U32 2#usize) : Result Unit :=
do
- let _ ←
- Array.index_mut_back U32 (Usize.ofInt 2) x (Usize.ofInt 0) (U32.ofInt 1)
+ let _ ← Array.update_usize U32 2#usize x 0#usize 1#u32
Result.ret ()
/- [array::update_array_mut_borrow]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def update_array_mut_borrow
- (x : Array U32 (Usize.ofInt 2)) : Result (Array U32 (Usize.ofInt 2)) :=
- Array.index_mut_back U32 (Usize.ofInt 2) x (Usize.ofInt 0) (U32.ofInt 1)
+ (x : Array U32 2#usize) : Result (Array U32 2#usize) :=
+ Array.update_usize U32 2#usize x 0#usize 1#u32
/- [array::update_mut_slice]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def update_mut_slice (x : Slice U32) : Result (Slice U32) :=
- Slice.index_mut_back U32 x (Usize.ofInt 0) (U32.ofInt 1)
+ Slice.update_usize U32 x 0#usize 1#u32
/- [array::update_all]: forward function -/
def update_all : Result Unit :=
do
- let _ ←
- update_array
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
- let x ←
- update_array_mut_borrow
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
- let s ← Array.to_slice_mut U32 (Usize.ofInt 2) x
+ let _ ← update_array (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let x ← update_array_mut_borrow (Array.make U32 2#usize [ 0#u32, 0#u32 ])
+ let s ← Array.to_slice U32 2#usize x
let s0 ← update_mut_slice s
- let _ ← Array.to_slice_mut_back U32 (Usize.ofInt 2) x s0
+ let _ ← Array.from_slice U32 2#usize x s0
Result.ret ()
/- [array::range_all]: forward function -/
def range_all : Result Unit :=
do
let s ←
- Array.subslice_mut U32 (Usize.ofInt 4)
- (Array.make U32 (Usize.ofInt 4) [
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0)
- ]) (Range.mk (Usize.ofInt 1) (Usize.ofInt 3))
+ core.array.Array.index_mut U32 (core.ops.range.Range Usize) 4#usize
+ (core.slice.index.Slice.coreopsindexIndexMutInst U32
+ (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32))
+ (Array.make U32 4#usize [ 0#u32, 0#u32, 0#u32, 0#u32 ])
+ { start := 1#usize, end_ := 3#usize }
let s0 ← update_mut_slice s
let _ ←
- Array.subslice_mut_back U32 (Usize.ofInt 4)
- (Array.make U32 (Usize.ofInt 4) [
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0)
- ]) (Range.mk (Usize.ofInt 1) (Usize.ofInt 3)) s0
+ core.array.Array.index_mut_back U32 (core.ops.range.Range Usize) 4#usize
+ (core.slice.index.Slice.coreopsindexIndexMutInst U32
+ (core.ops.range.Range Usize)
+ (core.slice.index.Range.coresliceindexSliceIndexInst U32))
+ (Array.make U32 4#usize [ 0#u32, 0#u32, 0#u32, 0#u32 ])
+ { start := 1#usize, end_ := 3#usize } s0
Result.ret ()
/- [array::deref_array_borrow]: forward function -/
-def deref_array_borrow (x : Array U32 (Usize.ofInt 2)) : Result U32 :=
- Array.index_shared U32 (Usize.ofInt 2) x (Usize.ofInt 0)
+def deref_array_borrow (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
/- [array::deref_array_mut_borrow]: forward function -/
-def deref_array_mut_borrow (x : Array U32 (Usize.ofInt 2)) : Result U32 :=
- Array.index_shared U32 (Usize.ofInt 2) x (Usize.ofInt 0)
+def deref_array_mut_borrow (x : Array U32 2#usize) : Result U32 :=
+ Array.index_usize U32 2#usize x 0#usize
/- [array::deref_array_mut_borrow]: backward function 0 -/
def deref_array_mut_borrow_back
- (x : Array U32 (Usize.ofInt 2)) : Result (Array U32 (Usize.ofInt 2)) :=
+ (x : Array U32 2#usize) : Result (Array U32 2#usize) :=
do
- let _ ← Array.index_shared U32 (Usize.ofInt 2) x (Usize.ofInt 0)
+ let _ ← Array.index_usize U32 2#usize x 0#usize
Result.ret x
/- [array::take_array_t]: forward function -/
-def take_array_t (a : Array T (Usize.ofInt 2)) : Result Unit :=
+def take_array_t (a : Array AB 2#usize) : Result Unit :=
Result.ret ()
/- [array::non_copyable_array]: forward function -/
def non_copyable_array : Result Unit :=
do
- let _ ← take_array_t (Array.make T (Usize.ofInt 2) [ T.A, T.B ])
+ let _ ← take_array_t (Array.make AB 2#usize [ AB.A, AB.B ])
Result.ret ()
/- [array::sum]: loop 0: forward function -/
@@ -353,15 +330,15 @@ divergent def sum_loop (s : Slice U32) (sum0 : U32) (i : Usize) : Result U32 :=
if i < i0
then
do
- let i1 ← Slice.index_shared U32 s i
+ let i1 ← Slice.index_usize U32 s i
let sum1 ← sum0 + i1
- let i2 ← i + (Usize.ofInt 1)
+ let i2 ← i + 1#usize
sum_loop s sum1 i2
else Result.ret sum0
/- [array::sum]: forward function -/
def sum (s : Slice U32) : Result U32 :=
- sum_loop s (U32.ofInt 0) (Usize.ofInt 0)
+ sum_loop s 0#u32 0#usize
/- [array::sum2]: loop 0: forward function -/
divergent def sum2_loop
@@ -370,11 +347,11 @@ divergent def sum2_loop
if i < i0
then
do
- let i1 ← Slice.index_shared U32 s i
- let i2 ← Slice.index_shared U32 s2 i
+ let i1 ← Slice.index_usize U32 s i
+ let i2 ← Slice.index_usize U32 s2 i
let i3 ← i1 + i2
let sum1 ← sum0 + i3
- let i4 ← i + (Usize.ofInt 1)
+ let i4 ← i + 1#usize
sum2_loop s s2 sum1 i4
else Result.ret sum0
@@ -384,27 +361,24 @@ def sum2 (s : Slice U32) (s2 : Slice U32) : Result U32 :=
let i0 := Slice.len U32 s2
if not (i = i0)
then Result.fail Error.panic
- else sum2_loop s s2 (U32.ofInt 0) (Usize.ofInt 0)
+ else sum2_loop s s2 0#u32 0#usize
/- [array::f0]: forward function -/
def f0 : Result Unit :=
do
let s ←
- Array.to_slice_mut U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 1), (U32.ofInt 2) ])
- let s0 ← Slice.index_mut_back U32 s (Usize.ofInt 0) (U32.ofInt 1)
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ let s0 ← Slice.update_usize U32 s 0#usize 1#u32
let _ ←
- Array.to_slice_mut_back U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 1), (U32.ofInt 2) ]) s0
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ]) s0
Result.ret ()
/- [array::f1]: forward function -/
def f1 : Result Unit :=
do
let _ ←
- Array.index_mut_back U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 1), (U32.ofInt 2) ])
- (Usize.ofInt 0) (U32.ofInt 1)
+ Array.update_usize U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ 0#usize 1#u32
Result.ret ()
/- [array::f2]: forward function -/
@@ -412,54 +386,46 @@ def f2 (i : U32) : Result Unit :=
Result.ret ()
/- [array::f4]: forward function -/
-def f4
- (x : Array U32 (Usize.ofInt 32)) (y : Usize) (z : Usize) :
- Result (Slice U32)
- :=
- Array.subslice_shared U32 (Usize.ofInt 32) x (Range.mk y z)
+def f4 (x : Array U32 32#usize) (y : Usize) (z : Usize) : Result (Slice U32) :=
+ core.array.Array.index U32 (core.ops.range.Range Usize) 32#usize
+ (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 -/
def f3 : Result U32 :=
do
let i ←
- Array.index_shared U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 1), (U32.ofInt 2) ])
- (Usize.ofInt 0)
+ Array.index_usize U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ 0#usize
let _ ← f2 i
+ let b := Array.repeat U32 32#usize 0#u32
let s ←
- Array.to_slice_shared U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 1), (U32.ofInt 2) ])
- let s0 ←
- f4
- (Array.make U32 (Usize.ofInt 32) [
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0),
- (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0), (U32.ofInt 0)
- ]) (Usize.ofInt 16) (Usize.ofInt 18)
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 1#u32, 2#u32 ])
+ let s0 ← f4 b 16#usize 18#usize
sum2 s s0
+/- [array::SZ] -/
+def sz_body : Result Usize := Result.ret 32#usize
+def sz_c : Usize := eval_global sz_body (by simp)
+
+/- [array::f5]: forward function -/
+def f5 (x : Array U32 32#usize) : Result U32 :=
+ Array.index_usize U32 32#usize x 0#usize
+
/- [array::ite]: forward function -/
def ite : Result Unit :=
do
let s ←
- Array.to_slice_mut U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let s0 ←
- Array.to_slice_mut U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ])
+ Array.to_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ])
let s1 ← index_mut_slice_u32_0_back s0
let _ ←
- Array.to_slice_mut_back U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ]) s1
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s1
let s2 ← index_mut_slice_u32_0_back s
let _ ←
- Array.to_slice_mut_back U32 (Usize.ofInt 2)
- (Array.make U32 (Usize.ofInt 2) [ (U32.ofInt 0), (U32.ofInt 0) ]) s2
+ Array.from_slice U32 2#usize (Array.make U32 2#usize [ 0#u32, 0#u32 ]) s2
Result.ret ()
end array
diff --git a/tests/lean/Array/Types.lean b/tests/lean/Array/Types.lean
index 72241276..60fa81ab 100644
--- a/tests/lean/Array/Types.lean
+++ b/tests/lean/Array/Types.lean
@@ -5,9 +5,9 @@ open Primitives
namespace array
-/- [array::T] -/
-inductive T :=
-| A : T
-| B : T
+/- [array::AB] -/
+inductive AB :=
+| A : AB
+| B : AB
end array
diff --git a/tests/lean/BetreeMain/Funs.lean b/tests/lean/BetreeMain/Funs.lean
index 07ef08dc..0901d449 100644
--- a/tests/lean/BetreeMain/Funs.lean
+++ b/tests/lean/BetreeMain/Funs.lean
@@ -40,77 +40,71 @@ def betree.store_leaf_node
/- [betree_main::betree::fresh_node_id]: forward function -/
def betree.fresh_node_id (counter : U64) : Result U64 :=
do
- let _ ← counter + (U64.ofInt 1)
+ let _ ← counter + 1#u64
Result.ret counter
/- [betree_main::betree::fresh_node_id]: backward function 0 -/
def betree.fresh_node_id_back (counter : U64) : Result U64 :=
- counter + (U64.ofInt 1)
+ counter + 1#u64
/- [betree_main::betree::NodeIdCounter::{0}::new]: forward function -/
def betree.NodeIdCounter.new : Result betree.NodeIdCounter :=
- Result.ret { next_node_id := (U64.ofInt 0) }
+ Result.ret { next_node_id := 0#u64 }
/- [betree_main::betree::NodeIdCounter::{0}::fresh_id]: forward function -/
def betree.NodeIdCounter.fresh_id (self : betree.NodeIdCounter) : Result U64 :=
do
- let _ ← self.next_node_id + (U64.ofInt 1)
+ let _ ← self.next_node_id + 1#u64
Result.ret self.next_node_id
/- [betree_main::betree::NodeIdCounter::{0}::fresh_id]: backward function 0 -/
def betree.NodeIdCounter.fresh_id_back
(self : betree.NodeIdCounter) : Result betree.NodeIdCounter :=
do
- let i ← self.next_node_id + (U64.ofInt 1)
+ let i ← self.next_node_id + 1#u64
Result.ret { next_node_id := i }
-/- [core::num::u64::{9}::MAX] -/
-def core_num_u64_max_body : Result U64 :=
- Result.ret (U64.ofInt 18446744073709551615)
-def core_num_u64_max_c : U64 := eval_global core_num_u64_max_body (by simp)
-
/- [betree_main::betree::upsert_update]: forward function -/
def betree.upsert_update
(prev : Option U64) (st : betree.UpsertFunState) : Result U64 :=
match prev with
- | Option.none =>
+ | none =>
match st with
| betree.UpsertFunState.Add v => Result.ret v
- | betree.UpsertFunState.Sub i => Result.ret (U64.ofInt 0)
- | Option.some prev0 =>
+ | betree.UpsertFunState.Sub i => Result.ret 0#u64
+ | some prev0 =>
match st with
| betree.UpsertFunState.Add v =>
do
- let margin ← core_num_u64_max_c - prev0
+ let margin ← core_u64_max - prev0
if margin >= v
then prev0 + v
- else Result.ret core_num_u64_max_c
+ else Result.ret core_u64_max
| betree.UpsertFunState.Sub v =>
if prev0 >= v
then prev0 - v
- else Result.ret (U64.ofInt 0)
+ else Result.ret 0#u64
/- [betree_main::betree::List::{1}::len]: forward function -/
divergent def betree.List.len (T : Type) (self : betree.List T) : Result U64 :=
match self with
- | betree.List.Cons t tl =>
- do
- let i ← betree.List.len T tl
- (U64.ofInt 1) + i
- | betree.List.Nil => Result.ret (U64.ofInt 0)
+ | betree.List.Cons t tl => do
+ let i ← betree.List.len T tl
+ 1#u64 + i
+ | betree.List.Nil => Result.ret 0#u64
/- [betree_main::betree::List::{1}::split_at]: forward function -/
divergent def betree.List.split_at
(T : Type) (self : betree.List T) (n : U64) :
Result ((betree.List T) × (betree.List T))
:=
- if n = (U64.ofInt 0)
+ if n = 0#u64
then Result.ret (betree.List.Nil, self)
else
match self with
| betree.List.Cons hd tl =>
do
- let i ← n - (U64.ofInt 1)
+ let i ← n - 1#u64
let p ← betree.List.split_at T tl i
let (ls0, ls1) := p
let l := ls0
@@ -121,13 +115,13 @@ divergent def betree.List.split_at
(there is a single backward function, and the forward function returns ()) -/
def betree.List.push_front
(T : Type) (self : betree.List T) (x : T) : Result (betree.List T) :=
- let tl := mem.replace (betree.List T) self betree.List.Nil
+ let tl := core.mem.replace (betree.List T) self betree.List.Nil
let l := tl
Result.ret (betree.List.Cons x l)
/- [betree_main::betree::List::{1}::pop_front]: forward function -/
def betree.List.pop_front (T : Type) (self : betree.List T) : Result T :=
- let ls := mem.replace (betree.List T) self betree.List.Nil
+ let ls := core.mem.replace (betree.List T) self betree.List.Nil
match ls with
| betree.List.Cons x tl => Result.ret x
| betree.List.Nil => Result.fail Error.panic
@@ -135,7 +129,7 @@ def betree.List.pop_front (T : Type) (self : betree.List T) : Result T :=
/- [betree_main::betree::List::{1}::pop_front]: backward function 0 -/
def betree.List.pop_front_back
(T : Type) (self : betree.List T) : Result (betree.List T) :=
- let ls := mem.replace (betree.List T) self betree.List.Nil
+ let ls := core.mem.replace (betree.List T) self betree.List.Nil
match ls with
| betree.List.Cons x tl => Result.ret tl
| betree.List.Nil => Result.fail Error.panic
@@ -261,7 +255,7 @@ divergent def betree.Node.apply_upserts
let v ← betree.upsert_update prev s
let msgs0 ←
betree.List.pop_front_back (U64 × betree.Message) msgs
- betree.Node.apply_upserts msgs0 (Option.some v) key st
+ betree.Node.apply_upserts msgs0 (some v) key st
else
do
let (st0, v) ← core.option.Option.unwrap U64 prev st
@@ -291,7 +285,7 @@ divergent def betree.Node.apply_upserts_back
let v ← betree.upsert_update prev s
let msgs0 ←
betree.List.pop_front_back (U64 × betree.Message) msgs
- betree.Node.apply_upserts_back msgs0 (Option.some v) key st
+ betree.Node.apply_upserts_back msgs0 (some v) key st
else
do
let (_, v) ← core.option.Option.unwrap U64 prev st
@@ -305,12 +299,12 @@ divergent def betree.Node.lookup_in_bindings
| betree.List.Cons hd tl =>
let (i, i0) := hd
if i = key
- then Result.ret (Option.some i0)
+ then Result.ret (some i0)
else
if i > key
- then Result.ret Option.none
+ then Result.ret none
else betree.Node.lookup_in_bindings key tl
- | betree.List.Nil => Result.ret Option.none
+ | betree.List.Nil => Result.ret none
/- [betree_main::betree::Internal::{4}::lookup_in_children]: forward function -/
mutual divergent def betree.Internal.lookup_in_children
@@ -353,13 +347,13 @@ divergent def betree.Node.lookup
if k != key
then
do
- let (st1, opt) ←
+ let (st1, o) ←
betree.Internal.lookup_in_children (betree.Internal.mk i i0 n n0)
key st0
let _ ←
betree.Node.lookup_first_message_for_key_back key msgs
(betree.List.Cons (k, msg) l)
- Result.ret (st1, opt)
+ Result.ret (st1, o)
else
match msg with
| betree.Message.Insert v =>
@@ -367,13 +361,13 @@ divergent def betree.Node.lookup
let _ ←
betree.Node.lookup_first_message_for_key_back key msgs
(betree.List.Cons (k, betree.Message.Insert v) l)
- Result.ret (st0, Option.some v)
+ Result.ret (st0, some v)
| betree.Message.Delete =>
do
let _ ←
betree.Node.lookup_first_message_for_key_back key msgs
(betree.List.Cons (k, betree.Message.Delete) l)
- Result.ret (st0, Option.none)
+ Result.ret (st0, none)
| betree.Message.Upsert ufs =>
do
let (st1, v) ←
@@ -392,21 +386,21 @@ divergent def betree.Node.lookup
let msgs0 ←
betree.Node.lookup_first_message_for_key_back key msgs pending0
let (st3, _) ← betree.store_internal_node i1 msgs0 st2
- Result.ret (st3, Option.some v0)
+ Result.ret (st3, some v0)
| betree.List.Nil =>
do
- let (st1, opt) ←
+ let (st1, o) ←
betree.Internal.lookup_in_children (betree.Internal.mk i i0 n n0)
key st0
let _ ←
betree.Node.lookup_first_message_for_key_back key msgs
betree.List.Nil
- Result.ret (st1, opt)
+ Result.ret (st1, o)
| betree.Node.Leaf node =>
do
let (st0, bindings) ← betree.load_leaf_node node.id st
- let opt ← betree.Node.lookup_in_bindings key bindings
- Result.ret (st0, opt)
+ let o ← betree.Node.lookup_in_bindings key bindings
+ Result.ret (st0, o)
/- [betree_main::betree::Node::{5}::lookup]: backward function 0 -/
divergent def betree.Node.lookup_back
@@ -565,7 +559,7 @@ def betree.Node.apply_to_internal
match m with
| betree.Message.Insert prev =>
do
- let v ← betree.upsert_update (Option.some prev) s
+ let v ← betree.upsert_update (some prev) s
let msgs1 ←
betree.List.pop_front_back (U64 × betree.Message) msgs0
let msgs2 ←
@@ -574,7 +568,7 @@ def betree.Node.apply_to_internal
betree.Node.lookup_first_message_for_key_back key msgs msgs2
| betree.Message.Delete =>
do
- let v ← betree.upsert_update Option.none s
+ let v ← betree.upsert_update none s
let msgs1 ←
betree.List.pop_front_back (U64 × betree.Message) msgs0
let msgs2 ←
@@ -670,7 +664,7 @@ def betree.Node.apply_to_leaf
| betree.Message.Upsert s =>
do
let (_, i) := hd
- let v ← betree.upsert_update (Option.some i) s
+ let v ← betree.upsert_update (some i) s
let bindings1 ← betree.List.pop_front_back (U64 × U64) bindings0
let bindings2 ←
betree.List.push_front (U64 × U64) bindings1 (key, v)
@@ -686,7 +680,7 @@ def betree.Node.apply_to_leaf
betree.Node.lookup_mut_in_bindings_back key bindings bindings0
| betree.Message.Upsert s =>
do
- let v ← betree.upsert_update Option.none s
+ let v ← betree.upsert_update none s
let bindings1 ←
betree.List.push_front (U64 × U64) bindings0 (key, v)
betree.Node.lookup_mut_in_bindings_back key bindings bindings1
@@ -813,7 +807,7 @@ divergent def betree.Node.apply_messages
let (st0, content) ← betree.load_leaf_node node.id st
let content0 ← betree.Node.apply_messages_to_leaf content msgs
let len ← betree.List.len (U64 × U64) content0
- let i ← (U64.ofInt 2) * params.split_size
+ let i ← 2#u64 * params.split_size
if len >= i
then
do
@@ -863,7 +857,7 @@ divergent def betree.Node.apply_messages_back
let (st0, content) ← betree.load_leaf_node node.id st
let content0 ← betree.Node.apply_messages_to_leaf content msgs
let len ← betree.List.len (U64 × U64) content0
- let i ← (U64.ofInt 2) * params.split_size
+ let i ← 2#u64 * params.split_size
if len >= i
then
do
@@ -923,7 +917,7 @@ def betree.BeTree.new
params :=
{ min_flush_size := min_flush_size, split_size := split_size },
node_id_cnt := node_id_cnt0,
- root := (betree.Node.Leaf { id := id, size := (U64.ofInt 0) })
+ root := (betree.Node.Leaf { id := id, size := 0#u64 })
})
/- [betree_main::betree::BeTree::{6}::apply]: forward function -/
diff --git a/tests/lean/Constants.lean b/tests/lean/Constants.lean
index 51b415d6..bd3a07b7 100644
--- a/tests/lean/Constants.lean
+++ b/tests/lean/Constants.lean
@@ -6,27 +6,23 @@ open Primitives
namespace constants
/- [constants::X0] -/
-def x0_body : Result U32 := Result.ret (U32.ofInt 0)
+def x0_body : Result U32 := Result.ret 0#u32
def x0_c : U32 := eval_global x0_body (by simp)
-/- [core::num::u32::{8}::MAX] -/
-def core_num_u32_max_body : Result U32 := Result.ret (U32.ofInt 4294967295)
-def core_num_u32_max_c : U32 := eval_global core_num_u32_max_body (by simp)
-
/- [constants::X1] -/
-def x1_body : Result U32 := Result.ret core_num_u32_max_c
+def x1_body : Result U32 := Result.ret core_u32_max
def x1_c : U32 := eval_global x1_body (by simp)
/- [constants::X2] -/
-def x2_body : Result U32 := Result.ret (U32.ofInt 3)
+def x2_body : Result U32 := Result.ret 3#u32
def x2_c : U32 := eval_global x2_body (by simp)
/- [constants::incr]: forward function -/
def incr (n : U32) : Result U32 :=
- n + (U32.ofInt 1)
+ n + 1#u32
/- [constants::X3] -/
-def x3_body : Result U32 := incr (U32.ofInt 32)
+def x3_body : Result U32 := incr 32#u32
def x3_c : U32 := eval_global x3_body (by simp)
/- [constants::mk_pair0]: forward function -/
@@ -43,44 +39,43 @@ def mk_pair1 (x : U32) (y : U32) : Result (Pair U32 U32) :=
Result.ret { x := x, y := y }
/- [constants::P0] -/
-def p0_body : Result (U32 × U32) := mk_pair0 (U32.ofInt 0) (U32.ofInt 1)
+def p0_body : Result (U32 × U32) := mk_pair0 0#u32 1#u32
def p0_c : (U32 × U32) := eval_global p0_body (by simp)
/- [constants::P1] -/
-def p1_body : Result (Pair U32 U32) := mk_pair1 (U32.ofInt 0) (U32.ofInt 1)
+def p1_body : Result (Pair U32 U32) := mk_pair1 0#u32 1#u32
def p1_c : Pair U32 U32 := eval_global p1_body (by simp)
/- [constants::P2] -/
-def p2_body : Result (U32 × U32) := Result.ret ((U32.ofInt 0), (U32.ofInt 1))
+def p2_body : Result (U32 × U32) := Result.ret (0#u32, 1#u32)
def p2_c : (U32 × U32) := eval_global p2_body (by simp)
/- [constants::P3] -/
-def p3_body : Result (Pair U32 U32) :=
- Result.ret { x := (U32.ofInt 0), y := (U32.ofInt 1) }
+def p3_body : Result (Pair U32 U32) := Result.ret { x := 0#u32, y := 1#u32 }
def p3_c : Pair U32 U32 := eval_global p3_body (by simp)
/- [constants::Wrap] -/
structure Wrap (T : Type) where
- val : T
+ value : T
/- [constants::Wrap::{0}::new]: forward function -/
-def Wrap.new (T : Type) (val : T) : Result (Wrap T) :=
- Result.ret { val := val }
+def Wrap.new (T : Type) (value : T) : Result (Wrap T) :=
+ Result.ret { value := value }
/- [constants::Y] -/
-def y_body : Result (Wrap I32) := Wrap.new I32 (I32.ofInt 2)
+def y_body : Result (Wrap I32) := Wrap.new I32 2#i32
def y_c : Wrap I32 := eval_global y_body (by simp)
/- [constants::unwrap_y]: forward function -/
def unwrap_y : Result I32 :=
- Result.ret y_c.val
+ Result.ret y_c.value
/- [constants::YVAL] -/
def yval_body : Result I32 := unwrap_y
def yval_c : I32 := eval_global yval_body (by simp)
/- [constants::get_z1::Z1] -/
-def get_z1_z1_body : Result I32 := Result.ret (I32.ofInt 3)
+def get_z1_z1_body : Result I32 := Result.ret 3#i32
def get_z1_z1_c : I32 := eval_global get_z1_z1_body (by simp)
/- [constants::get_z1]: forward function -/
@@ -92,7 +87,7 @@ def add (a : I32) (b : I32) : Result I32 :=
a + b
/- [constants::Q1] -/
-def q1_body : Result I32 := Result.ret (I32.ofInt 5)
+def q1_body : Result I32 := Result.ret 5#i32
def q1_c : I32 := eval_global q1_body (by simp)
/- [constants::Q2] -/
@@ -100,7 +95,7 @@ def q2_body : Result I32 := Result.ret q1_c
def q2_c : I32 := eval_global q2_body (by simp)
/- [constants::Q3] -/
-def q3_body : Result I32 := add q2_c (I32.ofInt 3)
+def q3_body : Result I32 := add q2_c 3#i32
def q3_c : I32 := eval_global q3_body (by simp)
/- [constants::get_z2]: forward function -/
@@ -111,7 +106,7 @@ def get_z2 : Result I32 :=
add q1_c i0
/- [constants::S1] -/
-def s1_body : Result U32 := Result.ret (U32.ofInt 6)
+def s1_body : Result U32 := Result.ret 6#u32
def s1_c : U32 := eval_global s1_body (by simp)
/- [constants::S2] -/
@@ -123,7 +118,7 @@ def s3_body : Result (Pair U32 U32) := Result.ret p3_c
def s3_c : Pair U32 U32 := eval_global s3_body (by simp)
/- [constants::S4] -/
-def s4_body : Result (Pair U32 U32) := mk_pair1 (U32.ofInt 7) (U32.ofInt 8)
+def s4_body : Result (Pair U32 U32) := mk_pair1 7#u32 8#u32
def s4_c : Pair U32 U32 := eval_global s4_body (by simp)
end constants
diff --git a/tests/lean/External/Funs.lean b/tests/lean/External/Funs.lean
index 055d7860..55fb07be 100644
--- a/tests/lean/External/Funs.lean
+++ b/tests/lean/External/Funs.lean
@@ -30,14 +30,14 @@ def swap_back
def test_new_non_zero_u32
(x : U32) (st : State) : Result (State × core.num.nonzero.NonZeroU32) :=
do
- let (st0, opt) ← core.num.nonzero.NonZeroU32.new x st
- core.option.Option.unwrap core.num.nonzero.NonZeroU32 opt st0
+ let (st0, o) ← core.num.nonzero.NonZeroU32.new x st
+ core.option.Option.unwrap core.num.nonzero.NonZeroU32 o st0
/- [external::test_vec]: forward function -/
def test_vec : Result Unit :=
do
- let v := Vec.new U32
- let _ ← Vec.push U32 v (U32.ofInt 0)
+ let v := alloc.vec.Vec.new U32
+ let _ ← alloc.vec.Vec.push U32 v 0#u32
Result.ret ()
/- Unit test for [external::test_vec] -/
@@ -75,14 +75,14 @@ def test_custom_swap_back
(x : U32) (y : U32) (st : State) (st0 : State) :
Result (State × (U32 × U32))
:=
- custom_swap_back U32 x y st (U32.ofInt 1) st0
+ custom_swap_back U32 x y st 1#u32 st0
/- [external::test_swap_non_zero]: forward function -/
def test_swap_non_zero (x : U32) (st : State) : Result (State × U32) :=
do
- let (st0, _) ← swap U32 x (U32.ofInt 0) st
- let (st1, (x0, _)) ← swap_back U32 x (U32.ofInt 0) st st0
- if x0 = (U32.ofInt 0)
+ let (st0, _) ← swap U32 x 0#u32 st
+ let (st1, (x0, _)) ← swap_back U32 x 0#u32 st st0
+ if x0 = 0#u32
then Result.fail Error.panic
else Result.ret (st1, x0)
diff --git a/tests/lean/Hashmap/Funs.lean b/tests/lean/Hashmap/Funs.lean
index 30b30e0b..8464c432 100644
--- a/tests/lean/Hashmap/Funs.lean
+++ b/tests/lean/Hashmap/Funs.lean
@@ -12,18 +12,22 @@ def hash_key (k : Usize) : Result Usize :=
/- [hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function -/
divergent def HashMap.allocate_slots_loop
- (T : Type) (slots : Vec (List T)) (n : Usize) : Result (Vec (List T)) :=
- if n > (Usize.ofInt 0)
+ (T : Type) (slots : alloc.vec.Vec (List T)) (n : Usize) :
+ Result (alloc.vec.Vec (List T))
+ :=
+ if n > 0#usize
then
do
- let slots0 ← Vec.push (List T) slots List.Nil
- let n0 ← n - (Usize.ofInt 1)
+ let slots0 ← alloc.vec.Vec.push (List T) slots List.Nil
+ let n0 ← n - 1#usize
HashMap.allocate_slots_loop T slots0 n0
else Result.ret slots
/- [hashmap::HashMap::{0}::allocate_slots]: forward function -/
def HashMap.allocate_slots
- (T : Type) (slots : Vec (List T)) (n : Usize) : Result (Vec (List T)) :=
+ (T : Type) (slots : alloc.vec.Vec (List T)) (n : Usize) :
+ Result (alloc.vec.Vec (List T))
+ :=
HashMap.allocate_slots_loop T slots n
/- [hashmap::HashMap::{0}::new_with_capacity]: forward function -/
@@ -33,13 +37,13 @@ def HashMap.new_with_capacity
Result (HashMap T)
:=
do
- let v := Vec.new (List T)
+ let v := alloc.vec.Vec.new (List T)
let slots ← HashMap.allocate_slots T v capacity
let i ← capacity * max_load_dividend
let i0 ← i / max_load_divisor
Result.ret
{
- num_entries := (Usize.ofInt 0),
+ num_entries := 0#usize,
max_load_factor := (max_load_dividend, max_load_divisor),
max_load := i0,
slots := slots
@@ -47,18 +51,23 @@ def HashMap.new_with_capacity
/- [hashmap::HashMap::{0}::new]: forward function -/
def HashMap.new (T : Type) : Result (HashMap T) :=
- HashMap.new_with_capacity T (Usize.ofInt 32) (Usize.ofInt 4) (Usize.ofInt 5)
+ HashMap.new_with_capacity T 32#usize 4#usize 5#usize
/- [hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
divergent def HashMap.clear_loop
- (T : Type) (slots : Vec (List T)) (i : Usize) : Result (Vec (List T)) :=
- let i0 := Vec.len (List T) slots
+ (T : Type) (slots : alloc.vec.Vec (List T)) (i : Usize) :
+ Result (alloc.vec.Vec (List T))
+ :=
+ let i0 := alloc.vec.Vec.len (List T) slots
if i < i0
then
do
- let i1 ← i + (Usize.ofInt 1)
- let slots0 ← Vec.index_mut_back (List T) slots i List.Nil
+ let i1 ← i + 1#usize
+ let slots0 ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T)) slots
+ i List.Nil
HashMap.clear_loop T slots0 i1
else Result.ret slots
@@ -66,8 +75,8 @@ divergent def HashMap.clear_loop
(there is a single backward function, and the forward function returns ()) -/
def HashMap.clear (T : Type) (self : HashMap T) : Result (HashMap T) :=
do
- let v ← HashMap.clear_loop T self.slots (Usize.ofInt 0)
- Result.ret { self with num_entries := (Usize.ofInt 0), slots := v }
+ let v ← HashMap.clear_loop T self.slots 0#usize
+ Result.ret { self with num_entries := 0#usize, slots := v }
/- [hashmap::HashMap::{0}::len]: forward function -/
def HashMap.len (T : Type) (self : HashMap T) : Result Usize :=
@@ -115,27 +124,32 @@ def HashMap.insert_no_resize
:=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
let inserted ← HashMap.insert_in_list T key value l
if inserted
then
do
- let i0 ← self.num_entries + (Usize.ofInt 1)
+ let i0 ← self.num_entries + 1#usize
let l0 ← HashMap.insert_in_list_back T key value l
- let v ← Vec.index_mut_back (List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod l0
Result.ret { self with num_entries := i0, slots := v }
else
do
let l0 ← HashMap.insert_in_list_back T key value l
- let v ← Vec.index_mut_back (List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod l0
Result.ret { self with slots := v }
-/- [core::num::u32::{8}::MAX] -/
-def core_num_u32_max_body : Result U32 := Result.ret (U32.ofInt 4294967295)
-def core_num_u32_max_c : U32 := eval_global core_num_u32_max_body (by simp)
-
/- [hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
divergent def HashMap.move_elements_from_list_loop
@@ -156,27 +170,35 @@ def HashMap.move_elements_from_list
/- [hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
divergent def HashMap.move_elements_loop
- (T : Type) (ntable : HashMap T) (slots : Vec (List T)) (i : Usize) :
- Result ((HashMap T) × (Vec (List T)))
+ (T : Type) (ntable : HashMap T) (slots : alloc.vec.Vec (List T)) (i : Usize)
+ :
+ Result ((HashMap T) × (alloc.vec.Vec (List T)))
:=
- let i0 := Vec.len (List T) slots
+ let i0 := alloc.vec.Vec.len (List T) slots
if i < i0
then
do
- let l ← Vec.index_mut (List T) slots i
- let ls := mem.replace (List T) l List.Nil
+ let l ←
+ alloc.vec.Vec.index_mut (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T)) slots
+ i
+ let ls := core.mem.replace (List T) l List.Nil
let ntable0 ← HashMap.move_elements_from_list T ntable ls
- let i1 ← i + (Usize.ofInt 1)
- let l0 := mem.replace_back (List T) l List.Nil
- let slots0 ← Vec.index_mut_back (List T) slots i l0
+ let i1 ← i + 1#usize
+ let l0 := core.mem.replace_back (List T) l List.Nil
+ let slots0 ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T)) slots
+ i l0
HashMap.move_elements_loop T ntable0 slots0 i1
else Result.ret (ntable, slots)
/- [hashmap::HashMap::{0}::move_elements]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def HashMap.move_elements
- (T : Type) (ntable : HashMap T) (slots : Vec (List T)) (i : Usize) :
- Result ((HashMap T) × (Vec (List T)))
+ (T : Type) (ntable : HashMap T) (slots : alloc.vec.Vec (List T)) (i : Usize)
+ :
+ Result ((HashMap T) × (alloc.vec.Vec (List T)))
:=
HashMap.move_elements_loop T ntable slots i
@@ -184,18 +206,17 @@ def HashMap.move_elements
(there is a single backward function, and the forward function returns ()) -/
def HashMap.try_resize (T : Type) (self : HashMap T) : Result (HashMap T) :=
do
- let max_usize ← Scalar.cast .Usize core_num_u32_max_c
- let capacity := Vec.len (List T) self.slots
- let n1 ← max_usize / (Usize.ofInt 2)
+ let max_usize ← Scalar.cast .Usize core_u32_max
+ let capacity := alloc.vec.Vec.len (List T) self.slots
+ let n1 ← max_usize / 2#usize
let (i, i0) := self.max_load_factor
let i1 ← n1 / i
if capacity <= i1
then
do
- let i2 ← capacity * (Usize.ofInt 2)
+ let i2 ← capacity * 2#usize
let ntable ← HashMap.new_with_capacity T i2 i i0
- let (ntable0, _) ←
- HashMap.move_elements T ntable self.slots (Usize.ofInt 0)
+ let (ntable0, _) ← HashMap.move_elements T ntable self.slots 0#usize
Result.ret
{
ntable0
@@ -237,9 +258,12 @@ def HashMap.contains_key
(T : Type) (self : HashMap T) (key : Usize) : Result Bool :=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_shared (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
HashMap.contains_key_in_list T key l
/- [hashmap::HashMap::{0}::get_in_list]: loop 0: forward function -/
@@ -260,9 +284,12 @@ def HashMap.get_in_list (T : Type) (key : Usize) (ls : List T) : Result T :=
def HashMap.get (T : Type) (self : HashMap T) (key : Usize) : Result T :=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_shared (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
HashMap.get_in_list T key l
/- [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function -/
@@ -302,9 +329,12 @@ def HashMap.get_mut_in_list_back
def HashMap.get_mut (T : Type) (self : HashMap T) (key : Usize) : Result T :=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
HashMap.get_mut_in_list T l key
/- [hashmap::HashMap::{0}::get_mut]: backward function 0 -/
@@ -314,11 +344,17 @@ def HashMap.get_mut_back
:=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
let l0 ← HashMap.get_mut_in_list_back T l key ret0
- let v ← Vec.index_mut_back (List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod l0
Result.ret { self with slots := v }
/- [hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function -/
@@ -328,12 +364,12 @@ divergent def HashMap.remove_from_list_loop
| List.Cons ckey t tl =>
if ckey = key
then
- let mv_ls := mem.replace (List T) (List.Cons ckey t tl) List.Nil
+ let mv_ls := core.mem.replace (List T) (List.Cons ckey t tl) List.Nil
match mv_ls with
- | List.Cons i cvalue tl0 => Result.ret (Option.some cvalue)
+ | List.Cons i cvalue tl0 => Result.ret (some cvalue)
| List.Nil => Result.fail Error.panic
else HashMap.remove_from_list_loop T key tl
- | List.Nil => Result.ret Option.none
+ | List.Nil => Result.ret none
/- [hashmap::HashMap::{0}::remove_from_list]: forward function -/
def HashMap.remove_from_list
@@ -347,7 +383,7 @@ divergent def HashMap.remove_from_list_loop_back
| List.Cons ckey t tl =>
if ckey = key
then
- let mv_ls := mem.replace (List T) (List.Cons ckey t tl) List.Nil
+ let mv_ls := core.mem.replace (List T) (List.Cons ckey t tl) List.Nil
match mv_ls with
| List.Cons i cvalue tl0 => Result.ret tl0
| List.Nil => Result.fail Error.panic
@@ -367,84 +403,91 @@ def HashMap.remove
(T : Type) (self : HashMap T) (key : Usize) : Result (Option T) :=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
let x ← HashMap.remove_from_list T key l
match x with
- | Option.none => Result.ret Option.none
- | Option.some x0 =>
- do
- let _ ← self.num_entries - (Usize.ofInt 1)
- Result.ret (Option.some x0)
+ | none => Result.ret none
+ | some x0 => do
+ let _ ← self.num_entries - 1#usize
+ Result.ret (some x0)
/- [hashmap::HashMap::{0}::remove]: backward function 0 -/
def HashMap.remove_back
(T : Type) (self : HashMap T) (key : Usize) : Result (HashMap T) :=
do
let hash ← hash_key key
- let i := Vec.len (List T) self.slots
+ let i := alloc.vec.Vec.len (List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod
let x ← HashMap.remove_from_list T key l
match x with
- | Option.none =>
+ | none =>
do
let l0 ← HashMap.remove_from_list_back T key l
- let v ← Vec.index_mut_back (List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod l0
Result.ret { self with slots := v }
- | Option.some x0 =>
+ | some x0 =>
do
- let i0 ← self.num_entries - (Usize.ofInt 1)
+ let i0 ← self.num_entries - 1#usize
let l0 ← HashMap.remove_from_list_back T key l
- let v ← Vec.index_mut_back (List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List T))
+ self.slots hash_mod l0
Result.ret { self with num_entries := i0, slots := v }
/- [hashmap::test1]: forward function -/
def test1 : Result Unit :=
do
let hm ← HashMap.new U64
- let hm0 ← HashMap.insert U64 hm (Usize.ofInt 0) (U64.ofInt 42)
- let hm1 ← HashMap.insert U64 hm0 (Usize.ofInt 128) (U64.ofInt 18)
- let hm2 ← HashMap.insert U64 hm1 (Usize.ofInt 1024) (U64.ofInt 138)
- let hm3 ← HashMap.insert U64 hm2 (Usize.ofInt 1056) (U64.ofInt 256)
- let i ← HashMap.get U64 hm3 (Usize.ofInt 128)
- if not (i = (U64.ofInt 18))
+ let hm0 ← HashMap.insert U64 hm 0#usize 42#u64
+ let hm1 ← HashMap.insert U64 hm0 128#usize 18#u64
+ let hm2 ← HashMap.insert U64 hm1 1024#usize 138#u64
+ let hm3 ← HashMap.insert U64 hm2 1056#usize 256#u64
+ let i ← HashMap.get U64 hm3 128#usize
+ if not (i = 18#u64)
then Result.fail Error.panic
else
do
- let hm4 ←
- HashMap.get_mut_back U64 hm3 (Usize.ofInt 1024) (U64.ofInt 56)
- let i0 ← HashMap.get U64 hm4 (Usize.ofInt 1024)
- if not (i0 = (U64.ofInt 56))
+ let hm4 ← HashMap.get_mut_back U64 hm3 1024#usize 56#u64
+ let i0 ← HashMap.get U64 hm4 1024#usize
+ if not (i0 = 56#u64)
then Result.fail Error.panic
else
do
- let x ← HashMap.remove U64 hm4 (Usize.ofInt 1024)
+ let x ← HashMap.remove U64 hm4 1024#usize
match x with
- | Option.none => Result.fail Error.panic
- | Option.some x0 =>
- if not (x0 = (U64.ofInt 56))
+ | none => Result.fail Error.panic
+ | some x0 =>
+ if not (x0 = 56#u64)
then Result.fail Error.panic
else
do
- let hm5 ← HashMap.remove_back U64 hm4 (Usize.ofInt 1024)
- let i1 ← HashMap.get U64 hm5 (Usize.ofInt 0)
- if not (i1 = (U64.ofInt 42))
+ let hm5 ← HashMap.remove_back U64 hm4 1024#usize
+ let i1 ← HashMap.get U64 hm5 0#usize
+ if not (i1 = 42#u64)
then Result.fail Error.panic
else
do
- let i2 ← HashMap.get U64 hm5 (Usize.ofInt 128)
- if not (i2 = (U64.ofInt 18))
+ let i2 ← HashMap.get U64 hm5 128#usize
+ if not (i2 = 18#u64)
then Result.fail Error.panic
else
do
- let i3 ← HashMap.get U64 hm5 (Usize.ofInt 1056)
- if not (i3 = (U64.ofInt 256))
+ let i3 ← HashMap.get U64 hm5 1056#usize
+ if not (i3 = 256#u64)
then Result.fail Error.panic
else Result.ret ()
-/- Unit test for [hashmap::test1] -/
-#assert (test1 == .ret ())
-
end hashmap
diff --git a/tests/lean/Hashmap/Properties.lean b/tests/lean/Hashmap/Properties.lean
index fe00ab14..e79c422d 100644
--- a/tests/lean/Hashmap/Properties.lean
+++ b/tests/lean/Hashmap/Properties.lean
@@ -157,7 +157,7 @@ instance : Inhabited (List α) where
def slots_s_inv (s : Core.List (List α)) : Prop :=
∀ (i : Int), 0 ≤ i → i < s.len → slot_t_inv s.len i (s.index i)
-def slots_t_inv (s : Vec (List α)) : Prop :=
+def slots_t_inv (s : alloc.vec.Vec (List α)) : Prop :=
slots_s_inv s.v
@[simp]
@@ -302,20 +302,19 @@ theorem insert_no_resize_spec {α : Type} (hm : HashMap α) (key : Usize) (value
| none => nhm.len_s = hm.len_s + 1
| some _ => nhm.len_s = hm.len_s) := by
rw [insert_no_resize]
- simp only [hash_key, bind_tc_ret] -- TODO: annoying
- have _ : (Vec.len (List α) hm.slots).val ≠ 0 := by checkpoint
+ -- Simplify. Note that this also simplifies some function calls, like array index
+ simp [hash_key, bind_tc_ret]
+ have _ : (alloc.vec.Vec.len (List α) hm.slots).val ≠ 0 := by
intro
simp_all [inv]
- progress keep _ as ⟨ hash_mod, hhm ⟩
- have _ : 0 ≤ hash_mod.val := by checkpoint scalar_tac
- have _ : hash_mod.val < Vec.length hm.slots := by
+ progress as ⟨ hash_mod, hhm ⟩
+ have _ : 0 ≤ hash_mod.val := by scalar_tac
+ have _ : hash_mod.val < alloc.vec.Vec.length hm.slots := by
have : 0 < hm.slots.val.len := by
simp [inv] at hinv
simp [hinv]
-- TODO: we want to automate that
simp [*, Int.emod_lt_of_pos]
- -- TODO: change the spec of Vec.index_mut to introduce a let-binding.
- -- or: make progress introduce the let-binding by itself (this is clearer)
progress as ⟨ l, h_leq ⟩
-- TODO: make progress use the names written in the goal
progress as ⟨ inserted ⟩
@@ -376,7 +375,7 @@ theorem insert_no_resize_spec {α : Type} (hm : HashMap α) (key : Usize) (value
-- TODO: we want to automate this
simp
apply Int.emod_nonneg k.val hvnz
- have _ : k_hash_mod < Vec.length hm.slots := by
+ have _ : k_hash_mod < alloc.vec.Vec.length hm.slots := by
-- TODO: we want to automate this
simp
have h := Int.emod_lt_of_pos k.val hvpos
diff --git a/tests/lean/Hashmap/Types.lean b/tests/lean/Hashmap/Types.lean
index 6455798d..e007bce0 100644
--- a/tests/lean/Hashmap/Types.lean
+++ b/tests/lean/Hashmap/Types.lean
@@ -15,6 +15,6 @@ structure HashMap (T : Type) where
num_entries : Usize
max_load_factor : (Usize × Usize)
max_load : Usize
- slots : Vec (List T)
+ slots : alloc.vec.Vec (List T)
end hashmap
diff --git a/tests/lean/HashmapMain/Funs.lean b/tests/lean/HashmapMain/Funs.lean
index aec957ec..74fa8653 100644
--- a/tests/lean/HashmapMain/Funs.lean
+++ b/tests/lean/HashmapMain/Funs.lean
@@ -13,21 +13,21 @@ def hashmap.hash_key (k : Usize) : Result Usize :=
/- [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function -/
divergent def hashmap.HashMap.allocate_slots_loop
- (T : Type) (slots : Vec (hashmap.List T)) (n : Usize) :
- Result (Vec (hashmap.List T))
+ (T : Type) (slots : alloc.vec.Vec (hashmap.List T)) (n : Usize) :
+ Result (alloc.vec.Vec (hashmap.List T))
:=
- if n > (Usize.ofInt 0)
+ if n > 0#usize
then
do
- let slots0 ← Vec.push (hashmap.List T) slots hashmap.List.Nil
- let n0 ← n - (Usize.ofInt 1)
+ let slots0 ← alloc.vec.Vec.push (hashmap.List T) slots hashmap.List.Nil
+ let n0 ← n - 1#usize
hashmap.HashMap.allocate_slots_loop T slots0 n0
else Result.ret slots
/- [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: forward function -/
def hashmap.HashMap.allocate_slots
- (T : Type) (slots : Vec (hashmap.List T)) (n : Usize) :
- Result (Vec (hashmap.List T))
+ (T : Type) (slots : alloc.vec.Vec (hashmap.List T)) (n : Usize) :
+ Result (alloc.vec.Vec (hashmap.List T))
:=
hashmap.HashMap.allocate_slots_loop T slots n
@@ -38,13 +38,13 @@ def hashmap.HashMap.new_with_capacity
Result (hashmap.HashMap T)
:=
do
- let v := Vec.new (hashmap.List T)
+ let v := alloc.vec.Vec.new (hashmap.List T)
let slots ← hashmap.HashMap.allocate_slots T v capacity
let i ← capacity * max_load_dividend
let i0 ← i / max_load_divisor
Result.ret
{
- num_entries := (Usize.ofInt 0),
+ num_entries := 0#usize,
max_load_factor := (max_load_dividend, max_load_divisor),
max_load := i0,
slots := slots
@@ -52,22 +52,23 @@ def hashmap.HashMap.new_with_capacity
/- [hashmap_main::hashmap::HashMap::{0}::new]: forward function -/
def hashmap.HashMap.new (T : Type) : Result (hashmap.HashMap T) :=
- hashmap.HashMap.new_with_capacity T (Usize.ofInt 32) (Usize.ofInt 4)
- (Usize.ofInt 5)
+ hashmap.HashMap.new_with_capacity T 32#usize 4#usize 5#usize
/- [hashmap_main::hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
divergent def hashmap.HashMap.clear_loop
- (T : Type) (slots : Vec (hashmap.List T)) (i : Usize) :
- Result (Vec (hashmap.List T))
+ (T : Type) (slots : alloc.vec.Vec (hashmap.List T)) (i : Usize) :
+ Result (alloc.vec.Vec (hashmap.List T))
:=
- let i0 := Vec.len (hashmap.List T) slots
+ let i0 := alloc.vec.Vec.len (hashmap.List T) slots
if i < i0
then
do
- let i1 ← i + (Usize.ofInt 1)
+ let i1 ← i + 1#usize
let slots0 ←
- Vec.index_mut_back (hashmap.List T) slots i hashmap.List.Nil
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) slots i hashmap.List.Nil
hashmap.HashMap.clear_loop T slots0 i1
else Result.ret slots
@@ -76,8 +77,8 @@ divergent def hashmap.HashMap.clear_loop
def hashmap.HashMap.clear
(T : Type) (self : hashmap.HashMap T) : Result (hashmap.HashMap T) :=
do
- let v ← hashmap.HashMap.clear_loop T self.slots (Usize.ofInt 0)
- Result.ret { self with num_entries := (Usize.ofInt 0), slots := v }
+ let v ← hashmap.HashMap.clear_loop T self.slots 0#usize
+ Result.ret { self with num_entries := 0#usize, slots := v }
/- [hashmap_main::hashmap::HashMap::{0}::len]: forward function -/
def hashmap.HashMap.len (T : Type) (self : hashmap.HashMap T) : Result Usize :=
@@ -130,27 +131,32 @@ def hashmap.HashMap.insert_no_resize
:=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
let inserted ← hashmap.HashMap.insert_in_list T key value l
if inserted
then
do
- let i0 ← self.num_entries + (Usize.ofInt 1)
+ let i0 ← self.num_entries + 1#usize
let l0 ← hashmap.HashMap.insert_in_list_back T key value l
- let v ← Vec.index_mut_back (hashmap.List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) self.slots hash_mod l0
Result.ret { self with num_entries := i0, slots := v }
else
do
let l0 ← hashmap.HashMap.insert_in_list_back T key value l
- let v ← Vec.index_mut_back (hashmap.List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) self.slots hash_mod l0
Result.ret { self with slots := v }
-/- [core::num::u32::{8}::MAX] -/
-def core_num_u32_max_body : Result U32 := Result.ret (U32.ofInt 4294967295)
-def core_num_u32_max_c : U32 := eval_global core_num_u32_max_body (by simp)
-
/- [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 ()) -/
divergent def hashmap.HashMap.move_elements_from_list_loop
@@ -175,29 +181,35 @@ def hashmap.HashMap.move_elements_from_list
/- [hashmap_main::hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
divergent def hashmap.HashMap.move_elements_loop
- (T : Type) (ntable : hashmap.HashMap T) (slots : Vec (hashmap.List T))
- (i : Usize) :
- Result ((hashmap.HashMap T) × (Vec (hashmap.List T)))
+ (T : Type) (ntable : hashmap.HashMap T)
+ (slots : alloc.vec.Vec (hashmap.List T)) (i : Usize) :
+ Result ((hashmap.HashMap T) × (alloc.vec.Vec (hashmap.List T)))
:=
- let i0 := Vec.len (hashmap.List T) slots
+ let i0 := alloc.vec.Vec.len (hashmap.List T) slots
if i < i0
then
do
- let l ← Vec.index_mut (hashmap.List T) slots i
- let ls := mem.replace (hashmap.List T) l hashmap.List.Nil
+ let l ←
+ alloc.vec.Vec.index_mut (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) slots i
+ let ls := core.mem.replace (hashmap.List T) l hashmap.List.Nil
let ntable0 ← hashmap.HashMap.move_elements_from_list T ntable ls
- let i1 ← i + (Usize.ofInt 1)
- let l0 := mem.replace_back (hashmap.List T) l hashmap.List.Nil
- let slots0 ← Vec.index_mut_back (hashmap.List T) slots i l0
+ let i1 ← i + 1#usize
+ let l0 := core.mem.replace_back (hashmap.List T) l hashmap.List.Nil
+ let slots0 ←
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) slots i l0
hashmap.HashMap.move_elements_loop T ntable0 slots0 i1
else Result.ret (ntable, slots)
/- [hashmap_main::hashmap::HashMap::{0}::move_elements]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def hashmap.HashMap.move_elements
- (T : Type) (ntable : hashmap.HashMap T) (slots : Vec (hashmap.List T))
- (i : Usize) :
- Result ((hashmap.HashMap T) × (Vec (hashmap.List T)))
+ (T : Type) (ntable : hashmap.HashMap T)
+ (slots : alloc.vec.Vec (hashmap.List T)) (i : Usize) :
+ Result ((hashmap.HashMap T) × (alloc.vec.Vec (hashmap.List T)))
:=
hashmap.HashMap.move_elements_loop T ntable slots i
@@ -206,18 +218,18 @@ def hashmap.HashMap.move_elements
def hashmap.HashMap.try_resize
(T : Type) (self : hashmap.HashMap T) : Result (hashmap.HashMap T) :=
do
- let max_usize ← Scalar.cast .Usize core_num_u32_max_c
- let capacity := Vec.len (hashmap.List T) self.slots
- let n1 ← max_usize / (Usize.ofInt 2)
+ let max_usize ← Scalar.cast .Usize core_u32_max
+ let capacity := alloc.vec.Vec.len (hashmap.List T) self.slots
+ let n1 ← max_usize / 2#usize
let (i, i0) := self.max_load_factor
let i1 ← n1 / i
if capacity <= i1
then
do
- let i2 ← capacity * (Usize.ofInt 2)
+ let i2 ← capacity * 2#usize
let ntable ← hashmap.HashMap.new_with_capacity T i2 i i0
let (ntable0, _) ←
- hashmap.HashMap.move_elements T ntable self.slots (Usize.ofInt 0)
+ hashmap.HashMap.move_elements T ntable self.slots 0#usize
Result.ret
{
ntable0
@@ -259,9 +271,12 @@ def hashmap.HashMap.contains_key
(T : Type) (self : hashmap.HashMap T) (key : Usize) : Result Bool :=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_shared (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
hashmap.HashMap.contains_key_in_list T key l
/- [hashmap_main::hashmap::HashMap::{0}::get_in_list]: loop 0: forward function -/
@@ -284,9 +299,12 @@ def hashmap.HashMap.get
(T : Type) (self : hashmap.HashMap T) (key : Usize) : Result T :=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_shared (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
hashmap.HashMap.get_in_list T key l
/- [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function -/
@@ -331,9 +349,12 @@ def hashmap.HashMap.get_mut
(T : Type) (self : hashmap.HashMap T) (key : Usize) : Result T :=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
hashmap.HashMap.get_mut_in_list T l key
/- [hashmap_main::hashmap::HashMap::{0}::get_mut]: backward function 0 -/
@@ -343,11 +364,17 @@ def hashmap.HashMap.get_mut_back
:=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
let l0 ← hashmap.HashMap.get_mut_in_list_back T l key ret0
- let v ← Vec.index_mut_back (hashmap.List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod l0
Result.ret { self with slots := v }
/- [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function -/
@@ -358,13 +385,13 @@ divergent def hashmap.HashMap.remove_from_list_loop
if ckey = key
then
let mv_ls :=
- mem.replace (hashmap.List T) (hashmap.List.Cons ckey t tl)
+ core.mem.replace (hashmap.List T) (hashmap.List.Cons ckey t tl)
hashmap.List.Nil
match mv_ls with
- | hashmap.List.Cons i cvalue tl0 => Result.ret (Option.some cvalue)
+ | hashmap.List.Cons i cvalue tl0 => Result.ret (some cvalue)
| hashmap.List.Nil => Result.fail Error.panic
else hashmap.HashMap.remove_from_list_loop T key tl
- | hashmap.List.Nil => Result.ret Option.none
+ | hashmap.List.Nil => Result.ret none
/- [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: forward function -/
def hashmap.HashMap.remove_from_list
@@ -379,7 +406,7 @@ divergent def hashmap.HashMap.remove_from_list_loop_back
if ckey = key
then
let mv_ls :=
- mem.replace (hashmap.List T) (hashmap.List.Cons ckey t tl)
+ core.mem.replace (hashmap.List T) (hashmap.List.Cons ckey t tl)
hashmap.List.Nil
match mv_ls with
| hashmap.List.Cons i cvalue tl0 => Result.ret tl0
@@ -400,16 +427,18 @@ def hashmap.HashMap.remove
(T : Type) (self : hashmap.HashMap T) (key : Usize) : Result (Option T) :=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
let x ← hashmap.HashMap.remove_from_list T key l
match x with
- | Option.none => Result.ret Option.none
- | Option.some x0 =>
- do
- let _ ← self.num_entries - (Usize.ofInt 1)
- Result.ret (Option.some x0)
+ | none => Result.ret none
+ | some x0 => do
+ let _ ← self.num_entries - 1#usize
+ Result.ret (some x0)
/- [hashmap_main::hashmap::HashMap::{0}::remove]: backward function 0 -/
def hashmap.HashMap.remove_back
@@ -418,75 +447,75 @@ def hashmap.HashMap.remove_back
:=
do
let hash ← hashmap.hash_key key
- let i := Vec.len (hashmap.List T) self.slots
+ let i := alloc.vec.Vec.len (hashmap.List T) self.slots
let hash_mod ← hash % i
- let l ← Vec.index_mut (hashmap.List T) self.slots hash_mod
+ let l ←
+ alloc.vec.Vec.index_mut (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List T))
+ self.slots hash_mod
let x ← hashmap.HashMap.remove_from_list T key l
match x with
- | Option.none =>
+ | none =>
do
let l0 ← hashmap.HashMap.remove_from_list_back T key l
- let v ← Vec.index_mut_back (hashmap.List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) self.slots hash_mod l0
Result.ret { self with slots := v }
- | Option.some x0 =>
+ | some x0 =>
do
- let i0 ← self.num_entries - (Usize.ofInt 1)
+ let i0 ← self.num_entries - 1#usize
let l0 ← hashmap.HashMap.remove_from_list_back T key l
- let v ← Vec.index_mut_back (hashmap.List T) self.slots hash_mod l0
+ let v ←
+ alloc.vec.Vec.index_mut_back (hashmap.List T) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (hashmap.List
+ T)) self.slots hash_mod l0
Result.ret { self with num_entries := i0, slots := v }
/- [hashmap_main::hashmap::test1]: forward function -/
def hashmap.test1 : Result Unit :=
do
let hm ← hashmap.HashMap.new U64
- let hm0 ← hashmap.HashMap.insert U64 hm (Usize.ofInt 0) (U64.ofInt 42)
- let hm1 ← hashmap.HashMap.insert U64 hm0 (Usize.ofInt 128) (U64.ofInt 18)
- let hm2 ←
- hashmap.HashMap.insert U64 hm1 (Usize.ofInt 1024) (U64.ofInt 138)
- let hm3 ←
- hashmap.HashMap.insert U64 hm2 (Usize.ofInt 1056) (U64.ofInt 256)
- let i ← hashmap.HashMap.get U64 hm3 (Usize.ofInt 128)
- if not (i = (U64.ofInt 18))
+ let hm0 ← hashmap.HashMap.insert U64 hm 0#usize 42#u64
+ let hm1 ← hashmap.HashMap.insert U64 hm0 128#usize 18#u64
+ let hm2 ← hashmap.HashMap.insert U64 hm1 1024#usize 138#u64
+ let hm3 ← hashmap.HashMap.insert U64 hm2 1056#usize 256#u64
+ let i ← hashmap.HashMap.get U64 hm3 128#usize
+ if not (i = 18#u64)
then Result.fail Error.panic
else
do
- let hm4 ←
- hashmap.HashMap.get_mut_back U64 hm3 (Usize.ofInt 1024)
- (U64.ofInt 56)
- let i0 ← hashmap.HashMap.get U64 hm4 (Usize.ofInt 1024)
- if not (i0 = (U64.ofInt 56))
+ let hm4 ← hashmap.HashMap.get_mut_back U64 hm3 1024#usize 56#u64
+ let i0 ← hashmap.HashMap.get U64 hm4 1024#usize
+ if not (i0 = 56#u64)
then Result.fail Error.panic
else
do
- let x ← hashmap.HashMap.remove U64 hm4 (Usize.ofInt 1024)
+ let x ← hashmap.HashMap.remove U64 hm4 1024#usize
match x with
- | Option.none => Result.fail Error.panic
- | Option.some x0 =>
- if not (x0 = (U64.ofInt 56))
+ | none => Result.fail Error.panic
+ | some x0 =>
+ if not (x0 = 56#u64)
then Result.fail Error.panic
else
do
- let hm5 ←
- hashmap.HashMap.remove_back U64 hm4 (Usize.ofInt 1024)
- let i1 ← hashmap.HashMap.get U64 hm5 (Usize.ofInt 0)
- if not (i1 = (U64.ofInt 42))
+ let hm5 ← hashmap.HashMap.remove_back U64 hm4 1024#usize
+ let i1 ← hashmap.HashMap.get U64 hm5 0#usize
+ if not (i1 = 42#u64)
then Result.fail Error.panic
else
do
- let i2 ← hashmap.HashMap.get U64 hm5 (Usize.ofInt 128)
- if not (i2 = (U64.ofInt 18))
+ let i2 ← hashmap.HashMap.get U64 hm5 128#usize
+ if not (i2 = 18#u64)
then Result.fail Error.panic
else
do
- let i3 ←
- hashmap.HashMap.get U64 hm5 (Usize.ofInt 1056)
- if not (i3 = (U64.ofInt 256))
+ let i3 ← hashmap.HashMap.get U64 hm5 1056#usize
+ if not (i3 = 256#u64)
then Result.fail Error.panic
else Result.ret ()
-/- Unit test for [hashmap_main::hashmap::test1] -/
-#assert (hashmap.test1 == .ret ())
-
/- [hashmap_main::insert_on_disk]: forward function -/
def insert_on_disk
(key : Usize) (value : U64) (st : State) : Result (State × Unit) :=
@@ -500,7 +529,4 @@ def insert_on_disk
def main : Result Unit :=
Result.ret ()
-/- Unit test for [hashmap_main::main] -/
-#assert (main == .ret ())
-
end hashmap_main
diff --git a/tests/lean/HashmapMain/Types.lean b/tests/lean/HashmapMain/Types.lean
index 2b5cbd6c..065c109b 100644
--- a/tests/lean/HashmapMain/Types.lean
+++ b/tests/lean/HashmapMain/Types.lean
@@ -15,7 +15,7 @@ structure hashmap.HashMap (T : Type) where
num_entries : Usize
max_load_factor : (Usize × Usize)
max_load : Usize
- slots : Vec (hashmap.List T)
+ slots : alloc.vec.Vec (hashmap.List T)
/- The state type used in the state-error monad -/
axiom State : Type
diff --git a/tests/lean/Loops.lean b/tests/lean/Loops.lean
index 60c73776..c6360338 100644
--- a/tests/lean/Loops.lean
+++ b/tests/lean/Loops.lean
@@ -1 +1,629 @@
-import Loops.Funs
+-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
+-- [loops]
+import Base
+open Primitives
+
+namespace loops
+
+/- [loops::sum]: loop 0: forward function -/
+divergent def sum_loop (max : U32) (i : U32) (s : U32) : Result U32 :=
+ if i < max
+ then do
+ let s0 ← s + i
+ let i0 ← i + 1#u32
+ sum_loop max i0 s0
+ else s * 2#u32
+
+/- [loops::sum]: forward function -/
+def sum (max : U32) : Result U32 :=
+ sum_loop max 0#u32 0#u32
+
+/- [loops::sum_with_mut_borrows]: loop 0: forward function -/
+divergent def sum_with_mut_borrows_loop
+ (max : U32) (mi : U32) (ms : U32) : Result U32 :=
+ if mi < max
+ then
+ do
+ let ms0 ← ms + mi
+ let mi0 ← mi + 1#u32
+ sum_with_mut_borrows_loop max mi0 ms0
+ else ms * 2#u32
+
+/- [loops::sum_with_mut_borrows]: forward function -/
+def sum_with_mut_borrows (max : U32) : Result U32 :=
+ sum_with_mut_borrows_loop max 0#u32 0#u32
+
+/- [loops::sum_with_shared_borrows]: loop 0: forward function -/
+divergent def sum_with_shared_borrows_loop
+ (max : U32) (i : U32) (s : U32) : Result U32 :=
+ if i < max
+ then
+ do
+ let i0 ← i + 1#u32
+ let s0 ← s + i0
+ sum_with_shared_borrows_loop max i0 s0
+ else s * 2#u32
+
+/- [loops::sum_with_shared_borrows]: forward function -/
+def sum_with_shared_borrows (max : U32) : Result U32 :=
+ sum_with_shared_borrows_loop max 0#u32 0#u32
+
+/- [loops::clear]: loop 0: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+divergent def clear_loop
+ (v : alloc.vec.Vec U32) (i : Usize) : Result (alloc.vec.Vec U32) :=
+ let i0 := alloc.vec.Vec.len U32 v
+ if i < i0
+ then
+ do
+ let i1 ← i + 1#usize
+ let v0 ←
+ alloc.vec.Vec.index_mut_back U32 Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst U32) v i 0#u32
+ clear_loop v0 i1
+ else Result.ret v
+
+/- [loops::clear]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def clear (v : alloc.vec.Vec U32) : Result (alloc.vec.Vec U32) :=
+ clear_loop v 0#usize
+
+/- [loops::List] -/
+inductive List (T : Type) :=
+| Cons : T → List T → List T
+| Nil : List T
+
+/- [loops::list_mem]: loop 0: forward function -/
+divergent def list_mem_loop (x : U32) (ls : List U32) : Result Bool :=
+ match ls with
+ | List.Cons y tl => if y = x
+ then Result.ret true
+ else list_mem_loop x tl
+ | List.Nil => Result.ret false
+
+/- [loops::list_mem]: forward function -/
+def list_mem (x : U32) (ls : List U32) : Result Bool :=
+ list_mem_loop x ls
+
+/- [loops::list_nth_mut_loop]: loop 0: forward function -/
+divergent def list_nth_mut_loop_loop
+ (T : Type) (ls : List T) (i : U32) : Result T :=
+ match ls with
+ | List.Cons x tl =>
+ if i = 0#u32
+ then Result.ret x
+ else do
+ let i0 ← i - 1#u32
+ list_nth_mut_loop_loop T tl i0
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop]: forward function -/
+def list_nth_mut_loop (T : Type) (ls : List T) (i : U32) : Result T :=
+ list_nth_mut_loop_loop T ls i
+
+/- [loops::list_nth_mut_loop]: loop 0: backward function 0 -/
+divergent def list_nth_mut_loop_loop_back
+ (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
+ match ls with
+ | List.Cons x tl =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl0 ← list_nth_mut_loop_loop_back T tl i0 ret0
+ Result.ret (List.Cons x tl0)
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop]: backward function 0 -/
+def list_nth_mut_loop_back
+ (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
+ list_nth_mut_loop_loop_back T ls i ret0
+
+/- [loops::list_nth_shared_loop]: loop 0: forward function -/
+divergent def list_nth_shared_loop_loop
+ (T : Type) (ls : List T) (i : U32) : Result T :=
+ match ls with
+ | List.Cons x tl =>
+ if i = 0#u32
+ then Result.ret x
+ else do
+ let i0 ← i - 1#u32
+ list_nth_shared_loop_loop T tl i0
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_loop]: forward function -/
+def list_nth_shared_loop (T : Type) (ls : List T) (i : U32) : Result T :=
+ list_nth_shared_loop_loop T ls i
+
+/- [loops::get_elem_mut]: loop 0: forward function -/
+divergent def get_elem_mut_loop (x : Usize) (ls : List Usize) : Result Usize :=
+ match ls with
+ | List.Cons y tl => if y = x
+ then Result.ret y
+ else get_elem_mut_loop x tl
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::get_elem_mut]: forward function -/
+def get_elem_mut
+ (slots : alloc.vec.Vec (List Usize)) (x : Usize) : Result Usize :=
+ do
+ let l ←
+ alloc.vec.Vec.index_mut (List Usize) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List Usize))
+ slots 0#usize
+ get_elem_mut_loop x l
+
+/- [loops::get_elem_mut]: loop 0: backward function 0 -/
+divergent def get_elem_mut_loop_back
+ (x : Usize) (ls : List Usize) (ret0 : Usize) : Result (List Usize) :=
+ match ls with
+ | List.Cons y tl =>
+ if y = x
+ then Result.ret (List.Cons ret0 tl)
+ else
+ do
+ let tl0 ← get_elem_mut_loop_back x tl ret0
+ Result.ret (List.Cons y tl0)
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::get_elem_mut]: backward function 0 -/
+def get_elem_mut_back
+ (slots : alloc.vec.Vec (List Usize)) (x : Usize) (ret0 : Usize) :
+ Result (alloc.vec.Vec (List Usize))
+ :=
+ do
+ let l ←
+ alloc.vec.Vec.index_mut (List Usize) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List Usize))
+ slots 0#usize
+ let l0 ← get_elem_mut_loop_back x l ret0
+ alloc.vec.Vec.index_mut_back (List Usize) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List Usize)) slots
+ 0#usize l0
+
+/- [loops::get_elem_shared]: loop 0: forward function -/
+divergent def get_elem_shared_loop
+ (x : Usize) (ls : List Usize) : Result Usize :=
+ match ls with
+ | List.Cons y tl => if y = x
+ then Result.ret y
+ else get_elem_shared_loop x tl
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::get_elem_shared]: forward function -/
+def get_elem_shared
+ (slots : alloc.vec.Vec (List Usize)) (x : Usize) : Result Usize :=
+ do
+ let l ←
+ alloc.vec.Vec.index (List Usize) Usize
+ (core.slice.index.usize.coresliceindexSliceIndexInst (List Usize))
+ slots 0#usize
+ get_elem_shared_loop x l
+
+/- [loops::id_mut]: forward function -/
+def id_mut (T : Type) (ls : List T) : Result (List T) :=
+ Result.ret ls
+
+/- [loops::id_mut]: backward function 0 -/
+def id_mut_back (T : Type) (ls : List T) (ret0 : List T) : Result (List T) :=
+ Result.ret ret0
+
+/- [loops::id_shared]: forward function -/
+def id_shared (T : Type) (ls : List T) : Result (List T) :=
+ Result.ret ls
+
+/- [loops::list_nth_mut_loop_with_id]: loop 0: forward function -/
+divergent def list_nth_mut_loop_with_id_loop
+ (T : Type) (i : U32) (ls : List T) : Result T :=
+ match ls with
+ | List.Cons x tl =>
+ if i = 0#u32
+ then Result.ret x
+ else do
+ let i0 ← i - 1#u32
+ list_nth_mut_loop_with_id_loop T i0 tl
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_with_id]: forward function -/
+def list_nth_mut_loop_with_id (T : Type) (ls : List T) (i : U32) : Result T :=
+ do
+ let ls0 ← id_mut T ls
+ list_nth_mut_loop_with_id_loop T i ls0
+
+/- [loops::list_nth_mut_loop_with_id]: loop 0: backward function 0 -/
+divergent def list_nth_mut_loop_with_id_loop_back
+ (T : Type) (i : U32) (ls : List T) (ret0 : T) : Result (List T) :=
+ match ls with
+ | List.Cons x tl =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl0 ← list_nth_mut_loop_with_id_loop_back T i0 tl ret0
+ Result.ret (List.Cons x tl0)
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_with_id]: backward function 0 -/
+def list_nth_mut_loop_with_id_back
+ (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
+ do
+ let ls0 ← id_mut T ls
+ let l ← list_nth_mut_loop_with_id_loop_back T i ls0 ret0
+ id_mut_back T ls l
+
+/- [loops::list_nth_shared_loop_with_id]: loop 0: forward function -/
+divergent def list_nth_shared_loop_with_id_loop
+ (T : Type) (i : U32) (ls : List T) : Result T :=
+ match ls with
+ | List.Cons x tl =>
+ if i = 0#u32
+ then Result.ret x
+ else do
+ let i0 ← i - 1#u32
+ list_nth_shared_loop_with_id_loop T i0 tl
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_loop_with_id]: forward function -/
+def list_nth_shared_loop_with_id
+ (T : Type) (ls : List T) (i : U32) : Result T :=
+ do
+ let ls0 ← id_shared T ls
+ list_nth_shared_loop_with_id_loop T i ls0
+
+/- [loops::list_nth_mut_loop_pair]: loop 0: forward function -/
+divergent def list_nth_mut_loop_pair_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else do
+ let i0 ← i - 1#u32
+ list_nth_mut_loop_pair_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_pair]: forward function -/
+def list_nth_mut_loop_pair
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ list_nth_mut_loop_pair_loop T ls0 ls1 i
+
+/- [loops::list_nth_mut_loop_pair]: loop 0: backward function 0 -/
+divergent def list_nth_mut_loop_pair_loop_back'a
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl0)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl00 ← list_nth_mut_loop_pair_loop_back'a T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x0 tl00)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_pair]: backward function 0 -/
+def list_nth_mut_loop_pair_back'a
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ list_nth_mut_loop_pair_loop_back'a T ls0 ls1 i ret0
+
+/- [loops::list_nth_mut_loop_pair]: loop 0: backward function 1 -/
+divergent def list_nth_mut_loop_pair_loop_back'b
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl1)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl10 ← list_nth_mut_loop_pair_loop_back'b T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x1 tl10)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_pair]: backward function 1 -/
+def list_nth_mut_loop_pair_back'b
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ list_nth_mut_loop_pair_loop_back'b T ls0 ls1 i ret0
+
+/- [loops::list_nth_shared_loop_pair]: loop 0: forward function -/
+divergent def list_nth_shared_loop_pair_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else do
+ let i0 ← i - 1#u32
+ list_nth_shared_loop_pair_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_loop_pair]: forward function -/
+def list_nth_shared_loop_pair
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ list_nth_shared_loop_pair_loop T ls0 ls1 i
+
+/- [loops::list_nth_mut_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_mut_loop_pair_merge_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else
+ do
+ let i0 ← i - 1#u32
+ list_nth_mut_loop_pair_merge_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_pair_merge]: forward function -/
+def list_nth_mut_loop_pair_merge
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ list_nth_mut_loop_pair_merge_loop T ls0 ls1 i
+
+/- [loops::list_nth_mut_loop_pair_merge]: loop 0: backward function 0 -/
+divergent def list_nth_mut_loop_pair_merge_loop_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : (T × T)) :
+ Result ((List T) × (List T))
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then let (t, t0) := ret0
+ Result.ret (List.Cons t tl0, List.Cons t0 tl1)
+ else
+ do
+ let i0 ← i - 1#u32
+ let (tl00, tl10) ←
+ list_nth_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x0 tl00, List.Cons x1 tl10)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_loop_pair_merge]: backward function 0 -/
+def list_nth_mut_loop_pair_merge_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : (T × T)) :
+ Result ((List T) × (List T))
+ :=
+ list_nth_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0
+
+/- [loops::list_nth_shared_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_shared_loop_pair_merge_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else
+ do
+ let i0 ← i - 1#u32
+ list_nth_shared_loop_pair_merge_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_loop_pair_merge]: forward function -/
+def list_nth_shared_loop_pair_merge
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ list_nth_shared_loop_pair_merge_loop T ls0 ls1 i
+
+/- [loops::list_nth_mut_shared_loop_pair]: loop 0: forward function -/
+divergent def list_nth_mut_shared_loop_pair_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else
+ do
+ let i0 ← i - 1#u32
+ list_nth_mut_shared_loop_pair_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_shared_loop_pair]: forward function -/
+def list_nth_mut_shared_loop_pair
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ list_nth_mut_shared_loop_pair_loop T ls0 ls1 i
+
+/- [loops::list_nth_mut_shared_loop_pair]: loop 0: backward function 0 -/
+divergent def list_nth_mut_shared_loop_pair_loop_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl0)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl00 ←
+ list_nth_mut_shared_loop_pair_loop_back T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x0 tl00)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_shared_loop_pair]: backward function 0 -/
+def list_nth_mut_shared_loop_pair_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ list_nth_mut_shared_loop_pair_loop_back T ls0 ls1 i ret0
+
+/- [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_mut_shared_loop_pair_merge_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else
+ do
+ let i0 ← i - 1#u32
+ list_nth_mut_shared_loop_pair_merge_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_shared_loop_pair_merge]: forward function -/
+def list_nth_mut_shared_loop_pair_merge
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ 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 -/
+divergent def list_nth_mut_shared_loop_pair_merge_loop_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl0)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl00 ←
+ list_nth_mut_shared_loop_pair_merge_loop_back T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x0 tl00)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_mut_shared_loop_pair_merge]: backward function 0 -/
+def list_nth_mut_shared_loop_pair_merge_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ list_nth_mut_shared_loop_pair_merge_loop_back T ls0 ls1 i ret0
+
+/- [loops::list_nth_shared_mut_loop_pair]: loop 0: forward function -/
+divergent def list_nth_shared_mut_loop_pair_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else
+ do
+ let i0 ← i - 1#u32
+ list_nth_shared_mut_loop_pair_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_mut_loop_pair]: forward function -/
+def list_nth_shared_mut_loop_pair
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ list_nth_shared_mut_loop_pair_loop T ls0 ls1 i
+
+/- [loops::list_nth_shared_mut_loop_pair]: loop 0: backward function 1 -/
+divergent def list_nth_shared_mut_loop_pair_loop_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl1)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl10 ←
+ list_nth_shared_mut_loop_pair_loop_back T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x1 tl10)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_mut_loop_pair]: backward function 1 -/
+def list_nth_shared_mut_loop_pair_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ list_nth_shared_mut_loop_pair_loop_back T ls0 ls1 i ret0
+
+/- [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_shared_mut_loop_pair_merge_loop
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (x0, x1)
+ else
+ do
+ let i0 ← i - 1#u32
+ list_nth_shared_mut_loop_pair_merge_loop T tl0 tl1 i0
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_mut_loop_pair_merge]: forward function -/
+def list_nth_shared_mut_loop_pair_merge
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
+ 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 -/
+divergent def list_nth_shared_mut_loop_pair_merge_loop_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ match ls0 with
+ | List.Cons x0 tl0 =>
+ match ls1 with
+ | List.Cons x1 tl1 =>
+ if i = 0#u32
+ then Result.ret (List.Cons ret0 tl1)
+ else
+ do
+ let i0 ← i - 1#u32
+ let tl10 ←
+ list_nth_shared_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0
+ Result.ret (List.Cons x1 tl10)
+ | List.Nil => Result.fail Error.panic
+ | List.Nil => Result.fail Error.panic
+
+/- [loops::list_nth_shared_mut_loop_pair_merge]: backward function 0 -/
+def list_nth_shared_mut_loop_pair_merge_back
+ (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
+ Result (List T)
+ :=
+ list_nth_shared_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0
+
+end loops
diff --git a/tests/lean/Loops/Funs.lean b/tests/lean/Loops/Funs.lean
deleted file mode 100644
index 5fbe200f..00000000
--- a/tests/lean/Loops/Funs.lean
+++ /dev/null
@@ -1,612 +0,0 @@
--- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
--- [loops]: function definitions
-import Base
-import Loops.Types
-open Primitives
-
-namespace loops
-
-/- [loops::sum]: loop 0: forward function -/
-divergent def sum_loop (max : U32) (i : U32) (s : U32) : Result U32 :=
- if i < max
- then do
- let s0 ← s + i
- let i0 ← i + (U32.ofInt 1)
- sum_loop max i0 s0
- else s * (U32.ofInt 2)
-
-/- [loops::sum]: forward function -/
-def sum (max : U32) : Result U32 :=
- sum_loop max (U32.ofInt 0) (U32.ofInt 0)
-
-/- [loops::sum_with_mut_borrows]: loop 0: forward function -/
-divergent def sum_with_mut_borrows_loop
- (max : U32) (mi : U32) (ms : U32) : Result U32 :=
- if mi < max
- then
- do
- let ms0 ← ms + mi
- let mi0 ← mi + (U32.ofInt 1)
- sum_with_mut_borrows_loop max mi0 ms0
- else ms * (U32.ofInt 2)
-
-/- [loops::sum_with_mut_borrows]: forward function -/
-def sum_with_mut_borrows (max : U32) : Result U32 :=
- sum_with_mut_borrows_loop max (U32.ofInt 0) (U32.ofInt 0)
-
-/- [loops::sum_with_shared_borrows]: loop 0: forward function -/
-divergent def sum_with_shared_borrows_loop
- (max : U32) (i : U32) (s : U32) : Result U32 :=
- if i < max
- then
- do
- let i0 ← i + (U32.ofInt 1)
- let s0 ← s + i0
- sum_with_shared_borrows_loop max i0 s0
- else s * (U32.ofInt 2)
-
-/- [loops::sum_with_shared_borrows]: forward function -/
-def sum_with_shared_borrows (max : U32) : Result U32 :=
- sum_with_shared_borrows_loop max (U32.ofInt 0) (U32.ofInt 0)
-
-/- [loops::clear]: loop 0: merged forward/backward function
- (there is a single backward function, and the forward function returns ()) -/
-divergent def clear_loop (v : Vec U32) (i : Usize) : Result (Vec U32) :=
- let i0 := Vec.len U32 v
- if i < i0
- then
- do
- let i1 ← i + (Usize.ofInt 1)
- let v0 ← Vec.index_mut_back U32 v i (U32.ofInt 0)
- clear_loop v0 i1
- else Result.ret v
-
-/- [loops::clear]: merged forward/backward function
- (there is a single backward function, and the forward function returns ()) -/
-def clear (v : Vec U32) : Result (Vec U32) :=
- clear_loop v (Usize.ofInt 0)
-
-/- [loops::list_mem]: loop 0: forward function -/
-divergent def list_mem_loop (x : U32) (ls : List U32) : Result Bool :=
- match ls with
- | List.Cons y tl => if y = x
- then Result.ret true
- else list_mem_loop x tl
- | List.Nil => Result.ret false
-
-/- [loops::list_mem]: forward function -/
-def list_mem (x : U32) (ls : List U32) : Result Bool :=
- list_mem_loop x ls
-
-/- [loops::list_nth_mut_loop]: loop 0: forward function -/
-divergent def list_nth_mut_loop_loop
- (T : Type) (ls : List T) (i : U32) : Result T :=
- match ls with
- | List.Cons x tl =>
- if i = (U32.ofInt 0)
- then Result.ret x
- else do
- let i0 ← i - (U32.ofInt 1)
- list_nth_mut_loop_loop T tl i0
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop]: forward function -/
-def list_nth_mut_loop (T : Type) (ls : List T) (i : U32) : Result T :=
- list_nth_mut_loop_loop T ls i
-
-/- [loops::list_nth_mut_loop]: loop 0: backward function 0 -/
-divergent def list_nth_mut_loop_loop_back
- (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
- match ls with
- | List.Cons x tl =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl0 ← list_nth_mut_loop_loop_back T tl i0 ret0
- Result.ret (List.Cons x tl0)
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop]: backward function 0 -/
-def list_nth_mut_loop_back
- (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
- list_nth_mut_loop_loop_back T ls i ret0
-
-/- [loops::list_nth_shared_loop]: loop 0: forward function -/
-divergent def list_nth_shared_loop_loop
- (T : Type) (ls : List T) (i : U32) : Result T :=
- match ls with
- | List.Cons x tl =>
- if i = (U32.ofInt 0)
- then Result.ret x
- else do
- let i0 ← i - (U32.ofInt 1)
- list_nth_shared_loop_loop T tl i0
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_loop]: forward function -/
-def list_nth_shared_loop (T : Type) (ls : List T) (i : U32) : Result T :=
- list_nth_shared_loop_loop T ls i
-
-/- [loops::get_elem_mut]: loop 0: forward function -/
-divergent def get_elem_mut_loop (x : Usize) (ls : List Usize) : Result Usize :=
- match ls with
- | List.Cons y tl => if y = x
- then Result.ret y
- else get_elem_mut_loop x tl
- | List.Nil => Result.fail Error.panic
-
-/- [loops::get_elem_mut]: forward function -/
-def get_elem_mut (slots : Vec (List Usize)) (x : Usize) : Result Usize :=
- do
- let l ← Vec.index_mut (List Usize) slots (Usize.ofInt 0)
- get_elem_mut_loop x l
-
-/- [loops::get_elem_mut]: loop 0: backward function 0 -/
-divergent def get_elem_mut_loop_back
- (x : Usize) (ls : List Usize) (ret0 : Usize) : Result (List Usize) :=
- match ls with
- | List.Cons y tl =>
- if y = x
- then Result.ret (List.Cons ret0 tl)
- else
- do
- let tl0 ← get_elem_mut_loop_back x tl ret0
- Result.ret (List.Cons y tl0)
- | List.Nil => Result.fail Error.panic
-
-/- [loops::get_elem_mut]: backward function 0 -/
-def get_elem_mut_back
- (slots : Vec (List Usize)) (x : Usize) (ret0 : Usize) :
- Result (Vec (List Usize))
- :=
- do
- let l ← Vec.index_mut (List Usize) slots (Usize.ofInt 0)
- let l0 ← get_elem_mut_loop_back x l ret0
- Vec.index_mut_back (List Usize) slots (Usize.ofInt 0) l0
-
-/- [loops::get_elem_shared]: loop 0: forward function -/
-divergent def get_elem_shared_loop
- (x : Usize) (ls : List Usize) : Result Usize :=
- match ls with
- | List.Cons y tl => if y = x
- then Result.ret y
- else get_elem_shared_loop x tl
- | List.Nil => Result.fail Error.panic
-
-/- [loops::get_elem_shared]: forward function -/
-def get_elem_shared (slots : Vec (List Usize)) (x : Usize) : Result Usize :=
- do
- let l ← Vec.index_shared (List Usize) slots (Usize.ofInt 0)
- get_elem_shared_loop x l
-
-/- [loops::id_mut]: forward function -/
-def id_mut (T : Type) (ls : List T) : Result (List T) :=
- Result.ret ls
-
-/- [loops::id_mut]: backward function 0 -/
-def id_mut_back (T : Type) (ls : List T) (ret0 : List T) : Result (List T) :=
- Result.ret ret0
-
-/- [loops::id_shared]: forward function -/
-def id_shared (T : Type) (ls : List T) : Result (List T) :=
- Result.ret ls
-
-/- [loops::list_nth_mut_loop_with_id]: loop 0: forward function -/
-divergent def list_nth_mut_loop_with_id_loop
- (T : Type) (i : U32) (ls : List T) : Result T :=
- match ls with
- | List.Cons x tl =>
- if i = (U32.ofInt 0)
- then Result.ret x
- else do
- let i0 ← i - (U32.ofInt 1)
- list_nth_mut_loop_with_id_loop T i0 tl
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_with_id]: forward function -/
-def list_nth_mut_loop_with_id (T : Type) (ls : List T) (i : U32) : Result T :=
- do
- let ls0 ← id_mut T ls
- list_nth_mut_loop_with_id_loop T i ls0
-
-/- [loops::list_nth_mut_loop_with_id]: loop 0: backward function 0 -/
-divergent def list_nth_mut_loop_with_id_loop_back
- (T : Type) (i : U32) (ls : List T) (ret0 : T) : Result (List T) :=
- match ls with
- | List.Cons x tl =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl0 ← list_nth_mut_loop_with_id_loop_back T i0 tl ret0
- Result.ret (List.Cons x tl0)
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_with_id]: backward function 0 -/
-def list_nth_mut_loop_with_id_back
- (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
- do
- let ls0 ← id_mut T ls
- let l ← list_nth_mut_loop_with_id_loop_back T i ls0 ret0
- id_mut_back T ls l
-
-/- [loops::list_nth_shared_loop_with_id]: loop 0: forward function -/
-divergent def list_nth_shared_loop_with_id_loop
- (T : Type) (i : U32) (ls : List T) : Result T :=
- match ls with
- | List.Cons x tl =>
- if i = (U32.ofInt 0)
- then Result.ret x
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_shared_loop_with_id_loop T i0 tl
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_loop_with_id]: forward function -/
-def list_nth_shared_loop_with_id
- (T : Type) (ls : List T) (i : U32) : Result T :=
- do
- let ls0 ← id_shared T ls
- list_nth_shared_loop_with_id_loop T i ls0
-
-/- [loops::list_nth_mut_loop_pair]: loop 0: forward function -/
-divergent def list_nth_mut_loop_pair_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_mut_loop_pair_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_pair]: forward function -/
-def list_nth_mut_loop_pair
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- list_nth_mut_loop_pair_loop T ls0 ls1 i
-
-/- [loops::list_nth_mut_loop_pair]: loop 0: backward function 0 -/
-divergent def list_nth_mut_loop_pair_loop_back'a
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl0)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl00 ← list_nth_mut_loop_pair_loop_back'a T tl0 tl1 i0 ret0
- Result.ret (List.Cons x0 tl00)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_pair]: backward function 0 -/
-def list_nth_mut_loop_pair_back'a
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- list_nth_mut_loop_pair_loop_back'a T ls0 ls1 i ret0
-
-/- [loops::list_nth_mut_loop_pair]: loop 0: backward function 1 -/
-divergent def list_nth_mut_loop_pair_loop_back'b
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl10 ← list_nth_mut_loop_pair_loop_back'b T tl0 tl1 i0 ret0
- Result.ret (List.Cons x1 tl10)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_pair]: backward function 1 -/
-def list_nth_mut_loop_pair_back'b
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- list_nth_mut_loop_pair_loop_back'b T ls0 ls1 i ret0
-
-/- [loops::list_nth_shared_loop_pair]: loop 0: forward function -/
-divergent def list_nth_shared_loop_pair_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_shared_loop_pair_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_loop_pair]: forward function -/
-def list_nth_shared_loop_pair
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- list_nth_shared_loop_pair_loop T ls0 ls1 i
-
-/- [loops::list_nth_mut_loop_pair_merge]: loop 0: forward function -/
-divergent def list_nth_mut_loop_pair_merge_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_mut_loop_pair_merge_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_pair_merge]: forward function -/
-def list_nth_mut_loop_pair_merge
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- list_nth_mut_loop_pair_merge_loop T ls0 ls1 i
-
-/- [loops::list_nth_mut_loop_pair_merge]: loop 0: backward function 0 -/
-divergent def list_nth_mut_loop_pair_merge_loop_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : (T × T)) :
- Result ((List T) × (List T))
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then let (t, t0) := ret0
- Result.ret (List.Cons t tl0, List.Cons t0 tl1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let (tl00, tl10) ←
- list_nth_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0
- Result.ret (List.Cons x0 tl00, List.Cons x1 tl10)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_loop_pair_merge]: backward function 0 -/
-def list_nth_mut_loop_pair_merge_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : (T × T)) :
- Result ((List T) × (List T))
- :=
- list_nth_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0
-
-/- [loops::list_nth_shared_loop_pair_merge]: loop 0: forward function -/
-divergent def list_nth_shared_loop_pair_merge_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_shared_loop_pair_merge_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_loop_pair_merge]: forward function -/
-def list_nth_shared_loop_pair_merge
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- list_nth_shared_loop_pair_merge_loop T ls0 ls1 i
-
-/- [loops::list_nth_mut_shared_loop_pair]: loop 0: forward function -/
-divergent def list_nth_mut_shared_loop_pair_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_mut_shared_loop_pair_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_shared_loop_pair]: forward function -/
-def list_nth_mut_shared_loop_pair
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- list_nth_mut_shared_loop_pair_loop T ls0 ls1 i
-
-/- [loops::list_nth_mut_shared_loop_pair]: loop 0: backward function 0 -/
-divergent def list_nth_mut_shared_loop_pair_loop_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl0)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl00 ←
- list_nth_mut_shared_loop_pair_loop_back T tl0 tl1 i0 ret0
- Result.ret (List.Cons x0 tl00)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_shared_loop_pair]: backward function 0 -/
-def list_nth_mut_shared_loop_pair_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- list_nth_mut_shared_loop_pair_loop_back T ls0 ls1 i ret0
-
-/- [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: forward function -/
-divergent def list_nth_mut_shared_loop_pair_merge_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_mut_shared_loop_pair_merge_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_shared_loop_pair_merge]: forward function -/
-def list_nth_mut_shared_loop_pair_merge
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- 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 -/
-divergent def list_nth_mut_shared_loop_pair_merge_loop_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl0)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl00 ←
- list_nth_mut_shared_loop_pair_merge_loop_back T tl0 tl1 i0 ret0
- Result.ret (List.Cons x0 tl00)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_mut_shared_loop_pair_merge]: backward function 0 -/
-def list_nth_mut_shared_loop_pair_merge_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- list_nth_mut_shared_loop_pair_merge_loop_back T ls0 ls1 i ret0
-
-/- [loops::list_nth_shared_mut_loop_pair]: loop 0: forward function -/
-divergent def list_nth_shared_mut_loop_pair_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_shared_mut_loop_pair_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_mut_loop_pair]: forward function -/
-def list_nth_shared_mut_loop_pair
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- list_nth_shared_mut_loop_pair_loop T ls0 ls1 i
-
-/- [loops::list_nth_shared_mut_loop_pair]: loop 0: backward function 1 -/
-divergent def list_nth_shared_mut_loop_pair_loop_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl10 ←
- list_nth_shared_mut_loop_pair_loop_back T tl0 tl1 i0 ret0
- Result.ret (List.Cons x1 tl10)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_mut_loop_pair]: backward function 1 -/
-def list_nth_shared_mut_loop_pair_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- list_nth_shared_mut_loop_pair_loop_back T ls0 ls1 i ret0
-
-/- [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: forward function -/
-divergent def list_nth_shared_mut_loop_pair_merge_loop
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (x0, x1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- list_nth_shared_mut_loop_pair_merge_loop T tl0 tl1 i0
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_mut_loop_pair_merge]: forward function -/
-def list_nth_shared_mut_loop_pair_merge
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
- 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 -/
-divergent def list_nth_shared_mut_loop_pair_merge_loop_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- match ls0 with
- | List.Cons x0 tl0 =>
- match ls1 with
- | List.Cons x1 tl1 =>
- if i = (U32.ofInt 0)
- then Result.ret (List.Cons ret0 tl1)
- else
- do
- let i0 ← i - (U32.ofInt 1)
- let tl10 ←
- list_nth_shared_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0
- Result.ret (List.Cons x1 tl10)
- | List.Nil => Result.fail Error.panic
- | List.Nil => Result.fail Error.panic
-
-/- [loops::list_nth_shared_mut_loop_pair_merge]: backward function 0 -/
-def list_nth_shared_mut_loop_pair_merge_back
- (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
- Result (List T)
- :=
- list_nth_shared_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0
-
-end loops
diff --git a/tests/lean/Loops/Types.lean b/tests/lean/Loops/Types.lean
deleted file mode 100644
index 018af901..00000000
--- a/tests/lean/Loops/Types.lean
+++ /dev/null
@@ -1,13 +0,0 @@
--- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
--- [loops]: type definitions
-import Base
-open Primitives
-
-namespace loops
-
-/- [loops::List] -/
-inductive List (T : Type) :=
-| Cons : T → List T → List T
-| Nil : List T
-
-end loops
diff --git a/tests/lean/NoNestedBorrows.lean b/tests/lean/NoNestedBorrows.lean
index 884e62c4..c4a6a265 100644
--- a/tests/lean/NoNestedBorrows.lean
+++ b/tests/lean/NoNestedBorrows.lean
@@ -54,12 +54,24 @@ def div_test (x : U32) (y : U32) : Result U32 :=
/- [no_nested_borrows::div_test1]: forward function -/
def div_test1 (x : U32) : Result U32 :=
- x / (U32.ofInt 2)
+ x / 2#u32
/- [no_nested_borrows::rem_test]: forward function -/
def rem_test (x : U32) (y : U32) : Result U32 :=
x % y
+/- [no_nested_borrows::mul_test]: forward function -/
+def mul_test (x : U32) (y : U32) : Result U32 :=
+ x * y
+
+/- [no_nested_borrows::CONST0] -/
+def const0_body : Result Usize := 1#usize + 1#usize
+def const0_c : Usize := eval_global const0_body (by simp)
+
+/- [no_nested_borrows::CONST1] -/
+def const1_body : Result Usize := 2#usize * 2#usize
+def const1_c : Usize := eval_global const1_body (by simp)
+
/- [no_nested_borrows::cast_test]: forward function -/
def cast_test (x : U32) : Result I32 :=
Scalar.cast .I32 x
@@ -67,7 +79,7 @@ def cast_test (x : U32) : Result I32 :=
/- [no_nested_borrows::test2]: forward function -/
def test2 : Result Unit :=
do
- let _ ← (U32.ofInt 23) + (U32.ofInt 44)
+ let _ ← 23#u32 + 44#u32
Result.ret ()
/- Unit test for [no_nested_borrows::test2] -/
@@ -82,10 +94,10 @@ def get_max (x : U32) (y : U32) : Result U32 :=
/- [no_nested_borrows::test3]: forward function -/
def test3 : Result Unit :=
do
- let x ← get_max (U32.ofInt 4) (U32.ofInt 3)
- let y ← get_max (U32.ofInt 10) (U32.ofInt 11)
+ let x ← get_max 4#u32 3#u32
+ let y ← get_max 10#u32 11#u32
let z ← x + y
- if not (z = (U32.ofInt 15))
+ if not (z = 15#u32)
then Result.fail Error.panic
else Result.ret ()
@@ -95,8 +107,8 @@ def test3 : Result Unit :=
/- [no_nested_borrows::test_neg1]: forward function -/
def test_neg1 : Result Unit :=
do
- let y ← - (I32.ofInt 3)
- if not (y = (I32.ofInt (-(3:Int))))
+ let y ← - 3#i32
+ if not (y = (-(3:Int))#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -105,7 +117,7 @@ def test_neg1 : Result Unit :=
/- [no_nested_borrows::refs_test1]: forward function -/
def refs_test1 : Result Unit :=
- if not ((I32.ofInt 1) = (I32.ofInt 1))
+ if not (1#i32 = 1#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -114,16 +126,16 @@ def refs_test1 : Result Unit :=
/- [no_nested_borrows::refs_test2]: forward function -/
def refs_test2 : Result Unit :=
- if not ((I32.ofInt 2) = (I32.ofInt 2))
+ if not (2#i32 = 2#i32)
then Result.fail Error.panic
else
- if not ((I32.ofInt 0) = (I32.ofInt 0))
+ if not (0#i32 = 0#i32)
then Result.fail Error.panic
else
- if not ((I32.ofInt 2) = (I32.ofInt 2))
+ if not (2#i32 = 2#i32)
then Result.fail Error.panic
else
- if not ((I32.ofInt 2) = (I32.ofInt 2))
+ if not (2#i32 = 2#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -139,9 +151,9 @@ def test_list1 : Result Unit :=
/- [no_nested_borrows::test_box1]: forward function -/
def test_box1 : Result Unit :=
- let b := (I32.ofInt 1)
+ let b := 1#i32
let x := b
- if not (x = (I32.ofInt 1))
+ if not (x = 1#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -167,8 +179,8 @@ def test_panic (b : Bool) : Result Unit :=
/- [no_nested_borrows::test_copy_int]: forward function -/
def test_copy_int : Result Unit :=
do
- let y ← copy_int (I32.ofInt 0)
- if not ((I32.ofInt 0) = y)
+ let y ← copy_int 0#i32
+ if not (0#i32 = y)
then Result.fail Error.panic
else Result.ret ()
@@ -185,7 +197,7 @@ def is_cons (T : Type) (l : List T) : Result Bool :=
def test_is_cons : Result Unit :=
do
let l := List.Nil
- let b ← is_cons I32 (List.Cons (I32.ofInt 0) l)
+ let b ← is_cons I32 (List.Cons 0#i32 l)
if not b
then Result.fail Error.panic
else Result.ret ()
@@ -203,9 +215,9 @@ def split_list (T : Type) (l : List T) : Result (T × (List T)) :=
def test_split_list : Result Unit :=
do
let l := List.Nil
- let p ← split_list I32 (List.Cons (I32.ofInt 0) l)
+ let p ← split_list I32 (List.Cons 0#i32 l)
let (hd, _) := p
- if not (hd = (I32.ofInt 0))
+ if not (hd = 0#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -228,19 +240,18 @@ def choose_back
/- [no_nested_borrows::choose_test]: forward function -/
def choose_test : Result Unit :=
do
- let z ← choose I32 true (I32.ofInt 0) (I32.ofInt 0)
- let z0 ← z + (I32.ofInt 1)
- if not (z0 = (I32.ofInt 1))
+ let z ← choose I32 true 0#i32 0#i32
+ let z0 ← z + 1#i32
+ if not (z0 = 1#i32)
then Result.fail Error.panic
else
do
- let (x, y) ← choose_back I32 true (I32.ofInt 0) (I32.ofInt 0) z0
- if not (x = (I32.ofInt 1))
+ let (x, y) ← choose_back I32 true 0#i32 0#i32 z0
+ if not (x = 1#i32)
then Result.fail Error.panic
- else
- if not (y = (I32.ofInt 0))
- then Result.fail Error.panic
- else Result.ret ()
+ else if not (y = 0#i32)
+ then Result.fail Error.panic
+ else Result.ret ()
/- Unit test for [no_nested_borrows::choose_test] -/
#assert (choose_test == .ret ())
@@ -268,17 +279,17 @@ divergent def list_length (T : Type) (l : List T) : Result U32 :=
match l with
| List.Cons t l1 => do
let i ← list_length T l1
- (U32.ofInt 1) + i
- | List.Nil => Result.ret (U32.ofInt 0)
+ 1#u32 + i
+ | List.Nil => Result.ret 0#u32
/- [no_nested_borrows::list_nth_shared]: forward function -/
divergent def list_nth_shared (T : Type) (l : List T) (i : U32) : Result T :=
match l with
| List.Cons x tl =>
- if i = (U32.ofInt 0)
+ if i = 0#u32
then Result.ret x
else do
- let i0 ← i - (U32.ofInt 1)
+ let i0 ← i - 1#u32
list_nth_shared T tl i0
| List.Nil => Result.fail Error.panic
@@ -286,10 +297,10 @@ divergent def list_nth_shared (T : Type) (l : List T) (i : U32) : Result T :=
divergent def list_nth_mut (T : Type) (l : List T) (i : U32) : Result T :=
match l with
| List.Cons x tl =>
- if i = (U32.ofInt 0)
+ if i = 0#u32
then Result.ret x
else do
- let i0 ← i - (U32.ofInt 1)
+ let i0 ← i - 1#u32
list_nth_mut T tl i0
| List.Nil => Result.fail Error.panic
@@ -298,11 +309,11 @@ divergent def list_nth_mut_back
(T : Type) (l : List T) (i : U32) (ret0 : T) : Result (List T) :=
match l with
| List.Cons x tl =>
- if i = (U32.ofInt 0)
+ if i = 0#u32
then Result.ret (List.Cons ret0 tl)
else
do
- let i0 ← i - (U32.ofInt 1)
+ let i0 ← i - 1#u32
let tl0 ← list_nth_mut_back T tl i0 ret0
Result.ret (List.Cons x tl0)
| List.Nil => Result.fail Error.panic
@@ -317,54 +328,49 @@ divergent def list_rev_aux
/- [no_nested_borrows::list_rev]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def list_rev (T : Type) (l : List T) : Result (List T) :=
- let li := mem.replace (List T) l List.Nil
+ let li := core.mem.replace (List T) l List.Nil
list_rev_aux T li List.Nil
/- [no_nested_borrows::test_list_functions]: forward function -/
def test_list_functions : Result Unit :=
do
let l := List.Nil
- let l0 := List.Cons (I32.ofInt 2) l
- let l1 := List.Cons (I32.ofInt 1) l0
- let i ← list_length I32 (List.Cons (I32.ofInt 0) l1)
- if not (i = (U32.ofInt 3))
+ let l0 := List.Cons 2#i32 l
+ let l1 := List.Cons 1#i32 l0
+ let i ← list_length I32 (List.Cons 0#i32 l1)
+ if not (i = 3#u32)
then Result.fail Error.panic
else
do
- let i0 ←
- list_nth_shared I32 (List.Cons (I32.ofInt 0) l1) (U32.ofInt 0)
- if not (i0 = (I32.ofInt 0))
+ let i0 ← list_nth_shared I32 (List.Cons 0#i32 l1) 0#u32
+ if not (i0 = 0#i32)
then Result.fail Error.panic
else
do
- let i1 ←
- list_nth_shared I32 (List.Cons (I32.ofInt 0) l1) (U32.ofInt 1)
- if not (i1 = (I32.ofInt 1))
+ let i1 ← list_nth_shared I32 (List.Cons 0#i32 l1) 1#u32
+ if not (i1 = 1#i32)
then Result.fail Error.panic
else
do
- let i2 ←
- list_nth_shared I32 (List.Cons (I32.ofInt 0) l1)
- (U32.ofInt 2)
- if not (i2 = (I32.ofInt 2))
+ let i2 ← list_nth_shared I32 (List.Cons 0#i32 l1) 2#u32
+ if not (i2 = 2#i32)
then Result.fail Error.panic
else
do
let ls ←
- list_nth_mut_back I32 (List.Cons (I32.ofInt 0) l1)
- (U32.ofInt 1) (I32.ofInt 3)
- let i3 ← list_nth_shared I32 ls (U32.ofInt 0)
- if not (i3 = (I32.ofInt 0))
+ list_nth_mut_back I32 (List.Cons 0#i32 l1) 1#u32 3#i32
+ let i3 ← list_nth_shared I32 ls 0#u32
+ if not (i3 = 0#i32)
then Result.fail Error.panic
else
do
- let i4 ← list_nth_shared I32 ls (U32.ofInt 1)
- if not (i4 = (I32.ofInt 3))
+ let i4 ← list_nth_shared I32 ls 1#u32
+ if not (i4 = 3#i32)
then Result.fail Error.panic
else
do
- let i5 ← list_nth_shared I32 ls (U32.ofInt 2)
- if not (i5 = (I32.ofInt 2))
+ let i5 ← list_nth_shared I32 ls 2#u32
+ if not (i5 = 2#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -427,15 +433,15 @@ structure StructWithTuple (T1 T2 : Type) where
/- [no_nested_borrows::new_tuple1]: forward function -/
def new_tuple1 : Result (StructWithTuple U32 U32) :=
- Result.ret { p := ((U32.ofInt 1), (U32.ofInt 2)) }
+ Result.ret { p := (1#u32, 2#u32) }
/- [no_nested_borrows::new_tuple2]: forward function -/
def new_tuple2 : Result (StructWithTuple I16 I16) :=
- Result.ret { p := ((I16.ofInt 1), (I16.ofInt 2)) }
+ Result.ret { p := (1#i16, 2#i16) }
/- [no_nested_borrows::new_tuple3]: forward function -/
def new_tuple3 : Result (StructWithTuple U64 I64) :=
- Result.ret { p := ((U64.ofInt 1), (I64.ofInt 2)) }
+ Result.ret { p := (1#u64, 2#i64) }
/- [no_nested_borrows::StructWithPair] -/
structure StructWithPair (T1 T2 : Type) where
@@ -443,31 +449,31 @@ structure StructWithPair (T1 T2 : Type) where
/- [no_nested_borrows::new_pair1]: forward function -/
def new_pair1 : Result (StructWithPair U32 U32) :=
- Result.ret { p := { x := (U32.ofInt 1), y := (U32.ofInt 2) } }
+ Result.ret { p := { x := 1#u32, y := 2#u32 } }
/- [no_nested_borrows::test_constants]: forward function -/
def test_constants : Result Unit :=
do
let swt ← new_tuple1
let (i, _) := swt.p
- if not (i = (U32.ofInt 1))
+ if not (i = 1#u32)
then Result.fail Error.panic
else
do
let swt0 ← new_tuple2
let (i0, _) := swt0.p
- if not (i0 = (I16.ofInt 1))
+ if not (i0 = 1#i16)
then Result.fail Error.panic
else
do
let swt1 ← new_tuple3
let (i1, _) := swt1.p
- if not (i1 = (U64.ofInt 1))
+ if not (i1 = 1#u64)
then Result.fail Error.panic
else
do
let swp ← new_pair1
- if not (swp.p.x = (U32.ofInt 1))
+ if not (swp.p.x = 1#u32)
then Result.fail Error.panic
else Result.ret ()
@@ -484,29 +490,29 @@ def test_weird_borrows1 : Result Unit :=
/- [no_nested_borrows::test_mem_replace]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def test_mem_replace (px : U32) : Result U32 :=
- let y := mem.replace U32 px (U32.ofInt 1)
- if not (y = (U32.ofInt 0))
+ let y := core.mem.replace U32 px 1#u32
+ if not (y = 0#u32)
then Result.fail Error.panic
- else Result.ret (U32.ofInt 2)
+ else Result.ret 2#u32
/- [no_nested_borrows::test_shared_borrow_bool1]: forward function -/
def test_shared_borrow_bool1 (b : Bool) : Result U32 :=
if b
- then Result.ret (U32.ofInt 0)
- else Result.ret (U32.ofInt 1)
+ then Result.ret 0#u32
+ else Result.ret 1#u32
/- [no_nested_borrows::test_shared_borrow_bool2]: forward function -/
def test_shared_borrow_bool2 : Result U32 :=
- Result.ret (U32.ofInt 0)
+ Result.ret 0#u32
/- [no_nested_borrows::test_shared_borrow_enum1]: forward function -/
def test_shared_borrow_enum1 (l : List U32) : Result U32 :=
match l with
- | List.Cons i l0 => Result.ret (U32.ofInt 1)
- | List.Nil => Result.ret (U32.ofInt 0)
+ | List.Cons i l0 => Result.ret 1#u32
+ | List.Nil => Result.ret 0#u32
/- [no_nested_borrows::test_shared_borrow_enum2]: forward function -/
def test_shared_borrow_enum2 : Result U32 :=
- Result.ret (U32.ofInt 0)
+ Result.ret 0#u32
end no_nested_borrows
diff --git a/tests/lean/Paper.lean b/tests/lean/Paper.lean
index c15c5e4b..ae4dd243 100644
--- a/tests/lean/Paper.lean
+++ b/tests/lean/Paper.lean
@@ -8,13 +8,13 @@ namespace paper
/- [paper::ref_incr]: merged forward/backward function
(there is a single backward function, and the forward function returns ()) -/
def ref_incr (x : I32) : Result I32 :=
- x + (I32.ofInt 1)
+ x + 1#i32
/- [paper::test_incr]: forward function -/
def test_incr : Result Unit :=
do
- let x ← ref_incr (I32.ofInt 0)
- if not (x = (I32.ofInt 1))
+ let x ← ref_incr 0#i32
+ if not (x = 1#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -37,19 +37,18 @@ def choose_back
/- [paper::test_choose]: forward function -/
def test_choose : Result Unit :=
do
- let z ← choose I32 true (I32.ofInt 0) (I32.ofInt 0)
- let z0 ← z + (I32.ofInt 1)
- if not (z0 = (I32.ofInt 1))
+ let z ← choose I32 true 0#i32 0#i32
+ let z0 ← z + 1#i32
+ if not (z0 = 1#i32)
then Result.fail Error.panic
else
do
- let (x, y) ← choose_back I32 true (I32.ofInt 0) (I32.ofInt 0) z0
- if not (x = (I32.ofInt 1))
+ let (x, y) ← choose_back I32 true 0#i32 0#i32 z0
+ if not (x = 1#i32)
then Result.fail Error.panic
- else
- if not (y = (I32.ofInt 0))
- then Result.fail Error.panic
- else Result.ret ()
+ else if not (y = 0#i32)
+ then Result.fail Error.panic
+ else Result.ret ()
/- Unit test for [paper::test_choose] -/
#assert (test_choose == .ret ())
@@ -63,10 +62,10 @@ inductive List (T : Type) :=
divergent def list_nth_mut (T : Type) (l : List T) (i : U32) : Result T :=
match l with
| List.Cons x tl =>
- if i = (U32.ofInt 0)
+ if i = 0#u32
then Result.ret x
else do
- let i0 ← i - (U32.ofInt 1)
+ let i0 ← i - 1#u32
list_nth_mut T tl i0
| List.Nil => Result.fail Error.panic
@@ -75,11 +74,11 @@ divergent def list_nth_mut_back
(T : Type) (l : List T) (i : U32) (ret0 : T) : Result (List T) :=
match l with
| List.Cons x tl =>
- if i = (U32.ofInt 0)
+ if i = 0#u32
then Result.ret (List.Cons ret0 tl)
else
do
- let i0 ← i - (U32.ofInt 1)
+ let i0 ← i - 1#u32
let tl0 ← list_nth_mut_back T tl i0 ret0
Result.ret (List.Cons x tl0)
| List.Nil => Result.fail Error.panic
@@ -90,20 +89,19 @@ divergent def sum (l : List I32) : Result I32 :=
| List.Cons x tl => do
let i ← sum tl
x + i
- | List.Nil => Result.ret (I32.ofInt 0)
+ | List.Nil => Result.ret 0#i32
/- [paper::test_nth]: forward function -/
def test_nth : Result Unit :=
do
let l := List.Nil
- let l0 := List.Cons (I32.ofInt 3) l
- let l1 := List.Cons (I32.ofInt 2) l0
- let x ← list_nth_mut I32 (List.Cons (I32.ofInt 1) l1) (U32.ofInt 2)
- let x0 ← x + (I32.ofInt 1)
- let l2 ←
- list_nth_mut_back I32 (List.Cons (I32.ofInt 1) l1) (U32.ofInt 2) x0
+ let l0 := List.Cons 3#i32 l
+ let l1 := List.Cons 2#i32 l0
+ let x ← list_nth_mut I32 (List.Cons 1#i32 l1) 2#u32
+ let x0 ← x + 1#i32
+ let l2 ← list_nth_mut_back I32 (List.Cons 1#i32 l1) 2#u32 x0
let i ← sum l2
- if not (i = (I32.ofInt 7))
+ if not (i = 7#i32)
then Result.fail Error.panic
else Result.ret ()
@@ -115,7 +113,7 @@ def call_choose (p : (U32 × U32)) : Result U32 :=
do
let (px, py) := p
let pz ← choose U32 true px py
- let pz0 ← pz + (U32.ofInt 1)
+ let pz0 ← pz + 1#u32
let (px0, _) ← choose_back U32 true px py pz0
Result.ret px0
diff --git a/tests/lean/Traits.lean b/tests/lean/Traits.lean
new file mode 100644
index 00000000..12e7eafa
--- /dev/null
+++ b/tests/lean/Traits.lean
@@ -0,0 +1,383 @@
+-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
+-- [traits]
+import Base
+open Primitives
+
+namespace traits
+
+/- Trait declaration: [traits::BoolTrait] -/
+structure BoolTrait (Self : Type) where
+ get_bool : Self → Result Bool
+
+/- [traits::Bool::{0}::get_bool]: forward function -/
+def Bool.get_bool (self : Bool) : Result Bool :=
+ Result.ret self
+
+/- Trait implementation: [traits::Bool::{0}] -/
+def Bool.BoolTraitInst : BoolTrait Bool := {
+ get_bool := Bool.get_bool
+}
+
+/- [traits::BoolTrait::ret_true]: forward function -/
+def BoolTrait.ret_true
+ {Self : Type} (self_clause : BoolTrait Self) (self : Self) : Result Bool :=
+ Result.ret true
+
+/- [traits::test_bool_trait_bool]: forward function -/
+def test_bool_trait_bool (x : Bool) : Result Bool :=
+ do
+ let b ← Bool.get_bool x
+ if b
+ then BoolTrait.ret_true Bool.BoolTraitInst x
+ else Result.ret false
+
+/- [traits::Option::{1}::get_bool]: forward function -/
+def Option.get_bool (T : Type) (self : Option T) : Result Bool :=
+ match self with
+ | none => Result.ret false
+ | some t => Result.ret true
+
+/- Trait implementation: [traits::Option::{1}] -/
+def Option.BoolTraitInst (T : Type) : BoolTrait (Option T) := {
+ get_bool := Option.get_bool T
+}
+
+/- [traits::test_bool_trait_option]: forward function -/
+def test_bool_trait_option (T : Type) (x : Option T) : Result Bool :=
+ do
+ let b ← Option.get_bool T x
+ if b
+ then BoolTrait.ret_true (Option.BoolTraitInst T) x
+ else Result.ret false
+
+/- [traits::test_bool_trait]: forward function -/
+def test_bool_trait (T : Type) (inst : BoolTrait T) (x : T) : Result Bool :=
+ inst.get_bool x
+
+/- Trait declaration: [traits::ToU64] -/
+structure ToU64 (Self : Type) where
+ to_u64 : Self → Result U64
+
+/- [traits::u64::{2}::to_u64]: forward function -/
+def u64.to_u64 (self : U64) : Result U64 :=
+ Result.ret self
+
+/- Trait implementation: [traits::u64::{2}] -/
+def u64.ToU64Inst : ToU64 U64 := {
+ to_u64 := u64.to_u64
+}
+
+/- [traits::Tuple2::{3}::to_u64]: forward function -/
+def Tuple2.to_u64 (A : Type) (inst : ToU64 A) (self : (A × A)) : Result U64 :=
+ do
+ let (t, t0) := self
+ let i ← inst.to_u64 t
+ let i0 ← inst.to_u64 t0
+ i + i0
+
+/- Trait implementation: [traits::Tuple2::{3}] -/
+def Tuple2.ToU64Inst (A : Type) (inst : ToU64 A) : ToU64 (A × A) := {
+ to_u64 := Tuple2.to_u64 A inst
+}
+
+/- [traits::f]: forward function -/
+def f (T : Type) (inst : ToU64 T) (x : (T × T)) : Result U64 :=
+ Tuple2.to_u64 T inst x
+
+/- [traits::g]: forward function -/
+def g (T : Type) (inst : ToU64 (T × T)) (x : (T × T)) : Result U64 :=
+ inst.to_u64 x
+
+/- [traits::h0]: forward function -/
+def h0 (x : U64) : Result U64 :=
+ u64.to_u64 x
+
+/- [traits::Wrapper] -/
+structure Wrapper (T : Type) where
+ x : T
+
+/- [traits::Wrapper::{4}::to_u64]: forward function -/
+def Wrapper.to_u64
+ (T : Type) (inst : ToU64 T) (self : Wrapper T) : Result U64 :=
+ inst.to_u64 self.x
+
+/- Trait implementation: [traits::Wrapper::{4}] -/
+def Wrapper.ToU64Inst (T : Type) (inst : ToU64 T) : ToU64 (Wrapper T) := {
+ to_u64 := Wrapper.to_u64 T inst
+}
+
+/- [traits::h1]: forward function -/
+def h1 (x : Wrapper U64) : Result U64 :=
+ Wrapper.to_u64 U64 u64.ToU64Inst x
+
+/- [traits::h2]: forward function -/
+def h2 (T : Type) (inst : ToU64 T) (x : Wrapper T) : Result U64 :=
+ Wrapper.to_u64 T inst x
+
+/- Trait declaration: [traits::ToType] -/
+structure ToType (Self T : Type) where
+ to_type : Self → Result T
+
+/- [traits::u64::{5}::to_type]: forward function -/
+def u64.to_type (self : U64) : Result Bool :=
+ Result.ret (self > 0#u64)
+
+/- Trait implementation: [traits::u64::{5}] -/
+def u64.ToTypeInst : ToType U64 Bool := {
+ to_type := u64.to_type
+}
+
+/- Trait declaration: [traits::OfType] -/
+structure OfType (Self : Type) where
+ of_type : forall (T : Type) (inst : ToType T Self), T → Result Self
+
+/- [traits::h3]: forward function -/
+def h3
+ (T1 T2 : Type) (inst : OfType T1) (inst0 : ToType T2 T1) (y : T2) :
+ Result T1
+ :=
+ inst.of_type T2 inst0 y
+
+/- Trait declaration: [traits::OfTypeBis] -/
+structure OfTypeBis (Self T : Type) where
+ parent_clause_0 : ToType T Self
+ of_type : T → Result Self
+
+/- [traits::h4]: forward function -/
+def h4
+ (T1 T2 : Type) (inst : OfTypeBis T1 T2) (inst0 : ToType T2 T1) (y : T2) :
+ Result T1
+ :=
+ inst.of_type y
+
+/- [traits::TestType] -/
+structure TestType (T : Type) where
+ _0 : T
+
+/- [traits::TestType::{6}::test::TestType1] -/
+structure TestType.test.TestType1 where
+ _0 : U64
+
+/- Trait declaration: [traits::TestType::{6}::test::TestTrait] -/
+structure TestType.test.TestTrait (Self : Type) where
+ test : Self → Result Bool
+
+/- [traits::TestType::{6}::test::TestType1::{0}::test]: forward function -/
+def TestType.test.TestType1.test
+ (self : TestType.test.TestType1) : Result Bool :=
+ Result.ret (self._0 > 1#u64)
+
+/- Trait implementation: [traits::TestType::{6}::test::TestType1::{0}] -/
+def TestType.test.TestType1.TestTypetestTestTraitInst : TestType.test.TestTrait
+ TestType.test.TestType1 := {
+ test := TestType.test.TestType1.test
+}
+
+/- [traits::TestType::{6}::test]: forward function -/
+def TestType.test
+ (T : Type) (inst : ToU64 T) (self : TestType T) (x : T) : Result Bool :=
+ do
+ let x0 ← inst.to_u64 x
+ if x0 > 0#u64
+ then TestType.test.TestType1.test { _0 := 0#u64 }
+ else Result.ret false
+
+/- [traits::BoolWrapper] -/
+structure BoolWrapper where
+ _0 : Bool
+
+/- [traits::BoolWrapper::{7}::to_type]: forward function -/
+def BoolWrapper.to_type
+ (T : Type) (inst : ToType Bool T) (self : BoolWrapper) : Result T :=
+ inst.to_type self._0
+
+/- Trait implementation: [traits::BoolWrapper::{7}] -/
+def BoolWrapper.ToTypeInst (T : Type) (inst : ToType Bool T) : ToType
+ BoolWrapper T := {
+ to_type := BoolWrapper.to_type T inst
+}
+
+/- [traits::WithConstTy::LEN2] -/
+def with_const_ty_len2_body : Result Usize := Result.ret 32#usize
+def with_const_ty_len2_c : Usize :=
+ eval_global with_const_ty_len2_body (by simp)
+
+/- Trait declaration: [traits::WithConstTy] -/
+structure WithConstTy (Self : Type) (LEN : Usize) where
+ LEN1 : Usize
+ LEN2 : Usize
+ V : Type
+ W : Type
+ W_clause_0 : ToU64 W
+ f : W → Array U8 LEN → Result W
+
+/- [traits::Bool::{8}::LEN1] -/
+def bool_len1_body : Result Usize := Result.ret 12#usize
+def bool_len1_c : Usize := eval_global bool_len1_body (by simp)
+
+/- [traits::Bool::{8}::f]: merged forward/backward function
+ (there is a single backward function, and the forward function returns ()) -/
+def Bool.f (i : U64) (a : Array U8 32#usize) : Result U64 :=
+ Result.ret i
+
+/- Trait implementation: [traits::Bool::{8}] -/
+def Bool.WithConstTyInst : WithConstTy Bool 32#usize := {
+ LEN1 := bool_len1_c
+ LEN2 := with_const_ty_len2_c
+ V := U8
+ W := U64
+ W_clause_0 := u64.ToU64Inst
+ f := Bool.f
+}
+
+/- [traits::use_with_const_ty1]: forward function -/
+def use_with_const_ty1
+ (H : Type) (LEN : Usize) (inst : WithConstTy H LEN) : Result Usize :=
+ let i := inst.LEN1
+ Result.ret i
+
+/- [traits::use_with_const_ty2]: forward function -/
+def use_with_const_ty2
+ (H : Type) (LEN : Usize) (inst : WithConstTy H LEN) (w : inst.W) :
+ Result Unit
+ :=
+ Result.ret ()
+
+/- [traits::use_with_const_ty3]: forward function -/
+def use_with_const_ty3
+ (H : Type) (LEN : Usize) (inst : WithConstTy H LEN) (x : inst.W) :
+ Result U64
+ :=
+ inst.W_clause_0.to_u64 x
+
+/- [traits::test_where1]: forward function -/
+def test_where1 (T : Type) (_x : T) : Result Unit :=
+ Result.ret ()
+
+/- [traits::test_where2]: forward function -/
+def test_where2
+ (T : Type) (inst : WithConstTy T 32#usize) (_x : U32) : Result Unit :=
+ Result.ret ()
+
+/- [alloc::string::String] -/
+axiom alloc.string.String : Type
+
+/- Trait declaration: [traits::ParentTrait0] -/
+structure ParentTrait0 (Self : Type) where
+ W : Type
+ get_name : Self → Result alloc.string.String
+ get_w : Self → Result W
+
+/- Trait declaration: [traits::ParentTrait1] -/
+structure ParentTrait1 (Self : Type) where
+
+/- Trait declaration: [traits::ChildTrait] -/
+structure ChildTrait (Self : Type) where
+ parent_clause_0 : ParentTrait0 Self
+ parent_clause_1 : ParentTrait1 Self
+
+/- [traits::test_child_trait1]: forward function -/
+def test_child_trait1
+ (T : Type) (inst : ChildTrait T) (x : T) : Result alloc.string.String :=
+ inst.parent_clause_0.get_name x
+
+/- [traits::test_child_trait2]: forward function -/
+def test_child_trait2
+ (T : Type) (inst : ChildTrait T) (x : T) : Result inst.parent_clause_0.W :=
+ inst.parent_clause_0.get_w x
+
+/- [traits::order1]: forward function -/
+def order1
+ (T U : Type) (inst : ParentTrait0 T) (inst0 : ParentTrait0 U) :
+ Result Unit
+ :=
+ Result.ret ()
+
+/- Trait declaration: [traits::ChildTrait1] -/
+structure ChildTrait1 (Self : Type) where
+ parent_clause_0 : ParentTrait1 Self
+
+/- Trait implementation: [traits::usize::{9}] -/
+def usize.ParentTrait1Inst : ParentTrait1 Usize := {
+}
+
+/- Trait implementation: [traits::usize::{10}] -/
+def usize.ChildTrait1Inst : ChildTrait1 Usize := {
+ parent_clause_0 := usize.ParentTrait1Inst
+}
+
+/- Trait declaration: [traits::Iterator] -/
+structure Iterator (Self : Type) where
+ Item : Type
+
+/- Trait declaration: [traits::IntoIterator] -/
+structure IntoIterator (Self : Type) where
+ Item : Type
+ IntoIter : Type
+ IntoIter_clause_0 : Iterator IntoIter
+ into_iter : Self → Result IntoIter
+
+/- Trait declaration: [traits::FromResidual] -/
+structure FromResidual (Self T : Type) where
+
+/- Trait declaration: [traits::Try] -/
+structure Try (Self : Type) where
+ Residual : Type
+ parent_clause_0 : FromResidual Self Residual
+
+/- Trait declaration: [traits::WithTarget] -/
+structure WithTarget (Self : Type) where
+ Target : Type
+
+/- Trait declaration: [traits::ParentTrait2] -/
+structure ParentTrait2 (Self : Type) where
+ U : Type
+ U_clause_0 : WithTarget U
+
+/- Trait declaration: [traits::ChildTrait2] -/
+structure ChildTrait2 (Self : Type) where
+ parent_clause_0 : ParentTrait2 Self
+ convert : parent_clause_0.U → Result parent_clause_0.U_clause_0.Target
+
+/- Trait implementation: [traits::u32::{11}] -/
+def u32.WithTargetInst : WithTarget U32 := {
+ Target := U32
+}
+
+/- Trait implementation: [traits::u32::{12}] -/
+def u32.ParentTrait2Inst : ParentTrait2 U32 := {
+ U := U32
+ U_clause_0 := u32.WithTargetInst
+}
+
+/- [traits::u32::{13}::convert]: forward function -/
+def u32.convert (x : U32) : Result U32 :=
+ Result.ret x
+
+/- Trait implementation: [traits::u32::{13}] -/
+def u32.ChildTrait2Inst : ChildTrait2 U32 := {
+ parent_clause_0 := u32.ParentTrait2Inst
+ convert := u32.convert
+}
+
+/- [traits::incr_u32]: forward function -/
+def incr_u32 (x : U32) : Result U32 :=
+ x + 1#u32
+
+/- Trait declaration: [traits::CFnOnce] -/
+structure CFnOnce (Self Args : Type) where
+ Output : Type
+ call_once : Self → Args → Result Output
+
+/- Trait declaration: [traits::CFnMut] -/
+structure CFnMut (Self Args : Type) where
+ parent_clause_0 : CFnOnce Self Args
+ call_mut : Self → Args → Result parent_clause_0.Output
+ call_mut_back : Self → Args → parent_clause_0.Output → Result Self
+
+/- Trait declaration: [traits::CFn] -/
+structure CFn (Self Args : Type) where
+ parent_clause_0 : CFnMut Self Args
+ call_mut : Self → Args → Result parent_clause_0.parent_clause_0.Output
+
+end traits
diff --git a/tests/lean/lakefile.lean b/tests/lean/lakefile.lean
index 8acf6973..fef94971 100644
--- a/tests/lean/lakefile.lean
+++ b/tests/lean/lakefile.lean
@@ -19,3 +19,4 @@ package «tests» {}
@[default_target] lean_lib paper
@[default_target] lean_lib poloniusList
@[default_target] lean_lib array
+@[default_target] lean_lib traits