7788f4a · typeable/refined-containers

git.iko.soy/typeable/refined-containers

on main help sign in

Add insertWith and insertWithKey

7788f4amniip2 years ago

src/Data/HashMap/Refined.hs+31

compare with main

unifiedsplit

@@ -50,6 +50,8 @@ module Data.HashMap.Refined

50 , FromTraversableProof(..)

51 -- * Insertion

52 , insert

53+ , insertWith

54+ , insertWithKey

53 , InsertProof(..)

55 , InsertProof(..)

54 , reinsert

56 , reinsert

55 , insertLookupWithKey

57 , insertLookupWithKey

@@ -198,6 +200,35 @@ insert

198insert k v (HashMap m) = SomeHashMapWith (HashMap $ HashMap.insert k v m)

200insert k v (HashMap m) = SomeHashMapWith (HashMap $ HashMap.insert k v m)

199 $ InsertProof (unsafeKey k) unsafeSubset

201 $ InsertProof (unsafeKey k) unsafeSubset

200

202

203+-- | Insert a key-value pair into the map to obtain a potentially larger map,

204+-- guaranteed to contain the given key. If the key was already present, the

205+-- supplied function is used to combine the new value with the old (in that

206+-- order).

207+insertWith

208+ :: forall s k a. Hashable k

209+ => (a -> a -> a)

210+ -> k

211+ -> a

212+ -> HashMap s k a

213+ -> SomeHashMapWith (InsertProof 'Hashed k s) k a

214+insertWith f k v (HashMap m) = SomeHashMapWith

215+ (HashMap $ HashMap.insertWith f k v m)

216+ $ InsertProof (unsafeKey k) unsafeSubset

217+

218+-- | Insert a key-value pair into the map to obtain a potentially larger map,

219+-- guaranteed to contain the given key. Like 'insertWith', but the combining

220+-- function has access to the key, which is guaranteed to be in the old map.

221+insertWithKey

222+ :: forall s k a. Hashable k

223+ => (Key s k -> a -> a -> a)

224+ -> k

225+ -> a

226+ -> HashMap s k a

227+ -> SomeHashMapWith (InsertProof 'Hashed k s) k a

228+insertWithKey f k v (HashMap m) = SomeHashMapWith

229+ (HashMap $ HashMap.insertWith (f $ unsafeKey k) k v m)

230+ $ InsertProof (unsafeKey k) unsafeSubset

231+

201-- | Overwrite a key-value pair that is known to already be in the map. The set

232-- | Overwrite a key-value pair that is known to already be in the map. The set

202-- of keys remains the same.

233-- of keys remains the same.

203reinsert

234reinsert

src/Data/HashMap/Strict/Refined.hs+31

@@ -50,6 +50,8 @@ module Data.HashMap.Strict.Refined

50 , FromTraversableProof(..)

51 -- * Insertion

52 , insert

53+ , insertWith

54+ , insertWithKey

53 , InsertProof(..)

55 , InsertProof(..)

54 , reinsert

56 , reinsert

55 , insertLookupWithKey

57 , insertLookupWithKey

@@ -206,6 +208,35 @@ insert

206insert k v (HashMap m) = SomeHashMapWith (HashMap $ HashMap.insert k v m)

208insert k v (HashMap m) = SomeHashMapWith (HashMap $ HashMap.insert k v m)

207 $ InsertProof (unsafeKey k) unsafeSubset

209 $ InsertProof (unsafeKey k) unsafeSubset

208

210

211+-- | Insert a key-value pair into the map to obtain a potentially larger map,

212+-- guaranteed to contain the given key. If the key was already present, the

213+-- supplied function is used to combine the new value with the old (in that

214+-- order).

215+insertWith

216+ :: forall s k a. Hashable k

217+ => (a -> a -> a)

218+ -> k

219+ -> a

220+ -> HashMap s k a

221+ -> SomeHashMapWith (InsertProof 'Hashed k s) k a

222+insertWith f k v (HashMap m) = SomeHashMapWith

223+ (HashMap $ HashMap.insertWith f k v m)

224+ $ InsertProof (unsafeKey k) unsafeSubset

225+

226+-- | Insert a key-value pair into the map to obtain a potentially larger map,

227+-- guaranteed to contain the given key. Like 'insertWith', but the combining

228+-- function has access to the key, which is guaranteed to be in the old map.

229+insertWithKey

230+ :: forall s k a. Hashable k

231+ => (Key s k -> a -> a -> a)

232+ -> k

233+ -> a

234+ -> HashMap s k a

235+ -> SomeHashMapWith (InsertProof 'Hashed k s) k a

236+insertWithKey f k v (HashMap m) = SomeHashMapWith

237+ (HashMap $ HashMap.insertWith (f $ unsafeKey k) k v m)

238+ $ InsertProof (unsafeKey k) unsafeSubset

239+

209-- | Overwrite a key-value pair that is known to already be in the map. The set

240-- | Overwrite a key-value pair that is known to already be in the map. The set

210-- of keys remains the same.

241-- of keys remains the same.

211reinsert

242reinsert

src/Data/IntMap/Refined.hs+29

@@ -41,6 +41,8 @@ module Data.IntMap.Refined

41 , FromTraversableProof(..)

42 -- * Insertion

43 , insert

44+ , insertWith

45+ , insertWithKey

44 , InsertProof(..)

46 , InsertProof(..)

45 , reinsert

47 , reinsert

46 , insertLookupWithKey

48 , insertLookupWithKey

@@ -202,6 +204,33 @@ insert

202insert k v (IntMap m) = SomeIntMapWith (IntMap $ IntMap.insert k v m)

204insert k v (IntMap m) = SomeIntMapWith (IntMap $ IntMap.insert k v m)

203 $ InsertProof (unsafeKey k) unsafeSubset

205 $ InsertProof (unsafeKey k) unsafeSubset

204

206

207+-- | Insert a key-value pair into the map to obtain a potentially larger map,

208+-- guaranteed to contain the given key. If the key was already present, the

209+-- supplied function is used to combine the new value with the old (in that

210+-- order).

211+insertWith

212+ :: forall s a. (a -> a -> a)

213+ -> Int

214+ -> a

215+ -> IntMap s a

216+ -> SomeIntMapWith (InsertProof 'Int Int s) a

217+insertWith f k v (IntMap m) = SomeIntMapWith

218+ (IntMap $ IntMap.insertWith f k v m)

219+ $ InsertProof (unsafeKey k) unsafeSubset

220+

221+-- | Insert a key-value pair into the map to obtain a potentially larger map,

222+-- guaranteed to contain the given key. Like 'insertWith', but the combining

223+-- function has access to the key, which is guaranteed to be in the old map.

224+insertWithKey

225+ :: forall s a. (Key s -> a -> a -> a)

226+ -> Int

227+ -> a

228+ -> IntMap s a

229+ -> SomeIntMapWith (InsertProof 'Int Int s) a

230+insertWithKey f k v (IntMap m) = SomeIntMapWith

231+ (IntMap $ IntMap.insertWithKey (f . unsafeKey) k v m)

232+ $ InsertProof (unsafeKey k) unsafeSubset

233+

205-- | Overwrite a key-value pair that is known to already be in the map. The set

234-- | Overwrite a key-value pair that is known to already be in the map. The set

206-- of keys remains the same.

235-- of keys remains the same.

207reinsert

236reinsert

src/Data/IntMap/Strict/Refined.hs+29

@@ -41,6 +41,8 @@ module Data.IntMap.Strict.Refined

41 , FromTraversableProof(..)

42 -- * Insertion

43 , insert

44+ , insertWith

45+ , insertWithKey

44 , InsertProof(..)

46 , InsertProof(..)

45 , reinsert

47 , reinsert

46 , insertLookupWithKey

48 , insertLookupWithKey

@@ -208,6 +210,33 @@ insert

208insert k v (IntMap m) = SomeIntMapWith (IntMap $ IntMap.insert k v m)

210insert k v (IntMap m) = SomeIntMapWith (IntMap $ IntMap.insert k v m)

209 $ InsertProof (unsafeKey k) unsafeSubset

211 $ InsertProof (unsafeKey k) unsafeSubset

210

212

213+-- | Insert a key-value pair into the map to obtain a potentially larger map,

214+-- guaranteed to contain the given key. If the key was already present, the

215+-- supplied function is used to combine the new value with the old (in that

216+-- order).

217+insertWith

218+ :: forall s a. (a -> a -> a)

219+ -> Int

220+ -> a

221+ -> IntMap s a

222+ -> SomeIntMapWith (InsertProof 'Int Int s) a

223+insertWith f k v (IntMap m) = SomeIntMapWith

224+ (IntMap $ IntMap.insertWith f k v m)

225+ $ InsertProof (unsafeKey k) unsafeSubset

226+

227+-- | Insert a key-value pair into the map to obtain a potentially larger map,

228+-- guaranteed to contain the given key. Like 'insertWith', but the combining

229+-- function has access to the key, which is guaranteed to be in the old map.

230+insertWithKey

231+ :: forall s a. (Key s -> a -> a -> a)

232+ -> Int

233+ -> a

234+ -> IntMap s a

235+ -> SomeIntMapWith (InsertProof 'Int Int s) a

236+insertWithKey f k v (IntMap m) = SomeIntMapWith

237+ (IntMap $ IntMap.insertWithKey (f . unsafeKey) k v m)

238+ $ InsertProof (unsafeKey k) unsafeSubset

239+

211-- | Overwrite a key-value pair that is known to already be in the map. The set

240-- | Overwrite a key-value pair that is known to already be in the map. The set

212-- of keys remains the same.

241-- of keys remains the same.

213reinsert

242reinsert

src/Data/Map/Refined.hs+30

@@ -50,6 +50,8 @@ module Data.Map.Refined

50 , FromTraversableProof(..)

51 -- * Insertion

52 , insert

53+ , insertWith

54+ , insertWithKey

53 , InsertProof(..)

55 , InsertProof(..)

54 , reinsert

56 , reinsert

55 , insertLookupWithKey

57 , insertLookupWithKey

@@ -206,6 +208,34 @@ insert

206insert k v (Map m) = SomeMapWith (Map $ Map.insert k v m)

208insert k v (Map m) = SomeMapWith (Map $ Map.insert k v m)

207 $ InsertProof (unsafeKey k) unsafeSubset

209 $ InsertProof (unsafeKey k) unsafeSubset

208

210

211+-- | Insert a key-value pair into the map to obtain a potentially larger map,

212+-- guaranteed to contain the given key. If the key was already present, the

213+-- supplied function is used to combine the new value with the old (in that

214+-- order).

215+insertWith

216+ :: forall s k a. Ord k

217+ => (a -> a -> a)

218+ -> k

219+ -> a

220+ -> Map s k a

221+ -> SomeMapWith (InsertProof 'Regular k s) k a

222+insertWith f k v (Map m) = SomeMapWith (Map $ Map.insertWith f k v m)

223+ $ InsertProof (unsafeKey k) unsafeSubset

224+

225+-- | Insert a key-value pair into the map to obtain a potentially larger map,

226+-- guaranteed to contain the given key. Like 'insertWith', but the combining

227+-- function has access to the key, which is guaranteed to be in the old map.

228+insertWithKey

229+ :: forall s k a. Ord k

230+ => (Key s k -> a -> a -> a)

231+ -> k

232+ -> a

233+ -> Map s k a

234+ -> SomeMapWith (InsertProof 'Regular k s) k a

235+insertWithKey f k v (Map m) = SomeMapWith

236+ (Map $ Map.insertWithKey (f . unsafeKey) k v m)

237+ $ InsertProof (unsafeKey k) unsafeSubset

238+

209-- | Overwrite a key-value pair that is known to already be in the map. The set

239-- | Overwrite a key-value pair that is known to already be in the map. The set

210-- of keys remains the same.

240-- of keys remains the same.

211reinsert

241reinsert

src/Data/Map/Strict/Refined.hs+30

@@ -50,6 +50,8 @@ module Data.Map.Strict.Refined

50 , FromTraversableProof(..)

51 -- * Insertion

52 , insert

53+ , insertWith

54+ , insertWithKey

53 , InsertProof(..)

55 , InsertProof(..)

54 , reinsert

56 , reinsert

55 , insertLookupWithKey

57 , insertLookupWithKey

@@ -213,6 +215,34 @@ insert

213insert k v (Map m) = SomeMapWith (Map $ Map.insert k v m)

215insert k v (Map m) = SomeMapWith (Map $ Map.insert k v m)

214 $ InsertProof (unsafeKey k) unsafeSubset

216 $ InsertProof (unsafeKey k) unsafeSubset

215

217

218+-- | Insert a key-value pair into the map to obtain a potentially larger map,

219+-- guaranteed to contain the given key. If the key was already present, the

220+-- supplied function is used to combine the new value with the old (in that

221+-- order).

222+insertWith

223+ :: forall s k a. Ord k

224+ => (a -> a -> a)

225+ -> k

226+ -> a

227+ -> Map s k a

228+ -> SomeMapWith (InsertProof 'Regular k s) k a

229+insertWith f k v (Map m) = SomeMapWith (Map $ Map.insertWith f k v m)

230+ $ InsertProof (unsafeKey k) unsafeSubset

231+

232+-- | Insert a key-value pair into the map to obtain a potentially larger map,

233+-- guaranteed to contain the given key. Like 'insertWith', but the combining

234+-- function has access to the key, which is guaranteed to be in the old map.

235+insertWithKey

236+ :: forall s k a. Ord k

237+ => (Key s k -> a -> a -> a)

238+ -> k

239+ -> a

240+ -> Map s k a

241+ -> SomeMapWith (InsertProof 'Regular k s) k a

242+insertWithKey f k v (Map m) = SomeMapWith

243+ (Map $ Map.insertWithKey (f . unsafeKey) k v m)

244+ $ InsertProof (unsafeKey k) unsafeSubset

245+

216-- | Overwrite a key-value pair that is known to already be in the map. The set

246-- | Overwrite a key-value pair that is known to already be in the map. The set

217-- of keys remains the same.

247-- of keys remains the same.

218reinsert

248reinsert