Safe Haskell  SafeInfered 

 class Foldable (m k) => Map m k where
 eqCmp :: m k a > k > k > Bool
 empty :: m k a
 singleton :: k > a > m k a
 doubleton :: k > a > k > a > m k a
 null :: m k a > Bool
 lookup :: k > m k a > Maybe a
 insertWith :: (a > a > a) > k > a > m k a > m k a
 insert :: k > a > m k a > m k a
 update :: (a > Maybe a) > k > m k a > m k a
 adjust :: (a > a) > k > m k a > m k a
 delete :: k > m k a > m k a
 alter :: (Maybe a > Maybe a) > k > m k a > m k a
 unionWith :: (a > a > a) > m k a > m k a > m k a
 differenceWith :: (a > b > Maybe a) > m k a > m k b > m k a
 intersectionWith :: (a > b > c) > m k a > m k b > m k c
 unionWithKey :: (k > a > a > a) > m k a > m k a > m k a
 differenceWithKey :: (k > a > b > Maybe a) > m k a > m k b > m k a
 intersectionWithKey :: (k > a > b > c) > m k a > m k b > m k c
 map :: (a > b) > m k a > m k b
 mapWithKey :: (k > a > b) > m k a > m k b
 mapAccum :: (a > b > (a, c)) > a > m k b > (a, m k c)
 mapAccumWithKey :: (a > k > b > (a, c)) > a > m k b > (a, m k c)
 filter :: (a > Bool) > m k a > m k a
 toList :: m k a > [(k, a)]
 fromList :: [(k, a)] > m k a
 fromListWith :: (a > a > a) > [(k, a)] > m k a
 serializeToList :: m k a > [(k, a)]
 deserializeFromList :: [(k, a)] > m k a
 isSubmapOfBy :: (a > b > Bool) > m k a > m k b > Bool
 singletonView :: m k a > Maybe (k, a)
 class Map m k => OrdMap m k where
 ordCmp :: m k a > k > k > Ordering
 toAscList :: m k a > [(k, a)]
 toDescList :: m k a > [(k, a)]
 splitLookup :: k > m k a > (m k a, Maybe a, m k a)
 split :: k > m k a > (m k a, m k a)
 minViewWithKey :: m k a > (Maybe (k, a), m k a)
 maxViewWithKey :: m k a > (Maybe (k, a), m k a)
 findPredecessor :: k > m k a > Maybe (k, a)
 findSuccessor :: k > m k a > Maybe (k, a)
 mapAccumAsc :: (a > b > (a, c)) > a > m k b > (a, m k c)
 mapAccumAscWithKey :: (a > k > b > (a, c)) > a > m k b > (a, m k c)
 mapAccumDesc :: (a > b > (a, c)) > a > m k b > (a, m k c)
 mapAccumDescWithKey :: (a > k > b > (a, c)) > a > m k b > (a, m k c)
 data AList k v
 data WrappedIntMap k v
Documentation
class Foldable (m k) => Map m k whereSource
Minimal complete implementation:

eqCmp

null

lookup

alter

unionWithKey
,differenceWithKey
,intersectionWithKey

toList

empty
orfromList
orfromListWith

isSubmapOfBy
For decent performance, supplying at least mapAccumWithKey
and filter
as
well is probably a good idea.
eqCmp :: m k a > k > k > BoolSource
Like an Eq
instance over k, but should compare on the same type as
m
does. In most cases this can be defined just as const (==)
.
singleton :: k > a > m k aSource
doubleton :: k > a > k > a > m k aSource
Precondition: the two keys differ
lookup :: k > m k a > Maybe aSource
insertWith :: (a > a > a) > k > a > m k a > m k aSource
Strictness can be whatever is more optimal for the map type, shouldn't matter
insert :: k > a > m k a > m k aSource
update :: (a > Maybe a) > k > m k a > m k aSource
adjust :: (a > a) > k > m k a > m k aSource
delete :: k > m k a > m k aSource
alter :: (Maybe a > Maybe a) > k > m k a > m k aSource
unionWith :: (a > a > a) > m k a > m k a > m k aSource
differenceWith :: (a > b > Maybe a) > m k a > m k b > m k aSource
intersectionWith :: (a > b > c) > m k a > m k b > m k cSource
unionWithKey :: (k > a > a > a) > m k a > m k a > m k aSource
differenceWithKey :: (k > a > b > Maybe a) > m k a > m k b > m k aSource
intersectionWithKey :: (k > a > b > c) > m k a > m k b > m k cSource
map :: (a > b) > m k a > m k bSource
mapWithKey :: (k > a > b) > m k a > m k bSource
mapAccum :: (a > b > (a, c)) > a > m k b > (a, m k c)Source
mapAccumWithKey :: (a > k > b > (a, c)) > a > m k b > (a, m k c)Source
filter :: (a > Bool) > m k a > m k aSource
toList :: m k a > [(k, a)]Source
fromList :: [(k, a)] > m k aSource
fromListWith :: (a > a > a) > [(k, a)] > m k aSource
serializeToList :: m k a > [(k, a)]Source
deserializeFromList :: [(k, a)] > m k aSource
isSubmapOfBy :: (a > b > Bool) > m k a > m k b > BoolSource
singletonView :: m k a > Maybe (k, a)Source
class Map m k => OrdMap m k whereSource
Minimal complete definition:
For decent performance, supplying at least the following is probably a good idea:
ordCmp :: m k a > k > k > OrderingSource
Like an Ord instance over k, but should compare on the same type as m
does. In most cases this can be defined just as const compare
.
toAscList :: m k a > [(k, a)]Source
toDescList :: m k a > [(k, a)]Source
splitLookup :: k > m k a > (m k a, Maybe a, m k a)Source
split :: k > m k a > (m k a, m k a)Source
minViewWithKey :: m k a > (Maybe (k, a), m k a)Source
maxViewWithKey :: m k a > (Maybe (k, a), m k a)Source
findPredecessor :: k > m k a > Maybe (k, a)Source
findSuccessor :: k > m k a > Maybe (k, a)Source
mapAccumAsc :: (a > b > (a, c)) > a > m k b > (a, m k c)Source
mapAccumAscWithKey :: (a > k > b > (a, c)) > a > m k b > (a, m k c)Source
mapAccumDesc :: (a > b > (a, c)) > a > m k b > (a, m k c)Source
mapAccumDescWithKey :: (a > k > b > (a, c)) > a > m k b > (a, m k c)Source
data WrappedIntMap k v Source
Enum k => OrdMap WrappedIntMap k  
Enum k => Map WrappedIntMap k  
Functor (WrappedIntMap k)  
Foldable (WrappedIntMap k)  
Traversable (WrappedIntMap k)  
Eq v => Eq (WrappedIntMap k v)  
Ord v => Ord (WrappedIntMap k v) 