Karya, built on 2022-03-21T01:30:44 (patch 89d1651424c35e564138d93424a157ff87457245)
Safe HaskellSafe-Inferred



Extra utils for Data.Map.



getM :: (Ord k, Monoid a) => Map k a -> k -> a Source #

filterKey :: (k -> Bool) -> Map k a -> Map k a Source #

deleteKeys :: Ord k => [k] -> Map k a -> Map k a Source #

insertList :: Ord k => [(k, v)] -> Map k v -> Map k v Source #

split2 :: Ord k => k -> Map k a -> (Map k a, Map k a) Source #

Like split, except include a matched key in the above map.

split3 :: Ord k => k -> k -> Map k a -> (Map k a, Map k a, Map k a) Source #

Split the map into the maps below, within, and above the given range. low to high is half-open, as usual.

within :: Ord k => k -> k -> Map k a -> Map k a Source #

Return the subset of the map that is between a half-open low and high key.

lookupClosest :: (Ord k, Num k) => k -> Map k v -> Maybe.Maybe (k, v) Source #

Find the closest key. If two are equidistant, favor the one below.

invert :: Ord a => Map k a -> Map a k Source #

multimap :: Ord k => [(k, a)] -> Map k [a] Source #

TODO Would it be more efficient to do 'fromListWith (++)'?

unique :: Ord a => [(a, b)] -> (Map a b, [(a, b)]) Source #

Like Map.fromList, but only accept the first of duplicate keys, and also return the rejected duplicates.

unique2 :: Ord k => [(k, v)] -> (Map k v, [(k, [v])]) Source #

Make a map, but if any keys collide, omit that key and return it along with the multiple values.

zipIntersection :: Ord k => Map k v1 -> Map k v2 -> [(k, v1, v2)] Source #

Given two maps, pair up the elements in map1 with a samed-keyed element in map2, if there is one. Elements that are only in map1 or map2 will not be included in the output.

pairs :: Ord k => Map k v1 -> Map k v2 -> [(k, Seq.Paired v1 v2)] Source #

Pair up elements from each map with equal keys.

paired :: Ord k => Map k v1 -> Map k v2 -> Map k (Seq.Paired v1 v2) Source #

uniqueUnion Source #


:: Ord k 
=> Map k a 
-> Map k a 
-> (Map k a, Map k a)

(union, rejected)

Like union, but also return a map of rejected duplicate keys from the map on the right.

uniqueUnions :: Ord k => [Map k a] -> (Map k a, Map k a) Source #

Like unions, but return a map of the rejected keys. Like Map.unions, the first key in the list wins. If there are multiple conflicting keys, only the first one will show up in the reject map.

mappend :: (Ord k, Monoid a) => Map k a -> Map k a -> Map k a Source #

The Data.Map Monoid instance is just a plain union, and doesn't mappend the values.

mconcat :: (Ord k, Monoid a) => [Map k a] -> Map k a Source #

Like Map.unionsWith Monoid.mappend, but collects the values together, in case mconcat is more efficient than successive mappends.