packages feed

enummapset 0.2.0 → 0.5.2.0

raw patch · 7 files changed

+1359/−587 lines, 7 filesdep +deepseqdep ~containersPVP ok

version bump matches the API change (PVP)

Dependencies added: deepseq

Dependency ranges changed: containers

API changes (from Hackage documentation)

- Data.EnumMap: (!) :: Enum k => EnumMap k a -> k -> a
- Data.EnumMap: (\\) :: EnumMap k a -> EnumMap k b -> EnumMap k a
- Data.EnumMap: adjust :: Enum k => (a -> a) -> k -> EnumMap k a -> EnumMap k a
- Data.EnumMap: adjustWithKey :: Enum k => (k -> a -> a) -> k -> EnumMap k a -> EnumMap k a
- Data.EnumMap: alter :: Enum k => (Maybe a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
- Data.EnumMap: assocs :: Enum k => EnumMap k a -> [(k, a)]
- Data.EnumMap: data EnumMap k a
- Data.EnumMap: delete :: Enum k => k -> EnumMap k a -> EnumMap k a
- Data.EnumMap: deleteFindMax :: Enum k => EnumMap k a -> ((k, a), EnumMap k a)
- Data.EnumMap: deleteFindMin :: Enum k => EnumMap k a -> ((k, a), EnumMap k a)
- Data.EnumMap: deleteMax :: EnumMap k a -> EnumMap k a
- Data.EnumMap: deleteMin :: EnumMap k a -> EnumMap k a
- Data.EnumMap: difference :: EnumMap k a -> EnumMap k b -> EnumMap k a
- Data.EnumMap: differenceWith :: (a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a
- Data.EnumMap: differenceWithKey :: Enum k => (k -> a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a
- Data.EnumMap: elems :: EnumMap k a -> [a]
- Data.EnumMap: empty :: EnumMap k a
- Data.EnumMap: enumMapToIntMap :: EnumMap k a -> IntMap a
- Data.EnumMap: filter :: (a -> Bool) -> EnumMap k a -> EnumMap k a
- Data.EnumMap: filterWithKey :: Enum k => (k -> a -> Bool) -> EnumMap k a -> EnumMap k a
- Data.EnumMap: findMax :: Enum k => EnumMap k a -> (k, a)
- Data.EnumMap: findMin :: Enum k => EnumMap k a -> (k, a)
- Data.EnumMap: findWithDefault :: Enum k => a -> k -> EnumMap k a -> a
- Data.EnumMap: fromAscList :: Enum k => [(k, a)] -> EnumMap k a
- Data.EnumMap: fromAscListWith :: Enum k => (a -> a -> a) -> [(k, a)] -> EnumMap k a
- Data.EnumMap: fromAscListWithKey :: Enum k => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a
- Data.EnumMap: fromDistinctAscList :: Enum k => [(k, a)] -> EnumMap k a
- Data.EnumMap: fromList :: Enum k => [(k, a)] -> EnumMap k a
- Data.EnumMap: fromListWith :: Enum k => (a -> a -> a) -> [(k, a)] -> EnumMap k a
- Data.EnumMap: fromListWithKey :: Enum k => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a
- Data.EnumMap: insert :: Enum k => k -> a -> EnumMap k a -> EnumMap k a
- Data.EnumMap: insertLookupWithKey :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> (Maybe a, EnumMap k a)
- Data.EnumMap: insertWith :: Enum k => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
- Data.EnumMap: insertWithKey :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
- Data.EnumMap: instance (Enum k, Read k, Read a) => Read (EnumMap k a)
- Data.EnumMap: instance (Enum k, Show k, Show a) => Show (EnumMap k a)
- Data.EnumMap: instance Eq a => Eq (EnumMap k a)
- Data.EnumMap: instance Foldable (EnumMap k)
- Data.EnumMap: instance Functor (EnumMap k)
- Data.EnumMap: instance Monoid (EnumMap k a)
- Data.EnumMap: instance Ord a => Ord (EnumMap k a)
- Data.EnumMap: instance Traversable (EnumMap k)
- Data.EnumMap: instance Typeable2 EnumMap
- Data.EnumMap: intMapToEnumMap :: IntMap a -> EnumMap k a
- Data.EnumMap: intersection :: EnumMap k a -> EnumMap k b -> EnumMap k a
- Data.EnumMap: intersectionWith :: (a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
- Data.EnumMap: intersectionWithKey :: Enum k => (k -> a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
- Data.EnumMap: isProperSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool
- Data.EnumMap: isProperSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool
- Data.EnumMap: isSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool
- Data.EnumMap: isSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool
- Data.EnumMap: keys :: Enum k => EnumMap k a -> [k]
- Data.EnumMap: keysSet :: Enum k => EnumMap k a -> EnumSet k
- Data.EnumMap: lookup :: Enum k => k -> EnumMap k a -> Maybe a
- Data.EnumMap: map :: (a -> b) -> EnumMap k a -> EnumMap k b
- Data.EnumMap: mapAccum :: (a -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
- Data.EnumMap: mapAccumRWithKey :: Enum k => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
- Data.EnumMap: mapAccumWithKey :: Enum k => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
- Data.EnumMap: mapEither :: (a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)
- Data.EnumMap: mapEitherWithKey :: Enum k => (k -> a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)
- Data.EnumMap: mapMaybe :: (a -> Maybe b) -> EnumMap k a -> EnumMap k b
- Data.EnumMap: mapMaybeWithKey :: Enum k => (k -> a -> Maybe b) -> EnumMap k a -> EnumMap k b
- Data.EnumMap: mapWithKey :: Enum k => (k -> a -> b) -> EnumMap k a -> EnumMap k b
- Data.EnumMap: maxView :: EnumMap k a -> Maybe (a, EnumMap k a)
- Data.EnumMap: maxViewWithKey :: Enum k => EnumMap k a -> Maybe ((k, a), EnumMap k a)
- Data.EnumMap: member :: Enum k => k -> EnumMap k a -> Bool
- Data.EnumMap: mergeWithKey :: Enum k => (k -> a -> b -> Maybe c) -> (EnumMap k a -> EnumMap k c) -> (EnumMap k b -> EnumMap k c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
- Data.EnumMap: minView :: EnumMap k a -> Maybe (a, EnumMap k a)
- Data.EnumMap: minViewWithKey :: Enum k => EnumMap k a -> Maybe ((k, a), EnumMap k a)
- Data.EnumMap: notMember :: Enum k => k -> EnumMap k a -> Bool
- Data.EnumMap: null :: EnumMap k a -> Bool
- Data.EnumMap: partition :: (a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)
- Data.EnumMap: partitionWithKey :: Enum k => (k -> a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)
- Data.EnumMap: singleton :: Enum k => k -> a -> EnumMap k a
- Data.EnumMap: size :: EnumMap k a -> Int
- Data.EnumMap: split :: Enum k => k -> EnumMap k a -> (EnumMap k a, EnumMap k a)
- Data.EnumMap: splitLookup :: Enum k => k -> EnumMap k a -> (EnumMap k a, Maybe a, EnumMap k a)
- Data.EnumMap: toAscList :: Enum k => EnumMap k a -> [(k, a)]
- Data.EnumMap: toList :: Enum k => EnumMap k a -> [(k, a)]
- Data.EnumMap: union :: EnumMap k a -> EnumMap k a -> EnumMap k a
- Data.EnumMap: unionWith :: (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
- Data.EnumMap: unionWithKey :: Enum k => (k -> a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
- Data.EnumMap: unions :: [EnumMap k a] -> EnumMap k a
- Data.EnumMap: unionsWith :: (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
- Data.EnumMap: update :: Enum k => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
- Data.EnumMap: updateLookupWithKey :: Enum k => (k -> a -> Maybe a) -> k -> EnumMap k a -> (Maybe a, EnumMap k a)
- Data.EnumMap: updateMax :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a
- Data.EnumMap: updateMaxWithKey :: Enum k => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a
- Data.EnumMap: updateMin :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a
- Data.EnumMap: updateMinWithKey :: Enum k => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a
- Data.EnumMap: updateWithKey :: Enum k => (k -> a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
- Data.EnumSet: instance (Enum e, Read e) => Read (EnumSet e)
- Data.EnumSet: instance (Enum e, Show e) => Show (EnumSet e)
- Data.EnumSet: instance Eq (EnumSet e)
- Data.EnumSet: instance Monoid (EnumSet e)
- Data.EnumSet: instance Ord (EnumSet e)
+ Data.EnumMap: insertWith' :: Enum k => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap: insertWithKey' :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: (!) :: Enum k => EnumMap k a -> k -> a
+ Data.EnumMap.Lazy: (\\) :: EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Lazy: adjust :: Enum k => (a -> a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: adjustWithKey :: Enum k => (k -> a -> a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: alter :: Enum k => (Maybe a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: assocs :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Lazy: data EnumMap k a
+ Data.EnumMap.Lazy: delete :: Enum k => k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: deleteFindMax :: Enum k => EnumMap k a -> ((k, a), EnumMap k a)
+ Data.EnumMap.Lazy: deleteFindMin :: Enum k => EnumMap k a -> ((k, a), EnumMap k a)
+ Data.EnumMap.Lazy: deleteMax :: EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: deleteMin :: EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: difference :: EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Lazy: differenceWith :: (a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Lazy: differenceWithKey :: Enum k => (k -> a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Lazy: elems :: EnumMap k a -> [a]
+ Data.EnumMap.Lazy: empty :: EnumMap k a
+ Data.EnumMap.Lazy: enumMapToIntMap :: EnumMap k a -> IntMap a
+ Data.EnumMap.Lazy: filter :: (a -> Bool) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: filterWithKey :: Enum k => (k -> a -> Bool) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: findMax :: Enum k => EnumMap k a -> (k, a)
+ Data.EnumMap.Lazy: findMin :: Enum k => EnumMap k a -> (k, a)
+ Data.EnumMap.Lazy: findWithDefault :: Enum k => a -> k -> EnumMap k a -> a
+ Data.EnumMap.Lazy: foldl :: Enum k => (a -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Lazy: foldl' :: Enum k => (a -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Lazy: foldlWithKey :: Enum k => (a -> k -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Lazy: foldlWithKey' :: Enum k => (a -> k -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Lazy: foldr :: Enum k => (a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Lazy: foldr' :: Enum k => (a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Lazy: foldrWithKey :: Enum k => (k -> a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Lazy: foldrWithKey' :: Enum k => (k -> a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Lazy: fromAscList :: Enum k => [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromAscListWith :: Enum k => (a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromAscListWithKey :: Enum k => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromDistinctAscList :: Enum k => [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromList :: Enum k => [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromListWith :: Enum k => (a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromListWithKey :: Enum k => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Lazy: fromSet :: Enum k => (k -> a) -> EnumSet k -> EnumMap k a
+ Data.EnumMap.Lazy: insert :: Enum k => k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: insertLookupWithKey :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> (Maybe a, EnumMap k a)
+ Data.EnumMap.Lazy: insertWith :: Enum k => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: insertWithKey :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: intMapToEnumMap :: IntMap a -> EnumMap k a
+ Data.EnumMap.Lazy: intersection :: EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Lazy: intersectionWith :: (a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
+ Data.EnumMap.Lazy: intersectionWithKey :: Enum k => (k -> a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
+ Data.EnumMap.Lazy: isProperSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool
+ Data.EnumMap.Lazy: isProperSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool
+ Data.EnumMap.Lazy: isSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool
+ Data.EnumMap.Lazy: isSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool
+ Data.EnumMap.Lazy: keys :: Enum k => EnumMap k a -> [k]
+ Data.EnumMap.Lazy: keysSet :: Enum k => EnumMap k a -> EnumSet k
+ Data.EnumMap.Lazy: lookup :: Enum k => k -> EnumMap k a -> Maybe a
+ Data.EnumMap.Lazy: lookupGE :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Lazy: lookupGT :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Lazy: lookupLE :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Lazy: lookupLT :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Lazy: map :: (a -> b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Lazy: mapAccum :: (a -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
+ Data.EnumMap.Lazy: mapAccumRWithKey :: Enum k => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
+ Data.EnumMap.Lazy: mapAccumWithKey :: Enum k => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
+ Data.EnumMap.Lazy: mapEither :: (a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)
+ Data.EnumMap.Lazy: mapEitherWithKey :: Enum k => (k -> a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)
+ Data.EnumMap.Lazy: mapKeys :: Enum k => (k -> k) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: mapKeysMonotonic :: Enum k => (k -> k) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: mapKeysWith :: Enum k => (a -> a -> a) -> (k -> k) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: mapMaybe :: (a -> Maybe b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Lazy: mapMaybeWithKey :: Enum k => (k -> a -> Maybe b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Lazy: mapWithKey :: Enum k => (k -> a -> b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Lazy: maxView :: EnumMap k a -> Maybe (a, EnumMap k a)
+ Data.EnumMap.Lazy: maxViewWithKey :: Enum k => EnumMap k a -> Maybe ((k, a), EnumMap k a)
+ Data.EnumMap.Lazy: member :: Enum k => k -> EnumMap k a -> Bool
+ Data.EnumMap.Lazy: mergeWithKey :: Enum k => (k -> a -> b -> Maybe c) -> (EnumMap k a -> EnumMap k c) -> (EnumMap k b -> EnumMap k c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
+ Data.EnumMap.Lazy: minView :: EnumMap k a -> Maybe (a, EnumMap k a)
+ Data.EnumMap.Lazy: minViewWithKey :: Enum k => EnumMap k a -> Maybe ((k, a), EnumMap k a)
+ Data.EnumMap.Lazy: notMember :: Enum k => k -> EnumMap k a -> Bool
+ Data.EnumMap.Lazy: null :: EnumMap k a -> Bool
+ Data.EnumMap.Lazy: partition :: (a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)
+ Data.EnumMap.Lazy: partitionWithKey :: Enum k => (k -> a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)
+ Data.EnumMap.Lazy: singleton :: Enum k => k -> a -> EnumMap k a
+ Data.EnumMap.Lazy: size :: EnumMap k a -> Int
+ Data.EnumMap.Lazy: split :: Enum k => k -> EnumMap k a -> (EnumMap k a, EnumMap k a)
+ Data.EnumMap.Lazy: splitLookup :: Enum k => k -> EnumMap k a -> (EnumMap k a, Maybe a, EnumMap k a)
+ Data.EnumMap.Lazy: toAscList :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Lazy: toDescList :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Lazy: toList :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Lazy: traverseWithKey :: (Applicative t, Enum k) => (k -> a -> t b) -> EnumMap k a -> t (EnumMap k b)
+ Data.EnumMap.Lazy: union :: EnumMap k a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: unionWith :: (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: unionWithKey :: Enum k => (k -> a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: unions :: [EnumMap k a] -> EnumMap k a
+ Data.EnumMap.Lazy: unionsWith :: (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
+ Data.EnumMap.Lazy: update :: Enum k => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: updateLookupWithKey :: Enum k => (k -> a -> Maybe a) -> k -> EnumMap k a -> (Maybe a, EnumMap k a)
+ Data.EnumMap.Lazy: updateMax :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: updateMaxWithKey :: Enum k => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: updateMin :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: updateMinWithKey :: Enum k => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Lazy: updateWithKey :: Enum k => (k -> a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: (!) :: Enum k => EnumMap k a -> k -> a
+ Data.EnumMap.Strict: (\\) :: EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Strict: adjust :: Enum k => (a -> a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: adjustWithKey :: Enum k => (k -> a -> a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: alter :: Enum k => (Maybe a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: assocs :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Strict: data EnumMap k a
+ Data.EnumMap.Strict: delete :: Enum k => k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: deleteFindMax :: Enum k => EnumMap k a -> ((k, a), EnumMap k a)
+ Data.EnumMap.Strict: deleteFindMin :: Enum k => EnumMap k a -> ((k, a), EnumMap k a)
+ Data.EnumMap.Strict: deleteMax :: EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: deleteMin :: EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: difference :: EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Strict: differenceWith :: (a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Strict: differenceWithKey :: Enum k => (k -> a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Strict: elems :: EnumMap k a -> [a]
+ Data.EnumMap.Strict: empty :: EnumMap k a
+ Data.EnumMap.Strict: enumMapToIntMap :: EnumMap k a -> IntMap a
+ Data.EnumMap.Strict: filter :: (a -> Bool) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: filterWithKey :: Enum k => (k -> a -> Bool) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: findMax :: Enum k => EnumMap k a -> (k, a)
+ Data.EnumMap.Strict: findMin :: Enum k => EnumMap k a -> (k, a)
+ Data.EnumMap.Strict: findWithDefault :: Enum k => a -> k -> EnumMap k a -> a
+ Data.EnumMap.Strict: foldl :: Enum k => (a -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Strict: foldl' :: Enum k => (a -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Strict: foldlWithKey :: Enum k => (a -> k -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Strict: foldlWithKey' :: Enum k => (a -> k -> b -> a) -> a -> EnumMap k b -> a
+ Data.EnumMap.Strict: foldr :: Enum k => (a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Strict: foldr' :: Enum k => (a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Strict: foldrWithKey :: Enum k => (k -> a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Strict: foldrWithKey' :: Enum k => (k -> a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap.Strict: fromAscList :: Enum k => [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromAscListWith :: Enum k => (a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromAscListWithKey :: Enum k => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromDistinctAscList :: Enum k => [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromList :: Enum k => [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromListWith :: Enum k => (a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromListWithKey :: Enum k => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a
+ Data.EnumMap.Strict: fromSet :: Enum k => (k -> a) -> EnumSet k -> EnumMap k a
+ Data.EnumMap.Strict: insert :: Enum k => k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: insertLookupWithKey :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> (Maybe a, EnumMap k a)
+ Data.EnumMap.Strict: insertWith :: Enum k => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: insertWithKey :: Enum k => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: intMapToEnumMap :: IntMap a -> EnumMap k a
+ Data.EnumMap.Strict: intersection :: EnumMap k a -> EnumMap k b -> EnumMap k a
+ Data.EnumMap.Strict: intersectionWith :: (a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
+ Data.EnumMap.Strict: intersectionWithKey :: Enum k => (k -> a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
+ Data.EnumMap.Strict: isProperSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool
+ Data.EnumMap.Strict: isProperSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool
+ Data.EnumMap.Strict: isSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool
+ Data.EnumMap.Strict: isSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool
+ Data.EnumMap.Strict: keys :: Enum k => EnumMap k a -> [k]
+ Data.EnumMap.Strict: keysSet :: Enum k => EnumMap k a -> EnumSet k
+ Data.EnumMap.Strict: lookup :: Enum k => k -> EnumMap k a -> Maybe a
+ Data.EnumMap.Strict: lookupGE :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Strict: lookupGT :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Strict: lookupLE :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Strict: lookupLT :: Enum k => k -> EnumMap k a -> Maybe (k, a)
+ Data.EnumMap.Strict: map :: (a -> b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Strict: mapAccum :: (a -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
+ Data.EnumMap.Strict: mapAccumRWithKey :: Enum k => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
+ Data.EnumMap.Strict: mapAccumWithKey :: Enum k => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)
+ Data.EnumMap.Strict: mapEither :: (a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)
+ Data.EnumMap.Strict: mapEitherWithKey :: Enum k => (k -> a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)
+ Data.EnumMap.Strict: mapKeys :: Enum k => (k -> k) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: mapKeysMonotonic :: Enum k => (k -> k) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: mapKeysWith :: Enum k => (a -> a -> a) -> (k -> k) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: mapMaybe :: (a -> Maybe b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Strict: mapMaybeWithKey :: Enum k => (k -> a -> Maybe b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Strict: mapWithKey :: Enum k => (k -> a -> b) -> EnumMap k a -> EnumMap k b
+ Data.EnumMap.Strict: maxView :: EnumMap k a -> Maybe (a, EnumMap k a)
+ Data.EnumMap.Strict: maxViewWithKey :: Enum k => EnumMap k a -> Maybe ((k, a), EnumMap k a)
+ Data.EnumMap.Strict: member :: Enum k => k -> EnumMap k a -> Bool
+ Data.EnumMap.Strict: mergeWithKey :: Enum k => (k -> a -> b -> Maybe c) -> (EnumMap k a -> EnumMap k c) -> (EnumMap k b -> EnumMap k c) -> EnumMap k a -> EnumMap k b -> EnumMap k c
+ Data.EnumMap.Strict: minView :: EnumMap k a -> Maybe (a, EnumMap k a)
+ Data.EnumMap.Strict: minViewWithKey :: Enum k => EnumMap k a -> Maybe ((k, a), EnumMap k a)
+ Data.EnumMap.Strict: notMember :: Enum k => k -> EnumMap k a -> Bool
+ Data.EnumMap.Strict: null :: EnumMap k a -> Bool
+ Data.EnumMap.Strict: partition :: (a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)
+ Data.EnumMap.Strict: partitionWithKey :: Enum k => (k -> a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)
+ Data.EnumMap.Strict: singleton :: Enum k => k -> a -> EnumMap k a
+ Data.EnumMap.Strict: size :: EnumMap k a -> Int
+ Data.EnumMap.Strict: split :: Enum k => k -> EnumMap k a -> (EnumMap k a, EnumMap k a)
+ Data.EnumMap.Strict: splitLookup :: Enum k => k -> EnumMap k a -> (EnumMap k a, Maybe a, EnumMap k a)
+ Data.EnumMap.Strict: toAscList :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Strict: toDescList :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Strict: toList :: Enum k => EnumMap k a -> [(k, a)]
+ Data.EnumMap.Strict: traverseWithKey :: (Applicative t, Enum k) => (k -> a -> t b) -> EnumMap k a -> t (EnumMap k b)
+ Data.EnumMap.Strict: union :: EnumMap k a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: unionWith :: (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: unionWithKey :: Enum k => (k -> a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: unions :: [EnumMap k a] -> EnumMap k a
+ Data.EnumMap.Strict: unionsWith :: (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
+ Data.EnumMap.Strict: update :: Enum k => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: updateLookupWithKey :: Enum k => (k -> a -> Maybe a) -> k -> EnumMap k a -> (Maybe a, EnumMap k a)
+ Data.EnumMap.Strict: updateMax :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: updateMaxWithKey :: Enum k => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: updateMin :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: updateMinWithKey :: Enum k => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a
+ Data.EnumMap.Strict: updateWithKey :: Enum k => (k -> a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
+ Data.EnumSet: foldl :: Enum k => (a -> k -> a) -> a -> EnumSet k -> a
+ Data.EnumSet: foldl' :: Enum k => (a -> k -> a) -> a -> EnumSet k -> a
+ Data.EnumSet: foldr :: Enum k => (k -> b -> b) -> b -> EnumSet k -> b
+ Data.EnumSet: foldr' :: Enum k => (k -> b -> b) -> b -> EnumSet k -> b
+ Data.EnumSet: instance (Enum k, Read k) => Read (EnumSet k)
+ Data.EnumSet: instance (Enum k, Show k) => Show (EnumSet k)
+ Data.EnumSet: instance Eq (EnumSet k)
+ Data.EnumSet: instance Monoid (EnumSet k)
+ Data.EnumSet: instance NFData (EnumSet k)
+ Data.EnumSet: instance Ord (EnumSet k)
+ Data.EnumSet: lookupGE :: Enum k => k -> EnumSet k -> Maybe k
+ Data.EnumSet: lookupGT :: Enum k => k -> EnumSet k -> Maybe k
+ Data.EnumSet: lookupLE :: Enum k => k -> EnumSet k -> Maybe k
+ Data.EnumSet: lookupLT :: Enum k => k -> EnumSet k -> Maybe k
+ Data.EnumSet: toDescList :: Enum k => EnumSet k -> [k]
- Data.EnumMap: fold :: (a -> b -> b) -> b -> EnumMap k a -> b
+ Data.EnumMap: fold :: Enum k => (a -> b -> b) -> b -> EnumMap k a -> b
- Data.EnumSet: (\\) :: EnumSet e -> EnumSet e -> EnumSet e
+ Data.EnumSet: (\\) :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet: data EnumSet e
+ Data.EnumSet: data EnumSet k
- Data.EnumSet: delete :: Enum e => e -> EnumSet e -> EnumSet e
+ Data.EnumSet: delete :: Enum k => k -> EnumSet k -> EnumSet k
- Data.EnumSet: deleteFindMax :: Enum e => EnumSet e -> (e, EnumSet e)
+ Data.EnumSet: deleteFindMax :: Enum k => EnumSet k -> (k, EnumSet k)
- Data.EnumSet: deleteFindMin :: Enum e => EnumSet e -> (e, EnumSet e)
+ Data.EnumSet: deleteFindMin :: Enum k => EnumSet k -> (k, EnumSet k)
- Data.EnumSet: deleteMax :: EnumSet e -> EnumSet e
+ Data.EnumSet: deleteMax :: EnumSet k -> EnumSet k
- Data.EnumSet: deleteMin :: EnumSet e -> EnumSet e
+ Data.EnumSet: deleteMin :: EnumSet k -> EnumSet k
- Data.EnumSet: difference :: EnumSet e -> EnumSet e -> EnumSet e
+ Data.EnumSet: difference :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet: elems :: Enum e => EnumSet e -> [e]
+ Data.EnumSet: elems :: Enum k => EnumSet k -> [k]
- Data.EnumSet: empty :: EnumSet e
+ Data.EnumSet: empty :: EnumSet k
- Data.EnumSet: enumSetToIntSet :: EnumSet e -> IntSet
+ Data.EnumSet: enumSetToIntSet :: EnumSet k -> IntSet
- Data.EnumSet: filter :: Enum e => (e -> Bool) -> EnumSet e -> EnumSet e
+ Data.EnumSet: filter :: Enum k => (k -> Bool) -> EnumSet k -> EnumSet k
- Data.EnumSet: findMax :: Enum e => EnumSet e -> e
+ Data.EnumSet: findMax :: Enum k => EnumSet k -> k
- Data.EnumSet: findMin :: Enum e => EnumSet e -> e
+ Data.EnumSet: findMin :: Enum k => EnumSet k -> k
- Data.EnumSet: fold :: Enum e => (e -> b -> b) -> b -> EnumSet e -> b
+ Data.EnumSet: fold :: Enum k => (k -> b -> b) -> b -> EnumSet k -> b
- Data.EnumSet: fromAscList :: Enum e => [e] -> EnumSet e
+ Data.EnumSet: fromAscList :: Enum k => [k] -> EnumSet k
- Data.EnumSet: fromDistinctAscList :: Enum e => [e] -> EnumSet e
+ Data.EnumSet: fromDistinctAscList :: Enum k => [k] -> EnumSet k
- Data.EnumSet: fromList :: Enum e => [e] -> EnumSet e
+ Data.EnumSet: fromList :: Enum k => [k] -> EnumSet k
- Data.EnumSet: insert :: Enum e => e -> EnumSet e -> EnumSet e
+ Data.EnumSet: insert :: Enum k => k -> EnumSet k -> EnumSet k
- Data.EnumSet: intSetToEnumSet :: IntSet -> EnumSet e
+ Data.EnumSet: intSetToEnumSet :: IntSet -> EnumSet k
- Data.EnumSet: intersection :: EnumSet e -> EnumSet e -> EnumSet e
+ Data.EnumSet: intersection :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet: isProperSubsetOf :: EnumSet e -> EnumSet e -> Bool
+ Data.EnumSet: isProperSubsetOf :: EnumSet k -> EnumSet k -> Bool
- Data.EnumSet: isSubsetOf :: EnumSet e -> EnumSet e -> Bool
+ Data.EnumSet: isSubsetOf :: EnumSet k -> EnumSet k -> Bool
- Data.EnumSet: map :: Enum e => (e -> e) -> EnumSet e -> EnumSet e
+ Data.EnumSet: map :: Enum k => (k -> k) -> EnumSet k -> EnumSet k
- Data.EnumSet: maxView :: Enum e => EnumSet e -> Maybe (e, EnumSet e)
+ Data.EnumSet: maxView :: Enum k => EnumSet k -> Maybe (k, EnumSet k)
- Data.EnumSet: member :: Enum e => e -> EnumSet e -> Bool
+ Data.EnumSet: member :: Enum k => k -> EnumSet k -> Bool
- Data.EnumSet: minView :: Enum e => EnumSet e -> Maybe (e, EnumSet e)
+ Data.EnumSet: minView :: Enum k => EnumSet k -> Maybe (k, EnumSet k)
- Data.EnumSet: notMember :: Enum e => e -> EnumSet e -> Bool
+ Data.EnumSet: notMember :: Enum k => k -> EnumSet k -> Bool
- Data.EnumSet: null :: EnumSet e -> Bool
+ Data.EnumSet: null :: EnumSet k -> Bool
- Data.EnumSet: partition :: Enum e => (e -> Bool) -> EnumSet e -> (EnumSet e, EnumSet e)
+ Data.EnumSet: partition :: Enum k => (k -> Bool) -> EnumSet k -> (EnumSet k, EnumSet k)
- Data.EnumSet: singleton :: Enum e => e -> EnumSet e
+ Data.EnumSet: singleton :: Enum k => k -> EnumSet k
- Data.EnumSet: size :: EnumSet e -> Int
+ Data.EnumSet: size :: EnumSet k -> Int
- Data.EnumSet: split :: Enum e => e -> EnumSet e -> (EnumSet e, EnumSet e)
+ Data.EnumSet: split :: Enum k => k -> EnumSet k -> (EnumSet k, EnumSet k)
- Data.EnumSet: splitMember :: Enum e => e -> EnumSet e -> (EnumSet e, Bool, EnumSet e)
+ Data.EnumSet: splitMember :: Enum k => k -> EnumSet k -> (EnumSet k, Bool, EnumSet k)
- Data.EnumSet: toAscList :: Enum e => EnumSet e -> [e]
+ Data.EnumSet: toAscList :: Enum k => EnumSet k -> [k]
- Data.EnumSet: toList :: Enum e => EnumSet e -> [e]
+ Data.EnumSet: toList :: Enum k => EnumSet k -> [k]
- Data.EnumSet: union :: EnumSet e -> EnumSet e -> EnumSet e
+ Data.EnumSet: union :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet: unions :: [EnumSet e] -> EnumSet e
+ Data.EnumSet: unions :: [EnumSet k] -> EnumSet k

Files

Data/EnumMap.hs view
@@ -1,533 +1,41 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}- -- | -- Module      :  $Header$ -- Description :  Data.IntMap with Enum keys.--- Copyright   :  (c) 2011 Michal Terepeta+-- Copyright   :  (c) 2011-2013 Michal Terepeta -- License     :  BSD3 -- Maintainer  :  michal.terepeta@gmail.com -- Stability   :  alpha--- Portability :  uses GeneralizedNewtypeDeriving+-- Portability :  uses DeriveDataTypeable and GeneralizedNewtypeDeriving  -- This is a simple wrapper for 'Data.IntMap' that works with any type of keys--- that are instances of 'Enum' type class. Useful if one wants to have the--- performance of 'Data.IntMap' and at the same time use something else than--- 'Int's (e.g. an 'Int' wrapped with newtype). For documentation please see the+-- that are instances of 'Enum' type class.  For documentation please see the -- one for 'Data.IntMap'.  module Data.EnumMap-  ( EnumMap--  -- * Wrapping/unwrapping-  , intMapToEnumMap-  , enumMapToIntMap--  -- * Operators-  , (!)-  , (\\)--  -- * Query-  , null-  , size-  , member-  , notMember-  , lookup-  , findWithDefault--  -- * Construction-  , empty-  , singleton--  -- ** Insertion-  , insert-  , insertWith-  , insertWithKey-  , insertLookupWithKey--  -- ** Delete\/Update-  , delete-  , adjust-  , adjustWithKey-  , update-  , updateWithKey-  , updateLookupWithKey-  , alter--  -- * Combine--  -- ** Union-  , union-  , unionWith-  , unionWithKey-  , unions-  , unionsWith--  -- ** Difference-  , difference-  , differenceWith-  , differenceWithKey--  -- ** Intersection-  , intersection-  , intersectionWith-  , intersectionWithKey--  -- ** Universal combining function-  , mergeWithKey--  -- * Traversal-  -- ** Map-  , map-  , mapWithKey-  , mapAccum-  , mapAccumWithKey-  , mapAccumRWithKey--  -- ** Fold+  ( module Data.EnumMap.Lazy+  , insertWith'+  , insertWithKey'   , fold   , foldWithKey--  -- * Conversion-  , elems-  , keys-  , keysSet-  , assocs--  -- ** Lists-  , toList-  , fromList-  , fromListWith-  , fromListWithKey--  -- ** Ordered lists-  , toAscList-  , fromAscList-  , fromAscListWith-  , fromAscListWithKey-  , fromDistinctAscList--  -- * Filter-  , filter-  , filterWithKey-  , partition-  , partitionWithKey--  , mapMaybe-  , mapMaybeWithKey-  , mapEither-  , mapEitherWithKey--  , split-  , splitLookup--  -- * Submap-  , isSubmapOf-  , isSubmapOfBy-  , isProperSubmapOf-  , isProperSubmapOfBy--  -- * Min\/Max-  , findMin-  , findMax-  , deleteMin-  , deleteMax-  , deleteFindMin-  , deleteFindMax-  , updateMin-  , updateMax-  , updateMinWithKey-  , updateMaxWithKey-  , minView-  , maxView-  , minViewWithKey-  , maxViewWithKey   ) where -import Prelude hiding ( filter, lookup, map, null )-import qualified Prelude as P--import Data.IntMap ( IntMap )-import qualified Data.IntMap as I--import Data.EnumSet ( EnumSet )-import qualified Data.EnumSet as EnumSet--import Control.Arrow ( first, second, (***) )-import Data.Foldable ( Foldable )-import Data.Monoid ( Monoid )-import Data.Traversable ( Traversable )-import Data.Typeable ( Typeable )--import Text.Read---- | Wrapper for 'IntMap' with 'Enum' keys.-newtype EnumMap k a = EnumMap { unWrap :: IntMap a }-  deriving (Eq, Foldable, Functor, Ord, Monoid, Traversable, Typeable)--instance (Enum k, Show k, Show a) => Show (EnumMap k a) where-  showsPrec p em = showParen (p > 10) $-    showString "fromList " . shows (toList em)--instance (Enum k, Read k, Read a) => Read (EnumMap k a) where-  readPrec = parens . prec 10 $ do-    Ident "fromList" <- lexP-    list <- readPrec-    return (fromList list)------- Conversion to/from 'IntMap'.------- | Wrap 'IntMap'.-intMapToEnumMap :: IntMap a -> EnumMap k a-intMapToEnumMap = EnumMap---- | Unwrap 'IntMap'.-enumMapToIntMap :: EnumMap k a -> IntMap a-enumMapToIntMap = unWrap------- A few useful functions used through the module. Not exported.-----pairWrap :: (IntMap a, IntMap b) -> (EnumMap k a, EnumMap k b)-pairWrap = EnumMap *** EnumMap-{-# INLINE pairWrap #-}------- Here begins the main part.-----(!) :: (Enum k) => EnumMap k a -> k -> a-(EnumMap im) ! k = im I.! (fromEnum k)-{-# INLINE (!) #-}--(\\) :: EnumMap k a -> EnumMap k b -> EnumMap k a-(EnumMap im1) \\ (EnumMap im2) = EnumMap $ im1 I.\\ im2-{-# INLINE (\\) #-}--null :: EnumMap k a -> Bool-null = I.null . unWrap-{-# INLINE null #-}--size :: EnumMap k a -> Int-size = I.size . unWrap-{-# INLINE size #-}--member :: (Enum k) => k -> EnumMap k a -> Bool-member k = I.member (fromEnum k) . unWrap-{-# INLINE member #-}--notMember :: (Enum k) => k -> EnumMap k a -> Bool-notMember k = I.notMember (fromEnum k) . unWrap-{-# INLINE notMember #-}--lookup :: (Enum k) => k -> EnumMap k a -> Maybe a-lookup k = I.lookup (fromEnum k) . unWrap-{-# INLINE lookup #-}--findWithDefault :: (Enum k) => a -> k -> EnumMap k a -> a-findWithDefault def k = I.findWithDefault def (fromEnum k) . unWrap-{-# INLINE findWithDefault #-}--empty :: EnumMap k a-empty = EnumMap $ I.empty-{-# INLINE empty #-}--singleton :: (Enum k) => k -> a -> EnumMap k a-singleton k = EnumMap . I.singleton (fromEnum k)-{-# INLINE singleton #-}--insert :: (Enum k) => k -> a -> EnumMap k a -> EnumMap k a-insert k a = EnumMap . I.insert (fromEnum k) a . unWrap-{-# INLINE insert #-}--insertWith :: (Enum k) => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a-insertWith f k a = EnumMap . I.insertWith f (fromEnum k) a . unWrap-{-# INLINE insertWith #-}--insertWithKey :: (Enum k) => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a-insertWithKey f k a = EnumMap . I.insertWithKey (f . toEnum) (fromEnum k) a . unWrap-{-# INLINE insertWithKey #-}--insertLookupWithKey :: (Enum k) => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> (Maybe a, EnumMap k a)-insertLookupWithKey f k a = second EnumMap . I.insertLookupWithKey (f . toEnum) (fromEnum k) a . unWrap-{-# INLINE insertLookupWithKey #-}--delete :: (Enum k) => k -> EnumMap k a -> EnumMap k a-delete k = EnumMap . I.delete (fromEnum k) . unWrap-{-# INLINE delete #-}--adjust ::  (Enum k) => (a -> a) -> k -> EnumMap k a -> EnumMap k a-adjust f k = EnumMap . I.adjust f (fromEnum k) . unWrap-{-# INLINE adjust #-}--adjustWithKey :: (Enum k) => (k -> a -> a) -> k -> EnumMap k a -> EnumMap k a-adjustWithKey f k = EnumMap . I.adjustWithKey (f . toEnum) (fromEnum k) . unWrap-{-# INLINE adjustWithKey #-}--update ::  (Enum k) => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a-update f k = EnumMap . I.update f (fromEnum k) . unWrap-{-# INLINE update #-}--updateWithKey ::  (Enum k) => (k -> a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a-updateWithKey f k = EnumMap . I.updateWithKey (f . toEnum) (fromEnum k) . unWrap-{-# INLINE updateWithKey #-}--updateLookupWithKey ::  (Enum k) => (k -> a -> Maybe a) -> k -> EnumMap k a -> (Maybe a,EnumMap k a)-updateLookupWithKey f k = second EnumMap . I.updateLookupWithKey (f . toEnum) (fromEnum k) . unWrap-{-# INLINE updateLookupWithKey #-}--alter :: (Enum k) => (Maybe a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a-alter f k = EnumMap . I.alter f (fromEnum k) . unWrap-{-# INLINE alter #-}--unions :: [EnumMap k a] -> EnumMap k a-unions = EnumMap . I.unions . P.map unWrap-{-# INLINE unions #-}--unionsWith :: (a -> a -> a) -> [EnumMap k a] -> EnumMap k a-unionsWith f = EnumMap . I.unionsWith f . P.map unWrap-{-# INLINE unionsWith #-}--union :: EnumMap k a -> EnumMap k a -> EnumMap k a-union (EnumMap im1) (EnumMap im2) = EnumMap $ I.union im1 im2-{-# INLINE union #-}--unionWith :: (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a-unionWith f (EnumMap im1) (EnumMap im2) = EnumMap $ I.unionWith f im1 im2-{-# INLINE unionWith #-}--unionWithKey :: (Enum k) => (k -> a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a-unionWithKey f (EnumMap im1) (EnumMap im2) = EnumMap $ I.unionWithKey (f . toEnum) im1 im2-{-# INLINE unionWithKey #-}--difference :: EnumMap k a -> EnumMap k b -> EnumMap k a-difference (EnumMap im1) (EnumMap im2) = EnumMap $ I.difference im1 im2-{-# INLINE difference #-}--differenceWith :: (a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a-differenceWith f (EnumMap im1) (EnumMap im2) = EnumMap $ I.differenceWith f im1 im2-{-# INLINE differenceWith #-}--differenceWithKey :: (Enum k) => (k -> a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a-differenceWithKey f (EnumMap im1) (EnumMap im2) = EnumMap $ I.differenceWithKey (f . toEnum) im1 im2-{-# INLINE differenceWithKey #-}--intersection :: EnumMap k a -> EnumMap k b -> EnumMap k a-intersection (EnumMap im1) (EnumMap im2) = EnumMap $ I.intersection im1 im2-{-# INLINE intersection #-}--intersectionWith :: (a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c-intersectionWith f (EnumMap im1) (EnumMap im2) = EnumMap $ I.intersectionWith f im1 im2-{-# INLINE intersectionWith #-}--intersectionWithKey :: (Enum k) => (k -> a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c-intersectionWithKey f (EnumMap im1) (EnumMap im2) = EnumMap $ I.intersectionWithKey (f . toEnum) im1 im2-{-# INLINE intersectionWithKey #-}--mergeWithKey :: (Enum k) => (k -> a -> b -> Maybe c) ->-    (EnumMap k a -> EnumMap k c) -> (EnumMap k b -> EnumMap k c) ->-    EnumMap k a -> EnumMap k b -> EnumMap k c-mergeWithKey f ga gb = \ ma mb -> EnumMap $-    I.mergeWithKey (f . toEnum) (unWrap . ga . EnumMap) (unWrap . gb . EnumMap) (unWrap ma) (unWrap mb)-{-# INLINE mergeWithKey #-}--updateMinWithKey :: (Enum k) => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a-updateMinWithKey f = EnumMap . I.updateMinWithKey (f . toEnum) . unWrap-{-# INLINE updateMinWithKey #-}--updateMaxWithKey :: (Enum k) => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a-updateMaxWithKey f = EnumMap . I.updateMaxWithKey (f . toEnum) . unWrap-{-# INLINE updateMaxWithKey #-}--maxViewWithKey :: (Enum k) => EnumMap k a -> Maybe ((k, a), EnumMap k a)-maxViewWithKey = fmap wrap . I.maxViewWithKey . unWrap-  where-    wrap ((i, a), im) = ((toEnum i, a), EnumMap im)-{-# INLINE maxViewWithKey #-}--minViewWithKey :: (Enum k) => EnumMap k a -> Maybe ((k, a), EnumMap k a)-minViewWithKey =  fmap wrap . I.minViewWithKey . unWrap-  where-    wrap ((i, a), imap) = ((toEnum i, a), EnumMap imap)-{-# INLINE minViewWithKey #-}--updateMax :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a-updateMax f = EnumMap . I.updateMax f . unWrap-{-# INLINE updateMax #-}--updateMin :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a-updateMin f = EnumMap . I.updateMin f . unWrap-{-# INLINE updateMin #-}--maxView :: EnumMap k a -> Maybe (a, EnumMap k a)-maxView = fmap (second EnumMap) . I.maxView . unWrap-{-# INLINE maxView #-}--minView :: EnumMap k a -> Maybe (a, EnumMap k a)-minView = fmap (second EnumMap) . I.minView . unWrap-{-# INLINE minView #-}--deleteFindMax :: (Enum k) => EnumMap k a -> ((k, a), EnumMap k a)-deleteFindMax = (first toEnum *** EnumMap) . I.deleteFindMax . unWrap-{-# INLINE deleteFindMax #-}--deleteFindMin :: (Enum k) => EnumMap k a -> ((k, a), EnumMap k a)-deleteFindMin = (first toEnum *** EnumMap) . I.deleteFindMin . unWrap-{-# INLINE deleteFindMin #-}--findMin :: (Enum k) => EnumMap k a -> (k, a)-findMin = first toEnum . I.findMin . unWrap-{-# INLINE findMin #-}--findMax :: (Enum k) => EnumMap k a -> (k, a)-findMax = first toEnum . I.findMax . unWrap-{-# INLINE findMax #-}--deleteMin :: EnumMap k a -> EnumMap k a-deleteMin = EnumMap . I.deleteMin . unWrap-{-# INLINE deleteMin #-}--deleteMax :: EnumMap k a -> EnumMap k a-deleteMax = EnumMap . I.deleteMax . unWrap-{-# INLINE deleteMax #-}--isProperSubmapOf :: (Eq a) => EnumMap k a -> EnumMap k a -> Bool-isProperSubmapOf (EnumMap im1) (EnumMap im2) = I.isProperSubmapOf im1 im2-{-# INLINE isProperSubmapOf #-}--isProperSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool-isProperSubmapOfBy p (EnumMap im1) (EnumMap im2) = I.isProperSubmapOfBy p im1 im2-{-# INLINE isProperSubmapOfBy #-}--isSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool-isSubmapOf (EnumMap im1) (EnumMap im2) = I.isSubmapOf im1 im2-{-# INLINE isSubmapOf #-}--isSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool-isSubmapOfBy p (EnumMap im1) (EnumMap im2) = I.isSubmapOfBy p im1 im2-{-# INLINE isSubmapOfBy #-}--map :: (a -> b) -> EnumMap k a -> EnumMap k b-map f = EnumMap . I.map f . unWrap-{-# INLINE map #-}--mapWithKey :: (Enum k) => (k -> a -> b) -> EnumMap k a -> EnumMap k b-mapWithKey f = EnumMap . I.mapWithKey (f . toEnum) . unWrap-{-# INLINE mapWithKey #-}--mapAccum :: (a -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)-mapAccum f a = second EnumMap . I.mapAccum f a . unWrap-{-# INLINE mapAccum #-}--mapAccumWithKey :: (Enum k) => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)-mapAccumWithKey f a = second EnumMap . I.mapAccumWithKey (\b -> f b . toEnum) a . unWrap-{-# INLINE mapAccumWithKey #-}--mapAccumRWithKey :: (Enum k) => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)-mapAccumRWithKey f a = second EnumMap . I.mapAccumRWithKey (\b -> f b . toEnum) a . unWrap-{-# INLINE mapAccumRWithKey #-}--filter :: (a -> Bool) -> EnumMap k a -> EnumMap k a-filter p = EnumMap . I.filter p . unWrap-{-# INLINE filter #-}--filterWithKey :: (Enum k) => (k -> a -> Bool) -> EnumMap k a -> EnumMap k a-filterWithKey p = EnumMap . I.filterWithKey (p . toEnum) . unWrap-{-# INLINE filterWithKey #-}--partition :: (a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)-partition p = pairWrap . I.partition p . unWrap-{-# INLINE partition #-}--partitionWithKey :: (Enum k) => (k -> a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)-partitionWithKey p = pairWrap . I.partitionWithKey (p . toEnum) . unWrap-{-# INLINE partitionWithKey #-}--mapMaybe :: (a -> Maybe b) -> EnumMap k a -> EnumMap k b-mapMaybe f = EnumMap . I.mapMaybe f . unWrap-{-# INLINE mapMaybe #-}--mapMaybeWithKey :: (Enum k) => (k -> a -> Maybe b) -> EnumMap k a -> EnumMap k b-mapMaybeWithKey f = EnumMap . I.mapMaybeWithKey (f . toEnum) . unWrap-{-# INLINE mapMaybeWithKey #-}+import Prelude hiding ( filter, foldr, foldl, lookup, map, null ) -mapEither :: (a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)-mapEither f = pairWrap . I.mapEither f . unWrap-{-# INLINE mapEither #-}+import Data.EnumMap.Lazy+import Data.EnumMap.Base -mapEitherWithKey :: (Enum k) => (k -> a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)-mapEitherWithKey f = pairWrap . I.mapEitherWithKey (f . toEnum) . unWrap-{-# INLINE mapEitherWithKey #-}+import qualified Data.IntMap as I -split :: (Enum k) => k -> EnumMap k a -> (EnumMap k a, EnumMap k a)-split k = pairWrap . I.split (fromEnum k) . unWrap-{-# INLINE split #-}+insertWith' :: (Enum k) => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a+insertWith' f k x = EnumMap . I.insertWith' f (fromEnum k) x . unWrap -splitLookup :: (Enum k) => k -> EnumMap k a -> (EnumMap k a, Maybe a, EnumMap k a)-splitLookup k = wrap . I.splitLookup (fromEnum k) . unWrap-  where-    wrap (im1, ma, im2) = (EnumMap im1, ma, EnumMap im2)-{-# INLINE splitLookup #-}+insertWithKey' :: (Enum k)+  => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a+insertWithKey' f k x =+  EnumMap . I.insertWithKey' (f . toEnum) (fromEnum k) x . unWrap -fold :: (a -> b -> b) -> b -> EnumMap k a -> b-fold f acc = I.fold f acc . unWrap-{-# INLINE fold #-}+fold :: (Enum k) => (a -> b -> b) -> b -> EnumMap k a -> b+fold f a = I.fold f a . unWrap  foldWithKey :: (Enum k) => (k -> a -> b -> b) -> b -> EnumMap k a -> b-foldWithKey f acc = I.foldWithKey (f . toEnum) acc . unWrap-{-# INLINE foldWithKey #-}--elems :: EnumMap k a -> [a]-elems = I.elems . unWrap-{-# INLINE elems #-}--keys :: (Enum k) => EnumMap k a -> [k]-keys = P.map toEnum . I.keys . unWrap-{-# INLINE keys #-}--keysSet :: (Enum k) => EnumMap k a -> EnumSet k-keysSet = EnumSet.fromDistinctAscList . keys-{-# INLINE keysSet #-}--assocs :: (Enum k) => EnumMap k a -> [(k, a)]-assocs = P.map (first toEnum) . I.assocs . unWrap-{-# INLINE assocs #-}--toList :: (Enum k) => EnumMap k a -> [(k, a)]-toList = P.map (first toEnum) . I.toList . unWrap-{-# INLINE toList #-}--toAscList :: (Enum k) => EnumMap k a -> [(k, a)]-toAscList = P.map (first toEnum) . I.toAscList . unWrap-{-# INLINE toAscList #-}--fromList :: (Enum k) => [(k, a)] -> EnumMap k a-fromList = EnumMap . I.fromList . P.map (first fromEnum)-{-# INLINE fromList #-}--fromListWith :: (Enum k) => (a -> a -> a) -> [(k, a)] -> EnumMap k a-fromListWith f = EnumMap . I.fromListWith f . P.map (first fromEnum)-{-# INLINE fromListWith #-}--fromListWithKey :: (Enum k) => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a-fromListWithKey f = EnumMap . I.fromListWithKey (f . toEnum) . P.map (first fromEnum)-{-# INLINE fromListWithKey #-}--fromAscList :: (Enum k) => [(k, a)] -> EnumMap k a-fromAscList = EnumMap . I.fromAscList . P.map (first fromEnum)-{-# INLINE fromAscList #-}--fromAscListWith :: (Enum k) => (a -> a -> a) -> [(k, a)] -> EnumMap k a-fromAscListWith f = EnumMap . I.fromAscListWith f . P.map (first fromEnum)-{-# INLINE fromAscListWith #-}--fromAscListWithKey :: (Enum k) => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a-fromAscListWithKey f = EnumMap . I.fromAscListWithKey (f . toEnum) . P.map (first fromEnum)-{-# INLINE fromAscListWithKey #-}--fromDistinctAscList :: (Enum k) => [(k, a)] -> EnumMap k a-fromDistinctAscList = EnumMap . I.fromDistinctAscList . P.map (first fromEnum)-{-# INLINE fromDistinctAscList #-}+foldWithKey f a = I.foldWithKey (f . toEnum) a . unWrap
+ Data/EnumMap/Base.hs view
@@ -0,0 +1,637 @@+{-# LANGUAGE DeriveDataTypeable         #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++-- |+-- Module      :  $Header$+-- Description :  Data.IntMap with Enum keys.+-- Copyright   :  (c) 2011-2013 Michal Terepeta+-- License     :  BSD3+-- Maintainer  :  michal.terepeta@gmail.com+-- Stability   :  alpha+-- Portability :  uses DeriveDataTypeable and GeneralizedNewtypeDeriving++module Data.EnumMap.Base+  ( EnumMap(..)++  -- * Wrapping/unwrapping+  , intMapToEnumMap+  , enumMapToIntMap++  -- * Operators+  , (!)+  , (\\)++  -- * Query+  , null+  , size+  , member+  , notMember+  , lookup+  , findWithDefault+  , lookupLT+  , lookupGT+  , lookupLE+  , lookupGE++  -- * Construction+  , empty+  , singleton++  -- ** Insertion+  , insert+  , insertWith+  , insertWithKey+  , insertLookupWithKey++  -- ** Delete\/Update+  , delete+  , adjust+  , adjustWithKey+  , update+  , updateWithKey+  , updateLookupWithKey+  , alter++  -- * Combine++  -- ** Union+  , union+  , unionWith+  , unionWithKey+  , unions+  , unionsWith++  -- ** Difference+  , difference+  , differenceWith+  , differenceWithKey++  -- ** Intersection+  , intersection+  , intersectionWith+  , intersectionWithKey++  -- ** Universal combining function+  , mergeWithKey++  -- * Traversal+  -- ** Map+  , map+  , mapWithKey+  , traverseWithKey+  , mapAccum+  , mapAccumWithKey+  , mapAccumRWithKey+  , mapKeys+  , mapKeysWith+  , mapKeysMonotonic++  -- * Folds+  , foldr+  , foldl+  , foldrWithKey+  , foldlWithKey+  -- ** Strict folds+  , foldr'+  , foldl'+  , foldrWithKey'+  , foldlWithKey'++  -- * Conversion+  , elems+  , keys+  , assocs+  , keysSet+  , fromSet++  -- ** Lists+  , toList+  , fromList+  , fromListWith+  , fromListWithKey++  -- ** Ordered lists+  , toAscList+  , toDescList+  , fromAscList+  , fromAscListWith+  , fromAscListWithKey+  , fromDistinctAscList++  -- * Filter+  , filter+  , filterWithKey+  , partition+  , partitionWithKey++  , mapMaybe+  , mapMaybeWithKey+  , mapEither+  , mapEitherWithKey++  , split+  , splitLookup++  -- * Submap+  , isSubmapOf+  , isSubmapOfBy+  , isProperSubmapOf+  , isProperSubmapOfBy++  -- * Min\/Max+  , findMin+  , findMax+  , deleteMin+  , deleteMax+  , deleteFindMin+  , deleteFindMax+  , updateMin+  , updateMax+  , updateMinWithKey+  , updateMaxWithKey+  , minView+  , maxView+  , minViewWithKey+  , maxViewWithKey+  ) where++import Prelude hiding ( filter, foldr, foldl, lookup, map, null )+import qualified Prelude as P++import Control.Applicative ( Applicative, liftA )++import Data.IntMap.Lazy ( IntMap )+import qualified Data.IntMap.Lazy as I++import Data.EnumSet ( EnumSet )+import qualified Data.EnumSet as EnumSet++import Control.Arrow ( first, second, (***) )+import Control.DeepSeq ( NFData )+import Data.Foldable ( Foldable )+import Data.Monoid ( Monoid )+import Data.Traversable ( Traversable )+import Data.Typeable ( Typeable )++import Text.Read++-- | Wrapper for 'IntMap' with 'Enum' keys.+newtype EnumMap k a = EnumMap { unWrap :: IntMap a }+  deriving (Eq, Foldable, Functor, Ord, Monoid, Traversable, Typeable, NFData)++instance (Enum k, Show k, Show a) => Show (EnumMap k a) where+  showsPrec p em = showParen (p > 10) $+    showString "fromList " . shows (toList em)++instance (Enum k, Read k, Read a) => Read (EnumMap k a) where+  readPrec = parens . prec 10 $ do+    Ident "fromList" <- lexP+    list <- readPrec+    return (fromList list)++--+-- Conversion to/from 'IntMap'.+--++-- | Wrap 'IntMap'.+intMapToEnumMap :: IntMap a -> EnumMap k a+intMapToEnumMap = EnumMap+{-# INLINE intMapToEnumMap #-}++-- | Unwrap 'IntMap'.+enumMapToIntMap :: EnumMap k a -> IntMap a+enumMapToIntMap = unWrap+{-# INLINE enumMapToIntMap #-}++--+-- Here begins the main part.+--++(!) :: (Enum k) => EnumMap k a -> k -> a+(EnumMap im) ! k = im I.! (fromEnum k)+{-# INLINE (!) #-}++(\\) :: EnumMap k a -> EnumMap k b -> EnumMap k a+(EnumMap im1) \\ (EnumMap im2) = EnumMap $ im1 I.\\ im2+{-# INLINE (\\) #-}++null :: EnumMap k a -> Bool+null = I.null . unWrap+{-# INLINE null #-}++size :: EnumMap k a -> Int+size = I.size . unWrap+{-# INLINE size #-}++member :: (Enum k) => k -> EnumMap k a -> Bool+member k = I.member (fromEnum k) . unWrap+{-# INLINE member #-}++notMember :: (Enum k) => k -> EnumMap k a -> Bool+notMember k = I.notMember (fromEnum k) . unWrap+{-# INLINE notMember #-}++lookup :: (Enum k) => k -> EnumMap k a -> Maybe a+lookup k = I.lookup (fromEnum k) . unWrap+{-# INLINE lookup #-}++findWithDefault :: (Enum k) => a -> k -> EnumMap k a -> a+findWithDefault def k = I.findWithDefault def (fromEnum k) . unWrap+{-# INLINE findWithDefault #-}++lookupLT :: (Enum k) => k -> EnumMap k a -> Maybe (k, a)+lookupLT k = fmap (first toEnum) . I.lookupLT (fromEnum k) . unWrap+{-# INLINE lookupLT #-}++lookupGT :: (Enum k) => k -> EnumMap k a -> Maybe (k, a)+lookupGT k = fmap (first toEnum) . I.lookupGT (fromEnum k) . unWrap+{-# INLINE lookupGT #-}++lookupLE :: (Enum k) => k -> EnumMap k a -> Maybe (k, a)+lookupLE k = fmap (first toEnum) . I.lookupLE (fromEnum k) . unWrap+{-# INLINE lookupLE #-}++lookupGE :: (Enum k) => k -> EnumMap k a -> Maybe (k, a)+lookupGE k = fmap (first toEnum) . I.lookupGE (fromEnum k) . unWrap+{-# INLINE lookupGE #-}++empty :: EnumMap k a+empty = EnumMap $ I.empty+{-# INLINE empty #-}++singleton :: (Enum k) => k -> a -> EnumMap k a+singleton k = EnumMap . I.singleton (fromEnum k)+{-# INLINE singleton #-}++insert :: (Enum k) => k -> a -> EnumMap k a -> EnumMap k a+insert k a = EnumMap . I.insert (fromEnum k) a . unWrap+{-# INLINE insert #-}++insertWith :: (Enum k) => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a+insertWith f k a = EnumMap . I.insertWith f (fromEnum k) a . unWrap+{-# INLINE insertWith #-}++insertWithKey :: (Enum k)+  => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a+insertWithKey f k a = EnumMap . I.insertWithKey (f . toEnum) (fromEnum k) a . unWrap+{-# INLINE insertWithKey #-}++insertLookupWithKey :: (Enum k)+  => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> (Maybe a, EnumMap k a)+insertLookupWithKey f k a =+  second EnumMap . I.insertLookupWithKey (f . toEnum) (fromEnum k) a . unWrap+{-# INLINE insertLookupWithKey #-}++delete :: (Enum k) => k -> EnumMap k a -> EnumMap k a+delete k = EnumMap . I.delete (fromEnum k) . unWrap+{-# INLINE delete #-}++adjust ::  (Enum k) => (a -> a) -> k -> EnumMap k a -> EnumMap k a+adjust f k = EnumMap . I.adjust f (fromEnum k) . unWrap+{-# INLINE adjust #-}++adjustWithKey :: (Enum k) => (k -> a -> a) -> k -> EnumMap k a -> EnumMap k a+adjustWithKey f k = EnumMap . I.adjustWithKey (f . toEnum) (fromEnum k) . unWrap+{-# INLINE adjustWithKey #-}++update ::  (Enum k) => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a+update f k = EnumMap . I.update f (fromEnum k) . unWrap+{-# INLINE update #-}++updateWithKey ::  (Enum k) => (k -> a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a+updateWithKey f k = EnumMap . I.updateWithKey (f . toEnum) (fromEnum k) . unWrap+{-# INLINE updateWithKey #-}++updateLookupWithKey ::  (Enum k)+  => (k -> a -> Maybe a) -> k -> EnumMap k a -> (Maybe a,EnumMap k a)+updateLookupWithKey f k =+  second EnumMap . I.updateLookupWithKey (f . toEnum) (fromEnum k) . unWrap+{-# INLINE updateLookupWithKey #-}++alter :: (Enum k) => (Maybe a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a+alter f k = EnumMap . I.alter f (fromEnum k) . unWrap+{-# INLINE alter #-}++unions :: [EnumMap k a] -> EnumMap k a+unions = EnumMap . I.unions . P.map unWrap+{-# INLINE unions #-}++unionsWith :: (a -> a -> a) -> [EnumMap k a] -> EnumMap k a+unionsWith f = EnumMap . I.unionsWith f . P.map unWrap+{-# INLINE unionsWith #-}++union :: EnumMap k a -> EnumMap k a -> EnumMap k a+union (EnumMap im1) (EnumMap im2) = EnumMap $ I.union im1 im2+{-# INLINE union #-}++unionWith :: (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a+unionWith f (EnumMap im1) (EnumMap im2) = EnumMap $ I.unionWith f im1 im2+{-# INLINE unionWith #-}++unionWithKey :: (Enum k)+  => (k -> a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a+unionWithKey f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.unionWithKey (f . toEnum) im1 im2+{-# INLINE unionWithKey #-}++difference :: EnumMap k a -> EnumMap k b -> EnumMap k a+difference (EnumMap im1) (EnumMap im2) = EnumMap $ I.difference im1 im2+{-# INLINE difference #-}++differenceWith :: (a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a+differenceWith f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.differenceWith f im1 im2+{-# INLINE differenceWith #-}++differenceWithKey :: (Enum k)+  => (k -> a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a+differenceWithKey f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.differenceWithKey (f . toEnum) im1 im2+{-# INLINE differenceWithKey #-}++intersection :: EnumMap k a -> EnumMap k b -> EnumMap k a+intersection (EnumMap im1) (EnumMap im2) = EnumMap $ I.intersection im1 im2+{-# INLINE intersection #-}++intersectionWith :: (a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c+intersectionWith f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.intersectionWith f im1 im2+{-# INLINE intersectionWith #-}++intersectionWithKey :: (Enum k)+  => (k -> a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c+intersectionWithKey f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.intersectionWithKey (f . toEnum) im1 im2+{-# INLINE intersectionWithKey #-}++mergeWithKey :: (Enum k)+  => (k -> a -> b -> Maybe c)+  -> (EnumMap k a -> EnumMap k c)+  -> (EnumMap k b -> EnumMap k c)+  -> EnumMap k a+  -> EnumMap k b+  -> EnumMap k c+mergeWithKey f ga gb = \ma mb -> EnumMap $+  I.mergeWithKey (f . toEnum)+                 (unWrap . ga . EnumMap)+                 (unWrap . gb . EnumMap)+                 (unWrap ma)+                 (unWrap mb)+{-# INLINE mergeWithKey #-}++updateMinWithKey :: (Enum k) => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMinWithKey f = EnumMap . I.updateMinWithKey (f . toEnum) . unWrap+{-# INLINE updateMinWithKey #-}++updateMaxWithKey :: (Enum k) => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMaxWithKey f = EnumMap . I.updateMaxWithKey (f . toEnum) . unWrap+{-# INLINE updateMaxWithKey #-}++maxViewWithKey :: (Enum k) => EnumMap k a -> Maybe ((k, a), EnumMap k a)+maxViewWithKey = fmap wrap . I.maxViewWithKey . unWrap+  where+    wrap ((i, a), im) = ((toEnum i, a), EnumMap im)+{-# INLINE maxViewWithKey #-}++minViewWithKey :: (Enum k) => EnumMap k a -> Maybe ((k, a), EnumMap k a)+minViewWithKey =  fmap wrap . I.minViewWithKey . unWrap+  where+    wrap ((i, a), imap) = ((toEnum i, a), EnumMap imap)+{-# INLINE minViewWithKey #-}++updateMax :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMax f = EnumMap . I.updateMax f . unWrap+{-# INLINE updateMax #-}++updateMin :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMin f = EnumMap . I.updateMin f . unWrap+{-# INLINE updateMin #-}++maxView :: EnumMap k a -> Maybe (a, EnumMap k a)+maxView = fmap (second EnumMap) . I.maxView . unWrap+{-# INLINE maxView #-}++minView :: EnumMap k a -> Maybe (a, EnumMap k a)+minView = fmap (second EnumMap) . I.minView . unWrap+{-# INLINE minView #-}++deleteFindMax :: (Enum k) => EnumMap k a -> ((k, a), EnumMap k a)+deleteFindMax = (first toEnum *** EnumMap) . I.deleteFindMax . unWrap+{-# INLINE deleteFindMax #-}++deleteFindMin :: (Enum k) => EnumMap k a -> ((k, a), EnumMap k a)+deleteFindMin = (first toEnum *** EnumMap) . I.deleteFindMin . unWrap+{-# INLINE deleteFindMin #-}++findMin :: (Enum k) => EnumMap k a -> (k, a)+findMin = first toEnum . I.findMin . unWrap+{-# INLINE findMin #-}++findMax :: (Enum k) => EnumMap k a -> (k, a)+findMax = first toEnum . I.findMax . unWrap+{-# INLINE findMax #-}++deleteMin :: EnumMap k a -> EnumMap k a+deleteMin = EnumMap . I.deleteMin . unWrap+{-# INLINE deleteMin #-}++deleteMax :: EnumMap k a -> EnumMap k a+deleteMax = EnumMap . I.deleteMax . unWrap+{-# INLINE deleteMax #-}++isProperSubmapOf :: (Eq a) => EnumMap k a -> EnumMap k a -> Bool+isProperSubmapOf (EnumMap im1) (EnumMap im2) = I.isProperSubmapOf im1 im2+{-# INLINE isProperSubmapOf #-}++isProperSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool+isProperSubmapOfBy p (EnumMap im1) (EnumMap im2) = I.isProperSubmapOfBy p im1 im2+{-# INLINE isProperSubmapOfBy #-}++isSubmapOf :: Eq a => EnumMap k a -> EnumMap k a -> Bool+isSubmapOf (EnumMap im1) (EnumMap im2) = I.isSubmapOf im1 im2+{-# INLINE isSubmapOf #-}++isSubmapOfBy :: (a -> b -> Bool) -> EnumMap k a -> EnumMap k b -> Bool+isSubmapOfBy p (EnumMap im1) (EnumMap im2) = I.isSubmapOfBy p im1 im2+{-# INLINE isSubmapOfBy #-}++map :: (a -> b) -> EnumMap k a -> EnumMap k b+map f = EnumMap . I.map f . unWrap+{-# INLINE map #-}++mapWithKey :: (Enum k) => (k -> a -> b) -> EnumMap k a -> EnumMap k b+mapWithKey f = EnumMap . I.mapWithKey (f . toEnum) . unWrap+{-# INLINE mapWithKey #-}++traverseWithKey :: (Applicative t, Enum k)+  => (k -> a -> t b) -> EnumMap k a -> t (EnumMap k b)+traverseWithKey f = liftA EnumMap . I.traverseWithKey (f . toEnum) . unWrap+{-# INLINE traverseWithKey #-}++mapAccum :: (a -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)+mapAccum f a = second EnumMap . I.mapAccum f a . unWrap+{-# INLINE mapAccum #-}++mapAccumWithKey :: (Enum k)+  => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)+mapAccumWithKey f a =+  second EnumMap . I.mapAccumWithKey (\b -> f b . toEnum) a . unWrap+{-# INLINE mapAccumWithKey #-}++mapAccumRWithKey :: (Enum k)+  => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)+mapAccumRWithKey f a =+  second EnumMap . I.mapAccumRWithKey (\b -> f b . toEnum) a . unWrap+{-# INLINE mapAccumRWithKey #-}++mapKeys :: (Enum k) => (k -> k) -> EnumMap k a -> EnumMap k a+mapKeys f = EnumMap . I.mapKeys (fromEnum . f . toEnum) . unWrap+{-# INLINE mapKeys #-}++mapKeysWith :: (Enum k) => (a -> a -> a) -> (k -> k) -> EnumMap k a -> EnumMap k a+mapKeysWith f g = EnumMap . I.mapKeysWith f (fromEnum . g . toEnum) . unWrap+{-# INLINE mapKeysWith #-}++mapKeysMonotonic :: (Enum k) => (k -> k) -> EnumMap k a -> EnumMap k a+mapKeysMonotonic f = EnumMap . I.mapKeysMonotonic (fromEnum . f . toEnum) . unWrap+{-# INLINE mapKeysMonotonic #-}++filter :: (a -> Bool) -> EnumMap k a -> EnumMap k a+filter p = EnumMap . I.filter p . unWrap+{-# INLINE filter #-}++filterWithKey :: (Enum k) => (k -> a -> Bool) -> EnumMap k a -> EnumMap k a+filterWithKey p = EnumMap . I.filterWithKey (p . toEnum) . unWrap+{-# INLINE filterWithKey #-}++partition :: (a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)+partition p = (EnumMap *** EnumMap) . I.partition p . unWrap+{-# INLINE partition #-}++partitionWithKey :: (Enum k)+   => (k -> a -> Bool) -> EnumMap k a -> (EnumMap k a, EnumMap k a)+partitionWithKey p =+  (EnumMap *** EnumMap) . I.partitionWithKey (p . toEnum) . unWrap+{-# INLINE partitionWithKey #-}++mapMaybe :: (a -> Maybe b) -> EnumMap k a -> EnumMap k b+mapMaybe f = EnumMap . I.mapMaybe f . unWrap+{-# INLINE mapMaybe #-}++mapMaybeWithKey :: (Enum k) => (k -> a -> Maybe b) -> EnumMap k a -> EnumMap k b+mapMaybeWithKey f = EnumMap . I.mapMaybeWithKey (f . toEnum) . unWrap+{-# INLINE mapMaybeWithKey #-}++mapEither :: (a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)+mapEither f = (EnumMap *** EnumMap) . I.mapEither f . unWrap+{-# INLINE mapEither #-}++mapEitherWithKey :: (Enum k)+  => (k -> a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)+mapEitherWithKey f =+  (EnumMap *** EnumMap) . I.mapEitherWithKey (f . toEnum) . unWrap+{-# INLINE mapEitherWithKey #-}++split :: (Enum k) => k -> EnumMap k a -> (EnumMap k a, EnumMap k a)+split k = (EnumMap *** EnumMap) . I.split (fromEnum k) . unWrap+{-# INLINE split #-}++splitLookup :: (Enum k) => k -> EnumMap k a -> (EnumMap k a, Maybe a, EnumMap k a)+splitLookup k = wrap . I.splitLookup (fromEnum k) . unWrap+  where+    wrap (im1, ma, im2) = (EnumMap im1, ma, EnumMap im2)+{-# INLINE splitLookup #-}++foldr :: (Enum k) => (a -> b -> b) -> b -> EnumMap k a -> b+foldr f a = I.foldr f a . unWrap+{-# INLINE foldr #-}++foldl :: (Enum k) => (a -> b -> a) -> a -> EnumMap k b -> a+foldl f a = I.foldl f a . unWrap+{-# INLINE foldl #-}++foldrWithKey :: (Enum k) => (k -> a -> b -> b) -> b -> EnumMap k a -> b+foldrWithKey f a = I.foldrWithKey (f . toEnum) a . unWrap+{-# INLINE foldrWithKey #-}++foldlWithKey :: (Enum k) => (a -> k -> b -> a) -> a -> EnumMap k b -> a+foldlWithKey f a = I.foldlWithKey (\a' -> f a' . toEnum) a . unWrap+{-# INLINE foldlWithKey #-}++foldr' :: (Enum k) => (a -> b -> b) -> b -> EnumMap k a -> b+foldr' f a = I.foldr' f a . unWrap+{-# INLINE foldr' #-}++foldl' :: (Enum k) => (a -> b -> a) -> a -> EnumMap k b -> a+foldl' f a = I.foldl' f a . unWrap+{-# INLINE foldl' #-}++foldrWithKey' :: (Enum k) => (k -> a -> b -> b) -> b -> EnumMap k a -> b+foldrWithKey' f a = I.foldrWithKey' (f . toEnum) a . unWrap+{-# INLINE foldrWithKey' #-}++foldlWithKey' :: (Enum k) => (a -> k -> b -> a) -> a -> EnumMap k b -> a+foldlWithKey' f a = I.foldlWithKey' (\a' -> f a' . toEnum) a . unWrap+{-# INLINE foldlWithKey' #-}++elems :: EnumMap k a -> [a]+elems = I.elems . unWrap+{-# INLINE elems #-}++keys :: (Enum k) => EnumMap k a -> [k]+keys = P.map toEnum . I.keys . unWrap+{-# INLINE keys #-}++keysSet :: (Enum k) => EnumMap k a -> EnumSet k+keysSet = EnumSet.fromDistinctAscList . keys+{-# INLINE keysSet #-}++fromSet :: (Enum k) => (k -> a) -> EnumSet k -> EnumMap k a+fromSet f = EnumMap . I.fromSet (f . toEnum) . EnumSet.enumSetToIntSet+{-# INLINE fromSet #-}++assocs :: (Enum k) => EnumMap k a -> [(k, a)]+assocs = P.map (first toEnum) . I.assocs . unWrap+{-# INLINE assocs #-}++toList :: (Enum k) => EnumMap k a -> [(k, a)]+toList = P.map (first toEnum) . I.toList . unWrap+{-# INLINE toList #-}++toAscList :: (Enum k) => EnumMap k a -> [(k, a)]+toAscList = P.map (first toEnum) . I.toAscList . unWrap+{-# INLINE toAscList #-}++toDescList :: (Enum k) => EnumMap k a -> [(k, a)]+toDescList = P.map (first toEnum) . I.toDescList . unWrap+{-# INLINE toDescList #-}++fromList :: (Enum k) => [(k, a)] -> EnumMap k a+fromList = EnumMap . I.fromList . P.map (first fromEnum)+{-# INLINE fromList #-}++fromListWith :: (Enum k) => (a -> a -> a) -> [(k, a)] -> EnumMap k a+fromListWith f = EnumMap . I.fromListWith f . P.map (first fromEnum)+{-# INLINE fromListWith #-}++fromListWithKey :: (Enum k) => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a+fromListWithKey f =+  EnumMap . I.fromListWithKey (f . toEnum) . P.map (first fromEnum)+{-# INLINE fromListWithKey #-}++fromAscList :: (Enum k) => [(k, a)] -> EnumMap k a+fromAscList = EnumMap . I.fromAscList . P.map (first fromEnum)+{-# INLINE fromAscList #-}++fromAscListWith :: (Enum k) => (a -> a -> a) -> [(k, a)] -> EnumMap k a+fromAscListWith f = EnumMap . I.fromAscListWith f . P.map (first fromEnum)+{-# INLINE fromAscListWith #-}++fromAscListWithKey :: (Enum k) => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a+fromAscListWithKey f =+  EnumMap . I.fromAscListWithKey (f . toEnum) . P.map (first fromEnum)+{-# INLINE fromAscListWithKey #-}++fromDistinctAscList :: (Enum k) => [(k, a)] -> EnumMap k a+fromDistinctAscList = EnumMap . I.fromDistinctAscList . P.map (first fromEnum)+{-# INLINE fromDistinctAscList #-}
+ Data/EnumMap/Lazy.hs view
@@ -0,0 +1,161 @@+-- |+-- Module      :  $Header$+-- Description :  Data.IntMap.Lazy with Enum keys.+-- Copyright   :  (c) 2011-2013 Michal Terepeta+-- License     :  BSD3+-- Maintainer  :  michal.terepeta@gmail.com+-- Stability   :  alpha+-- Portability :  uses DeriveDataTypeable and GeneralizedNewtypeDeriving++-- This is a simple wrapper for 'Data.IntMap.Lazy' that works with any type of+-- keys that are instances of 'Enum' type class.  For documentation please see+-- the one for 'Data.IntMap'.++module Data.EnumMap.Lazy+  ( EnumMap++  -- * Wrapping/unwrapping+  , intMapToEnumMap+  , enumMapToIntMap++  -- * Operators+  , (!)+  , (\\)++  -- * Query+  , null+  , size+  , member+  , notMember+  , lookup+  , findWithDefault+  , lookupLT+  , lookupGT+  , lookupLE+  , lookupGE++  -- * Construction+  , empty+  , singleton++  -- ** Insertion+  , insert+  , insertWith+  , insertWithKey+  , insertLookupWithKey++  -- ** Delete\/Update+  , delete+  , adjust+  , adjustWithKey+  , update+  , updateWithKey+  , updateLookupWithKey+  , alter++  -- * Combine++  -- ** Union+  , union+  , unionWith+  , unionWithKey+  , unions+  , unionsWith++  -- ** Difference+  , difference+  , differenceWith+  , differenceWithKey++  -- ** Intersection+  , intersection+  , intersectionWith+  , intersectionWithKey++  -- ** Universal combining function+  , mergeWithKey++  -- * Traversal+  -- ** Map+  , map+  , mapWithKey+  , traverseWithKey+  , mapAccum+  , mapAccumWithKey+  , mapAccumRWithKey+  , mapKeys+  , mapKeysWith+  , mapKeysMonotonic++  -- * Folds+  , foldr+  , foldl+  , foldrWithKey+  , foldlWithKey+  -- ** Strict folds+  , foldr'+  , foldl'+  , foldrWithKey'+  , foldlWithKey'++  -- * Conversion+  , elems+  , keys+  , assocs+  , keysSet+  , fromSet++  -- ** Lists+  , toList+  , fromList+  , fromListWith+  , fromListWithKey++  -- ** Ordered lists+  , toAscList+  , toDescList+  , fromAscList+  , fromAscListWith+  , fromAscListWithKey+  , fromDistinctAscList++  -- * Filter+  , filter+  , filterWithKey+  , partition+  , partitionWithKey++  , mapMaybe+  , mapMaybeWithKey+  , mapEither+  , mapEitherWithKey++  , split+  , splitLookup++  -- * Submap+  , isSubmapOf+  , isSubmapOfBy+  , isProperSubmapOf+  , isProperSubmapOfBy++  -- * Min\/Max+  , findMin+  , findMax+  , deleteMin+  , deleteMax+  , deleteFindMin+  , deleteFindMax+  , updateMin+  , updateMax+  , updateMinWithKey+  , updateMaxWithKey+  , minView+  , maxView+  , minViewWithKey+  , maxViewWithKey+  ) where++import Prelude hiding ( filter, foldr, foldl, lookup, map, null )++import Data.EnumMap.Base
+ Data/EnumMap/Strict.hs view
@@ -0,0 +1,414 @@+-- |+-- Module      :  $Header$+-- Description :  Data.IntMap.Strict with Enum keys.+-- Copyright   :  (c) 2011-2013 Michal Terepeta+-- License     :  BSD3+-- Maintainer  :  michal.terepeta@gmail.com+-- Stability   :  alpha+-- Portability :  uses DeriveDataTypeable and GeneralizedNewtypeDeriving++-- This is a simple wrapper for 'Data.IntMap.Strict' that works with any type of+-- keys that are instances of 'Enum' type class.  For documentation please see+-- the one for 'Data.IntMap'.++module Data.EnumMap.Strict+  ( EnumMap++  -- * Wrapping/unwrapping+  , intMapToEnumMap+  , enumMapToIntMap++  -- * Operators+  , (!)+  , (\\)++  -- * Query+  , null+  , size+  , member+  , notMember+  , lookup+  , findWithDefault+  , lookupLT+  , lookupGT+  , lookupLE+  , lookupGE++  -- * Construction+  , empty+  , singleton++  -- ** Insertion+  , insert+  , insertWith+  , insertWithKey+  , insertLookupWithKey++  -- ** Delete\/Update+  , delete+  , adjust+  , adjustWithKey+  , update+  , updateWithKey+  , updateLookupWithKey+  , alter++  -- * Combine++  -- ** Union+  , union+  , unionWith+  , unionWithKey+  , unions+  , unionsWith++  -- ** Difference+  , difference+  , differenceWith+  , differenceWithKey++  -- ** Intersection+  , intersection+  , intersectionWith+  , intersectionWithKey++  -- ** Universal combining function+  , mergeWithKey++  -- * Traversal+  -- ** Map+  , map+  , mapWithKey+  , traverseWithKey+  , mapAccum+  , mapAccumWithKey+  , mapAccumRWithKey+  , mapKeys+  , mapKeysWith+  , mapKeysMonotonic++  -- * Folds+  , foldr+  , foldl+  , foldrWithKey+  , foldlWithKey+  -- ** Strict folds+  , foldr'+  , foldl'+  , foldrWithKey'+  , foldlWithKey'++  -- * Conversion+  , elems+  , keys+  , assocs+  , keysSet+  , fromSet++  -- ** Lists+  , toList+  , fromList+  , fromListWith+  , fromListWithKey++  -- ** Ordered lists+  , toAscList+  , toDescList+  , fromAscList+  , fromAscListWith+  , fromAscListWithKey+  , fromDistinctAscList++  -- * Filter+  , filter+  , filterWithKey+  , partition+  , partitionWithKey++  , mapMaybe+  , mapMaybeWithKey+  , mapEither+  , mapEitherWithKey++  , split+  , splitLookup++  -- * Submap+  , isSubmapOf+  , isSubmapOfBy+  , isProperSubmapOf+  , isProperSubmapOfBy++  -- * Min\/Max+  , findMin+  , findMax+  , deleteMin+  , deleteMax+  , deleteFindMin+  , deleteFindMax+  , updateMin+  , updateMax+  , updateMinWithKey+  , updateMaxWithKey+  , minView+  , maxView+  , minViewWithKey+  , maxViewWithKey+  ) where++import Prelude hiding ( filter, foldr, foldl, lookup, map, null )+import qualified Prelude as P++import Control.Arrow ( (***), first, second )++import qualified Data.IntMap.Strict as I++import Data.EnumSet ( EnumSet )+import qualified Data.EnumSet as EnumSet++import Data.EnumMap.Base hiding+  ( findWithDefault+  , singleton+  , insert+  , insertWith+  , insertWithKey+  , insertLookupWithKey+  , adjust+  , adjustWithKey+  , update+  , updateWithKey+  , updateLookupWithKey+  , alter+  , unionsWith+  , unionWith+  , unionWithKey+  , differenceWith+  , differenceWithKey+  , intersectionWith+  , intersectionWithKey+  , mergeWithKey+  , updateMinWithKey+  , updateMaxWithKey+  , updateMax+  , updateMin+  , map+  , mapWithKey+  , mapAccum+  , mapAccumWithKey+  , mapAccumRWithKey+  , mapKeysWith+  , mapMaybe+  , mapMaybeWithKey+  , mapEither+  , mapEitherWithKey+  , fromSet+  , fromList+  , fromListWith+  , fromListWithKey+  , fromAscList+  , fromAscListWith+  , fromAscListWithKey+  , fromDistinctAscList+  )++findWithDefault :: (Enum k) => a -> k -> EnumMap k a -> a+findWithDefault def k = I.findWithDefault def (fromEnum k) . unWrap+{-# INLINE findWithDefault #-}++singleton :: (Enum k) => k -> a -> EnumMap k a+singleton k = EnumMap . I.singleton (fromEnum k)+{-# INLINE singleton #-}++insert :: (Enum k) => k -> a -> EnumMap k a -> EnumMap k a+insert k a = EnumMap . I.insert (fromEnum k) a . unWrap+{-# INLINE insert #-}++insertWith :: (Enum k) => (a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a+insertWith f k a = EnumMap . I.insertWith f (fromEnum k) a . unWrap+{-# INLINE insertWith #-}++insertWithKey :: (Enum k)+  => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> EnumMap k a+insertWithKey f k a =+  EnumMap . I.insertWithKey (f . toEnum) (fromEnum k) a . unWrap+{-# INLINE insertWithKey #-}++insertLookupWithKey :: (Enum k)+  => (k -> a -> a -> a) -> k -> a -> EnumMap k a -> (Maybe a, EnumMap k a)+insertLookupWithKey f k a =+  second EnumMap . I.insertLookupWithKey (f . toEnum) (fromEnum k) a . unWrap+{-# INLINE insertLookupWithKey #-}++adjust ::  (Enum k) => (a -> a) -> k -> EnumMap k a -> EnumMap k a+adjust f k = EnumMap . I.adjust f (fromEnum k) . unWrap+{-# INLINE adjust #-}++adjustWithKey :: (Enum k) => (k -> a -> a) -> k -> EnumMap k a -> EnumMap k a+adjustWithKey f k = EnumMap . I.adjustWithKey (f . toEnum) (fromEnum k) . unWrap+{-# INLINE adjustWithKey #-}++alter :: (Enum k) => (Maybe a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a+alter f k = EnumMap . I.alter f (fromEnum k) . unWrap+{-# INLINE alter #-}++unionsWith :: (a -> a -> a) -> [EnumMap k a] -> EnumMap k a+unionsWith f = EnumMap . I.unionsWith f . P.map unWrap+{-# INLINE unionsWith #-}++unionWith :: (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a+unionWith f (EnumMap im1) (EnumMap im2) = EnumMap $ I.unionWith f im1 im2+{-# INLINE unionWith #-}++unionWithKey :: (Enum k)+  => (k -> a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a+unionWithKey f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.unionWithKey (f . toEnum) im1 im2+{-# INLINE unionWithKey #-}++differenceWith :: (a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a+differenceWith f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.differenceWith f im1 im2+{-# INLINE differenceWith #-}++differenceWithKey :: (Enum k)+  => (k -> a -> b -> Maybe a) -> EnumMap k a -> EnumMap k b -> EnumMap k a+differenceWithKey f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.differenceWithKey (f . toEnum) im1 im2+{-# INLINE differenceWithKey #-}++intersectionWith :: (a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c+intersectionWith f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.intersectionWith f im1 im2+{-# INLINE intersectionWith #-}++intersectionWithKey :: (Enum k)+  => (k -> a -> b -> c) -> EnumMap k a -> EnumMap k b -> EnumMap k c+intersectionWithKey f (EnumMap im1) (EnumMap im2) =+  EnumMap $ I.intersectionWithKey (f . toEnum) im1 im2+{-# INLINE intersectionWithKey #-}++mergeWithKey :: (Enum k)+  => (k -> a -> b -> Maybe c)+  -> (EnumMap k a -> EnumMap k c)+  -> (EnumMap k b -> EnumMap k c)+  -> EnumMap k a+  -> EnumMap k b+  -> EnumMap k c+mergeWithKey f ga gb = \ma mb -> EnumMap $+  I.mergeWithKey (f . toEnum)+                 (unWrap . ga . EnumMap)+                 (unWrap . gb . EnumMap)+                 (unWrap ma)+                 (unWrap mb)+{-# INLINE mergeWithKey #-}++update ::  (Enum k) => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a+update f k = EnumMap . I.update f (fromEnum k) . unWrap+{-# INLINE update #-}++updateWithKey ::  (Enum k)+  => (k -> a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a+updateWithKey f k = EnumMap . I.updateWithKey (f . toEnum) (fromEnum k) . unWrap+{-# INLINE updateWithKey #-}++updateLookupWithKey ::  (Enum k)+  => (k -> a -> Maybe a) -> k -> EnumMap k a -> (Maybe a,EnumMap k a)+updateLookupWithKey f k =+  second EnumMap . I.updateLookupWithKey (f . toEnum) (fromEnum k) . unWrap+{-# INLINE updateLookupWithKey #-}++updateMinWithKey :: (Enum k) => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMinWithKey f = EnumMap . I.updateMinWithKey (f . toEnum) . unWrap+{-# INLINE updateMinWithKey #-}++updateMaxWithKey :: (Enum k) => (k -> a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMaxWithKey f = EnumMap . I.updateMaxWithKey (f . toEnum) . unWrap+{-# INLINE updateMaxWithKey #-}++updateMax :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMax f = EnumMap . I.updateMax f . unWrap+{-# INLINE updateMax #-}++updateMin :: (a -> Maybe a) -> EnumMap k a -> EnumMap k a+updateMin f = EnumMap . I.updateMin f . unWrap+{-# INLINE updateMin #-}++map :: (a -> b) -> EnumMap k a -> EnumMap k b+map f = EnumMap . I.map f . unWrap+{-# INLINE map #-}++mapWithKey :: (Enum k) => (k -> a -> b) -> EnumMap k a -> EnumMap k b+mapWithKey f = EnumMap . I.mapWithKey (f . toEnum) . unWrap+{-# INLINE mapWithKey #-}++mapAccum :: (a -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)+mapAccum f a = second EnumMap . I.mapAccum f a . unWrap+{-# INLINE mapAccum #-}++mapAccumWithKey :: (Enum k)+  => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)+mapAccumWithKey f a =+  second EnumMap . I.mapAccumWithKey (\b -> f b . toEnum) a . unWrap+{-# INLINE mapAccumWithKey #-}++mapAccumRWithKey :: (Enum k)+  => (a -> k -> b -> (a, c)) -> a -> EnumMap k b -> (a, EnumMap k c)+mapAccumRWithKey f a =+  second EnumMap . I.mapAccumRWithKey (\b -> f b . toEnum) a . unWrap+{-# INLINE mapAccumRWithKey #-}++mapKeysWith :: (Enum k) => (a -> a -> a) -> (k -> k) -> EnumMap k a -> EnumMap k a+mapKeysWith f g = EnumMap . I.mapKeysWith f (fromEnum . g . toEnum) . unWrap+{-# INLINE mapKeysWith #-}++mapMaybe :: (a -> Maybe b) -> EnumMap k a -> EnumMap k b+mapMaybe f = EnumMap . I.mapMaybe f . unWrap+{-# INLINE mapMaybe #-}++mapMaybeWithKey :: (Enum k) => (k -> a -> Maybe b) -> EnumMap k a -> EnumMap k b+mapMaybeWithKey f = EnumMap . I.mapMaybeWithKey (f . toEnum) . unWrap+{-# INLINE mapMaybeWithKey #-}++mapEither :: (a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)+mapEither f = (EnumMap *** EnumMap) . I.mapEither f . unWrap+{-# INLINE mapEither #-}++mapEitherWithKey :: (Enum k)+  => (k -> a -> Either b c) -> EnumMap k a -> (EnumMap k b, EnumMap k c)+mapEitherWithKey f =+  (EnumMap *** EnumMap) . I.mapEitherWithKey (f . toEnum) . unWrap+{-# INLINE mapEitherWithKey #-}++fromSet :: (Enum k) => (k -> a) -> EnumSet k -> EnumMap k a+fromSet f = EnumMap . I.fromSet (f . toEnum) . EnumSet.enumSetToIntSet+{-# INLINE fromSet #-}++fromList :: (Enum k) => [(k, a)] -> EnumMap k a+fromList = EnumMap . I.fromList . P.map (first fromEnum)+{-# INLINE fromList #-}++fromListWith :: (Enum k) => (a -> a -> a) -> [(k, a)] -> EnumMap k a+fromListWith f = EnumMap . I.fromListWith f . P.map (first fromEnum)+{-# INLINE fromListWith #-}++fromListWithKey :: (Enum k) => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a+fromListWithKey f =+  EnumMap . I.fromListWithKey (f . toEnum) . P.map (first fromEnum)+{-# INLINE fromListWithKey #-}++fromAscList :: (Enum k) => [(k, a)] -> EnumMap k a+fromAscList = EnumMap . I.fromAscList . P.map (first fromEnum)+{-# INLINE fromAscList #-}++fromAscListWith :: (Enum k) => (a -> a -> a) -> [(k, a)] -> EnumMap k a+fromAscListWith f = EnumMap . I.fromAscListWith f . P.map (first fromEnum)+{-# INLINE fromAscListWith #-}++fromAscListWithKey :: (Enum k) => (k -> a -> a -> a) -> [(k, a)] -> EnumMap k a+fromAscListWithKey f =+  EnumMap . I.fromAscListWithKey (f . toEnum) . P.map (first fromEnum)+{-# INLINE fromAscListWithKey #-}++fromDistinctAscList :: (Enum k) => [(k, a)] -> EnumMap k a+fromDistinctAscList = EnumMap . I.fromDistinctAscList . P.map (first fromEnum)+{-# INLINE fromDistinctAscList #-}
Data/EnumSet.hs view
@@ -1,14 +1,14 @@-{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveDataTypeable         #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}  -- | -- Module      :  $Header$ -- Description :  Data.IntSet with Enum elements.--- Copyright   :  (c) 2011 Michal Terepeta+-- Copyright   :  (c) 2011-2013 Michal Terepeta -- License     :  BSD3 -- Maintainer  :  michal.terepeta@gmail.com -- Stability   :  alpha--- Portability :  uses GeneralizedNewtypeDeriving+-- Portability :  uses DeriveDataTypeable and GeneralizedNewtypeDeriving  -- This is a simple wrapper for 'Data.IntSet' that allows storing any elements -- of Enum type class. Useful if one wants to have the performance of@@ -30,6 +30,10 @@   , size   , member   , notMember+  , lookupLT+  , lookupGT+  , lookupLE+  , lookupGE   , isSubsetOf   , isProperSubsetOf @@ -54,9 +58,16 @@   -- * Map   , map -  -- * Fold+  -- * Folds+  , foldr+  , foldl+  -- ** Strict folds+  , foldr'+  , foldl'+  -- ** Legacy folds   , fold +   -- * Min\/Max   , findMin   , findMax@@ -76,30 +87,34 @@    -- ** Ordered list   , toAscList+  , toDescList   , fromAscList   , fromDistinctAscList+   ) where -import Prelude hiding ( filter, lookup, map, null )+import Prelude hiding ( filter, foldl, foldr, lookup, map, null ) import qualified Prelude as P  import Data.IntSet ( IntSet ) import qualified Data.IntSet as I +import Control.Arrow ( (***) )+import Control.DeepSeq ( NFData ) import Data.Monoid ( Monoid ) import Data.Typeable ( Typeable )  import Text.Read  -- | Wrapper for 'IntSet' with 'Enum' elements.-newtype EnumSet e = EnumSet { unWrap :: IntSet }-  deriving (Eq, Monoid, Ord, Typeable)+newtype EnumSet k = EnumSet { unWrap :: IntSet }+  deriving (Eq, Monoid, Ord, Typeable, NFData) -instance (Enum e, Show e) => Show (EnumSet e) where-  showsPrec p es = showParen (p > 10) $-    showString "fromList " . shows (toList es)+instance (Enum k, Show k) => Show (EnumSet k) where+  showsPrec p ks = showParen (p > 10) $+    showString "fromList " . shows (toList ks) -instance (Enum e, Read e) => Read (EnumSet e) where+instance (Enum k, Read k) => Read (EnumSet k) where   readPrec = parens . prec 10 $ do     Ident "fromList" <- lexP     list <- readPrec@@ -110,167 +125,193 @@ --  -- | Wrap 'IntSet'.-intSetToEnumSet :: IntSet -> EnumSet e+intSetToEnumSet :: IntSet -> EnumSet k intSetToEnumSet = EnumSet+{-# INLINE intSetToEnumSet #-}  -- | Unwrap 'IntSet'.-enumSetToIntSet :: EnumSet e -> IntSet+enumSetToIntSet :: EnumSet k -> IntSet enumSetToIntSet = unWrap------- A few useful functions used through the module; not exported.-----pairWrap :: (IntSet, IntSet) -> (EnumSet e, EnumSet e)-pairWrap (is1, is2) = (EnumSet is1, EnumSet is2)-{-# INLINE pairWrap #-}--toEnumWrap :: (Enum e) => (Int, IntSet) -> (e, EnumSet e)-toEnumWrap (i, is) = (toEnum i, EnumSet is)-{-# INLINE toEnumWrap #-}+{-# INLINE enumSetToIntSet #-}  -- -- Here begins the main part. -- -(\\) :: EnumSet e -> EnumSet e -> EnumSet e+(\\) :: EnumSet k -> EnumSet k -> EnumSet k (EnumSet is1) \\ (EnumSet is2) = EnumSet $ is1 I.\\ is2 {-# INLINE (\\) #-} -null :: EnumSet e -> Bool+null :: EnumSet k -> Bool null = I.null . unWrap {-# INLINE null #-} -size :: EnumSet e -> Int+size :: EnumSet k -> Int size = I.size . unWrap {-# INLINE size #-} -member :: (Enum e) => e -> EnumSet e -> Bool-member e = I.member (fromEnum e) . unWrap+member :: (Enum k) => k -> EnumSet k -> Bool+member k = I.member (fromEnum k) . unWrap {-# INLINE member #-} -notMember :: (Enum e) => e -> EnumSet e -> Bool-notMember e = I.notMember (fromEnum e) . unWrap+notMember :: (Enum k) => k -> EnumSet k -> Bool+notMember k = I.notMember (fromEnum k) . unWrap {-# INLINE notMember #-} -empty :: EnumSet e+lookupLT :: (Enum k) => k -> EnumSet k -> Maybe k+lookupLT k = fmap toEnum . I.lookupLT (fromEnum k) . unWrap+{-# INLINE lookupLT #-}++lookupGT :: (Enum k) => k -> EnumSet k -> Maybe k+lookupGT k = fmap toEnum . I.lookupGT (fromEnum k) . unWrap+{-# INLINE lookupGT #-}++lookupLE :: (Enum k) => k -> EnumSet k -> Maybe k+lookupLE k = fmap toEnum . I.lookupLE (fromEnum k) . unWrap+{-# INLINE lookupLE #-}++lookupGE :: (Enum k) => k -> EnumSet k -> Maybe k+lookupGE k = fmap toEnum . I.lookupGE (fromEnum k) . unWrap+{-# INLINE lookupGE #-}++empty :: EnumSet k empty = EnumSet I.empty {-# INLINE empty #-} -singleton :: (Enum e) => e -> EnumSet e+singleton :: (Enum k) => k -> EnumSet k singleton = EnumSet . I.singleton . fromEnum {-# INLINE singleton #-} -insert :: (Enum e) => e -> EnumSet e -> EnumSet e-insert e = EnumSet . I.insert (fromEnum e) . unWrap+insert :: (Enum k) => k -> EnumSet k -> EnumSet k+insert k = EnumSet . I.insert (fromEnum k) . unWrap {-# INLINE insert #-} -delete :: (Enum e) => e -> EnumSet e -> EnumSet e-delete e = EnumSet . I.delete (fromEnum e) . unWrap+delete :: (Enum k) => k -> EnumSet k -> EnumSet k+delete k = EnumSet . I.delete (fromEnum k) . unWrap {-# INLINE delete #-} -unions :: [EnumSet e] -> EnumSet e+unions :: [EnumSet k] -> EnumSet k unions = EnumSet . I.unions . P.map unWrap {-# INLINE unions #-} -union :: EnumSet e -> EnumSet e -> EnumSet e+union :: EnumSet k -> EnumSet k -> EnumSet k union (EnumSet is1) (EnumSet is2) = EnumSet $ I.union is1 is2 {-# INLINE union #-} -difference :: EnumSet e -> EnumSet e -> EnumSet e+difference :: EnumSet k -> EnumSet k -> EnumSet k difference (EnumSet is1) (EnumSet is2) = EnumSet $ I.difference is1 is2 {-# INLINE difference #-} -intersection :: EnumSet e -> EnumSet e -> EnumSet e+intersection :: EnumSet k -> EnumSet k -> EnumSet k intersection (EnumSet is1) (EnumSet is2) = EnumSet $ I.intersection is1 is2 {-# INLINE intersection #-} -isProperSubsetOf :: EnumSet e -> EnumSet e -> Bool+isProperSubsetOf :: EnumSet k -> EnumSet k -> Bool isProperSubsetOf (EnumSet is1) (EnumSet is2) = I.isProperSubsetOf is1 is2 {-# INLINE isProperSubsetOf #-} -isSubsetOf :: EnumSet e -> EnumSet e -> Bool+isSubsetOf :: EnumSet k -> EnumSet k -> Bool isSubsetOf (EnumSet is1) (EnumSet is2) = I.isSubsetOf is1 is2 {-# INLINE isSubsetOf #-} -filter :: (Enum e) => (e -> Bool) -> EnumSet e -> EnumSet e+filter :: (Enum k) => (k -> Bool) -> EnumSet k -> EnumSet k filter f = EnumSet . I.filter (f . toEnum) . unWrap {-# INLINE filter #-} -partition :: (Enum e) => (e -> Bool) -> EnumSet e -> (EnumSet e, EnumSet e)-partition f = pairWrap . I.partition (f . toEnum) . unWrap+partition :: (Enum k) => (k -> Bool) -> EnumSet k -> (EnumSet k, EnumSet k)+partition f = (EnumSet *** EnumSet) . I.partition (f . toEnum) . unWrap {-# INLINE partition #-} -split :: (Enum e) => e -> EnumSet e -> (EnumSet e, EnumSet e)-split e = pairWrap . I.split (fromEnum e) . unWrap+split :: (Enum k) => k -> EnumSet k -> (EnumSet k, EnumSet k)+split k = (EnumSet *** EnumSet) . I.split (fromEnum k) . unWrap {-# INLINE split #-} -splitMember :: (Enum e) => e -> EnumSet e -> (EnumSet e, Bool, EnumSet e)-splitMember e =  wrap . I.splitMember (fromEnum e) . unWrap+splitMember :: (Enum k) => k -> EnumSet k -> (EnumSet k, Bool, EnumSet k)+splitMember k =  wrap . I.splitMember (fromEnum k) . unWrap   where     wrap (is1, b, is2) = (EnumSet is1, b, EnumSet is2) {-# INLINE splitMember #-} -maxView :: (Enum e) => EnumSet e -> Maybe (e, EnumSet e)-maxView = fmap toEnumWrap . I.maxView . unWrap+maxView :: (Enum k) => EnumSet k -> Maybe (k, EnumSet k)+maxView = fmap (toEnum *** EnumSet) . I.maxView . unWrap {-# INLINE maxView #-} -minView :: (Enum e) => EnumSet e -> Maybe (e, EnumSet e)-minView = fmap toEnumWrap . I.minView  . unWrap+minView :: (Enum k) => EnumSet k -> Maybe (k, EnumSet k)+minView = fmap (toEnum *** EnumSet) . I.minView  . unWrap {-# INLINE minView #-} -deleteFindMin :: (Enum e) => EnumSet e -> (e, EnumSet e)-deleteFindMin = toEnumWrap  . I.deleteFindMin . unWrap+deleteFindMin :: (Enum k) => EnumSet k -> (k, EnumSet k)+deleteFindMin = (toEnum *** EnumSet) . I.deleteFindMin . unWrap {-# INLINE deleteFindMin #-} -deleteFindMax :: (Enum e) => EnumSet e -> (e, EnumSet e)-deleteFindMax = toEnumWrap . I.deleteFindMax . unWrap+deleteFindMax :: (Enum k) => EnumSet k -> (k, EnumSet k)+deleteFindMax = (toEnum *** EnumSet) . I.deleteFindMax . unWrap {-# INLINE deleteFindMax #-} -findMin :: (Enum e) => EnumSet e -> e+findMin :: (Enum k) => EnumSet k -> k findMin = toEnum . I.findMin . unWrap {-# INLINE findMin #-} -findMax :: (Enum e) => EnumSet e -> e+findMax :: (Enum k) => EnumSet k -> k findMax = toEnum . I.findMax . unWrap {-# INLINE findMax #-} -deleteMin :: EnumSet e -> EnumSet e+deleteMin :: EnumSet k -> EnumSet k deleteMin = EnumSet . I.deleteMin . unWrap {-# INLINE deleteMin #-} -deleteMax :: EnumSet e -> EnumSet e+deleteMax :: EnumSet k -> EnumSet k deleteMax = EnumSet . I.deleteMax . unWrap {-# INLINE deleteMax #-} -map :: (Enum e) => (e -> e) -> EnumSet e -> EnumSet e+map :: (Enum k) => (k -> k) -> EnumSet k -> EnumSet k map f = EnumSet . I.map (fromEnum . f . toEnum) . unWrap {-# INLINE map #-} -fold :: (Enum e) => (e -> b -> b) -> b -> EnumSet e -> b+foldr :: (Enum k) => (k -> b -> b) -> b -> EnumSet k -> b+foldr f acc = I.foldr (f . toEnum) acc . unWrap+{-# INLINE foldr #-}++foldl :: (Enum k) => (a -> k -> a) -> a -> EnumSet k -> a+foldl f acc = I.foldl (\a -> f a . toEnum) acc . unWrap+{-# INLINE foldl #-}++foldr' :: (Enum k) => (k -> b -> b) -> b -> EnumSet k -> b+foldr' f acc = I.foldr' (f . toEnum) acc . unWrap+{-# INLINE foldr' #-}++foldl' :: (Enum k) => (a -> k -> a) -> a -> EnumSet k -> a+foldl' f acc = I.foldl' (\a -> f a . toEnum) acc . unWrap+{-# INLINE foldl' #-}++fold :: (Enum k) => (k -> b -> b) -> b -> EnumSet k -> b fold f acc = I.fold (f . toEnum) acc . unWrap {-# INLINE fold #-} -elems :: (Enum e) => EnumSet e -> [e]+elems :: (Enum k) => EnumSet k -> [k] elems = P.map toEnum . I.elems . unWrap {-# INLINE elems #-} -toList :: (Enum e) => EnumSet e -> [e]+toList :: (Enum k) => EnumSet k -> [k] toList = P.map toEnum . I.toList . unWrap {-# INLINE toList #-} -toAscList :: (Enum e) => EnumSet e -> [e]+toAscList :: (Enum k) => EnumSet k -> [k] toAscList = P.map toEnum . I.toAscList . unWrap {-# INLINE toAscList #-} -fromList :: (Enum e) => [e] -> EnumSet e+toDescList :: (Enum k) => EnumSet k -> [k]+toDescList = P.map toEnum . I.toDescList . unWrap+{-# INLINE toDescList #-}++fromList :: (Enum k) => [k] -> EnumSet k fromList = EnumSet . I.fromList . P.map fromEnum {-# INLINE fromList #-} -fromAscList :: (Enum e) => [e] -> EnumSet e+fromAscList :: (Enum k) => [k] -> EnumSet k fromAscList = EnumSet . I.fromAscList . P.map fromEnum {-# INLINE fromAscList #-} -fromDistinctAscList :: (Enum e) => [e] -> EnumSet e+fromDistinctAscList :: (Enum k) => [k] -> EnumSet k fromDistinctAscList = EnumSet . I.fromDistinctAscList . P.map fromEnum {-# INLINE fromDistinctAscList #-}
LICENSE view
@@ -1,4 +1,4 @@-Copyright (c)2011, Michal Terepeta+Copyright (c) 2011-2013 Michal Terepeta  All rights reserved.
enummapset.cabal view
@@ -1,5 +1,5 @@ name:           enummapset-version:        0.2.0+version:        0.5.2.0 synopsis:       IntMap and IntSet with Enum keys/elements. description:    This package contains simple wrappers around 'Data.IntMap' and                 'Data.IntSet' with 'Enum' keys and elements respectively.@@ -10,7 +10,7 @@ license-file:   LICENSE author:         Michal Terepeta maintainer:     Michal Terepeta <michal.terepeta@gmail.com>-copyright:      (c) 2011 Michal Terepeta+copyright:      (c) 2011-2013 Michal Terepeta  category:       Data build-type:     Simple@@ -21,13 +21,24 @@   type:         git   location:     https://github.com/michalt/enummapset.git +flag debug+  description:  Debug build (more warnings, etc.)+  default:      False+ Library   exposed-modules:     Data.EnumMap+    Data.EnumMap.Lazy+    Data.EnumMap.Strict     Data.EnumSet +  other-modules:+    Data.EnumMap.Base+   build-depends:     base < 5,-    containers >= 0.5 && < 0.6+    containers >= 0.5.2 && < 0.6,+    deepseq -  ghc-options: -Wall+  if flag(debug)+    ghc-options: -Wall