-- 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.5.4

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.TH
type RepInfo = (Q Type, Q Exp, Q Exp)

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

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.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.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)