TrieMap 0.5.4 → 0.6.0
raw patch · 6 files changed
+20/−41 lines, 6 filesPVP ok
version bump matches the API change (PVP)
API changes (from Hackage documentation)
- Data.TrieMap: instance (TKey k) => Monoid (TMap k a)
- Data.TrieMap.Class: instance (TKey k) => Foldable (TMap k)
- Data.TrieMap.Class: instance (TKey k) => Functor (TMap k)
- Data.TrieMap.Class: instance (TKey k) => Traversable (TMap k)
- Data.TrieMap.Modifiers: instance (Eq a) => Eq (Ordered a)
- Data.TrieMap.Modifiers: instance (Eq k) => Eq (Rev k)
- Data.TrieMap.Modifiers: instance (Ord a) => Ord (Ordered a)
- Data.TrieMap.Modifiers: instance (Ord k) => Ord (Rev k)
- Data.TrieSet: instance (TKey a) => Eq (TSet a)
- Data.TrieSet: instance (TKey a) => Monoid (TSet a)
+ Data.TrieMap: instance TKey k => Monoid (TMap k a)
+ Data.TrieMap.Class: instance TKey k => Foldable (TMap k)
+ Data.TrieMap.Class: instance TKey k => Functor (TMap k)
+ Data.TrieMap.Class: instance TKey k => Traversable (TMap k)
+ Data.TrieMap.Modifiers: instance Eq a => Eq (Ordered a)
+ Data.TrieMap.Modifiers: instance Eq k => Eq (Rev k)
+ Data.TrieMap.Modifiers: instance Ord a => Ord (Ordered a)
+ Data.TrieMap.Modifiers: instance Ord k => Ord (Rev k)
+ Data.TrieMap.Representation: instance Repr a[aiIn] => Repr (IntMap a[aiIn])
+ Data.TrieMap.Representation: instance ReprT IntMap
+ Data.TrieSet: instance TKey a => Eq (TSet a)
+ Data.TrieSet: instance TKey a => Monoid (TSet a)
- Data.TrieMap: (!) :: (TKey k) => TMap k a -> k -> a
+ Data.TrieMap: (!) :: TKey k => TMap k a -> k -> a
- Data.TrieMap: (\\) :: (TKey k) => TMap k a -> TMap k b -> TMap k a
+ Data.TrieMap: (\\) :: TKey k => TMap k a -> TMap k b -> TMap k a
- Data.TrieMap: adjust :: (TKey k) => (a -> a) -> k -> TMap k a -> TMap k a
+ Data.TrieMap: adjust :: TKey k => (a -> a) -> k -> TMap k a -> TMap k a
- Data.TrieMap: adjustWithKey :: (TKey k) => (k -> a -> a) -> k -> TMap k a -> TMap k a
+ Data.TrieMap: adjustWithKey :: TKey k => (k -> a -> a) -> k -> TMap k a -> TMap k a
- Data.TrieMap: alter :: (TKey k) => (Maybe a -> Maybe a) -> k -> TMap k a -> TMap k a
+ Data.TrieMap: alter :: TKey k => (Maybe a -> Maybe a) -> k -> TMap k a -> TMap k a
- Data.TrieMap: assocs :: (TKey k) => TMap k a -> [(k, a)]
+ Data.TrieMap: assocs :: TKey k => TMap k a -> [(k, a)]
- Data.TrieMap: delete :: (TKey k) => k -> TMap k a -> TMap k a
+ Data.TrieMap: delete :: TKey k => k -> TMap k a -> TMap k a
- Data.TrieMap: deleteFindMax :: (TKey k) => TMap k a -> ((k, a), TMap k a)
+ Data.TrieMap: deleteFindMax :: TKey k => TMap k a -> ((k, a), TMap k a)
- Data.TrieMap: deleteFindMin :: (TKey k) => TMap k a -> ((k, a), TMap k a)
+ Data.TrieMap: deleteFindMin :: TKey k => TMap k a -> ((k, a), TMap k a)
- Data.TrieMap: deleteMax :: (TKey k) => TMap k a -> TMap k a
+ Data.TrieMap: deleteMax :: TKey k => TMap k a -> TMap k a
- Data.TrieMap: deleteMin :: (TKey k) => TMap k a -> TMap k a
+ Data.TrieMap: deleteMin :: TKey k => TMap k a -> TMap k a
- Data.TrieMap: difference :: (TKey k) => TMap k a -> TMap k b -> TMap k a
+ Data.TrieMap: difference :: TKey k => TMap k a -> TMap k b -> TMap k a
- Data.TrieMap: differenceWith :: (TKey k) => (a -> b -> Maybe a) -> TMap k a -> TMap k b -> TMap k a
+ Data.TrieMap: differenceWith :: TKey k => (a -> b -> Maybe a) -> TMap k a -> TMap k b -> TMap k a
- Data.TrieMap: differenceWithKey :: (TKey k) => (k -> a -> b -> Maybe a) -> TMap k a -> TMap k b -> TMap k a
+ Data.TrieMap: differenceWithKey :: TKey k => (k -> a -> b -> Maybe a) -> TMap k a -> TMap k b -> TMap k a
- Data.TrieMap: elems :: (TKey k) => TMap k a -> [a]
+ Data.TrieMap: elems :: TKey k => TMap k a -> [a]
- Data.TrieMap: empty :: (TKey k) => TMap k a
+ Data.TrieMap: empty :: TKey k => TMap k a
- Data.TrieMap: filter :: (TKey k) => (a -> Bool) -> TMap k a -> TMap k a
+ Data.TrieMap: filter :: TKey k => (a -> Bool) -> TMap k a -> TMap k a
- Data.TrieMap: filterWithKey :: (TKey k) => (k -> a -> Bool) -> TMap k a -> TMap k a
+ Data.TrieMap: filterWithKey :: TKey k => (k -> a -> Bool) -> TMap k a -> TMap k a
- Data.TrieMap: findMax :: (TKey k) => TMap k a -> (k, a)
+ Data.TrieMap: findMax :: TKey k => TMap k a -> (k, a)
- Data.TrieMap: findMin :: (TKey k) => TMap k a -> (k, a)
+ Data.TrieMap: findMin :: TKey k => TMap k a -> (k, a)
- Data.TrieMap: findWithDefault :: (TKey k) => a -> k -> TMap k a -> a
+ Data.TrieMap: findWithDefault :: TKey k => a -> k -> TMap k a -> a
- Data.TrieMap: fold :: (TKey k) => (a -> b -> b) -> b -> TMap k a -> b
+ Data.TrieMap: fold :: TKey k => (a -> b -> b) -> b -> TMap k a -> b
- Data.TrieMap: foldWithKey :: (TKey k) => (k -> a -> b -> b) -> b -> TMap k a -> b
+ Data.TrieMap: foldWithKey :: TKey k => (k -> a -> b -> b) -> b -> TMap k a -> b
- Data.TrieMap: foldlWithKey :: (TKey k) => (b -> k -> a -> b) -> b -> TMap k a -> b
+ Data.TrieMap: foldlWithKey :: TKey k => (b -> k -> a -> b) -> b -> TMap k a -> b
- Data.TrieMap: foldrWithKey :: (TKey k) => (k -> a -> b -> b) -> b -> TMap k a -> b
+ Data.TrieMap: foldrWithKey :: TKey k => (k -> a -> b -> b) -> b -> TMap k a -> b
- Data.TrieMap: fromAscList :: (TKey k) => [(k, a)] -> TMap k a
+ Data.TrieMap: fromAscList :: TKey k => [(k, a)] -> TMap k a
- Data.TrieMap: fromAscListWith :: (TKey k) => (a -> a -> a) -> [(k, a)] -> TMap k a
+ Data.TrieMap: fromAscListWith :: TKey k => (a -> a -> a) -> [(k, a)] -> TMap k a
- Data.TrieMap: fromAscListWithKey :: (TKey k) => (k -> a -> a -> a) -> [(k, a)] -> TMap k a
+ Data.TrieMap: fromAscListWithKey :: TKey k => (k -> a -> a -> a) -> [(k, a)] -> TMap k a
- Data.TrieMap: fromDistinctAscList :: (TKey k) => [(k, a)] -> TMap k a
+ Data.TrieMap: fromDistinctAscList :: TKey k => [(k, a)] -> TMap k a
- Data.TrieMap: fromList :: (TKey k) => [(k, a)] -> TMap k a
+ Data.TrieMap: fromList :: TKey k => [(k, a)] -> TMap k a
- Data.TrieMap: fromListWith :: (TKey k) => (a -> a -> a) -> [(k, a)] -> TMap k a
+ Data.TrieMap: fromListWith :: TKey k => (a -> a -> a) -> [(k, a)] -> TMap k a
- Data.TrieMap: fromListWithKey :: (TKey k) => (k -> a -> a -> a) -> [(k, a)] -> TMap k a
+ Data.TrieMap: fromListWithKey :: TKey k => (k -> a -> a -> a) -> [(k, a)] -> TMap k a
- Data.TrieMap: insert :: (TKey k) => k -> a -> TMap k a -> TMap k a
+ Data.TrieMap: insert :: TKey k => k -> a -> TMap k a -> TMap k a
- Data.TrieMap: insertWith :: (TKey k) => (a -> a -> a) -> k -> a -> TMap k a -> TMap k a
+ Data.TrieMap: insertWith :: TKey k => (a -> a -> a) -> k -> a -> TMap k a -> TMap k a
- Data.TrieMap: insertWithKey :: (TKey k) => (k -> a -> a -> a) -> k -> a -> TMap k a -> TMap k a
+ Data.TrieMap: insertWithKey :: TKey k => (k -> a -> a -> a) -> k -> a -> TMap k a -> TMap k a
- Data.TrieMap: intersection :: (TKey k) => TMap k a -> TMap k b -> TMap k a
+ Data.TrieMap: intersection :: TKey k => TMap k a -> TMap k b -> TMap k a
- Data.TrieMap: intersectionMaybeWith :: (TKey k) => (a -> b -> Maybe c) -> TMap k a -> TMap k b -> TMap k c
+ Data.TrieMap: intersectionMaybeWith :: TKey k => (a -> b -> Maybe c) -> TMap k a -> TMap k b -> TMap k c
- Data.TrieMap: intersectionMaybeWithKey :: (TKey k) => (k -> a -> b -> Maybe c) -> TMap k a -> TMap k b -> TMap k c
+ Data.TrieMap: intersectionMaybeWithKey :: TKey k => (k -> a -> b -> Maybe c) -> TMap k a -> TMap k b -> TMap k c
- Data.TrieMap: intersectionWith :: (TKey k) => (a -> b -> c) -> TMap k a -> TMap k b -> TMap k c
+ Data.TrieMap: intersectionWith :: TKey k => (a -> b -> c) -> TMap k a -> TMap k b -> TMap k c
- Data.TrieMap: intersectionWithKey :: (TKey k) => (k -> a -> b -> c) -> TMap k a -> TMap k b -> TMap k c
+ Data.TrieMap: intersectionWithKey :: TKey k => (k -> a -> b -> c) -> TMap k a -> TMap k b -> TMap k c
- Data.TrieMap: isSubmapOfBy :: (TKey k) => (a -> b -> Bool) -> TMap k a -> TMap k b -> Bool
+ Data.TrieMap: isSubmapOfBy :: TKey k => (a -> b -> Bool) -> TMap k a -> TMap k b -> Bool
- Data.TrieMap: keys :: (TKey k) => TMap k a -> [k]
+ Data.TrieMap: keys :: TKey k => TMap k a -> [k]
- Data.TrieMap: lookup :: (TKey k) => k -> TMap k a -> Maybe a
+ Data.TrieMap: lookup :: TKey k => k -> TMap k a -> Maybe a
- Data.TrieMap: lookupAt :: (TKey k) => Int -> TMap k a -> Maybe (Int, k, a)
+ Data.TrieMap: lookupAt :: TKey k => Int -> TMap k a -> Maybe (Int, k, a)
- Data.TrieMap: lookupIndex :: (TKey k) => k -> TMap k a -> Maybe Int
+ Data.TrieMap: lookupIndex :: TKey k => k -> TMap k a -> Maybe Int
- Data.TrieMap: lookupWithIndex :: (TKey k) => k -> TMap k a -> Maybe (Int, k, a)
+ Data.TrieMap: lookupWithIndex :: TKey k => k -> TMap k a -> Maybe (Int, k, a)
- Data.TrieMap: map :: (TKey k) => (a -> b) -> TMap k a -> TMap k b
+ Data.TrieMap: map :: TKey k => (a -> b) -> TMap k a -> TMap k b
- Data.TrieMap: mapEither :: (TKey k) => (a -> Either b c) -> TMap k a -> (TMap k b, TMap k c)
+ Data.TrieMap: mapEither :: TKey k => (a -> Either b c) -> TMap k a -> (TMap k b, TMap k c)
- Data.TrieMap: mapEitherWithKey :: (TKey k) => (k -> a -> Either b c) -> TMap k a -> (TMap k b, TMap k c)
+ Data.TrieMap: mapEitherWithKey :: TKey k => (k -> a -> Either b c) -> TMap k a -> (TMap k b, TMap k c)
- Data.TrieMap: mapMaybe :: (TKey k) => (a -> Maybe b) -> TMap k a -> TMap k b
+ Data.TrieMap: mapMaybe :: TKey k => (a -> Maybe b) -> TMap k a -> TMap k b
- Data.TrieMap: mapMaybeWithKey :: (TKey k) => (k -> a -> Maybe b) -> TMap k a -> TMap k b
+ Data.TrieMap: mapMaybeWithKey :: TKey k => (k -> a -> Maybe b) -> TMap k a -> TMap k b
- Data.TrieMap: mapWithKey :: (TKey k) => (k -> a -> b) -> TMap k a -> TMap k b
+ Data.TrieMap: mapWithKey :: TKey k => (k -> a -> b) -> TMap k a -> TMap k b
- Data.TrieMap: maxView :: (TKey k) => TMap k a -> Maybe (a, TMap k a)
+ Data.TrieMap: maxView :: TKey k => TMap k a -> Maybe (a, TMap k a)
- Data.TrieMap: maxViewWithKey :: (TKey k) => TMap k a -> Maybe ((k, a), TMap k a)
+ Data.TrieMap: maxViewWithKey :: TKey k => TMap k a -> Maybe ((k, a), TMap k a)
- Data.TrieMap: member :: (TKey k) => k -> TMap k a -> Bool
+ Data.TrieMap: member :: TKey k => k -> TMap k a -> Bool
- Data.TrieMap: minView :: (TKey k) => TMap k a -> Maybe (a, TMap k a)
+ Data.TrieMap: minView :: TKey k => TMap k a -> Maybe (a, TMap k a)
- Data.TrieMap: minViewWithKey :: (TKey k) => TMap k a -> Maybe ((k, a), TMap k a)
+ Data.TrieMap: minViewWithKey :: TKey k => TMap k a -> Maybe ((k, a), TMap k a)
- Data.TrieMap: neighborhood :: (TKey k) => k -> TMap k a -> (Maybe (Int, k, a), Maybe (Int, k, a), Maybe (Int, k, a))
+ Data.TrieMap: neighborhood :: TKey k => k -> TMap k a -> (Maybe (Int, k, a), Maybe (Int, k, a), Maybe (Int, k, a))
- Data.TrieMap: neighborhoodAt :: (TKey k) => Int -> TMap k a -> (Maybe (Int, k, a), Maybe (Int, k, a), Maybe (Int, k, a))
+ Data.TrieMap: neighborhoodAt :: TKey k => Int -> TMap k a -> (Maybe (Int, k, a), Maybe (Int, k, a), Maybe (Int, k, a))
- Data.TrieMap: notMember :: (TKey k) => k -> TMap k a -> Bool
+ Data.TrieMap: notMember :: TKey k => k -> TMap k a -> Bool
- Data.TrieMap: null :: (TKey k) => TMap k a -> Bool
+ Data.TrieMap: null :: TKey k => TMap k a -> Bool
- Data.TrieMap: partition :: (TKey k) => (a -> Bool) -> TMap k a -> (TMap k a, TMap k a)
+ Data.TrieMap: partition :: TKey k => (a -> Bool) -> TMap k a -> (TMap k a, TMap k a)
- Data.TrieMap: partitionWithKey :: (TKey k) => (k -> a -> Bool) -> TMap k a -> (TMap k a, TMap k a)
+ Data.TrieMap: partitionWithKey :: TKey k => (k -> a -> Bool) -> TMap k a -> (TMap k a, TMap k a)
- Data.TrieMap: predecessor :: (TKey k) => k -> TMap k a -> Maybe (Int, k, a)
+ Data.TrieMap: predecessor :: TKey k => k -> TMap k a -> Maybe (Int, k, a)
- Data.TrieMap: predecessorAt :: (TKey k) => Int -> TMap k a -> Maybe (Int, k, a)
+ Data.TrieMap: predecessorAt :: TKey k => Int -> TMap k a -> Maybe (Int, k, a)
- Data.TrieMap: singleton :: (TKey k) => k -> a -> TMap k a
+ Data.TrieMap: singleton :: TKey k => k -> a -> TMap k a
- Data.TrieMap: size :: (TKey k) => TMap k a -> Int
+ Data.TrieMap: size :: TKey k => TMap k a -> Int
- Data.TrieMap: split :: (TKey k) => k -> TMap k a -> (TMap k a, TMap k a)
+ Data.TrieMap: split :: TKey k => k -> TMap k a -> (TMap k a, TMap k a)
- Data.TrieMap: splitLookup :: (TKey k) => k -> TMap k a -> (TMap k a, Maybe a, TMap k a)
+ Data.TrieMap: splitLookup :: TKey k => k -> TMap k a -> (TMap k a, Maybe a, TMap k a)
- Data.TrieMap: successor :: (TKey k) => k -> TMap k a -> Maybe (Int, k, a)
+ Data.TrieMap: successor :: TKey k => k -> TMap k a -> Maybe (Int, k, a)
- Data.TrieMap: successorAt :: (TKey k) => Int -> TMap k a -> Maybe (Int, k, a)
+ Data.TrieMap: successorAt :: TKey k => Int -> TMap k a -> Maybe (Int, k, a)
- Data.TrieMap: union :: (TKey k) => TMap k a -> TMap k a -> TMap k a
+ Data.TrieMap: union :: TKey k => TMap k a -> TMap k a -> TMap k a
- Data.TrieMap: unionMaybeWith :: (TKey k) => (a -> a -> Maybe a) -> TMap k a -> TMap k a -> TMap k a
+ Data.TrieMap: unionMaybeWith :: TKey k => (a -> a -> Maybe a) -> TMap k a -> TMap k a -> TMap k a
- Data.TrieMap: unionMaybeWithKey :: (TKey k) => (k -> a -> a -> Maybe a) -> TMap k a -> TMap k a -> TMap k a
+ Data.TrieMap: unionMaybeWithKey :: TKey k => (k -> a -> a -> Maybe a) -> TMap k a -> TMap k a -> TMap k a
- Data.TrieMap: unionWith :: (TKey k) => (a -> a -> a) -> TMap k a -> TMap k a -> TMap k a
+ Data.TrieMap: unionWith :: TKey k => (a -> a -> a) -> TMap k a -> TMap k a -> TMap k a
- Data.TrieMap: unionWithKey :: (TKey k) => (k -> a -> a -> a) -> TMap k a -> TMap k a -> TMap k a
+ Data.TrieMap: unionWithKey :: TKey k => (k -> a -> a -> a) -> TMap k a -> TMap k a -> TMap k a
- Data.TrieMap: update :: (TKey k) => (a -> Maybe a) -> k -> TMap k a -> TMap k a
+ Data.TrieMap: update :: TKey k => (a -> Maybe a) -> k -> TMap k a -> TMap k a
- Data.TrieMap: updateMax :: (TKey k) => (a -> Maybe a) -> TMap k a -> TMap k a
+ Data.TrieMap: updateMax :: TKey k => (a -> Maybe a) -> TMap k a -> TMap k a
- Data.TrieMap: updateMaxWithKey :: (TKey k) => (k -> a -> Maybe a) -> TMap k a -> TMap k a
+ Data.TrieMap: updateMaxWithKey :: TKey k => (k -> a -> Maybe a) -> TMap k a -> TMap k a
- Data.TrieMap: updateMin :: (TKey k) => (a -> Maybe a) -> TMap k a -> TMap k a
+ Data.TrieMap: updateMin :: TKey k => (a -> Maybe a) -> TMap k a -> TMap k a
- Data.TrieMap: updateMinWithKey :: (TKey k) => (k -> a -> Maybe a) -> TMap k a -> TMap k a
+ Data.TrieMap: updateMinWithKey :: TKey k => (k -> a -> Maybe a) -> TMap k a -> TMap k a
- Data.TrieMap: updateWithKey :: (TKey k) => (k -> a -> Maybe a) -> k -> TMap k a -> TMap k a
+ Data.TrieMap: updateWithKey :: TKey k => (k -> a -> Maybe a) -> k -> TMap k a -> TMap k a
- Data.TrieMap.Class: class (Ord k) => TrieKey k m | m -> k
+ Data.TrieMap.Class: class Ord k => TrieKey k m | m -> k
- Data.TrieMap.MultiRec: class (HEq phi f) => HOrd phi f
+ Data.TrieMap.MultiRec: class HEq phi f => HOrd phi f
- Data.TrieMap.MultiRec: class (HOrd0 phi r) => HTrieKey phi :: (* -> *) r :: (* -> *) m | m -> phi r
+ Data.TrieMap.MultiRec: class HOrd0 phi r => HTrieKey phi :: (* -> *) r :: (* -> *) m | m -> phi r
- Data.TrieMap.MultiRec: class (HOrd phi f) => HTrieKeyT phi :: (* -> *) f :: ((* -> *) -> * -> *) m | m -> phi f
+ Data.TrieMap.MultiRec: class HOrd phi f => HTrieKeyT phi :: (* -> *) f :: ((* -> *) -> * -> *) m | m -> phi f
- Data.TrieMap.MultiRec: compareH :: (HOrd phi f) => (forall ix. phi ix -> Comparator (r ix)) -> phi ix -> Comparator (f r ix)
+ Data.TrieMap.MultiRec: compareH :: HOrd phi f => (forall ix. phi ix -> Comparator (r ix)) -> phi ix -> Comparator (f r ix)
- Data.TrieMap.Regular: class (EqT f) => OrdT f
+ Data.TrieMap.Regular: class EqT f => OrdT f
- Data.TrieMap.Regular: class (OrdT f) => TrieKeyT f :: (* -> *) m :: (* -> * -> *) | m -> f, f -> m
+ Data.TrieMap.Regular: class OrdT f => TrieKeyT f :: (* -> *) m :: (* -> * -> *) | m -> f, f -> m
- Data.TrieMap.Regular: compareT0 :: (OrdT f) => Comparator a -> Comparator (f a)
+ Data.TrieMap.Regular: compareT0 :: OrdT f => Comparator a -> Comparator (f a)
- Data.TrieMap.Regular: eqT0 :: (EqT f) => (a -> a -> Bool) -> f a -> f a -> Bool
+ Data.TrieMap.Regular: eqT0 :: EqT f => (a -> a -> Bool) -> f a -> f a -> Bool
- Data.TrieMap.Regular: from :: (Regular a) => a -> PF a a
+ Data.TrieMap.Regular: from :: Regular a => a -> PF a a
- Data.TrieMap.Regular: to :: (Regular a) => PF a a -> a
+ Data.TrieMap.Regular: to :: Regular a => PF a a -> a
- Data.TrieMap.Representation: class (Functor (RepT f)) => ReprT f
+ Data.TrieMap.Representation: class Functor (RepT f) => ReprT f
- Data.TrieMap.Representation: fromRep :: (Repr a) => Rep a -> a
+ Data.TrieMap.Representation: fromRep :: Repr a => Rep a -> a
- Data.TrieMap.Representation: fromRepT :: (ReprT f) => RepT f a -> f a
+ Data.TrieMap.Representation: fromRepT :: ReprT f => RepT f a -> f a
- Data.TrieMap.Representation: fromRepTMap :: (ReprT f) => (b -> a) -> RepT f b -> f a
+ Data.TrieMap.Representation: fromRepTMap :: ReprT f => (b -> a) -> RepT f b -> f a
- Data.TrieMap.Representation: toRep :: (Repr a) => a -> Rep a
+ Data.TrieMap.Representation: toRep :: Repr a => a -> Rep a
- Data.TrieMap.Representation: toRepT :: (ReprT f) => f a -> RepT f a
+ Data.TrieMap.Representation: toRepT :: ReprT f => f a -> RepT f a
- Data.TrieMap.Representation: toRepTMap :: (ReprT f) => (a -> b) -> f a -> RepT f b
+ Data.TrieMap.Representation: toRepTMap :: ReprT f => (a -> b) -> f a -> RepT f b
- Data.TrieSet: (\\) :: (TKey a) => TSet a -> TSet a -> TSet a
+ Data.TrieSet: (\\) :: TKey a => TSet a -> TSet a -> TSet a
- Data.TrieSet: delete :: (TKey a) => a -> TSet a -> TSet a
+ Data.TrieSet: delete :: TKey a => a -> TSet a -> TSet a
- Data.TrieSet: deleteFindMax :: (TKey a) => TSet a -> (a, TSet a)
+ Data.TrieSet: deleteFindMax :: TKey a => TSet a -> (a, TSet a)
- Data.TrieSet: deleteFindMin :: (TKey a) => TSet a -> (a, TSet a)
+ Data.TrieSet: deleteFindMin :: TKey a => TSet a -> (a, TSet a)
- Data.TrieSet: deleteMax :: (TKey a) => TSet a -> TSet a
+ Data.TrieSet: deleteMax :: TKey a => TSet a -> TSet a
- Data.TrieSet: deleteMin :: (TKey a) => TSet a -> TSet a
+ Data.TrieSet: deleteMin :: TKey a => TSet a -> TSet a
- Data.TrieSet: difference :: (TKey a) => TSet a -> TSet a -> TSet a
+ Data.TrieSet: difference :: TKey a => TSet a -> TSet a -> TSet a
- Data.TrieSet: elems :: (TKey a) => TSet a -> [a]
+ Data.TrieSet: elems :: TKey a => TSet a -> [a]
- Data.TrieSet: empty :: (TKey a) => TSet a
+ Data.TrieSet: empty :: TKey a => TSet a
- Data.TrieSet: filter :: (TKey a) => (a -> Bool) -> TSet a -> TSet a
+ Data.TrieSet: filter :: TKey a => (a -> Bool) -> TSet a -> TSet a
- Data.TrieSet: findMax :: (TKey a) => TSet a -> a
+ Data.TrieSet: findMax :: TKey a => TSet a -> a
- Data.TrieSet: findMin :: (TKey a) => TSet a -> a
+ Data.TrieSet: findMin :: TKey a => TSet a -> a
- Data.TrieSet: fold :: (TKey a) => (a -> b -> b) -> b -> TSet a -> b
+ Data.TrieSet: fold :: TKey a => (a -> b -> b) -> b -> TSet a -> b
- Data.TrieSet: foldl :: (TKey b) => (a -> b -> a) -> a -> TSet b -> a
+ Data.TrieSet: foldl :: TKey b => (a -> b -> a) -> a -> TSet b -> a
- Data.TrieSet: foldr :: (TKey a) => (a -> b -> b) -> b -> TSet a -> b
+ Data.TrieSet: foldr :: TKey a => (a -> b -> b) -> b -> TSet a -> b
- Data.TrieSet: fromAscList :: (TKey a) => [a] -> TSet a
+ Data.TrieSet: fromAscList :: TKey a => [a] -> TSet a
- Data.TrieSet: fromDistinctAscList :: (TKey a) => [a] -> TSet a
+ Data.TrieSet: fromDistinctAscList :: TKey a => [a] -> TSet a
- Data.TrieSet: fromList :: (TKey a) => [a] -> TSet a
+ Data.TrieSet: fromList :: TKey a => [a] -> TSet a
- Data.TrieSet: insert :: (TKey a) => a -> TSet a -> TSet a
+ Data.TrieSet: insert :: TKey a => a -> TSet a -> TSet a
- Data.TrieSet: intersection :: (TKey a) => TSet a -> TSet a -> TSet a
+ Data.TrieSet: intersection :: TKey a => TSet a -> TSet a -> TSet a
- Data.TrieSet: isProperSubsetOf :: (TKey a) => TSet a -> TSet a -> Bool
+ Data.TrieSet: isProperSubsetOf :: TKey a => TSet a -> TSet a -> Bool
- Data.TrieSet: isSubsetOf :: (TKey a) => TSet a -> TSet a -> Bool
+ Data.TrieSet: isSubsetOf :: TKey a => TSet a -> TSet a -> Bool
- Data.TrieSet: maxView :: (TKey a) => TSet a -> Maybe (a, TSet a)
+ Data.TrieSet: maxView :: TKey a => TSet a -> Maybe (a, TSet a)
- Data.TrieSet: member :: (TKey a) => a -> TSet a -> Bool
+ Data.TrieSet: member :: TKey a => a -> TSet a -> Bool
- Data.TrieSet: minView :: (TKey a) => TSet a -> Maybe (a, TSet a)
+ Data.TrieSet: minView :: TKey a => TSet a -> Maybe (a, TSet a)
- Data.TrieSet: notMember :: (TKey a) => a -> TSet a -> Bool
+ Data.TrieSet: notMember :: TKey a => a -> TSet a -> Bool
- Data.TrieSet: null :: (TKey a) => TSet a -> Bool
+ Data.TrieSet: null :: TKey a => TSet a -> Bool
- Data.TrieSet: partition :: (TKey a) => (a -> Bool) -> TSet a -> (TSet a, TSet a)
+ Data.TrieSet: partition :: TKey a => (a -> Bool) -> TSet a -> (TSet a, TSet a)
- Data.TrieSet: singleton :: (TKey a) => a -> TSet a
+ Data.TrieSet: singleton :: TKey a => a -> TSet a
- Data.TrieSet: size :: (TKey a) => TSet a -> Int
+ Data.TrieSet: size :: TKey a => TSet a -> Int
- Data.TrieSet: split :: (TKey a) => a -> TSet a -> (TSet a, TSet a)
+ Data.TrieSet: split :: TKey a => a -> TSet a -> (TSet a, TSet a)
- Data.TrieSet: splitMember :: (TKey a) => a -> TSet a -> (TSet a, Bool, TSet a)
+ Data.TrieSet: splitMember :: TKey a => a -> TSet a -> (TSet a, Bool, TSet a)
- Data.TrieSet: symmetricDifference :: (TKey a) => TSet a -> TSet a -> TSet a
+ Data.TrieSet: symmetricDifference :: TKey a => TSet a -> TSet a -> TSet a
- Data.TrieSet: toAscList :: (TKey a) => TSet a -> [a]
+ Data.TrieSet: toAscList :: TKey a => TSet a -> [a]
- Data.TrieSet: toList :: (TKey a) => TSet a -> [a]
+ Data.TrieSet: toList :: TKey a => TSet a -> [a]
- Data.TrieSet: union :: (TKey a) => TSet a -> TSet a -> TSet a
+ Data.TrieSet: union :: TKey a => TSet a -> TSet a -> TSet a
Files
- Data/TrieMap/MultiRec/Ord.hs +1/−1
- Data/TrieMap/Regular/TH.hs +7/−28
- Data/TrieMap/Rep/Instances.hs +0/−4
- Data/TrieMap/Rep/TH.hs +3/−7
- Data/TrieMap/Representation.hs +8/−0
- TrieMap.cabal +1/−1
Data/TrieMap/MultiRec/Ord.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE FlexibleInstances, TypeOperators, MultiParamTypeClasses, Rank2Types #-}+{-# LANGUAGE FlexibleInstances, TypeOperators, MultiParamTypeClasses, Rank2Types, GADTs #-} module Data.TrieMap.MultiRec.Ord where
Data/TrieMap/Regular/TH.hs view
@@ -9,34 +9,13 @@ deriveM :: Q [Dec] -> Q [Dec] deriveM decs = do iT@(InstanceD cxt inst _:_) <- decs- (InstanceD _ _ myDecs:_) <- [d|- instance (TrieKeyT f m, Ord (f k), TrieKey k mm) => TrieKey (f k) (m k) where- emptyM = emptyT- nullM = nullT- lookupM = lookupT- lookupIxM = lookupIxT- assocAtM = assocAtT--- updateAtM = updateAtT-- alterM = alterT- alterLookupM = alterLookupT- traverseWithKeyM = traverseWithKeyT- foldWithKeyM = foldWithKeyT- foldlWithKeyM = foldlWithKeyT- mapEitherM = mapEitherT- splitLookupM = splitLookupT- unionM = unionT- isectM = isectT- diffM = diffT- extractM = extractT--- extractMinM = extractMinT--- extractMaxM = extractMaxT--- alterMinM = alterMinT--- alterMaxM = alterMaxT- isSubmapM = isSubmapT- fromListM = fromListT- fromAscListM = fromAscListT- fromDistAscListM = fromDistAscListT |]+ let myDecs = zipWith (\ m t -> ValD (VarP m) (NormalB (VarE t)) [])+ ['emptyM, 'nullM, 'lookupM, 'lookupIxM, 'assocAtM, 'alterM, 'alterLookupM, 'traverseWithKeyM,+ 'foldWithKeyM, 'foldlWithKeyM, 'mapEitherM, 'splitLookupM, 'unionM, 'isectM, 'diffM, 'extractM,+ 'isSubmapM, 'fromListM, 'fromAscListM, 'fromDistAscListM]+ ['emptyT, 'nullT, 'lookupT, 'lookupIxT, 'assocAtT, 'alterT, 'alterLookupT, 'traverseWithKeyT,+ 'foldWithKeyT, 'foldlWithKeyT, 'mapEitherT, 'splitLookupT, 'unionT, 'isectT, 'diffT, 'extractT,+ 'isSubmapT, 'fromListT, 'fromAscListT, 'fromDistAscListT] k <- mkVar "k" let triekey = ConT ''TrieKey let triemap = ConT ''TrieMap
Data/TrieMap/Rep/Instances.hs view
@@ -251,10 +251,6 @@ toRep = toRep . ISet.toList fromRep = ISet.fromDistinctAscList . fromRep -$(genRepT [d|- instance ReprT IMap.IntMap where- toRepTMap f m = List [(toRep k, f a) | (k, a) <- IMap.assocs m]- fromRepTMap f (List xs) = IMap.fromDistinctAscList [(fromRep k, f a) | (k, a) <- xs] |]) type instance RepT Seq.Seq = [] type instance Rep (Seq.Seq a) = [Rep a]
Data/TrieMap/Rep/TH.hs view
@@ -31,14 +31,10 @@ genRepT :: Q [Dec] -> Q [Dec] genRepT decs = do iT@(InstanceD cxt (reprt `AppT` f) _:_) <- decs- (InstanceD _ _ myDecs:_) <- [d|- instance (ReprT f, Repr a) => Repr (f a) where- toRep = toRepTMap toRep- fromRep = fromRepTMap fromRep- |]+ let myDecs = [ValD (VarP 'toRep) (NormalB (AppE (VarE 'toRepTMap) (VarE 'toRep))) [],+ ValD (VarP 'fromRep) (NormalB (AppE (VarE 'fromRepTMap) (VarE 'fromRep))) []] a <- mkVar "a"- repr <- conT ''Repr- return (InstanceD (repr `AppT` a:cxt) (repr `AppT` (f `AppT` a)) myDecs :iT)+ return (InstanceD (ClassP ''Repr [a]:cxt) (ConT ''Repr `AppT` (f `AppT` a)) myDecs :iT) (~>) :: Type -> Type -> Type a ~> b = AppT (AppT ArrowT a) b
Data/TrieMap/Representation.hs view
@@ -1,6 +1,14 @@+{-# LANGUAGE TemplateHaskell, QuasiQuotes #-} module Data.TrieMap.Representation (Repr(..), ReprT(..), Rep, RepT) where import Data.TrieMap.Rep import Data.TrieMap.Rep.Instances+import Data.TrieMap.Rep.TH import Data.TrieMap.Regular.Rep+import Data.TrieMap.Regular.Base+import qualified Data.IntMap as IMap +$(genRepT [d|+ instance ReprT IMap.IntMap where+ toRepTMap f m = List [(toRep k, f a) | (k, a) <- IMap.assocs m]+ fromRepTMap f (List xs) = IMap.fromDistinctAscList [(fromRep k, f a) | (k, a) <- xs] |])
TrieMap.cabal view
@@ -1,5 +1,5 @@ name: TrieMap-version: 0.5.4+version: 0.6.0 tested-with: GHC category: Algorithms synopsis: Automatic type inference of generalized tries.