-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Automatic type inference of generalized tries.
--   
--   Builds on the multirec library to create a system capable of automatic
--   or simple generalized trie type inference.
@package TrieMap
@version 0.6.0

module Data.TrieMap.Modifiers
newtype Ordered a
Ord :: a -> Ordered a
unOrd :: Ordered a -> a
newtype Rev k
Rev :: k -> Rev k
getRev :: Rev k -> k
instance Eq k => Eq (Rev k)
instance Eq a => Eq (Ordered a)
instance Ord a => Ord (Ordered a)
instance Functor Rev
instance Functor Ordered
instance Ord k => Ord (Rev k)

module Data.TrieMap.Representation
class Repr a
toRep :: Repr a => a -> Rep a
fromRep :: Repr a => Rep a -> a
class Functor (RepT f) => ReprT f
toRepT :: ReprT f => f a -> RepT f a
fromRepT :: ReprT f => RepT f a -> f a
toRepTMap :: ReprT f => (a -> b) -> f a -> RepT f b
fromRepTMap :: ReprT f => (b -> a) -> RepT f b -> f a
instance ReprT IntMap
instance Repr a[aiIn] => Repr (IntMap a[aiIn])

module Data.TrieMap.Representation.TH
type RepInfo = (Q Type, Q Exp, Q Exp)

module Data.TrieMap.Regular
class OrdT f => TrieKeyT f :: (* -> *) m :: (* -> * -> *) | m -> f, f -> m
newtype K0 a r
K0 :: a -> K0 a r
unK0 :: K0 a r -> a
newtype I0 r
I0 :: r -> I0 r
unI0 :: I0 r -> r
data U0 r
U0 :: U0 r
data (:*:) f g r
(:*:) :: f r -> g r -> :*: f g r
data (:+:) f g r
L :: (f r) -> :+: f g r
R :: (g r) -> :+: f g r
newtype L f r
List :: [f r] -> L f r
newtype O f g r
O :: (f (g r)) -> O f g r
newtype Reg r
Reg :: r -> Reg r
unReg :: Reg r -> r
newtype Fix f
In :: f (Fix f) -> Fix f
out :: Fix f -> f (Fix f)
class Regular a
from :: Regular a => a -> PF a a
to :: Regular a => PF a a -> a
from' :: (Functor (PF a), Regular a) => Reg a -> PF a (Reg a)
to' :: (Functor (PF a), Regular a) => PF a (Reg a) -> Reg a
partEithers :: [((f :+: g) r, a)] -> ([(f r, a)], [(g r, a)])
class EqT f
eqT0 :: EqT f => (a -> a -> Bool) -> f a -> f a -> Bool
type Comparator a = a -> a -> Ordering
class EqT f => OrdT f
compareT0 :: OrdT f => Comparator a -> Comparator (f a)

module Data.TrieMap.MultiRec
class HOrd phi f => HTrieKeyT phi :: (* -> *) f :: ((* -> *) -> * -> *) m | m -> phi f
class HOrd0 phi r => HTrieKey phi :: (* -> *) r :: (* -> *) m | m -> phi r
newtype Family phi :: (* -> *) ix
F :: ix -> Family ix
unF :: Family ix -> ix
class HEq phi f => HOrd phi f
compareH :: HOrd phi f => (forall ix. phi ix -> Comparator (r ix)) -> phi ix -> Comparator (f r ix)

module Data.TrieMap.Class
newtype TMap k a
TMap :: TrieMap (Rep k) (Elem a) -> TMap k a
getTMap :: TMap k a -> TrieMap (Rep k) (Elem a)
newtype TSet a
TSet :: (TMap a ()) -> TSet a
class (Repr k, TrieKey (Rep k) (TrieMap (Rep k))) => TKey k
class (ReprT f, TrieKeyT (RepT f) (TrieMapT (RepT f))) => TKeyT f
class Ord k => TrieKey k m | m -> k
instance TKey k => Traversable (TMap k)
instance TKey k => Foldable (TMap k)
instance TKey k => Functor (TMap k)
instance (ReprT f, TrieKeyT (RepT f) (TrieMapT (RepT f))) => TKeyT f
instance (Repr k, TrieKey (Rep k) (TrieMap (Rep k))) => TKey k

module Data.TrieMap
class (Repr k, TrieKey (Rep k) (TrieMap (Rep k))) => TKey k
data TMap k a
(!) :: TKey k => TMap k a -> k -> a
(\\) :: TKey k => TMap k a -> TMap k b -> TMap k a
null :: TKey k => TMap k a -> Bool
size :: TKey k => TMap k a -> Int
member :: TKey k => k -> TMap k a -> Bool
notMember :: TKey k => k -> TMap k a -> Bool
lookup :: TKey k => k -> TMap k a -> Maybe a
findWithDefault :: TKey k => a -> k -> TMap k a -> a
empty :: TKey k => TMap k a
singleton :: TKey k => k -> a -> TMap k a
insert :: TKey k => k -> a -> TMap k a -> TMap k a
insertWith :: TKey k => (a -> a -> a) -> k -> a -> TMap k a -> TMap k a
insertWithKey :: TKey k => (k -> a -> a -> a) -> k -> a -> TMap k a -> TMap k a
delete :: TKey k => k -> TMap k a -> TMap k a
adjust :: TKey k => (a -> a) -> k -> TMap k a -> TMap k a
adjustWithKey :: TKey k => (k -> a -> a) -> k -> TMap k a -> TMap k a
update :: TKey k => (a -> Maybe a) -> k -> TMap k a -> TMap k a
updateWithKey :: TKey k => (k -> a -> Maybe a) -> k -> TMap k a -> TMap k a
alter :: TKey k => (Maybe a -> Maybe a) -> k -> TMap k a -> TMap k a
union :: TKey k => TMap k a -> TMap k a -> TMap k a
unionWith :: TKey k => (a -> a -> a) -> TMap k a -> TMap k a -> TMap k a
unionWithKey :: TKey k => (k -> a -> a -> a) -> TMap k a -> TMap k a -> TMap k a
unionMaybeWith :: TKey k => (a -> a -> Maybe a) -> TMap k a -> TMap k a -> TMap k a
unionMaybeWithKey :: TKey k => (k -> a -> a -> Maybe a) -> TMap k a -> TMap k a -> TMap k a
difference :: TKey k => TMap k a -> TMap k b -> TMap k a
differenceWith :: TKey k => (a -> b -> Maybe a) -> TMap k a -> TMap k b -> TMap k a
differenceWithKey :: TKey k => (k -> a -> b -> Maybe a) -> TMap k a -> TMap k b -> TMap k a
intersection :: TKey k => TMap k a -> TMap k b -> TMap k a
intersectionWith :: TKey k => (a -> b -> c) -> TMap k a -> TMap k b -> TMap k c
intersectionWithKey :: TKey k => (k -> a -> b -> c) -> TMap k a -> TMap k b -> TMap k c
intersectionMaybeWith :: TKey k => (a -> b -> Maybe c) -> TMap k a -> TMap k b -> TMap k c
intersectionMaybeWithKey :: TKey k => (k -> a -> b -> Maybe c) -> TMap k a -> TMap k b -> TMap k c
map :: TKey k => (a -> b) -> TMap k a -> TMap k b
mapWithKey :: TKey k => (k -> a -> b) -> TMap k a -> TMap k b
mapKeys :: (TKey k, TKey k') => (k -> k') -> TMap k a -> TMap k' a
mapKeysWith :: (TKey k, TKey k') => (a -> a -> a) -> (k -> k') -> TMap k a -> TMap k' a
mapKeysMonotonic :: (TKey k, TKey k') => (k -> k') -> TMap k a -> TMap k' a
traverseWithKey :: (TKey k, Applicative f) => (k -> a -> f b) -> TMap k a -> f (TMap k b)
fold :: TKey k => (a -> b -> b) -> b -> TMap k a -> b
foldWithKey :: TKey k => (k -> a -> b -> b) -> b -> TMap k a -> b
foldrWithKey :: TKey k => (k -> a -> b -> b) -> b -> TMap k a -> b
foldlWithKey :: TKey k => (b -> k -> a -> b) -> b -> TMap k a -> b
elems :: TKey k => TMap k a -> [a]
keys :: TKey k => TMap k a -> [k]
assocs :: TKey k => TMap k a -> [(k, a)]
fromList :: TKey k => [(k, a)] -> TMap k a
fromListWith :: TKey k => (a -> a -> a) -> [(k, a)] -> TMap k a
fromListWithKey :: TKey k => (k -> a -> a -> a) -> [(k, a)] -> TMap k a
fromAscList :: TKey k => [(k, a)] -> TMap k a
fromAscListWith :: TKey k => (a -> a -> a) -> [(k, a)] -> TMap k a
fromAscListWithKey :: TKey k => (k -> a -> a -> a) -> [(k, a)] -> TMap k a
fromDistinctAscList :: TKey k => [(k, a)] -> TMap k a
filter :: TKey k => (a -> Bool) -> TMap k a -> TMap k a
filterWithKey :: TKey k => (k -> a -> Bool) -> TMap k a -> TMap k a
partition :: TKey k => (a -> Bool) -> TMap k a -> (TMap k a, TMap k a)
partitionWithKey :: TKey k => (k -> a -> Bool) -> TMap k a -> (TMap k a, TMap k a)
mapMaybe :: TKey k => (a -> Maybe b) -> TMap k a -> TMap k b
mapMaybeWithKey :: TKey k => (k -> a -> Maybe b) -> TMap k a -> TMap k b
mapEither :: TKey k => (a -> Either b c) -> TMap k a -> (TMap k b, TMap k c)
mapEitherWithKey :: TKey k => (k -> a -> Either b c) -> TMap k a -> (TMap k b, TMap k c)
split :: TKey k => k -> TMap k a -> (TMap k a, TMap k a)
splitLookup :: TKey k => k -> TMap k a -> (TMap k a, Maybe a, TMap k a)
isSubmapOf :: (TKey k, Eq a) => TMap k a -> TMap k a -> Bool
isSubmapOfBy :: TKey k => (a -> b -> Bool) -> TMap k a -> TMap k b -> Bool

-- | <tt><a>predecessor</a> k a</tt> returns the index, key, and value of
--   the immediate predecessor of <tt>k</tt> in the map. The predecessor is
--   the element with the largest key <tt>&lt; k</tt>.
predecessor :: TKey k => k -> TMap k a -> Maybe (Int, k, a)
lookupWithIndex :: TKey k => k -> TMap k a -> Maybe (Int, k, a)
successor :: TKey k => k -> TMap k a -> Maybe (Int, k, a)
neighborhood :: TKey k => k -> TMap k a -> (Maybe (Int, k, a), Maybe (Int, k, a), Maybe (Int, k, a))
lookupIndex :: TKey k => k -> TMap k a -> Maybe Int
predecessorAt :: TKey k => Int -> TMap k a -> Maybe (Int, k, a)
lookupAt :: TKey k => Int -> TMap k a -> Maybe (Int, k, a)
successorAt :: TKey k => Int -> TMap k a -> Maybe (Int, k, a)
neighborhoodAt :: TKey k => Int -> TMap k a -> (Maybe (Int, k, a), Maybe (Int, k, a), Maybe (Int, k, a))
findMin :: TKey k => TMap k a -> (k, a)
findMax :: TKey k => TMap k a -> (k, a)
deleteMin :: TKey k => TMap k a -> TMap k a
deleteMax :: TKey k => TMap k a -> TMap k a
deleteFindMin :: TKey k => TMap k a -> ((k, a), TMap k a)
deleteFindMax :: TKey k => TMap k a -> ((k, a), TMap k a)
updateMin :: TKey k => (a -> Maybe a) -> TMap k a -> TMap k a
updateMax :: TKey k => (a -> Maybe a) -> TMap k a -> TMap k a
updateMinWithKey :: TKey k => (k -> a -> Maybe a) -> TMap k a -> TMap k a
updateMaxWithKey :: TKey k => (k -> a -> Maybe a) -> TMap k a -> TMap k a
minView :: TKey k => TMap k a -> Maybe (a, TMap k a)
maxView :: TKey k => TMap k a -> Maybe (a, TMap k a)
minViewWithKey :: TKey k => TMap k a -> Maybe ((k, a), TMap k a)
maxViewWithKey :: TKey k => TMap k a -> Maybe ((k, a), TMap k a)
instance TKey k => Monoid (TMap k a)
instance (Ord k, TKey k, Ord a) => Ord (TMap k a)
instance (Eq k, TKey k, Eq a) => Eq (TMap k a)
instance (Show k, Show a, TKey k) => Show (TMap k a)

module Data.TrieSet
data TSet a
(\\) :: TKey a => TSet a -> TSet a -> TSet a
null :: TKey a => TSet a -> Bool
size :: TKey a => TSet a -> Int
member :: TKey a => a -> TSet a -> Bool
notMember :: TKey a => a -> TSet a -> Bool
isSubsetOf :: TKey a => TSet a -> TSet a -> Bool
isProperSubsetOf :: TKey a => TSet a -> TSet a -> Bool
empty :: TKey a => TSet a
singleton :: TKey a => a -> TSet a
insert :: TKey a => a -> TSet a -> TSet a
delete :: TKey a => a -> TSet a -> TSet a
union :: TKey a => TSet a -> TSet a -> TSet a
symmetricDifference :: TKey a => TSet a -> TSet a -> TSet a
intersection :: TKey a => TSet a -> TSet a -> TSet a
difference :: TKey a => TSet a -> TSet a -> TSet a
filter :: TKey a => (a -> Bool) -> TSet a -> TSet a
partition :: TKey a => (a -> Bool) -> TSet a -> (TSet a, TSet a)
split :: TKey a => a -> TSet a -> (TSet a, TSet a)
splitMember :: TKey a => a -> TSet a -> (TSet a, Bool, TSet a)
map :: (TKey a, TKey b) => (a -> b) -> TSet a -> TSet b
mapMonotonic :: (TKey a, TKey b) => (a -> b) -> TSet a -> TSet b
fold :: TKey a => (a -> b -> b) -> b -> TSet a -> b
foldl :: TKey b => (a -> b -> a) -> a -> TSet b -> a
foldr :: TKey a => (a -> b -> b) -> b -> TSet a -> b
findMin :: TKey a => TSet a -> a
findMax :: TKey a => TSet a -> a
deleteMin :: TKey a => TSet a -> TSet a
deleteMax :: TKey a => TSet a -> TSet a
deleteFindMin :: TKey a => TSet a -> (a, TSet a)
deleteFindMax :: TKey a => TSet a -> (a, TSet a)
minView :: TKey a => TSet a -> Maybe (a, TSet a)
maxView :: TKey a => TSet a -> Maybe (a, TSet a)
elems :: TKey a => TSet a -> [a]
toList :: TKey a => TSet a -> [a]
fromList :: TKey a => [a] -> TSet a
toAscList :: TKey a => TSet a -> [a]
fromAscList :: TKey a => [a] -> TSet a
fromDistinctAscList :: TKey a => [a] -> TSet a
instance TKey a => Monoid (TSet a)
instance (TKey a, Show a) => Show (TSet a)
instance (TKey a, Ord a) => Ord (TSet a)
instance TKey a => Eq (TSet a)