@@ -37,135 +37,135 @@ type ('k,'v,'id) t = {
37
37
cmp : ('k ,'id) cmp ;
38
38
data : ('k ,'v, 'id ) Dict .t
39
39
}
40
- [@@ bs.deriving abstract ]
41
40
42
41
43
42
44
43
45
- let fromArray (type k ) (type idx ) data ~(id : (k,idx) id ) =
44
+
45
+ let fromArray (type k idx ) data ~(id : (k,idx) id ) =
46
46
let module M = (val id) in
47
47
let cmp = M. cmp in
48
- t ~ cmp ~ data: (Dict. fromArray ~cmp data)
48
+ { cmp; data = (Dict. fromArray ~cmp data)}
49
49
50
50
let remove m x =
51
- let cmp, odata = m |. (cmpGet, dataGet) in
51
+ let { cmp; data = odata} = m in
52
52
let newData = Dict. remove odata x ~cmp in
53
53
if newData == odata then m
54
- else t ~ cmp ~ data: newData
54
+ else { cmp; data = newData}
55
55
56
56
let removeMany m x =
57
- let cmp, odata = m |. (cmpGet, dataGet) in
57
+ let { cmp; data = odata} = m in
58
58
let newData = Dict. removeMany odata x ~cmp in
59
- t ~ cmp ~ data: newData
59
+ { cmp; data = newData}
60
60
61
61
let set m key d =
62
- let cmp = cmpGet m in
63
- t ~ cmp ~ data: ( Dict. set ~cmp (dataGet m) key d)
62
+ let cmp = m.cmp in
63
+ { cmp; data = Dict. set ~cmp m.data key d}
64
64
65
65
let mergeMany m e =
66
- let cmp = cmpGet m in
67
- t ~ cmp ~ data: ( Dict. mergeMany ~cmp (dataGet m) e)
66
+ let cmp = m.cmp in
67
+ { cmp; data = Dict. mergeMany ~cmp m.data e}
68
68
69
69
let updateU m key f =
70
- let cmp = cmpGet m in
71
- t ~ cmp ~ data: ( Dict. updateU ~cmp (dataGet m) key f )
70
+ let cmp = m.cmp in
71
+ { cmp; data = Dict. updateU ~cmp m.data key f }
72
72
let update m key f = updateU m key (fun [@bs ] a -> f a )
73
73
let split m x =
74
- let cmp = cmpGet m in
75
- let (l,r),b = Dict. split ~cmp (dataGet m) x in
76
- (t ~ cmp ~ data: l, t ~ cmp ~ data: r ), b
74
+ let cmp = m.cmp in
75
+ let (l,r),b = Dict. split ~cmp m.data x in
76
+ ({ cmp; data= l}, { cmp; data= r} ), b
77
77
78
78
let mergeU s1 s2 f =
79
- let cmp = cmpGet s1 in
80
- t ~ cmp ~ data: (Dict. mergeU ~cmp (dataGet s1 ) (dataGet s2 ) f)
79
+ let cmp = s1.cmp in
80
+ { cmp; data= (Dict. mergeU ~cmp (s1.data ) (s2.data ) f)}
81
81
82
82
let merge s1 s2 f =
83
83
mergeU s1 s2 (fun [@bs ] a b c -> f a b c)
84
84
85
85
let make (type key ) (type idx ) ~(id : (key, idx) id ) =
86
86
let module M = (val id) in
87
- t ~cmp: M. cmp ~ data: Dict. empty
87
+ {cmp = M. cmp; data = Dict. empty}
88
88
89
89
let isEmpty map =
90
- Dict. isEmpty (dataGet map)
90
+ Dict. isEmpty map.data
91
91
92
- let findFirstByU m f = Dict. findFirstByU (dataGet m) f
92
+ let findFirstByU m f = Dict. findFirstByU m.data f
93
93
let findFirstBy m f = findFirstByU m (fun [@bs ] a b -> f a b)
94
- let forEachU m f = Dict. forEachU (dataGet m) f
94
+ let forEachU m f = Dict. forEachU m.data f
95
95
let forEach m f = forEachU m (fun [@bs ] a b -> f a b)
96
- let reduceU m acc f = Dict. reduceU (dataGet m) acc f
96
+ let reduceU m acc f = Dict. reduceU m.data acc f
97
97
let reduce m acc f = reduceU m acc (fun[@ bs] a b c -> f a b c )
98
- let everyU m f = Dict. everyU (dataGet m) f
98
+ let everyU m f = Dict. everyU m.data f
99
99
let every m f = everyU m (fun [@bs ] a b -> f a b)
100
- let someU m f = Dict. someU (dataGet m) f
100
+ let someU m f = Dict. someU m.data f
101
101
let some m f = someU m (fun[@ bs] a b -> f a b)
102
102
let keepU m f =
103
- t ~ cmp: (cmpGet m) ~ data: (Dict. keepU (dataGet m) f)
103
+ { cmp = m.cmp; data = (Dict. keepU m.data f)}
104
104
let keep m f = keepU m (fun [@bs ] a b -> f a b)
105
105
106
106
let partitionU m p =
107
- let cmp = cmpGet m in
108
- let l,r = m |. dataGet |. Dict. partitionU p in
109
- t ~ cmp ~ data: l, t ~ cmp ~ data: r
107
+ let cmp = m.cmp in
108
+ let l,r = m . data |. Dict. partitionU p in
109
+ { cmp; data= l}, { cmp; data= r}
110
110
let partition m p = partitionU m (fun [@bs ] a b -> p a b)
111
111
112
112
let mapU m f =
113
- t ~ cmp: (cmpGet m) ~ data: ( Dict. mapU (dataGet m) f)
113
+ { cmp = m.cmp; data = Dict. mapU m.data f}
114
114
let map m f = mapU m (fun [@bs ] a -> f a)
115
115
let mapWithKeyU m f =
116
- t ~ cmp: (cmpGet m) ~ data: (Dict. mapWithKeyU (dataGet m) f)
116
+ { cmp = (m.cmp); data = (Dict. mapWithKeyU m.data f)}
117
117
let mapWithKey m f = mapWithKeyU m (fun [@bs ] a b -> f a b)
118
- let size map = Dict. size (dataGet map)
119
- let toList map = Dict. toList (dataGet map)
120
- let toArray m = Dict. toArray (dataGet m)
121
- let keysToArray m = Dict. keysToArray (dataGet m)
122
- let valuesToArray m = Dict. valuesToArray (dataGet m)
123
- let minKey m = Dict. minKey (dataGet m)
124
- let minKeyUndefined m = Dict. minKeyUndefined (dataGet m)
125
- let maxKey m = Dict. maxKey (dataGet m)
126
- let maxKeyUndefined m = Dict. maxKeyUndefined (dataGet m)
127
- let minimum m = Dict. minimum (dataGet m)
128
- let minUndefined m = Dict. minUndefined (dataGet m)
129
- let maximum m = Dict. maximum (dataGet m)
130
- let maxUndefined m = Dict. maxUndefined (dataGet m)
118
+ let size map = Dict. size map.data
119
+ let toList map = Dict. toList map.data
120
+ let toArray m = Dict. toArray m.data
121
+ let keysToArray m = Dict. keysToArray m.data
122
+ let valuesToArray m = Dict. valuesToArray m.data
123
+ let minKey m = Dict. minKey m.data
124
+ let minKeyUndefined m = Dict. minKeyUndefined m.data
125
+ let maxKey m = Dict. maxKey m.data
126
+ let maxKeyUndefined m = Dict. maxKeyUndefined m.data
127
+ let minimum m = Dict. minimum m.data
128
+ let minUndefined m = Dict. minUndefined m.data
129
+ let maximum m = Dict. maximum m.data
130
+ let maxUndefined m = Dict. maxUndefined m.data
131
131
132
132
let get map x =
133
- Dict. get ~cmp: (cmpGet map) (dataGet map) x
133
+ Dict. get ~cmp: map.cmp map.data x
134
134
135
135
let getUndefined map x =
136
- Dict. getUndefined ~cmp: (cmpGet map) (dataGet map) x
136
+ Dict. getUndefined ~cmp: map.cmp map.data x
137
137
138
138
let getWithDefault map x def =
139
- Dict. getWithDefault ~cmp: (cmpGet map) (dataGet map) x def
139
+ Dict. getWithDefault ~cmp: map.cmp map.data x def
140
140
141
141
let getExn map x =
142
- Dict. getExn ~cmp: (cmpGet map) (dataGet map) x
142
+ Dict. getExn ~cmp: map.cmp map.data x
143
143
144
144
let has map x =
145
- Dict. has ~cmp: (cmpGet map) (dataGet map) x
145
+ Dict. has ~cmp: map.cmp map.data x
146
146
147
147
let checkInvariantInternal m =
148
- Dict. checkInvariantInternal (dataGet m)
148
+ Dict. checkInvariantInternal m.data
149
149
150
150
let eqU m1 m2 veq =
151
- Dict. eqU ~kcmp: (cmpGet m1) ~veq (dataGet m1) (dataGet m2)
151
+ Dict. eqU ~kcmp: m1.cmp ~veq m1.data m2.data
152
152
let eq m1 m2 veq = eqU m1 m2 (fun[@ bs] a b -> veq a b)
153
153
154
154
let cmpU m1 m2 vcmp =
155
- Dict. cmpU ~kcmp: (cmpGet m1) ~vcmp (dataGet m1) (dataGet m2)
155
+ Dict. cmpU ~kcmp: m1.cmp ~vcmp m1.data m2.data
156
156
let cmp m1 m2 vcmp = cmpU m1 m2 (fun [@bs ] a b -> vcmp a b)
157
157
158
- let getData = dataGet
158
+ let getData m = m.data
159
159
160
160
let getId (type key ) (type identity ) (m : (key,_,identity) t ) : (key, identity) id =
161
161
let module T = struct
162
162
type nonrec identity = identity
163
163
type nonrec t = key
164
- let cmp = cmpGet m
164
+ let cmp = m.cmp
165
165
end in
166
166
(module T )
167
167
168
168
let packIdData (type key ) (type idx ) ~(id : (key, idx) id ) ~data =
169
169
let module M = (val id) in
170
- t ~ cmp: M. cmp ~ data
170
+ { cmp = M. cmp ; data}
171
171
0 commit comments