Karya, built on 2020-11-26T21:03:17 (patch 23b5be2d53a9e8e7d6136cda5aae2849abe5cded)
Safe HaskellNone



Extra utils for Data.Map.



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

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

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

insert_list :: 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.

lookup_closest :: (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.

zip_intersection :: 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.

unique_union 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.

unique_unions :: 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.