enummapset-th 0.5.1.0 → 0.6.0.0
raw patch · 8 files changed
+229/−208 lines, 8 filesdep ~basedep ~containersdep ~template-haskellPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base, containers, template-haskell
API changes (from Hackage documentation)
- Data.EnumMap.Base: (!) :: Enum k => EnumMap k a_acra -> k -> a_acra
- Data.EnumMap.Base: (\\) :: EnumMap k a_acru -> EnumMap k b_acrv -> EnumMap k a_acru
- Data.EnumMap.Base: EnumMap :: IntMap v -> EnumMap k v
- Data.EnumMap.Base: adjust :: Enum k => (a_acxH -> a_acxH) -> k -> EnumMap k a_acxH -> EnumMap k a_acxH
- Data.EnumMap.Base: adjustWithKey :: Enum k => (k -> a_acy0 -> a_acy0) -> k -> EnumMap k a_acy0 -> EnumMap k a_acy0
- Data.EnumMap.Base: alter :: Enum k => (Maybe a_aczq -> Maybe a_aczq) -> k -> EnumMap k a_aczq -> EnumMap k a_aczq
- Data.EnumMap.Base: assocs :: Enum k => EnumMap k a_acJD -> [(k, a_acJD)]
- Data.EnumMap.Base: delete :: Enum k => k -> EnumMap k a_acxn -> EnumMap k a_acxn
- Data.EnumMap.Base: deleteFindMax :: Enum k => EnumMap k a_acUP -> ((k, a_acUP), EnumMap k a_acUP)
- Data.EnumMap.Base: deleteFindMin :: Enum k => EnumMap k a_acUo -> ((k, a_acUo), EnumMap k a_acUo)
- Data.EnumMap.Base: deleteMax :: EnumMap k a_acU8 -> EnumMap k a_acU8
- Data.EnumMap.Base: deleteMin :: EnumMap k a_acTS -> EnumMap k a_acTS
- Data.EnumMap.Base: difference :: EnumMap k a_acB5 -> EnumMap k b_acB6 -> EnumMap k a_acB5
- Data.EnumMap.Base: differenceWith :: (a_acBm -> b_acBn -> Maybe a_acBm) -> EnumMap k a_acBm -> EnumMap k b_acBn -> EnumMap k a_acBm
- Data.EnumMap.Base: differenceWithKey :: Enum k => (k -> a_acBD -> b_acBE -> Maybe a_acBD) -> EnumMap k a_acBD -> EnumMap k b_acBE -> EnumMap k a_acBD
- Data.EnumMap.Base: elems :: EnumMap k a_acJ4 -> [a_acJ4]
- Data.EnumMap.Base: empty :: EnumMap k a_a4fv
- Data.EnumMap.Base: filter :: (a_acOt -> Bool) -> EnumMap k a_acOt -> EnumMap k a_acOt
- Data.EnumMap.Base: filterWithKey :: Enum k => (k -> a_acOJ -> Bool) -> EnumMap k a_acOJ -> EnumMap k a_acOJ
- Data.EnumMap.Base: findMax :: Enum k => EnumMap k a_acTu -> (k, a_acTu)
- Data.EnumMap.Base: findMin :: Enum k => EnumMap k a_acT6 -> (k, a_acT6)
- Data.EnumMap.Base: findWithDefault :: Enum k => a_acth -> k -> EnumMap k a_acth -> a_acth
- Data.EnumMap.Base: foldl :: (a_a4aU -> b_a4aV -> a_a4aU) -> a_a4aU -> EnumMap k b_a4aV -> a_a4aU
- Data.EnumMap.Base: foldl' :: (a_acI9 -> b_acIa -> a_acI9) -> a_acI9 -> EnumMap k b_acIa -> a_acI9
- Data.EnumMap.Base: foldlWithKey :: Enum k => (a_acHy -> k -> b_acHz -> a_acHy) -> a_acHy -> EnumMap k b_acHz -> a_acHy
- Data.EnumMap.Base: foldlWithKey' :: Enum k => (a_acIK -> k -> b_acIL -> a_acIK) -> a_acIK -> EnumMap k b_acIL -> a_acIK
- Data.EnumMap.Base: foldr :: (a_a4aQ -> b_a4aR -> b_a4aR) -> b_a4aR -> EnumMap k a_a4aQ -> b_a4aR
- Data.EnumMap.Base: foldr' :: (a_acHS -> b_acHT -> b_acHT) -> b_acHT -> EnumMap k a_acHS -> b_acHT
- Data.EnumMap.Base: foldrWithKey :: Enum k => (k -> a_acHe -> b_acHf -> b_acHf) -> b_acHf -> EnumMap k a_acHe -> b_acHf
- Data.EnumMap.Base: foldrWithKey' :: Enum k => (k -> a_acIq -> b_acIr -> b_acIr) -> b_acIr -> EnumMap k a_acIq -> b_acIr
- Data.EnumMap.Base: fromAscList :: Enum k => [(k, a_acMU)] -> EnumMap k a_acMU
- Data.EnumMap.Base: fromAscListWith :: Enum k => (a_acNi -> a_acNi -> a_acNi) -> [(k, a_acNi)] -> EnumMap k a_acNi
- Data.EnumMap.Base: fromAscListWithKey :: Enum k => (k -> a_acNG -> a_acNG -> a_acNG) -> [(k, a_acNG)] -> EnumMap k a_acNG
- Data.EnumMap.Base: fromDistinctAscList :: Enum k => [(k, a_acO5)] -> EnumMap k a_acO5
- Data.EnumMap.Base: fromList :: Enum k => [(k, a_acKY)] -> EnumMap k a_acKY
- Data.EnumMap.Base: fromListWith :: Enum k => (a_acLm -> a_acLm -> a_acLm) -> [(k, a_acLm)] -> EnumMap k a_acLm
- Data.EnumMap.Base: fromListWithKey :: Enum k => (k -> a_acLK -> a_acLK -> a_acLK) -> [(k, a_acLK)] -> EnumMap k a_acLK
- Data.EnumMap.Base: fromSet :: Enum k => (k -> a_acKh) -> EnumSet k -> EnumMap k a_acKh
- Data.EnumMap.Base: insert :: Enum k => k -> a_acvX -> EnumMap k a_acvX -> EnumMap k a_acvX
- Data.EnumMap.Base: insertLookupWithKey :: Enum k => (k -> a_acwV -> a_acwV -> a_acwV) -> k -> a_acwV -> EnumMap k a_acwV -> (Maybe a_acwV, EnumMap k a_acwV)
- Data.EnumMap.Base: insertWith :: Enum k => (a_acwh -> a_acwh -> a_acwh) -> k -> a_acwh -> EnumMap k a_acwh -> EnumMap k a_acwh
- Data.EnumMap.Base: insertWithKey :: Enum k => (k -> a_acwA -> a_acwA -> a_acwA) -> k -> a_acwA -> EnumMap k a_acwA -> EnumMap k a_acwA
- Data.EnumMap.Base: intersection :: EnumMap k a_acBX -> EnumMap k b_acBY -> EnumMap k a_acBX
- Data.EnumMap.Base: intersectionWith :: (a_acCe -> b_acCf -> c_acCg) -> EnumMap k a_acCe -> EnumMap k b_acCf -> EnumMap k c_acCg
- Data.EnumMap.Base: intersectionWithKey :: Enum k => (k -> a_acCw -> b_acCx -> c_acCy) -> EnumMap k a_acCw -> EnumMap k b_acCx -> EnumMap k c_acCy
- Data.EnumMap.Base: isProperSubmapOf :: Eq a_acSw => EnumMap k a_acSw -> EnumMap k a_acSw -> Bool
- Data.EnumMap.Base: isProperSubmapOfBy :: (a_acSP -> b_acSQ -> Bool) -> EnumMap k a_acSP -> EnumMap k b_acSQ -> Bool
- Data.EnumMap.Base: isSubmapOf :: Eq a_acRW => EnumMap k a_acRW -> EnumMap k a_acRW -> Bool
- Data.EnumMap.Base: isSubmapOfBy :: (a_acSf -> b_acSg -> Bool) -> EnumMap k a_acSf -> EnumMap k b_acSg -> Bool
- Data.EnumMap.Base: keys :: Enum k => EnumMap k a_acJk -> [k]
- Data.EnumMap.Base: keysSet :: EnumMap k a_acK1 -> EnumSet k
- Data.EnumMap.Base: lookup :: Enum k => k -> EnumMap k a_acsV -> Maybe a_acsV
- Data.EnumMap.Base: lookupGE :: Enum k => k -> EnumMap k a_acuX -> Maybe (k, a_acuX)
- Data.EnumMap.Base: lookupGT :: Enum k => k -> EnumMap k a_acu3 -> Maybe (k, a_acu3)
- Data.EnumMap.Base: lookupLE :: Enum k => k -> EnumMap k a_acuv -> Maybe (k, a_acuv)
- Data.EnumMap.Base: lookupLT :: Enum k => k -> EnumMap k a_actB -> Maybe (k, a_actB)
- Data.EnumMap.Base: map :: (a_a4fm -> b_a4fn) -> EnumMap k a_a4fm -> EnumMap k b_a4fn
- Data.EnumMap.Base: mapAccum :: (a_acEc -> b_acEd -> (a_acEc, c_acEe)) -> a_acEc -> EnumMap k b_acEd -> (a_acEc, EnumMap k c_acEe)
- Data.EnumMap.Base: mapAccumRWithKey :: Enum k => (a_acFa -> k -> b_acFb -> (a_acFa, c_acFc)) -> a_acFa -> EnumMap k b_acFb -> (a_acFa, EnumMap k c_acFc)
- Data.EnumMap.Base: mapAccumWithKey :: Enum k => (a_acEF -> k -> b_acEG -> (a_acEF, c_acEH)) -> a_acEF -> EnumMap k b_acEG -> (a_acEF, EnumMap k c_acEH)
- Data.EnumMap.Base: mapEither :: (a_acQn -> Either b_acQo c_acQp) -> EnumMap k a_acQn -> (EnumMap k b_acQo, EnumMap k c_acQp)
- Data.EnumMap.Base: mapEitherWithKey :: Enum k => (k -> a_acQL -> Either b_acQM c_acQN) -> EnumMap k a_acQL -> (EnumMap k b_acQM, EnumMap k c_acQN)
- Data.EnumMap.Base: mapKeys :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_acFG -> EnumMap k' a_acFG
- Data.EnumMap.Base: mapKeysMonotonic :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_acGo -> EnumMap k' a_acGo
- Data.EnumMap.Base: mapKeysWith :: (Enum k, Enum k') => (a_acG2 -> a_acG2 -> a_acG2) -> (k -> k') -> EnumMap k a_acG2 -> EnumMap k' a_acG2
- Data.EnumMap.Base: mapMaybe :: (a_acPM -> Maybe b_acPN) -> EnumMap k a_acPM -> EnumMap k b_acPN
- Data.EnumMap.Base: mapMaybeWithKey :: Enum k => (k -> a_acQ3 -> Maybe b_acQ4) -> EnumMap k a_acQ3 -> EnumMap k b_acQ4
- Data.EnumMap.Base: mapWithKey :: Enum k => (k -> a_acDr -> b_acDs) -> EnumMap k a_acDr -> EnumMap k b_acDs
- Data.EnumMap.Base: maxView :: EnumMap k a_acWM -> Maybe (a_acWM, EnumMap k a_acWM)
- Data.EnumMap.Base: maxViewWithKey :: Enum k => EnumMap k a_acXD -> Maybe ((k, a_acXD), EnumMap k a_acXD)
- Data.EnumMap.Base: member :: Enum k => k -> EnumMap k a_acsi -> Bool
- Data.EnumMap.Base: mergeWithKey :: Enum k => (k -> a_acCR -> b_acCS -> Maybe c_acCT) -> (EnumMap k a_acCR -> EnumMap k c_acCT) -> (EnumMap k b_acCS -> EnumMap k c_acCT) -> EnumMap k a_acCR -> EnumMap k b_acCS -> EnumMap k c_acCT
- Data.EnumMap.Base: minView :: EnumMap k a_acWo -> Maybe (a_acWo, EnumMap k a_acWo)
- Data.EnumMap.Base: minViewWithKey :: Enum k => EnumMap k a_acXa -> Maybe ((k, a_acXa), EnumMap k a_acXa)
- Data.EnumMap.Base: newtype EnumMap k v
- Data.EnumMap.Base: notMember :: Enum k => k -> EnumMap k a_acsC -> Bool
- Data.EnumMap.Base: null :: EnumMap k a_acrL -> Bool
- Data.EnumMap.Base: partition :: (a_acP2 -> Bool) -> EnumMap k a_acP2 -> (EnumMap k a_acP2, EnumMap k a_acP2)
- Data.EnumMap.Base: partitionWithKey :: Enum k => (k -> a_acPo -> Bool) -> EnumMap k a_acPo -> (EnumMap k a_acPo, EnumMap k a_acPo)
- Data.EnumMap.Base: showTree :: Show a_acY6 => EnumMap k a_acY6 -> String
- Data.EnumMap.Base: showTreeWith :: Show a_acYp => Bool -> Bool -> EnumMap k a_acYp -> String
- Data.EnumMap.Base: singleton :: Enum k => k -> a_acvE -> EnumMap k a_acvE
- Data.EnumMap.Base: size :: EnumMap k a_acs1 -> Int
- Data.EnumMap.Base: split :: Enum k => k -> EnumMap k a_acRb -> (EnumMap k a_acRb, EnumMap k a_acRb)
- Data.EnumMap.Base: splitLookup :: Enum k => k -> EnumMap k a_acRA -> (EnumMap k a_acRA, Maybe a_acRA, EnumMap k a_acRA)
- Data.EnumMap.Base: toAscList :: Enum k => EnumMap k a_a56G -> [(k, a_a56G)]
- Data.EnumMap.Base: toDescList :: Enum k => EnumMap k a_acMw -> [(k, a_acMw)]
- Data.EnumMap.Base: toList :: Enum k => EnumMap k a_acKA -> [(k, a_acKA)]
- Data.EnumMap.Base: traverseWithKey :: (Enum k, Applicative t_acDM) => (k -> a_acDL -> t_acDM b_acDN) -> EnumMap k a_acDL -> t_acDM (EnumMap k b_acDN)
- Data.EnumMap.Base: unEnumMap :: EnumMap k v -> IntMap v
- Data.EnumMap.Base: union :: EnumMap k a_a4fw -> EnumMap k a_a4fw -> EnumMap k a_a4fw
- Data.EnumMap.Base: unionWith :: (a_acA1 -> a_acA1 -> a_acA1) -> EnumMap k a_acA1 -> EnumMap k a_acA1 -> EnumMap k a_acA1
- Data.EnumMap.Base: unionWithKey :: Enum k => (k -> a_acAh -> a_acAh -> a_acAh) -> EnumMap k a_acAh -> EnumMap k a_acAh -> EnumMap k a_acAh
- Data.EnumMap.Base: unions :: [EnumMap k a_a4fx] -> EnumMap k a_a4fx
- Data.EnumMap.Base: unionsWith :: (a_acAP -> a_acAP -> a_acAP) -> [EnumMap k a_acAP] -> EnumMap k a_acAP
- Data.EnumMap.Base: update :: Enum k => (a_acyk -> Maybe a_acyk) -> k -> EnumMap k a_acyk -> EnumMap k a_acyk
- Data.EnumMap.Base: updateLookupWithKey :: Enum k => (k -> a_acyY -> Maybe a_acyY) -> k -> EnumMap k a_acyY -> (Maybe a_acyY, EnumMap k a_acyY)
- Data.EnumMap.Base: updateMax :: (a_acVw -> Maybe a_acVw) -> EnumMap k a_acVw -> EnumMap k a_acVw
- Data.EnumMap.Base: updateMaxWithKey :: Enum k => (k -> a_acW5 -> Maybe a_acW5) -> EnumMap k a_acW5 -> EnumMap k a_acW5
- Data.EnumMap.Base: updateMin :: (a_acVg -> Maybe a_acVg) -> EnumMap k a_acVg -> EnumMap k a_acVg
- Data.EnumMap.Base: updateMinWithKey :: Enum k => (k -> a_acVM -> Maybe a_acVM) -> EnumMap k a_acVM -> EnumMap k a_acVM
- Data.EnumMap.Base: updateWithKey :: Enum k => (k -> a_acyD -> Maybe a_acyD) -> k -> EnumMap k a_acyD -> EnumMap k a_acyD
- Data.EnumMap.Lazy: instance [safe] (Enum k, Read k, Read a) => Read (EnumMap k a)
- Data.EnumMap.Lazy: instance [safe] (Enum k, Show k, Show a) => Show (EnumMap k a)
- Data.EnumMap.Strict: data EnumMap k v
- Data.EnumSet: instance [safe] (Enum k, Read k) => Read (EnumSet k)
- Data.EnumSet: instance [safe] (Enum k, Show k) => Show (EnumSet k)
- Data.EnumSet.Base: (\\) :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: EnumSet :: IntSet -> EnumSet k
- Data.EnumSet.Base: delete :: Enum k => k -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: deleteFindMax :: Enum k => EnumSet k -> (k, EnumSet k)
- Data.EnumSet.Base: deleteFindMin :: Enum k => EnumSet k -> (k, EnumSet k)
- Data.EnumSet.Base: deleteMax :: EnumSet k -> EnumSet k
- Data.EnumSet.Base: deleteMin :: EnumSet k -> EnumSet k
- Data.EnumSet.Base: difference :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: elems :: Enum k => EnumSet k -> [k]
- Data.EnumSet.Base: empty :: EnumSet k
- Data.EnumSet.Base: filter :: Enum k => (k -> Bool) -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: findMax :: Enum k => EnumSet k -> k
- Data.EnumSet.Base: findMin :: Enum k => EnumSet k -> k
- Data.EnumSet.Base: foldl :: Enum k => (a_a8YA -> k -> a_a8YA) -> a_a8YA -> EnumSet k -> a_a8YA
- Data.EnumSet.Base: foldl' :: Enum k => (a_a8Zc -> k -> a_a8Zc) -> a_a8Zc -> EnumSet k -> a_a8Zc
- Data.EnumSet.Base: foldr :: Enum k => (k -> b_a8Yh -> b_a8Yh) -> b_a8Yh -> EnumSet k -> b_a8Yh
- Data.EnumSet.Base: foldr' :: Enum k => (k -> b_a8YT -> b_a8YT) -> b_a8YT -> EnumSet k -> b_a8YT
- Data.EnumSet.Base: fromAscList :: Enum k => [k] -> EnumSet k
- Data.EnumSet.Base: fromDistinctAscList :: Enum k => [k] -> EnumSet k
- Data.EnumSet.Base: fromList :: Enum k => [k] -> EnumSet k
- Data.EnumSet.Base: insert :: Enum k => k -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: intersection :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: isProperSubsetOf :: EnumSet k -> EnumSet k -> Bool
- Data.EnumSet.Base: isSubsetOf :: EnumSet k -> EnumSet k -> Bool
- Data.EnumSet.Base: lookupGE :: Enum k => k -> EnumSet k -> Maybe k
- Data.EnumSet.Base: lookupGT :: Enum k => k -> EnumSet k -> Maybe k
- Data.EnumSet.Base: lookupLE :: Enum k => k -> EnumSet k -> Maybe k
- Data.EnumSet.Base: lookupLT :: Enum k => k -> EnumSet k -> Maybe k
- Data.EnumSet.Base: map :: (Enum k, Enum k') => (k -> k') -> EnumSet k -> EnumSet k'
- Data.EnumSet.Base: maxView :: Enum k => EnumSet k -> Maybe (k, EnumSet k)
- Data.EnumSet.Base: member :: Enum k => k -> EnumSet k -> Bool
- Data.EnumSet.Base: minView :: Enum k => EnumSet k -> Maybe (k, EnumSet k)
- Data.EnumSet.Base: newtype EnumSet k
- Data.EnumSet.Base: notMember :: Enum k => k -> EnumSet k -> Bool
- Data.EnumSet.Base: null :: EnumSet k -> Bool
- Data.EnumSet.Base: partition :: Enum k => (k -> Bool) -> EnumSet k -> (EnumSet k, EnumSet k)
- Data.EnumSet.Base: showTree :: EnumSet k -> String
- Data.EnumSet.Base: showTreeWith :: Bool -> Bool -> EnumSet k -> String
- Data.EnumSet.Base: singleton :: Enum k => k -> EnumSet k
- Data.EnumSet.Base: size :: EnumSet k -> Int
- Data.EnumSet.Base: split :: Enum k => k -> EnumSet k -> (EnumSet k, EnumSet k)
- Data.EnumSet.Base: splitMember :: Enum k => k -> EnumSet k -> (EnumSet k, Bool, EnumSet k)
- Data.EnumSet.Base: toAscList :: Enum k => EnumSet k -> [k]
- Data.EnumSet.Base: toDescList :: Enum k => EnumSet k -> [k]
- Data.EnumSet.Base: toList :: Enum k => EnumSet k -> [k]
- Data.EnumSet.Base: unEnumSet :: EnumSet k -> IntSet
- Data.EnumSet.Base: union :: EnumSet k -> EnumSet k -> EnumSet k
- Data.EnumSet.Base: unions :: [EnumSet k] -> EnumSet k
+ Data.EnumMap.Lazy: (!) :: Enum k => EnumMap k a_ac42 -> k -> a_ac42
+ Data.EnumMap.Lazy: (\\) :: EnumMap k a_ac4m -> EnumMap k b_ac4n -> EnumMap k a_ac4m
+ Data.EnumMap.Lazy: EnumMap :: IntMap v -> EnumMap k v
+ Data.EnumMap.Lazy: adjust :: Enum k => (a_ampc -> a_ampc) -> k -> EnumMap k a_ampc -> EnumMap k a_ampc
+ Data.EnumMap.Lazy: adjustWithKey :: Enum k => (k -> a_ampv -> a_ampv) -> k -> EnumMap k a_ampv -> EnumMap k a_ampv
+ Data.EnumMap.Lazy: alter :: Enum k => (Maybe a_amqV -> Maybe a_amqV) -> k -> EnumMap k a_amqV -> EnumMap k a_amqV
+ Data.EnumMap.Lazy: assocs :: Enum k => EnumMap k a_acmC -> [(k, a_acmC)]
+ Data.EnumMap.Lazy: delete :: Enum k => k -> EnumMap k a_acah -> EnumMap k a_acah
+ Data.EnumMap.Lazy: deleteFindMax :: Enum k => EnumMap k a_acxR -> ((k, a_acxR), EnumMap k a_acxR)
+ Data.EnumMap.Lazy: deleteFindMin :: Enum k => EnumMap k a_acxq -> ((k, a_acxq), EnumMap k a_acxq)
+ Data.EnumMap.Lazy: deleteMax :: EnumMap k a_acxa -> EnumMap k a_acxa
+ Data.EnumMap.Lazy: deleteMin :: EnumMap k a_acwU -> EnumMap k a_acwU
+ Data.EnumMap.Lazy: difference :: EnumMap k a_ace1 -> EnumMap k b_ace2 -> EnumMap k a_ace1
+ Data.EnumMap.Lazy: differenceWith :: (a_amsP -> b_amsQ -> Maybe a_amsP) -> EnumMap k a_amsP -> EnumMap k b_amsQ -> EnumMap k a_amsP
+ Data.EnumMap.Lazy: differenceWithKey :: Enum k => (k -> a_amt6 -> b_amt7 -> Maybe a_amt6) -> EnumMap k a_amt6 -> EnumMap k b_amt7 -> EnumMap k a_amt6
+ Data.EnumMap.Lazy: elems :: EnumMap k a_acm3 -> [a_acm3]
+ Data.EnumMap.Lazy: empty :: EnumMap k a_ac8i
+ Data.EnumMap.Lazy: filter :: (a_acrt -> Bool) -> EnumMap k a_acrt -> EnumMap k a_acrt
+ Data.EnumMap.Lazy: filterWithKey :: Enum k => (k -> a_acrJ -> Bool) -> EnumMap k a_acrJ -> EnumMap k a_acrJ
+ Data.EnumMap.Lazy: findMax :: Enum k => EnumMap k a_acww -> (k, a_acww)
+ Data.EnumMap.Lazy: findMin :: Enum k => EnumMap k a_acw8 -> (k, a_acw8)
+ Data.EnumMap.Lazy: findWithDefault :: Enum k => a_amkW -> k -> EnumMap k a_amkW -> a_amkW
+ Data.EnumMap.Lazy: foldl :: (a_acjW -> b_acjX -> a_acjW) -> a_acjW -> EnumMap k b_acjX -> a_acjW
+ Data.EnumMap.Lazy: foldl' :: (a_acl8 -> b_acl9 -> a_acl8) -> a_acl8 -> EnumMap k b_acl9 -> a_acl8
+ Data.EnumMap.Lazy: foldlWithKey :: Enum k => (a_ackx -> k -> b_acky -> a_ackx) -> a_ackx -> EnumMap k b_acky -> a_ackx
+ Data.EnumMap.Lazy: foldlWithKey' :: Enum k => (a_aclJ -> k -> b_aclK -> a_aclJ) -> a_aclJ -> EnumMap k b_aclK -> a_aclJ
+ Data.EnumMap.Lazy: foldr :: (a_acjF -> b_acjG -> b_acjG) -> b_acjG -> EnumMap k a_acjF -> b_acjG
+ Data.EnumMap.Lazy: foldr' :: (a_ackR -> b_ackS -> b_ackS) -> b_ackS -> EnumMap k a_ackR -> b_ackS
+ Data.EnumMap.Lazy: foldrWithKey :: Enum k => (k -> a_ackd -> b_acke -> b_acke) -> b_acke -> EnumMap k a_ackd -> b_acke
+ Data.EnumMap.Lazy: foldrWithKey' :: Enum k => (k -> a_aclp -> b_aclq -> b_aclq) -> b_aclq -> EnumMap k a_aclp -> b_aclq
+ Data.EnumMap.Lazy: fromAscList :: Enum k => [(k, a_amDX)] -> EnumMap k a_amDX
+ Data.EnumMap.Lazy: fromAscListWith :: Enum k => (a_amEl -> a_amEl -> a_amEl) -> [(k, a_amEl)] -> EnumMap k a_amEl
+ Data.EnumMap.Lazy: fromAscListWithKey :: Enum k => (k -> a_amEJ -> a_amEJ -> a_amEJ) -> [(k, a_amEJ)] -> EnumMap k a_amEJ
+ Data.EnumMap.Lazy: fromDistinctAscList :: Enum k => [(k, a_amF8)] -> EnumMap k a_amF8
+ Data.EnumMap.Lazy: fromList :: Enum k => [(k, a_amC2)] -> EnumMap k a_amC2
+ Data.EnumMap.Lazy: fromListWith :: Enum k => (a_amCq -> a_amCq -> a_amCq) -> [(k, a_amCq)] -> EnumMap k a_amCq
+ Data.EnumMap.Lazy: fromListWithKey :: Enum k => (k -> a_amCO -> a_amCO -> a_amCO) -> [(k, a_amCO)] -> EnumMap k a_amCO
+ Data.EnumMap.Lazy: fromSet :: Enum k => (k -> a_amBm) -> EnumSet k -> EnumMap k a_amBm
+ Data.EnumMap.Lazy: insert :: Enum k => k -> a_amnu -> EnumMap k a_amnu -> EnumMap k a_amnu
+ Data.EnumMap.Lazy: insertLookupWithKey :: Enum k => (k -> a_amos -> a_amos -> a_amos) -> k -> a_amos -> EnumMap k a_amos -> (Maybe a_amos, EnumMap k a_amos)
+ Data.EnumMap.Lazy: insertWith :: Enum k => (a_amnO -> a_amnO -> a_amnO) -> k -> a_amnO -> EnumMap k a_amnO -> EnumMap k a_amnO
+ Data.EnumMap.Lazy: insertWithKey :: Enum k => (k -> a_amo7 -> a_amo7 -> a_amo7) -> k -> a_amo7 -> EnumMap k a_amo7 -> EnumMap k a_amo7
+ Data.EnumMap.Lazy: instance (Data k, Data v) => Data (EnumMap k v)
+ Data.EnumMap.Lazy: instance (Enum k, Read k, Read a) => Read (EnumMap k a)
+ Data.EnumMap.Lazy: instance (Enum k, Show k, Show a) => Show (EnumMap k a)
+ Data.EnumMap.Lazy: instance Eq v => Eq (EnumMap k v)
+ Data.EnumMap.Lazy: instance Foldable (EnumMap k)
+ Data.EnumMap.Lazy: instance Functor (EnumMap k)
+ Data.EnumMap.Lazy: instance Monoid (EnumMap k v)
+ Data.EnumMap.Lazy: instance NFData v => NFData (EnumMap k v)
+ Data.EnumMap.Lazy: instance Ord v => Ord (EnumMap k v)
+ Data.EnumMap.Lazy: instance Traversable (EnumMap k)
+ Data.EnumMap.Lazy: instance Typeable2 EnumMap
+ Data.EnumMap.Lazy: intersection :: EnumMap k a_aceT -> EnumMap k b_aceU -> EnumMap k a_aceT
+ Data.EnumMap.Lazy: intersectionWith :: (a_amtF -> b_amtG -> c_amtH) -> EnumMap k a_amtF -> EnumMap k b_amtG -> EnumMap k c_amtH
+ Data.EnumMap.Lazy: intersectionWithKey :: Enum k => (k -> a_amtX -> b_amtY -> c_amtZ) -> EnumMap k a_amtX -> EnumMap k b_amtY -> EnumMap k c_amtZ
+ Data.EnumMap.Lazy: isProperSubmapOf :: Eq a_acvy => EnumMap k a_acvy -> EnumMap k a_acvy -> Bool
+ Data.EnumMap.Lazy: isProperSubmapOfBy :: (a_acvR -> b_acvS -> Bool) -> EnumMap k a_acvR -> EnumMap k b_acvS -> Bool
+ Data.EnumMap.Lazy: isSubmapOf :: Eq a_acuY => EnumMap k a_acuY -> EnumMap k a_acuY -> Bool
+ Data.EnumMap.Lazy: isSubmapOfBy :: (a_acvh -> b_acvi -> Bool) -> EnumMap k a_acvh -> EnumMap k b_acvi -> Bool
+ Data.EnumMap.Lazy: keys :: Enum k => EnumMap k a_acmj -> [k]
+ Data.EnumMap.Lazy: keysSet :: EnumMap k a_acn0 -> EnumSet k
+ Data.EnumMap.Lazy: lookup :: Enum k => k -> EnumMap k a_ac5O -> Maybe a_ac5O
+ Data.EnumMap.Lazy: lookupGE :: Enum k => k -> EnumMap k a_ac7Q -> Maybe (k, a_ac7Q)
+ Data.EnumMap.Lazy: lookupGT :: Enum k => k -> EnumMap k a_ac6W -> Maybe (k, a_ac6W)
+ Data.EnumMap.Lazy: lookupLE :: Enum k => k -> EnumMap k a_ac7o -> Maybe (k, a_ac7o)
+ Data.EnumMap.Lazy: lookupLT :: Enum k => k -> EnumMap k a_ac6u -> Maybe (k, a_ac6u)
+ Data.EnumMap.Lazy: map :: (a_amuD -> b_amuE) -> EnumMap k a_amuD -> EnumMap k b_amuE
+ Data.EnumMap.Lazy: mapAccum :: (a_amvz -> b_amvA -> (a_amvz, c_amvB)) -> a_amvz -> EnumMap k b_amvA -> (a_amvz, EnumMap k c_amvB)
+ Data.EnumMap.Lazy: mapAccumRWithKey :: Enum k => (a_amwx -> k -> b_amwy -> (a_amwx, c_amwz)) -> a_amwx -> EnumMap k b_amwy -> (a_amwx, EnumMap k c_amwz)
+ Data.EnumMap.Lazy: mapAccumWithKey :: Enum k => (a_amw2 -> k -> b_amw3 -> (a_amw2, c_amw4)) -> a_amw2 -> EnumMap k b_amw3 -> (a_amw2, EnumMap k c_amw4)
+ Data.EnumMap.Lazy: mapEither :: (a_amHm -> Either b_amHn c_amHo) -> EnumMap k a_amHm -> (EnumMap k b_amHn, EnumMap k c_amHo)
+ Data.EnumMap.Lazy: mapEitherWithKey :: Enum k => (k -> a_amHK -> Either b_amHL c_amHM) -> EnumMap k a_amHK -> (EnumMap k b_amHL, EnumMap k c_amHM)
+ Data.EnumMap.Lazy: mapKeys :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_aciB -> EnumMap k' a_aciB
+ Data.EnumMap.Lazy: mapKeysMonotonic :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_acjj -> EnumMap k' a_acjj
+ Data.EnumMap.Lazy: mapKeysWith :: (Enum k, Enum k') => (a_amxo -> a_amxo -> a_amxo) -> (k -> k') -> EnumMap k a_amxo -> EnumMap k' a_amxo
+ Data.EnumMap.Lazy: mapMaybe :: (a_amGL -> Maybe b_amGM) -> EnumMap k a_amGL -> EnumMap k b_amGM
+ Data.EnumMap.Lazy: mapMaybeWithKey :: Enum k => (k -> a_amH2 -> Maybe b_amH3) -> EnumMap k a_amH2 -> EnumMap k b_amH3
+ Data.EnumMap.Lazy: mapWithKey :: Enum k => (k -> a_amuU -> b_amuV) -> EnumMap k a_amuU -> EnumMap k b_amuV
+ Data.EnumMap.Lazy: maxView :: EnumMap k a_aczO -> Maybe (a_aczO, EnumMap k a_aczO)
+ Data.EnumMap.Lazy: maxViewWithKey :: Enum k => EnumMap k a_acAF -> Maybe ((k, a_acAF), EnumMap k a_acAF)
+ Data.EnumMap.Lazy: member :: Enum k => k -> EnumMap k a_ac5b -> Bool
+ Data.EnumMap.Lazy: mergeWithKey :: Enum k => (k -> a_amui -> b_amuj -> Maybe c_amuk) -> (EnumMap k a_amui -> EnumMap k c_amuk) -> (EnumMap k b_amuj -> EnumMap k c_amuk) -> EnumMap k a_amui -> EnumMap k b_amuj -> EnumMap k c_amuk
+ Data.EnumMap.Lazy: minView :: EnumMap k a_aczq -> Maybe (a_aczq, EnumMap k a_aczq)
+ Data.EnumMap.Lazy: minViewWithKey :: Enum k => EnumMap k a_acAc -> Maybe ((k, a_acAc), EnumMap k a_acAc)
+ Data.EnumMap.Lazy: newtype EnumMap k v
+ Data.EnumMap.Lazy: notMember :: Enum k => k -> EnumMap k a_ac5v -> Bool
+ Data.EnumMap.Lazy: null :: EnumMap k a_ac4D -> Bool
+ Data.EnumMap.Lazy: partition :: (a_acs2 -> Bool) -> EnumMap k a_acs2 -> (EnumMap k a_acs2, EnumMap k a_acs2)
+ Data.EnumMap.Lazy: partitionWithKey :: Enum k => (k -> a_acso -> Bool) -> EnumMap k a_acso -> (EnumMap k a_acso, EnumMap k a_acso)
+ Data.EnumMap.Lazy: showTree :: Show a_acB8 => EnumMap k a_acB8 -> String
+ Data.EnumMap.Lazy: showTreeWith :: Show a_acBr => Bool -> Bool -> EnumMap k a_acBr -> String
+ Data.EnumMap.Lazy: singleton :: Enum k => k -> a_amnb -> EnumMap k a_amnb
+ Data.EnumMap.Lazy: size :: EnumMap k a -> Int
+ Data.EnumMap.Lazy: split :: Enum k => k -> EnumMap k a_acud -> (EnumMap k a_acud, EnumMap k a_acud)
+ Data.EnumMap.Lazy: splitLookup :: Enum k => k -> EnumMap k a_acuC -> (EnumMap k a_acuC, Maybe a_acuC, EnumMap k a_acuC)
+ Data.EnumMap.Lazy: toAscList :: Enum k => EnumMap k a_acp8 -> [(k, a_acp8)]
+ Data.EnumMap.Lazy: toDescList :: Enum k => EnumMap k a_acpw -> [(k, a_acpw)]
+ Data.EnumMap.Lazy: toList :: Enum k => EnumMap k a_acnz -> [(k, a_acnz)]
+ Data.EnumMap.Lazy: traverseWithKey :: (Enum k, Applicative t_acgK) => (k -> a_acgJ -> t_acgK b_acgL) -> EnumMap k a_acgJ -> t_acgK (EnumMap k b_acgL)
+ Data.EnumMap.Lazy: unEnumMap :: EnumMap k v -> IntMap v
+ Data.EnumMap.Lazy: union :: EnumMap k a_accG -> EnumMap k a_accG -> EnumMap k a_accG
+ Data.EnumMap.Lazy: unionWith :: (a_amrw -> a_amrw -> a_amrw) -> EnumMap k a_amrw -> EnumMap k a_amrw -> EnumMap k a_amrw
+ Data.EnumMap.Lazy: unionWithKey :: Enum k => (k -> a_amrM -> a_amrM -> a_amrM) -> EnumMap k a_amrM -> EnumMap k a_amrM -> EnumMap k a_amrM
+ Data.EnumMap.Lazy: unions :: [EnumMap k a_acdv] -> EnumMap k a_acdv
+ Data.EnumMap.Lazy: unionsWith :: (a_amsk -> a_amsk -> a_amsk) -> [EnumMap k a_amsk] -> EnumMap k a_amsk
+ Data.EnumMap.Lazy: update :: Enum k => (a_ampP -> Maybe a_ampP) -> k -> EnumMap k a_ampP -> EnumMap k a_ampP
+ Data.EnumMap.Lazy: updateLookupWithKey :: Enum k => (k -> a_amqt -> Maybe a_amqt) -> k -> EnumMap k a_amqt -> (Maybe a_amqt, EnumMap k a_amqt)
+ Data.EnumMap.Lazy: updateMax :: (a_amMg -> Maybe a_amMg) -> EnumMap k a_amMg -> EnumMap k a_amMg
+ Data.EnumMap.Lazy: updateMaxWithKey :: Enum k => (k -> a_amMP -> Maybe a_amMP) -> EnumMap k a_amMP -> EnumMap k a_amMP
+ Data.EnumMap.Lazy: updateMin :: (a_amM0 -> Maybe a_amM0) -> EnumMap k a_amM0 -> EnumMap k a_amM0
+ Data.EnumMap.Lazy: updateMinWithKey :: Enum k => (k -> a_amMw -> Maybe a_amMw) -> EnumMap k a_amMw -> EnumMap k a_amMw
+ Data.EnumMap.Lazy: updateWithKey :: Enum k => (k -> a_amq8 -> Maybe a_amq8) -> k -> EnumMap k a_amq8 -> EnumMap k a_amq8
+ Data.EnumMap.Strict: EnumMap :: IntMap v -> EnumMap k v
+ Data.EnumMap.Strict: instance (Data k, Data v) => Data (EnumMap k v)
+ Data.EnumMap.Strict: instance (Enum k, Read k, Read a) => Read (EnumMap k a)
+ Data.EnumMap.Strict: instance (Enum k, Show k, Show a) => Show (EnumMap k a)
+ Data.EnumMap.Strict: instance Eq v => Eq (EnumMap k v)
+ Data.EnumMap.Strict: instance Foldable (EnumMap k)
+ Data.EnumMap.Strict: instance Functor (EnumMap k)
+ Data.EnumMap.Strict: instance Monoid (EnumMap k v)
+ Data.EnumMap.Strict: instance NFData v => NFData (EnumMap k v)
+ Data.EnumMap.Strict: instance Ord v => Ord (EnumMap k v)
+ Data.EnumMap.Strict: instance Traversable (EnumMap k)
+ Data.EnumMap.Strict: instance Typeable2 EnumMap
+ Data.EnumMap.Strict: newtype EnumMap k v
+ Data.EnumMap.Strict: unEnumMap :: EnumMap k v -> IntMap v
+ Data.EnumSet: (\\) :: EnumSet k -> EnumSet k -> EnumSet k
+ Data.EnumSet: EnumSet :: IntSet -> EnumSet k
+ Data.EnumSet: delete :: Enum k => k -> EnumSet k -> EnumSet k
+ Data.EnumSet: deleteFindMax :: Enum k => EnumSet k -> (k, EnumSet k)
+ Data.EnumSet: deleteFindMin :: Enum k => EnumSet k -> (k, EnumSet k)
+ Data.EnumSet: deleteMax :: EnumSet k -> EnumSet k
+ Data.EnumSet: deleteMin :: EnumSet k -> EnumSet k
+ Data.EnumSet: difference :: EnumSet k -> EnumSet k -> EnumSet k
+ Data.EnumSet: elems :: Enum k => EnumSet k -> [k]
+ Data.EnumSet: empty :: EnumSet k
+ Data.EnumSet: filter :: Enum k => (k -> Bool) -> EnumSet k -> EnumSet k
+ Data.EnumSet: findMax :: Enum k => EnumSet k -> k
+ Data.EnumSet: findMin :: Enum k => EnumSet k -> k
+ Data.EnumSet: foldl :: Enum k => (a_a7sA -> k -> a_a7sA) -> a_a7sA -> EnumSet k -> a_a7sA
+ Data.EnumSet: foldl' :: Enum k => (a_a7tc -> k -> a_a7tc) -> a_a7tc -> EnumSet k -> a_a7tc
+ Data.EnumSet: foldr :: Enum k => (k -> b_a7sh -> b_a7sh) -> b_a7sh -> EnumSet k -> b_a7sh
+ Data.EnumSet: foldr' :: Enum k => (k -> b_a7sT -> b_a7sT) -> b_a7sT -> EnumSet k -> b_a7sT
+ Data.EnumSet: fromAscList :: Enum k => [k] -> EnumSet k
+ Data.EnumSet: fromDistinctAscList :: Enum k => [k] -> EnumSet k
+ Data.EnumSet: fromList :: Enum k => [k] -> EnumSet k
+ Data.EnumSet: insert :: Enum k => k -> EnumSet k -> EnumSet k
+ Data.EnumSet: instance (Enum k, Read k) => Read (EnumSet k)
+ Data.EnumSet: instance (Enum k, Show k) => Show (EnumSet k)
+ Data.EnumSet: instance Data k => Data (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: instance Typeable1 EnumSet
+ Data.EnumSet: intersection :: EnumSet k -> EnumSet k -> EnumSet k
+ Data.EnumSet: isProperSubsetOf :: EnumSet k -> EnumSet k -> Bool
+ Data.EnumSet: isSubsetOf :: EnumSet k -> EnumSet k -> Bool
+ 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: map :: (Enum k, Enum k') => (k -> k') -> EnumSet k -> EnumSet k'
+ Data.EnumSet: maxView :: Enum k => EnumSet k -> Maybe (k, EnumSet k)
+ Data.EnumSet: member :: Enum k => k -> EnumSet k -> Bool
+ Data.EnumSet: minView :: Enum k => EnumSet k -> Maybe (k, EnumSet k)
+ Data.EnumSet: newtype EnumSet k
+ Data.EnumSet: notMember :: Enum k => k -> EnumSet k -> Bool
+ Data.EnumSet: null :: EnumSet k -> Bool
+ Data.EnumSet: partition :: Enum k => (k -> Bool) -> EnumSet k -> (EnumSet k, EnumSet k)
+ Data.EnumSet: showTree :: EnumSet k -> String
+ Data.EnumSet: showTreeWith :: Bool -> Bool -> EnumSet k -> String
+ Data.EnumSet: singleton :: Enum k => k -> EnumSet k
+ Data.EnumSet: size :: EnumSet k -> Int
+ Data.EnumSet: split :: Enum k => k -> EnumSet k -> (EnumSet k, EnumSet k)
+ Data.EnumSet: splitMember :: Enum k => k -> EnumSet k -> (EnumSet k, Bool, EnumSet k)
+ Data.EnumSet: toAscList :: Enum k => EnumSet k -> [k]
+ Data.EnumSet: toDescList :: Enum k => EnumSet k -> [k]
+ Data.EnumSet: toList :: Enum k => EnumSet k -> [k]
+ Data.EnumSet: unEnumSet :: EnumSet k -> IntSet
+ Data.EnumSet: union :: EnumSet k -> EnumSet k -> EnumSet k
+ Data.EnumSet: unions :: [EnumSet k] -> EnumSet k
- Data.EnumMap.Strict: (!) :: Enum k => EnumMap k a_acra -> k -> a_acra
+ Data.EnumMap.Strict: (!) :: Enum k => EnumMap k a_ac42 -> k -> a_ac42
- Data.EnumMap.Strict: (\\) :: EnumMap k a_acru -> EnumMap k b_acrv -> EnumMap k a_acru
+ Data.EnumMap.Strict: (\\) :: EnumMap k a_ac4m -> EnumMap k b_ac4n -> EnumMap k a_ac4m
- Data.EnumMap.Strict: adjust :: Enum k => (a_aleu -> a_aleu) -> k -> EnumMap k a_aleu -> EnumMap k a_aleu
+ Data.EnumMap.Strict: adjust :: Enum k => (a_acaB -> a_acaB) -> k -> EnumMap k a_acaB -> EnumMap k a_acaB
- Data.EnumMap.Strict: adjustWithKey :: Enum k => (k -> a_aleN -> a_aleN) -> k -> EnumMap k a_aleN -> EnumMap k a_aleN
+ Data.EnumMap.Strict: adjustWithKey :: Enum k => (k -> a_acaU -> a_acaU) -> k -> EnumMap k a_acaU -> EnumMap k a_acaU
- Data.EnumMap.Strict: alter :: Enum k => (Maybe a_algc -> Maybe a_algc) -> k -> EnumMap k a_algc -> EnumMap k a_algc
+ Data.EnumMap.Strict: alter :: Enum k => (Maybe a_acck -> Maybe a_acck) -> k -> EnumMap k a_acck -> EnumMap k a_acck
- Data.EnumMap.Strict: assocs :: Enum k => EnumMap k a_acJD -> [(k, a_acJD)]
+ Data.EnumMap.Strict: assocs :: Enum k => EnumMap k a_acmC -> [(k, a_acmC)]
- Data.EnumMap.Strict: delete :: Enum k => k -> EnumMap k a_acxn -> EnumMap k a_acxn
+ Data.EnumMap.Strict: delete :: Enum k => k -> EnumMap k a_acah -> EnumMap k a_acah
- Data.EnumMap.Strict: deleteFindMax :: Enum k => EnumMap k a_acUP -> ((k, a_acUP), EnumMap k a_acUP)
+ Data.EnumMap.Strict: deleteFindMax :: Enum k => EnumMap k a_acxR -> ((k, a_acxR), EnumMap k a_acxR)
- Data.EnumMap.Strict: deleteFindMin :: Enum k => EnumMap k a_acUo -> ((k, a_acUo), EnumMap k a_acUo)
+ Data.EnumMap.Strict: deleteFindMin :: Enum k => EnumMap k a_acxq -> ((k, a_acxq), EnumMap k a_acxq)
- Data.EnumMap.Strict: deleteMax :: EnumMap k a_acU8 -> EnumMap k a_acU8
+ Data.EnumMap.Strict: deleteMax :: EnumMap k a_acxa -> EnumMap k a_acxa
- Data.EnumMap.Strict: deleteMin :: EnumMap k a_acTS -> EnumMap k a_acTS
+ Data.EnumMap.Strict: deleteMin :: EnumMap k a_acwU -> EnumMap k a_acwU
- Data.EnumMap.Strict: difference :: EnumMap k a_acB5 -> EnumMap k b_acB6 -> EnumMap k a_acB5
+ Data.EnumMap.Strict: difference :: EnumMap k a_ace1 -> EnumMap k b_ace2 -> EnumMap k a_ace1
- Data.EnumMap.Strict: differenceWith :: (a_ali6 -> b_ali7 -> Maybe a_ali6) -> EnumMap k a_ali6 -> EnumMap k b_ali7 -> EnumMap k a_ali6
+ Data.EnumMap.Strict: differenceWith :: (a_acei -> b_acej -> Maybe a_acei) -> EnumMap k a_acei -> EnumMap k b_acej -> EnumMap k a_acei
- Data.EnumMap.Strict: differenceWithKey :: Enum k => (k -> a_alin -> b_alio -> Maybe a_alin) -> EnumMap k a_alin -> EnumMap k b_alio -> EnumMap k a_alin
+ Data.EnumMap.Strict: differenceWithKey :: Enum k => (k -> a_acez -> b_aceA -> Maybe a_acez) -> EnumMap k a_acez -> EnumMap k b_aceA -> EnumMap k a_acez
- Data.EnumMap.Strict: elems :: EnumMap k a_acJ4 -> [a_acJ4]
+ Data.EnumMap.Strict: elems :: EnumMap k a_acm3 -> [a_acm3]
- Data.EnumMap.Strict: empty :: EnumMap k a_a4fv
+ Data.EnumMap.Strict: empty :: EnumMap k a_ac8i
- Data.EnumMap.Strict: filter :: (a_acOt -> Bool) -> EnumMap k a_acOt -> EnumMap k a_acOt
+ Data.EnumMap.Strict: filter :: (a_acrt -> Bool) -> EnumMap k a_acrt -> EnumMap k a_acrt
- Data.EnumMap.Strict: filterWithKey :: Enum k => (k -> a_acOJ -> Bool) -> EnumMap k a_acOJ -> EnumMap k a_acOJ
+ Data.EnumMap.Strict: filterWithKey :: Enum k => (k -> a_acrJ -> Bool) -> EnumMap k a_acrJ -> EnumMap k a_acrJ
- Data.EnumMap.Strict: findMax :: Enum k => EnumMap k a_acTu -> (k, a_acTu)
+ Data.EnumMap.Strict: findMax :: Enum k => EnumMap k a_acww -> (k, a_acww)
- Data.EnumMap.Strict: findMin :: Enum k => EnumMap k a_acT6 -> (k, a_acT6)
+ Data.EnumMap.Strict: findMin :: Enum k => EnumMap k a_acw8 -> (k, a_acw8)
- Data.EnumMap.Strict: findWithDefault :: Enum k => a_alaf -> k -> EnumMap k a_alaf -> a_alaf
+ Data.EnumMap.Strict: findWithDefault :: Enum k => a_ac6a -> k -> EnumMap k a_ac6a -> a_ac6a
- Data.EnumMap.Strict: foldl :: (a_a4aU -> b_a4aV -> a_a4aU) -> a_a4aU -> EnumMap k b_a4aV -> a_a4aU
+ Data.EnumMap.Strict: foldl :: (a_acjW -> b_acjX -> a_acjW) -> a_acjW -> EnumMap k b_acjX -> a_acjW
- Data.EnumMap.Strict: foldl' :: (a_acI9 -> b_acIa -> a_acI9) -> a_acI9 -> EnumMap k b_acIa -> a_acI9
+ Data.EnumMap.Strict: foldl' :: (a_acl8 -> b_acl9 -> a_acl8) -> a_acl8 -> EnumMap k b_acl9 -> a_acl8
- Data.EnumMap.Strict: foldlWithKey :: Enum k => (a_acHy -> k -> b_acHz -> a_acHy) -> a_acHy -> EnumMap k b_acHz -> a_acHy
+ Data.EnumMap.Strict: foldlWithKey :: Enum k => (a_ackx -> k -> b_acky -> a_ackx) -> a_ackx -> EnumMap k b_acky -> a_ackx
- Data.EnumMap.Strict: foldlWithKey' :: Enum k => (a_acIK -> k -> b_acIL -> a_acIK) -> a_acIK -> EnumMap k b_acIL -> a_acIK
+ Data.EnumMap.Strict: foldlWithKey' :: Enum k => (a_aclJ -> k -> b_aclK -> a_aclJ) -> a_aclJ -> EnumMap k b_aclK -> a_aclJ
- Data.EnumMap.Strict: foldr :: (a_a4aQ -> b_a4aR -> b_a4aR) -> b_a4aR -> EnumMap k a_a4aQ -> b_a4aR
+ Data.EnumMap.Strict: foldr :: (a_acjF -> b_acjG -> b_acjG) -> b_acjG -> EnumMap k a_acjF -> b_acjG
- Data.EnumMap.Strict: foldr' :: (a_acHS -> b_acHT -> b_acHT) -> b_acHT -> EnumMap k a_acHS -> b_acHT
+ Data.EnumMap.Strict: foldr' :: (a_ackR -> b_ackS -> b_ackS) -> b_ackS -> EnumMap k a_ackR -> b_ackS
- Data.EnumMap.Strict: foldrWithKey :: Enum k => (k -> a_acHe -> b_acHf -> b_acHf) -> b_acHf -> EnumMap k a_acHe -> b_acHf
+ Data.EnumMap.Strict: foldrWithKey :: Enum k => (k -> a_ackd -> b_acke -> b_acke) -> b_acke -> EnumMap k a_ackd -> b_acke
- Data.EnumMap.Strict: foldrWithKey' :: Enum k => (k -> a_acIq -> b_acIr -> b_acIr) -> b_acIr -> EnumMap k a_acIq -> b_acIr
+ Data.EnumMap.Strict: foldrWithKey' :: Enum k => (k -> a_aclp -> b_aclq -> b_aclq) -> b_aclq -> EnumMap k a_aclp -> b_aclq
- Data.EnumMap.Strict: fromAscList :: Enum k => [(k, a_altd)] -> EnumMap k a_altd
+ Data.EnumMap.Strict: fromAscList :: Enum k => [(k, a_acpU)] -> EnumMap k a_acpU
- Data.EnumMap.Strict: fromAscListWith :: Enum k => (a_altB -> a_altB -> a_altB) -> [(k, a_altB)] -> EnumMap k a_altB
+ Data.EnumMap.Strict: fromAscListWith :: Enum k => (a_acqi -> a_acqi -> a_acqi) -> [(k, a_acqi)] -> EnumMap k a_acqi
- Data.EnumMap.Strict: fromAscListWithKey :: Enum k => (k -> a_altZ -> a_altZ -> a_altZ) -> [(k, a_altZ)] -> EnumMap k a_altZ
+ Data.EnumMap.Strict: fromAscListWithKey :: Enum k => (k -> a_acqG -> a_acqG -> a_acqG) -> [(k, a_acqG)] -> EnumMap k a_acqG
- Data.EnumMap.Strict: fromDistinctAscList :: Enum k => [(k, a_aluo)] -> EnumMap k a_aluo
+ Data.EnumMap.Strict: fromDistinctAscList :: Enum k => [(k, a_acr5)] -> EnumMap k a_acr5
- Data.EnumMap.Strict: fromList :: Enum k => [(k, a_alri)] -> EnumMap k a_alri
+ Data.EnumMap.Strict: fromList :: Enum k => [(k, a_acnX)] -> EnumMap k a_acnX
- Data.EnumMap.Strict: fromListWith :: Enum k => (a_alrG -> a_alrG -> a_alrG) -> [(k, a_alrG)] -> EnumMap k a_alrG
+ Data.EnumMap.Strict: fromListWith :: Enum k => (a_acol -> a_acol -> a_acol) -> [(k, a_acol)] -> EnumMap k a_acol
- Data.EnumMap.Strict: fromListWithKey :: Enum k => (k -> a_als4 -> a_als4 -> a_als4) -> [(k, a_als4)] -> EnumMap k a_als4
+ Data.EnumMap.Strict: fromListWithKey :: Enum k => (k -> a_acoJ -> a_acoJ -> a_acoJ) -> [(k, a_acoJ)] -> EnumMap k a_acoJ
- Data.EnumMap.Strict: fromSet :: Enum k => (k -> a_alqC) -> EnumSet k -> EnumMap k a_alqC
+ Data.EnumMap.Strict: fromSet :: Enum k => (k -> a_acng) -> EnumSet k -> EnumMap k a_acng
- Data.EnumMap.Strict: insert :: Enum k => k -> a_alcN -> EnumMap k a_alcN -> EnumMap k a_alcN
+ Data.EnumMap.Strict: insert :: Enum k => k -> a_ac8R -> EnumMap k a_ac8R -> EnumMap k a_ac8R
- Data.EnumMap.Strict: insertLookupWithKey :: Enum k => (k -> a_aldL -> a_aldL -> a_aldL) -> k -> a_aldL -> EnumMap k a_aldL -> (Maybe a_aldL, EnumMap k a_aldL)
+ Data.EnumMap.Strict: insertLookupWithKey :: Enum k => (k -> a_ac9P -> a_ac9P -> a_ac9P) -> k -> a_ac9P -> EnumMap k a_ac9P -> (Maybe a_ac9P, EnumMap k a_ac9P)
- Data.EnumMap.Strict: insertWith :: Enum k => (a_ald7 -> a_ald7 -> a_ald7) -> k -> a_ald7 -> EnumMap k a_ald7 -> EnumMap k a_ald7
+ Data.EnumMap.Strict: insertWith :: Enum k => (a_ac9b -> a_ac9b -> a_ac9b) -> k -> a_ac9b -> EnumMap k a_ac9b -> EnumMap k a_ac9b
- Data.EnumMap.Strict: insertWithKey :: Enum k => (k -> a_aldq -> a_aldq -> a_aldq) -> k -> a_aldq -> EnumMap k a_aldq -> EnumMap k a_aldq
+ Data.EnumMap.Strict: insertWithKey :: Enum k => (k -> a_ac9u -> a_ac9u -> a_ac9u) -> k -> a_ac9u -> EnumMap k a_ac9u -> EnumMap k a_ac9u
- Data.EnumMap.Strict: intersection :: EnumMap k a_acBX -> EnumMap k b_acBY -> EnumMap k a_acBX
+ Data.EnumMap.Strict: intersection :: EnumMap k a_aceT -> EnumMap k b_aceU -> EnumMap k a_aceT
- Data.EnumMap.Strict: intersectionWith :: (a_aliW -> b_aliX -> c_aliY) -> EnumMap k a_aliW -> EnumMap k b_aliX -> EnumMap k c_aliY
+ Data.EnumMap.Strict: intersectionWith :: (a_acfa -> b_acfb -> c_acfc) -> EnumMap k a_acfa -> EnumMap k b_acfb -> EnumMap k c_acfc
- Data.EnumMap.Strict: intersectionWithKey :: Enum k => (k -> a_alje -> b_aljf -> c_aljg) -> EnumMap k a_alje -> EnumMap k b_aljf -> EnumMap k c_aljg
+ Data.EnumMap.Strict: intersectionWithKey :: Enum k => (k -> a_acfs -> b_acft -> c_acfu) -> EnumMap k a_acfs -> EnumMap k b_acft -> EnumMap k c_acfu
- Data.EnumMap.Strict: isProperSubmapOf :: Eq a_acSw => EnumMap k a_acSw -> EnumMap k a_acSw -> Bool
+ Data.EnumMap.Strict: isProperSubmapOf :: Eq a_acvy => EnumMap k a_acvy -> EnumMap k a_acvy -> Bool
- Data.EnumMap.Strict: isProperSubmapOfBy :: (a_acSP -> b_acSQ -> Bool) -> EnumMap k a_acSP -> EnumMap k b_acSQ -> Bool
+ Data.EnumMap.Strict: isProperSubmapOfBy :: (a_acvR -> b_acvS -> Bool) -> EnumMap k a_acvR -> EnumMap k b_acvS -> Bool
- Data.EnumMap.Strict: isSubmapOf :: Eq a_acRW => EnumMap k a_acRW -> EnumMap k a_acRW -> Bool
+ Data.EnumMap.Strict: isSubmapOf :: Eq a_acuY => EnumMap k a_acuY -> EnumMap k a_acuY -> Bool
- Data.EnumMap.Strict: isSubmapOfBy :: (a_acSf -> b_acSg -> Bool) -> EnumMap k a_acSf -> EnumMap k b_acSg -> Bool
+ Data.EnumMap.Strict: isSubmapOfBy :: (a_acvh -> b_acvi -> Bool) -> EnumMap k a_acvh -> EnumMap k b_acvi -> Bool
- Data.EnumMap.Strict: keys :: Enum k => EnumMap k a_acJk -> [k]
+ Data.EnumMap.Strict: keys :: Enum k => EnumMap k a_acmj -> [k]
- Data.EnumMap.Strict: keysSet :: EnumMap k a_acK1 -> EnumSet k
+ Data.EnumMap.Strict: keysSet :: EnumMap k a_acn0 -> EnumSet k
- Data.EnumMap.Strict: lookup :: Enum k => k -> EnumMap k a_acsV -> Maybe a_acsV
+ Data.EnumMap.Strict: lookup :: Enum k => k -> EnumMap k a_ac5O -> Maybe a_ac5O
- Data.EnumMap.Strict: lookupGE :: Enum k => k -> EnumMap k a_acuX -> Maybe (k, a_acuX)
+ Data.EnumMap.Strict: lookupGE :: Enum k => k -> EnumMap k a_ac7Q -> Maybe (k, a_ac7Q)
- Data.EnumMap.Strict: lookupGT :: Enum k => k -> EnumMap k a_acu3 -> Maybe (k, a_acu3)
+ Data.EnumMap.Strict: lookupGT :: Enum k => k -> EnumMap k a_ac6W -> Maybe (k, a_ac6W)
- Data.EnumMap.Strict: lookupLE :: Enum k => k -> EnumMap k a_acuv -> Maybe (k, a_acuv)
+ Data.EnumMap.Strict: lookupLE :: Enum k => k -> EnumMap k a_ac7o -> Maybe (k, a_ac7o)
- Data.EnumMap.Strict: lookupLT :: Enum k => k -> EnumMap k a_actB -> Maybe (k, a_actB)
+ Data.EnumMap.Strict: lookupLT :: Enum k => k -> EnumMap k a_ac6u -> Maybe (k, a_ac6u)
- Data.EnumMap.Strict: map :: (a_aljU -> b_aljV) -> EnumMap k a_aljU -> EnumMap k b_aljV
+ Data.EnumMap.Strict: map :: (a_acg8 -> b_acg9) -> EnumMap k a_acg8 -> EnumMap k b_acg9
- Data.EnumMap.Strict: mapAccum :: (a_alkQ -> b_alkR -> (a_alkQ, c_alkS)) -> a_alkQ -> EnumMap k b_alkR -> (a_alkQ, EnumMap k c_alkS)
+ Data.EnumMap.Strict: mapAccum :: (a_ach7 -> b_ach8 -> (a_ach7, c_ach9)) -> a_ach7 -> EnumMap k b_ach8 -> (a_ach7, EnumMap k c_ach9)
- Data.EnumMap.Strict: mapAccumRWithKey :: Enum k => (a_allO -> k -> b_allP -> (a_allO, c_allQ)) -> a_allO -> EnumMap k b_allP -> (a_allO, EnumMap k c_allQ)
+ Data.EnumMap.Strict: mapAccumRWithKey :: Enum k => (a_aci5 -> k -> b_aci6 -> (a_aci5, c_aci7)) -> a_aci5 -> EnumMap k b_aci6 -> (a_aci5, EnumMap k c_aci7)
- Data.EnumMap.Strict: mapAccumWithKey :: Enum k => (a_allj -> k -> b_allk -> (a_allj, c_alll)) -> a_allj -> EnumMap k b_allk -> (a_allj, EnumMap k c_alll)
+ Data.EnumMap.Strict: mapAccumWithKey :: Enum k => (a_achA -> k -> b_achB -> (a_achA, c_achC)) -> a_achA -> EnumMap k b_achB -> (a_achA, EnumMap k c_achC)
- Data.EnumMap.Strict: mapEither :: (a_alwC -> Either b_alwD c_alwE) -> EnumMap k a_alwC -> (EnumMap k b_alwD, EnumMap k c_alwE)
+ Data.EnumMap.Strict: mapEither :: (a_acto -> Either b_actp c_actq) -> EnumMap k a_acto -> (EnumMap k b_actp, EnumMap k c_actq)
- Data.EnumMap.Strict: mapEitherWithKey :: Enum k => (k -> a_alx0 -> Either b_alx1 c_alx2) -> EnumMap k a_alx0 -> (EnumMap k b_alx1, EnumMap k c_alx2)
+ Data.EnumMap.Strict: mapEitherWithKey :: Enum k => (k -> a_actM -> Either b_actN c_actO) -> EnumMap k a_actM -> (EnumMap k b_actN, EnumMap k c_actO)
- Data.EnumMap.Strict: mapKeys :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_acFG -> EnumMap k' a_acFG
+ Data.EnumMap.Strict: mapKeys :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_aciB -> EnumMap k' a_aciB
- Data.EnumMap.Strict: mapKeysMonotonic :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_acGo -> EnumMap k' a_acGo
+ Data.EnumMap.Strict: mapKeysMonotonic :: (Enum k, Enum k') => (k -> k') -> EnumMap k a_acjj -> EnumMap k' a_acjj
- Data.EnumMap.Strict: mapKeysWith :: (Enum k, Enum k') => (a_almE -> a_almE -> a_almE) -> (k -> k') -> EnumMap k a_almE -> EnumMap k' a_almE
+ Data.EnumMap.Strict: mapKeysWith :: (Enum k, Enum k') => (a_aciX -> a_aciX -> a_aciX) -> (k -> k') -> EnumMap k a_aciX -> EnumMap k' a_aciX
- Data.EnumMap.Strict: mapMaybe :: (a_alw1 -> Maybe b_alw2) -> EnumMap k a_alw1 -> EnumMap k b_alw2
+ Data.EnumMap.Strict: mapMaybe :: (a_acsN -> Maybe b_acsO) -> EnumMap k a_acsN -> EnumMap k b_acsO
- Data.EnumMap.Strict: mapMaybeWithKey :: Enum k => (k -> a_alwi -> Maybe b_alwj) -> EnumMap k a_alwi -> EnumMap k b_alwj
+ Data.EnumMap.Strict: mapMaybeWithKey :: Enum k => (k -> a_act4 -> Maybe b_act5) -> EnumMap k a_act4 -> EnumMap k b_act5
- Data.EnumMap.Strict: mapWithKey :: Enum k => (k -> a_alkb -> b_alkc) -> EnumMap k a_alkb -> EnumMap k b_alkc
+ Data.EnumMap.Strict: mapWithKey :: Enum k => (k -> a_acgp -> b_acgq) -> EnumMap k a_acgp -> EnumMap k b_acgq
- Data.EnumMap.Strict: maxView :: EnumMap k a_acWM -> Maybe (a_acWM, EnumMap k a_acWM)
+ Data.EnumMap.Strict: maxView :: EnumMap k a_aczO -> Maybe (a_aczO, EnumMap k a_aczO)
- Data.EnumMap.Strict: maxViewWithKey :: Enum k => EnumMap k a_acXD -> Maybe ((k, a_acXD), EnumMap k a_acXD)
+ Data.EnumMap.Strict: maxViewWithKey :: Enum k => EnumMap k a_acAF -> Maybe ((k, a_acAF), EnumMap k a_acAF)
- Data.EnumMap.Strict: member :: Enum k => k -> EnumMap k a_acsi -> Bool
+ Data.EnumMap.Strict: member :: Enum k => k -> EnumMap k a_ac5b -> Bool
- Data.EnumMap.Strict: mergeWithKey :: Enum k => (k -> a_aljz -> b_aljA -> Maybe c_aljB) -> (EnumMap k a_aljz -> EnumMap k c_aljB) -> (EnumMap k b_aljA -> EnumMap k c_aljB) -> EnumMap k a_aljz -> EnumMap k b_aljA -> EnumMap k c_aljB
+ Data.EnumMap.Strict: mergeWithKey :: Enum k => (k -> a_acfN -> b_acfO -> Maybe c_acfP) -> (EnumMap k a_acfN -> EnumMap k c_acfP) -> (EnumMap k b_acfO -> EnumMap k c_acfP) -> EnumMap k a_acfN -> EnumMap k b_acfO -> EnumMap k c_acfP
- Data.EnumMap.Strict: minView :: EnumMap k a_acWo -> Maybe (a_acWo, EnumMap k a_acWo)
+ Data.EnumMap.Strict: minView :: EnumMap k a_aczq -> Maybe (a_aczq, EnumMap k a_aczq)
- Data.EnumMap.Strict: minViewWithKey :: Enum k => EnumMap k a_acXa -> Maybe ((k, a_acXa), EnumMap k a_acXa)
+ Data.EnumMap.Strict: minViewWithKey :: Enum k => EnumMap k a_acAc -> Maybe ((k, a_acAc), EnumMap k a_acAc)
- Data.EnumMap.Strict: notMember :: Enum k => k -> EnumMap k a_acsC -> Bool
+ Data.EnumMap.Strict: notMember :: Enum k => k -> EnumMap k a_ac5v -> Bool
- Data.EnumMap.Strict: null :: EnumMap k a_acrL -> Bool
+ Data.EnumMap.Strict: null :: EnumMap k a_ac4D -> Bool
- Data.EnumMap.Strict: partition :: (a_acP2 -> Bool) -> EnumMap k a_acP2 -> (EnumMap k a_acP2, EnumMap k a_acP2)
+ Data.EnumMap.Strict: partition :: (a_acs2 -> Bool) -> EnumMap k a_acs2 -> (EnumMap k a_acs2, EnumMap k a_acs2)
- Data.EnumMap.Strict: partitionWithKey :: Enum k => (k -> a_acPo -> Bool) -> EnumMap k a_acPo -> (EnumMap k a_acPo, EnumMap k a_acPo)
+ Data.EnumMap.Strict: partitionWithKey :: Enum k => (k -> a_acso -> Bool) -> EnumMap k a_acso -> (EnumMap k a_acso, EnumMap k a_acso)
- Data.EnumMap.Strict: showTree :: Show a_acY6 => EnumMap k a_acY6 -> String
+ Data.EnumMap.Strict: showTree :: Show a_acB8 => EnumMap k a_acB8 -> String
- Data.EnumMap.Strict: showTreeWith :: Show a_acYp => Bool -> Bool -> EnumMap k a_acYp -> String
+ Data.EnumMap.Strict: showTreeWith :: Show a_acBr => Bool -> Bool -> EnumMap k a_acBr -> String
- Data.EnumMap.Strict: singleton :: Enum k => k -> a_alcu -> EnumMap k a_alcu
+ Data.EnumMap.Strict: singleton :: Enum k => k -> a_ac8y -> EnumMap k a_ac8y
- Data.EnumMap.Strict: size :: EnumMap k a_acs1 -> Int
+ Data.EnumMap.Strict: size :: EnumMap k a -> Int
- Data.EnumMap.Strict: split :: Enum k => k -> EnumMap k a_acRb -> (EnumMap k a_acRb, EnumMap k a_acRb)
+ Data.EnumMap.Strict: split :: Enum k => k -> EnumMap k a_acud -> (EnumMap k a_acud, EnumMap k a_acud)
- Data.EnumMap.Strict: splitLookup :: Enum k => k -> EnumMap k a_acRA -> (EnumMap k a_acRA, Maybe a_acRA, EnumMap k a_acRA)
+ Data.EnumMap.Strict: splitLookup :: Enum k => k -> EnumMap k a_acuC -> (EnumMap k a_acuC, Maybe a_acuC, EnumMap k a_acuC)
- Data.EnumMap.Strict: toAscList :: Enum k => EnumMap k a_a56G -> [(k, a_a56G)]
+ Data.EnumMap.Strict: toAscList :: Enum k => EnumMap k a_acp8 -> [(k, a_acp8)]
- Data.EnumMap.Strict: toDescList :: Enum k => EnumMap k a_acMw -> [(k, a_acMw)]
+ Data.EnumMap.Strict: toDescList :: Enum k => EnumMap k a_acpw -> [(k, a_acpw)]
- Data.EnumMap.Strict: toList :: Enum k => EnumMap k a_acKA -> [(k, a_acKA)]
+ Data.EnumMap.Strict: toList :: Enum k => EnumMap k a_acnz -> [(k, a_acnz)]
- Data.EnumMap.Strict: traverseWithKey :: (Enum k, Applicative t_acDM) => (k -> a_acDL -> t_acDM b_acDN) -> EnumMap k a_acDL -> t_acDM (EnumMap k b_acDN)
+ Data.EnumMap.Strict: traverseWithKey :: (Enum k, Applicative t_acgK) => (k -> a_acgJ -> t_acgK b_acgL) -> EnumMap k a_acgJ -> t_acgK (EnumMap k b_acgL)
- Data.EnumMap.Strict: union :: EnumMap k a_a4fw -> EnumMap k a_a4fw -> EnumMap k a_a4fw
+ Data.EnumMap.Strict: union :: EnumMap k a_accG -> EnumMap k a_accG -> EnumMap k a_accG
- Data.EnumMap.Strict: unionWith :: (a_algN -> a_algN -> a_algN) -> EnumMap k a_algN -> EnumMap k a_algN -> EnumMap k a_algN
+ Data.EnumMap.Strict: unionWith :: (a_accW -> a_accW -> a_accW) -> EnumMap k a_accW -> EnumMap k a_accW -> EnumMap k a_accW
- Data.EnumMap.Strict: unionWithKey :: Enum k => (k -> a_alh3 -> a_alh3 -> a_alh3) -> EnumMap k a_alh3 -> EnumMap k a_alh3 -> EnumMap k a_alh3
+ Data.EnumMap.Strict: unionWithKey :: Enum k => (k -> a_acdc -> a_acdc -> a_acdc) -> EnumMap k a_acdc -> EnumMap k a_acdc -> EnumMap k a_acdc
- Data.EnumMap.Strict: unions :: [EnumMap k a_a4fx] -> EnumMap k a_a4fx
+ Data.EnumMap.Strict: unions :: [EnumMap k a_acdv] -> EnumMap k a_acdv
- Data.EnumMap.Strict: unionsWith :: (a_alhB -> a_alhB -> a_alhB) -> [EnumMap k a_alhB] -> EnumMap k a_alhB
+ Data.EnumMap.Strict: unionsWith :: (a_acdL -> a_acdL -> a_acdL) -> [EnumMap k a_acdL] -> EnumMap k a_acdL
- Data.EnumMap.Strict: update :: Enum k => (a_alf7 -> Maybe a_alf7) -> k -> EnumMap k a_alf7 -> EnumMap k a_alf7
+ Data.EnumMap.Strict: update :: Enum k => (a_acbe -> Maybe a_acbe) -> k -> EnumMap k a_acbe -> EnumMap k a_acbe
- Data.EnumMap.Strict: updateLookupWithKey :: Enum k => (k -> a_alfL -> Maybe a_alfL) -> k -> EnumMap k a_alfL -> (Maybe a_alfL, EnumMap k a_alfL)
+ Data.EnumMap.Strict: updateLookupWithKey :: Enum k => (k -> a_acbS -> Maybe a_acbS) -> k -> EnumMap k a_acbS -> (Maybe a_acbS, EnumMap k a_acbS)
- Data.EnumMap.Strict: updateMax :: (a_alBv -> Maybe a_alBv) -> EnumMap k a_alBv -> EnumMap k a_alBv
+ Data.EnumMap.Strict: updateMax :: (a_acyy -> Maybe a_acyy) -> EnumMap k a_acyy -> EnumMap k a_acyy
- Data.EnumMap.Strict: updateMaxWithKey :: Enum k => (k -> a_alC4 -> Maybe a_alC4) -> EnumMap k a_alC4 -> EnumMap k a_alC4
+ Data.EnumMap.Strict: updateMaxWithKey :: Enum k => (k -> a_acz7 -> Maybe a_acz7) -> EnumMap k a_acz7 -> EnumMap k a_acz7
- Data.EnumMap.Strict: updateMin :: (a_alBf -> Maybe a_alBf) -> EnumMap k a_alBf -> EnumMap k a_alBf
+ Data.EnumMap.Strict: updateMin :: (a_acyi -> Maybe a_acyi) -> EnumMap k a_acyi -> EnumMap k a_acyi
- Data.EnumMap.Strict: updateMinWithKey :: Enum k => (k -> a_alBL -> Maybe a_alBL) -> EnumMap k a_alBL -> EnumMap k a_alBL
+ Data.EnumMap.Strict: updateMinWithKey :: Enum k => (k -> a_acyO -> Maybe a_acyO) -> EnumMap k a_acyO -> EnumMap k a_acyO
- Data.EnumMap.Strict: updateWithKey :: Enum k => (k -> a_alfq -> Maybe a_alfq) -> k -> EnumMap k a_alfq -> EnumMap k a_alfq
+ Data.EnumMap.Strict: updateWithKey :: Enum k => (k -> a_acbx -> Maybe a_acbx) -> k -> EnumMap k a_acbx -> EnumMap k a_acbx
Files
- Data/EnumMap/Base.hs +0/−19
- Data/EnumMap/Lazy.hs +3/−24
- Data/EnumMap/Strict.hs +1/−18
- Data/EnumMapSetWrapper.hs +59/−28
- Data/EnumSet.hs +88/−8
- Data/EnumSet/Base.hs +0/−85
- enummapset-th.cabal +9/−7
- include/map.inc +69/−19
− Data/EnumMap/Base.hs
@@ -1,19 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE Trustworthy #-}-{-# OPTIONS_GHC -fno-warn-unused-imports #-}-{-# OPTIONS_HADDOCK not-home #-}--module Data.EnumMap.Base- ( EnumMap (..)- , module Data.EnumMap.Base- ) where--import Prelude ()-import Data.IntMap.Lazy--import Data.EnumMapSetWrapper--#include "map.inc"-
Data/EnumMap/Lazy.hs view
@@ -1,24 +1,3 @@-{-# LANGUAGE Safe #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}---- | Documentation: <http://hackage.haskell.org/packages/archive/containers/latest/doc/html/Data-IntMap-Lazy.html>-module Data.EnumMap.Lazy- ( module Data.EnumMap.Base- ) where--import Prelude-import Text.ParserCombinators.ReadPrec-import Text.Read--import Data.EnumMap.Base (EnumMap)-import Data.EnumMap.Base hiding (EnumMap (EnumMap))--instance (Enum k, Show k, Show a) => Show (EnumMap k a) where- showsPrec p m = showParen (p > 10) $- showString "fromList " . shows (toList m)--instance (Enum k, Read k, Read a) => Read (EnumMap k a) where- readPrec = parens . prec 10 $ do- Ident "fromList" <- lexP- fromList `fmap` readPrec-+{-# LANGUAGE CPP #-}+#define STRICT Lazy+#include "map.inc"
Data/EnumMap/Strict.hs view
@@ -1,20 +1,3 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE Trustworthy #-}-{-# OPTIONS_GHC -fno-warn-unused-imports #-}---- | Documentation: <http://hackage.haskell.org/packages/archive/containers/latest/doc/html/Data-IntMap-Strict.html>-module Data.EnumMap.Strict- ( EnumMap- , module Data.EnumMap.Strict- ) where--import Prelude ()-import Data.IntMap.Strict--import Data.EnumMapSetWrapper-import Data.EnumMap.Lazy ({-instance Show, Read-})-+#define STRICT Strict #include "map.inc"-
Data/EnumMapSetWrapper.hs view
@@ -1,8 +1,4 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveFoldable #-}-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE DeriveTraversable #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE Unsafe #-} {-# LANGUAGE ViewPatterns #-}@@ -35,28 +31,32 @@ -} -module Data.EnumMapSetWrapper (EnumMap (..), EnumSet (..), w, w') where+module Data.EnumMapSetWrapper (w, w') where import Prelude import Control.Applicative import Control.Arrow import Data.List (nub)-import Data.IntSet (IntSet, Key)-import Data.IntMap (IntMap)+import Data.IntSet (IntSet)+import Data.IntMap (IntMap, Key)+#if !MIN_VERSION_containers(0,5,1)+import qualified Data.IntSet as IntSet+import qualified Data.IntMap as IntMap+#endif import Language.Haskell.TH.Syntax -import Control.DeepSeq-import Data.Foldable-import Data.Traversable-import Data.Typeable-import Data.Data-import Data.Monoid+enumMap, enumSet :: Name+enumMap = mkName "EnumMap"+enumSet = mkName "EnumSet" -newtype EnumMap k v = EnumMap { unEnumMap :: IntMap v } deriving- (Eq, Ord, Monoid, Functor, Foldable, Traversable, Typeable, Data, NFData)+enumMapT :: Name -> Type -> Type+enumMapT k v = ConT enumMap `AppT` VarT k `AppT` v+enumSetT :: Name -> Type+enumSetT k = ConT enumSet `AppT` VarT k -newtype EnumSet k = EnumSet { unEnumSet :: IntSet } deriving- (Eq, Ord, Monoid, Typeable, Data, NFData)+unEnumMapE, unEnumSetE :: Exp+unEnumMapE = VarE (mkName "unEnumMap")+unEnumSetE = VarE (mkName "unEnumSet") ------------------------------------------------------------------------ @@ -65,6 +65,9 @@ o :: Exp -> Exp -> Exp o = flip UInfixE (VarE '(.)) +arrT :: Type -> Type -> Type+arrT a b = ArrowT `AppT` a `AppT` b+ -- | @pre f ≃ (. f)@ pre :: Exp -> Exp pre f = InfixE Nothing (VarE '(.)) (Just (ParensE f))@@ -90,18 +93,22 @@ ForallT tvs cxt t -> (wrap, [], ForallT tvs (nub $ cxt' ++ cxt) t') where (wrap, cxt', t') = pos k t - ArrowT `AppT` a `AppT` b -> (wrap, cxt, ArrowT `AppT` a' `AppT` b') where+ ArrowT `AppT` a `AppT` b -> (wrap, cxt, a' `arrT` b') where (a'unwrap, a'cxt, a') = neg ki a (b'wrap, b'cxt, b') = pos ko b cxt = nub (a'cxt ++ b'cxt) wrap = post b'wrap `o` pre a'unwrap +#if MIN_VERSION_containers(0,5,1) ConT ((==) ''Key -> True) ->+#else+ ConT ((||) <$> (==) ''Key <*> (==) ''Int -> True) ->+#endif (VarE 'toEnum, [ClassP ''Enum [VarT k]], VarT k) ConT ((==) ''IntMap -> True) `AppT` v ->- (ConE 'EnumMap, [], ConT ''EnumMap `AppT` VarT k `AppT` v)+ (ConE enumMap, [], enumMapT k v) ConT ((==) ''IntSet -> True) ->- (ConE 'EnumSet, [], ConT ''EnumSet `AppT` VarT k)+ (ConE enumSet, [], enumSetT k) ConT ((==) ''Maybe -> True) `AppT` a -> (VarE 'fmap `AppE` wrap, cxt, ConT ''Maybe `AppT` a') where (wrap, cxt, a') = pos k a@@ -135,18 +142,22 @@ neg :: Name -> Type -> (Exp, Cxt, Type) neg k typ = case typ of- ArrowT `AppT` a `AppT` b -> (unwrap, cxt, ArrowT `AppT` a' `AppT` b') where+ ArrowT `AppT` a `AppT` b -> (unwrap, cxt, a' `arrT` b') where (a'wrap, a'cxt, a') = pos ki a (b'unwrap, b'cxt, b') = neg ko b cxt = nub (a'cxt ++ b'cxt) unwrap = post b'unwrap `o` pre a'wrap +#if MIN_VERSION_containers(0,5,1) ConT ((==) ''Key -> True) ->+#else+ ConT ((||) <$> (==) ''Key <*> (==) ''Int -> True) ->+#endif (VarE 'fromEnum, [ClassP ''Enum [VarT k]], VarT k) ConT ((==) ''IntMap -> True) `AppT` v ->- (VarE 'unEnumMap, [], ConT ''EnumMap `AppT` VarT k `AppT` v)+ (unEnumMapE, [], enumMapT k v) ConT ((==) ''IntSet -> True) ->- (VarE 'unEnumSet, [], ConT ''EnumSet `AppT` VarT k)+ (unEnumSetE, [], enumSetT k) TupleT 2 `AppT` a `AppT` b -> (unwrap, cxt, TupleT 2 `AppT` a' `AppT` b') where@@ -186,15 +197,35 @@ w, w' :: Name -> Q [Dec] (w, w') = (wrap True, wrap False) where wrap :: Bool -> Name -> Q [Dec]+#if !MIN_VERSION_containers(0,5,1)+ wrap _ name | name == 'IntMap.size = do+ let size = mkName "size"+ let a = mkName "a"+ let t' = ForallT [PlainTV ki, PlainTV a] [] $+ enumMapT ki (VarT a) `arrT` ConT ''Int+ let body = NormalB (VarE name `o` unEnumMapE)+ return [ inlineD size, SigD size t', ValD (VarP size) body [] ]+ wrap _ name | name == 'IntSet.size = do+ let size = mkName "size"+ let t' = ForallT [PlainTV ki] [] $+ enumSetT ki `arrT` ConT ''Int+ let body = NormalB (VarE name `o` unEnumSetE)+ return [ inlineD size, SigD size t', ValD (VarP size) body [] ]+#endif wrap subst name@(mkName . nameBase -> base) = do- VarI _name (pos ko -> (e, cxt', typ')) _dec fixity <- reify name+ VarI _name (pos ko -> (e, cxt', typ')) _dec _fixity <- reify name let ks = map PlainTV [ki, ko] let t' = (if subst then substT ko ki else id) $ case typ' of ForallT tvs cxt t -> ForallT (ks ++ tvs) (nub $ cxt' ++ cxt) t t -> ForallT ks cxt' t let body = NormalB (e `AppE` VarE name)- return [ InfixD fixity base- , PragmaD (InlineP base Inline FunLike AllPhases)- , SigD base t', ValD (VarP base) body [] ]+ return [ inlineD base, SigD base t', ValD (VarP base) body [] ]++ inlineD base = PragmaD $ InlineP base+#if MIN_VERSION_template_haskell(2,8,0)+ Inline FunLike AllPhases+#else+ (InlineSpec True False Nothing)+#endif
Data/EnumSet.hs view
@@ -1,17 +1,97 @@-{-# LANGUAGE Safe #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE Trustworthy #-} -- | Documentation: <http://hackage.haskell.org/packages/archive/containers/latest/doc/html/Data-IntSet.html>-module Data.EnumSet- ( module Data.EnumSet.Base- ) where+module Data.EnumSet where -import Prelude+import Prelude (Eq, Ord, Enum, Functor (..), (.), ($), (>))+import Control.DeepSeq+import Data.IntSet+import Data.Typeable+import Data.Data+import Data.Monoid import Text.ParserCombinators.ReadPrec import Text.Read+import Text.Show -import Data.EnumSet.Base+import Data.EnumMapSetWrapper +newtype EnumSet k = EnumSet { unEnumSet :: IntSet } deriving+ (Eq, Ord, Monoid, Typeable, Data, NFData)++-- * Operators+w '(\\)++-- * Query+w 'null+w 'size+w 'member+w 'notMember+w 'lookupLT+w 'lookupGT+w 'lookupLE+w 'lookupGE+w 'isSubsetOf+w 'isProperSubsetOf++-- * Construction+w 'empty+w 'singleton+w 'insert+w 'delete++-- * Combine+w 'union+w 'unions+w 'difference+w 'intersection++-- * Filter+w 'filter+w 'partition+w 'split+w 'splitMember++-- * Map+w' 'map++-- * Folds+w 'foldr+w 'foldl++-- * Strict folds+w 'foldr'+w 'foldl'++-- * Min/Max+w 'findMin+w 'findMax+w 'deleteMin+w 'deleteMax+w 'deleteFindMin+w 'deleteFindMax+w 'maxView+w 'minView++-- * Conversion: List+w 'elems+w 'toList+w 'fromList++-- * Conversion: Ordered list+w 'toAscList+w 'toDescList+w 'fromAscList+w 'fromDistinctAscList++-- * Debugging+w 'showTree+w 'showTreeWith++------------------------------------------------------------------------+ instance (Enum k, Show k) => Show (EnumSet k) where showsPrec p s = showParen (p > 10) $ showString "fromList " . shows (toList s)@@ -19,5 +99,5 @@ instance (Enum k, Read k) => Read (EnumSet k) where readPrec = parens . prec 10 $ do Ident "fromList" <- lexP- fromList `fmap` readPrec+ fmap fromList readPrec
− Data/EnumSet/Base.hs
@@ -1,85 +0,0 @@-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE Trustworthy #-}-{-# OPTIONS_GHC -fno-warn-unused-imports #-}-{-# OPTIONS_HADDOCK not-home #-}--module Data.EnumSet.Base- ( EnumSet (..)- , module Data.EnumSet.Base- ) where--import Prelude ()-import Data.IntSet--import Data.EnumMapSetWrapper---- Operators-w '(\\)---- Query-w 'null-w 'size-w 'member-w 'notMember-w 'lookupLT-w 'lookupGT-w 'lookupLE-w 'lookupGE-w 'isSubsetOf-w 'isProperSubsetOf---- Construction-w 'empty-w 'singleton-w 'insert-w 'delete---- Combine-w 'union-w 'unions-w 'difference-w 'intersection---- Filter-w 'filter-w 'partition-w 'split-w 'splitMember---- Map-w' 'map---- Folds-w 'foldr-w 'foldl---- Strict folds-w 'foldr'-w 'foldl'---- Min/Max-w 'findMin-w 'findMax-w 'deleteMin-w 'deleteMax-w 'deleteFindMin-w 'deleteFindMax-w 'maxView-w 'minView---- Conversion: List-w 'elems-w 'toList-w 'fromList---- Conversion: Ordered list-w 'toAscList-w 'toDescList-w 'fromAscList-w 'fromDistinctAscList---- Debugging-w 'showTree-w 'showTreeWith-
enummapset-th.cabal view
@@ -1,5 +1,5 @@ name: enummapset-th-version: 0.5.1.0+version: 0.6.0.0 synopsis: TH-generated EnumSet/EnumMap wrappers around IntSet/IntMap. description: This package wraps @IntSet@ and @IntMap@ from @containers@, and provides@@ -10,12 +10,16 @@ The boilerplate is generated using Template Haskell, so unlike @enummapset@ it's easier to maintain and keep up-to-date with @containers@. On the downside, it's less portable.+ .+ Note that "Data.EnumMap.Lazy" and "Data.EnumMap.Strict" provide distinct+ newtype wrappers, and their respective 'Functor' instances behave as+ expected, unlike that of @IntMap@ which is alway lazy. homepage: https://github.com/liyang/enummapset-th license: BSD3 license-file: LICENSE author: Liyang HU maintainer: enummapset-th@liyang.hu-copyright: © 2012 Liyang HU+copyright: © 2013 Liyang HU category: Data build-type: Simple cabal-version: >= 1.8@@ -28,18 +32,16 @@ library exposed-modules:- Data.EnumMap.Base Data.EnumMap.Lazy Data.EnumMap.Strict Data.EnumSet- Data.EnumSet.Base other-modules: Data.EnumMapSetWrapper build-depends:- base >= 4.6 && < 5,+ base >= 4.5 && < 5, deepseq >= 1.3,- containers >= 0.5.1.0 && < 0.6,- template-haskell >= 2.8+ containers >= 0.5 && < 0.6,+ template-haskell >= 2.7 include-dirs: include ghc-options: -Wall
include/map.inc view
@@ -1,8 +1,40 @@--- Operators+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE Trustworthy #-}++-- | Documentation: <http://hackage.haskell.org/packages/archive/containers/latest/doc/html/Data-IntMap-STRICT.html>+module Data.EnumMap.STRICT where++import Prelude (Eq, Ord, Enum, Functor (..), (.), ($), (>), const)+import Control.DeepSeq+import Data.Data+import Data.Foldable (Foldable)+import Data.IntMap.STRICT+import Data.Monoid+import Data.Traversable+import Text.ParserCombinators.ReadPrec+import Text.Read+import Text.Show++import Data.EnumMapSetWrapper+import Data.EnumSet (EnumSet (..))++infixr 1 `EnumMap`+newtype EnumMap k v = EnumMap { unEnumMap :: IntMap v } deriving+ (Eq, Ord, Monoid, Typeable, Data, NFData)++------------------------------------------------------------------------++-- * Operators w '(!) w '(\\) --- Query+-- * Query w 'null w 'size w 'member@@ -14,17 +46,17 @@ w 'lookupLE w 'lookupGE --- Construction+-- * Construction w 'empty w 'singleton --- Insertion+-- * Insertion w 'insert w 'insertWith w 'insertWithKey w 'insertLookupWithKey --- Delete/Update+-- * Delete/Update w 'delete w 'adjust w 'adjustWithKey@@ -33,27 +65,27 @@ w 'updateLookupWithKey w 'alter --- Combine: Union+-- * Combine: Union w 'union w 'unionWith w 'unionWithKey w 'unions w 'unionsWith --- Combine: Difference+-- * Combine: Difference w 'difference w 'differenceWith w 'differenceWithKey --- Combine: Intersection+-- * Combine: Intersection w 'intersection w 'intersectionWith w 'intersectionWithKey --- Combine: Universal combining function+-- * Combine: Universal combining function w 'mergeWithKey --- Traversal: Map+-- * Traversal: Map w 'map w 'mapWithKey w 'traverseWithKey@@ -64,32 +96,32 @@ w' 'mapKeysWith w' 'mapKeysMonotonic --- Traversal: Folds+-- * Traversal: Folds w 'foldr w 'foldl w 'foldrWithKey w 'foldlWithKey --- Traversal: Strict folds+-- * Traversal: Strict folds w 'foldr' w 'foldl' w 'foldrWithKey' w 'foldlWithKey' --- Conversion+-- * Conversion w 'elems w 'keys w 'assocs w 'keysSet w 'fromSet --- Conversion: Lists+-- * Conversion: Lists w 'toList w 'fromList w 'fromListWith w 'fromListWithKey --- Conversion: Ordered lists+-- * Conversion: Ordered lists w 'toAscList w 'toDescList w 'fromAscList@@ -97,7 +129,7 @@ w 'fromAscListWithKey w 'fromDistinctAscList --- Filter+-- * Filter w 'filter w 'filterWithKey w 'partition@@ -109,13 +141,13 @@ w 'split w 'splitLookup --- Submap+-- * Submap w 'isSubmapOf w 'isSubmapOfBy w 'isProperSubmapOf w 'isProperSubmapOfBy --- Min/Max+-- * Min/Max w 'findMin w 'findMax w 'deleteMin@@ -131,9 +163,27 @@ w 'minViewWithKey w 'maxViewWithKey --- Debugging+-- * Debugging w 'showTree w 'showTreeWith++------------------------------------------------------------------------++instance Functor (EnumMap k) where+ {-# INLINE fmap #-}+ fmap = map++deriving instance Foldable (EnumMap k)+deriving instance Traversable (EnumMap k)++instance (Enum k, Show k, Show a) => Show (EnumMap k a) where+ showsPrec p m = showParen (p > 10) $+ showString "fromList " . shows (toList m)++instance (Enum k, Read k, Read a) => Read (EnumMap k a) where+ readPrec = parens . prec 10 $ do+ Ident "fromList" <- lexP+ fromList `fmap` readPrec -- vim: ft=haskell: