insertWith -package:dhall

insertWith :: (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
containers Data.IntMap.Internal Data.IntMap.Lazy Data.IntMap.Strict Data.IntMap.Strict.Internal
Insert with a combining function. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert f new_value old_value. 
insertWith (++) 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "xxxa")]
insertWith (++) 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")]
insertWith (++) 5 "xxx" empty                         == singleton 5 "xxx"
Also see the performance note on fromListWith.
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
containers Data.Map.Internal Data.Map.Lazy Data.Map.Strict Data.Map.Strict.Internal
Insert with a function, combining new value and old value. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value). 
insertWith (++) 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "xxxa")]
insertWith (++) 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")]
insertWith (++) 5 "xxx" empty                         == singleton 5 "xxx"
Also see the performance note on fromListWith.
insertWith :: (a -> a -> a) -> Key -> a -> KeyMap a -> KeyMap a
aeson Data.Aeson.KeyMap
Insert with a function combining new and old values, taken in that order.
insertWith :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMap k v -> HashMap k v
unordered-containers Data.HashMap.Internal Data.HashMap.Internal.Strict Data.HashMap.Lazy Data.HashMap.Strict, rio RIO.HashMap
Associate the value with the key in this map. If this map previously contained a mapping for the key, the old value is replaced by the result of applying the given function to the new and old value. Example: 
insertWith f k v map
where f new old = new + old
insertWith :: (a -> a -> a) -> Key -> a -> Word64Map a -> Word64Map a
ghc GHC.Data.Word64Map.Internal GHC.Data.Word64Map.Lazy GHC.Data.Word64Map.Strict GHC.Data.Word64Map.Strict.Internal, ghc-lib-parser GHC.Data.Word64Map.Internal GHC.Data.Word64Map.Lazy GHC.Data.Word64Map.Strict GHC.Data.Word64Map.Strict.Internal
Insert with a combining function. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert f new_value old_value. 
insertWith (++) 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "xxxa")]
insertWith (++) 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")]
insertWith (++) 5 "xxx" empty                         == singleton 5 "xxx"
insertWith :: (a -> a -> a) -> Key -> a -> CharMap a -> CharMap a
regex-tdfa Data.IntMap.CharMap2
insertWith :: Enum key => (a -> a -> a) -> key -> a -> EnumMap key a -> EnumMap key a
regex-tdfa Data.IntMap.EnumMap2
insertWith :: DynamicMap t => (Val t -> Val t -> Val t) -> Key t -> Val t -> t -> t
relude Relude.Extra.Map
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
rio RIO.Map
O(log n). Insert with a function, combining new value and old value. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value). 
insertWith (++) 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "xxxa")]
insertWith (++) 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")]
insertWith (++) 5 "xxx" empty                         == singleton 5 "xxx"
insertWith :: IsMap map => (MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> map
mono-traversable Data.Containers
Insert a key-value pair into a map. Inserts the value directly if the key does not exist in the map. Otherwise, apply a supplied function that accepts the new value and the previous value and insert that result into the map.
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> T k a
non-empty Data.NonEmpty.Map
\k a -> forAllMap $ \m -> Map.insertWith (++) k a m == NonEmptyMap.flatten (NonEmptyMap.insertWith (++) k a m)
insertWith :: GCompare k => (f v -> f v -> f v) -> k v -> f v -> DMap k f -> DMap k f
dependent-map Data.Dependent.Map
O(log n). Insert with a function, combining new value and old value. insertWith f key value mp will insert the entry key :=> value into mp if key does not exist in the map. If the key does exist, the function will insert the entry key :=> f new_value old_value.
insertWith :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insert-ordered-containers Data.HashMap.Strict.InsOrd
insertWith :: (a -> a -> a) -> ByteString -> a -> Trie a -> Trie a
bytestring-trie Data.Trie.Convenience
Insert a new key, with a function to resolve conflicts.
insertWith :: OrdF k => (a tp -> a tp -> a tp) -> k tp -> a tp -> MapF k a -> MapF k a
parameterized-utils Data.Parameterized.Map
insertWith f new m inserts the binding into m. It inserts f new old if m already contains an equivalent value old, and new otherwise. It returns an Unchanged value if the map stays the same size and an Updated value if a new entry was inserted.
insertWith :: (Ord k, Ord p) => (p -> p -> p) -> k -> p -> PSQ k p -> PSQ k p
PSQueue Data.PSQueue Data.PSQueue.Internal
O(log n) Insert a binding with a combining function.
insertWith :: (Hashable k, Eq k) => (a -> a -> a) -> k -> a -> MonoidalHashMap k a -> MonoidalHashMap k a
monoidal-containers Data.HashMap.Monoidal
O(log n). Insert a value on some key, if it exists apply the combining function.
insertWith :: forall a . (a -> a -> a) -> Int -> a -> MonoidalIntMap a -> MonoidalIntMap a
monoidal-containers Data.IntMap.Monoidal Data.IntMap.Monoidal.Strict
insertWith :: forall k a . Ord k => (a -> a -> a) -> k -> a -> MonoidalMap k a -> MonoidalMap k a
monoidal-containers Data.Map.Monoidal Data.Map.Monoidal.Strict
insertWith :: Ord n => (e -> e -> e) -> n -> n -> e -> Graph n e -> Graph n e
Agda Agda.Utils.Graph.AdjacencyMap.Unidirectional
insertWith f s t new inserts an edge from s to t into the graph. If there is already an edge from s to t with label old, then this edge gets replaced by an edge with label f new old, and otherwise the edge's label is new. O(log n).
insertWith :: Ord k => (v -> v -> v) -> [k] -> v -> Trie k v -> Trie k v
Agda Agda.Utils.Trie
Insert with function merging new value with old value.
insertWith :: (Hashable k, Ord k) => (a -> a -> a) -> k -> a -> Map k a -> Map k a
hashmap Data.HashMap
Insert with a combining function. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert f new_value old_value.
insertWith :: Enum k => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
enummapset Data.EnumMap.Lazy Data.EnumMap.Strict
insertWith :: (a -> a -> a) -> Key -> a -> NEIntMap a -> NEIntMap a
nonempty-containers Data.IntMap.NonEmpty Data.IntMap.NonEmpty.Internal
O(log n). Insert with a function, combining new value and old value. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value). See insertIntMapWith for a version where the first argument is a IntMap. 
insertWith (++) 5 "xxx" (fromList ((5,"a") :| [(3,"b")])) == fromList ((3, "b") :| [(5, "xxxa")])
insertWith (++) 7 "xxx" (fromList ((5,"a") :| [(3,"b")])) == fromList ((3, "b") :| [(5, "a"), (7, "xxx")])
insertWith :: Ord k => (a -> a -> a) -> k -> a -> NEMap k a -> NEMap k a
nonempty-containers Data.Map.NonEmpty
O(log n). Insert with a function, combining new value and old value. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value). See insertMapWith for a version where the first argument is a Map. 
insertWith (++) 5 "xxx" (fromList ((5,"a") :| [(3,"b")])) == fromList ((3, "b") :| [(5, "xxxa")])
insertWith (++) 7 "xxx" (fromList ((5,"a") :| [(3,"b")])) == fromList ((3, "b") :| [(5, "a"), (7, "xxx")])