{-# OPTIONS -fno-monomorphism-restriction #-}

-- | impedance matching:
-- provide old Data.FiniteMap interface
-- but use new Data.Map implementation

module Autolib.Data.Map 

where

import qualified Data.Map.Strict as M

type FiniteMap k a = M.Map k a


emptyFM :: Map k a
emptyFM = Map k a
forall k a. Map k a
M.empty
isEmptyFM :: Map k a -> Bool
isEmptyFM = Map k a -> Bool
forall k a. Map k a -> Bool
M.null
sizeFM :: Map k a -> Int
sizeFM = Map k a -> Int
forall k a. Map k a -> Int
M.size
unitFM :: k -> a -> Map k a
unitFM = k -> a -> Map k a
forall k a. k -> a -> Map k a
M.singleton
eltsFM :: Map k a -> [a]
eltsFM = Map k a -> [a]
forall k a. Map k a -> [a]
M.elems
keysFM :: Map k a -> [k]
keysFM = Map k a -> [k]
forall k a. Map k a -> [k]
M.keys
fmToList :: Map k a -> [(k, a)]
fmToList = Map k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
M.assocs
listToFM :: [(k, a)] -> Map k a
listToFM = [(k, a)] -> Map k a
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
delFromFM :: Map a a -> a -> Map a a
delFromFM = (a -> Map a a -> Map a a) -> Map a a -> a -> Map a a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> Map a a -> Map a a
forall k a. Ord k => k -> Map k a -> Map k a
M.delete
foldFM :: (k -> a -> b -> b) -> b -> Map k a -> b
foldFM = (k -> a -> b -> b) -> b -> Map k a -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
M.foldrWithKey -- foldr or foldl ??

-- | explicit signature is necessary
-- because the new type would not use Maybe but Monad m => m instead
lookupFM :: Ord k => FiniteMap k a -> k -> Maybe a
lookupFM :: forall k a. Ord k => FiniteMap k a -> k -> Maybe a
lookupFM = (k -> FiniteMap k a -> Maybe a) -> FiniteMap k a -> k -> Maybe a
forall a b c. (a -> b -> c) -> b -> a -> c
flip k -> FiniteMap k a -> Maybe a
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup

lookupWithDefaultFM :: Map k a -> a -> k -> a
lookupWithDefaultFM Map k a
f a
a k
k = a -> k -> Map k a -> a
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault a
a k
k Map k a
f
elemFM :: k -> Map k a -> Bool
elemFM = k -> Map k a -> Bool
forall k a. Ord k => k -> Map k a -> Bool
M.member
mapFM :: (k -> a -> b) -> Map k a -> Map k b
mapFM = (k -> a -> b) -> Map k a -> Map k b
forall k a b. (k -> a -> b) -> Map k a -> Map k b
M.mapWithKey
addToFM :: Map k a -> k -> a -> Map k a
addToFM Map k a
fm k
k a
a = k -> a -> Map k a -> Map k a
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
k a
a Map k a
fm
addToFM_C :: (a -> a -> a) -> Map k a -> k -> a -> Map k a
addToFM_C a -> a -> a
fun Map k a
m k
k a
a = (a -> a -> a) -> k -> a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
M.insertWith a -> a -> a
fun k
k a
a Map k a
m


addListToFM :: Map k a -> t (k, a) -> Map k a
addListToFM Map k a
m t (k, a)
pairs = ((k, a) -> Map k a -> Map k a) -> Map k a -> t (k, a) -> Map k a
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr (\ (k
k,a
a) -> k -> a -> Map k a -> Map k a
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
k a
a) Map k a
m t (k, a)
pairs
addListToFM_C :: (a -> a -> a) -> Map k a -> t (k, a) -> Map k a
addListToFM_C a -> a -> a
fun Map k a
m t (k, a)
pairs = ((k, a) -> Map k a -> Map k a) -> Map k a -> t (k, a) -> Map k a
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr (\ (k
k, a
a) -> (a -> a -> a) -> k -> a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
M.insertWith a -> a -> a
fun k
k a
a) Map k a
m t (k, a)
pairs

-- better performance according to <http://www.haskell.org/pipermail/libraries/2005-February/003341.html>
-- BUT these are not equivalent!
-- addListToFM m = union m . fromList
-- addListToFM_C fun m = unionWith fun m . fromList

plusFM :: Map k a -> Map k a -> Map k a
plusFM = Map k a -> Map k a -> Map k a
forall k a. Ord k => Map k a -> Map k a -> Map k a
M.union
plusFM_C :: (a -> a -> a) -> Map k a -> Map k a -> Map k a
plusFM_C = (a -> a -> a) -> Map k a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith
filterFM :: (k -> a -> Bool) -> Map k a -> Map k a
filterFM = (k -> a -> Bool) -> Map k a -> Map k a
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
M.filterWithKey
intersectFM_C :: (a -> b -> c) -> Map k a -> Map k b -> Map k c
intersectFM_C = (a -> b -> c) -> Map k a -> Map k b -> Map k c
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
M.intersectionWith