-- 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 1.0.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
newtype Key k
Key :: k -> Key k
getKey :: Key k -> k
instance Eq k => Eq (Rev k)
instance Eq a => Eq (Ordered a)
instance Ord a => Ord (Ordered a)
instance Repr k => Repr (Key k)
instance (Repr k, Ord (Rep k)) => Ord (Key k)
instance (Repr k, Eq (Rep k)) => Eq (Key k)
instance Functor Rev
instance Functor Ordered
instance Ord k => Ord (Rev k)

module Data.TrieMap.Representation.TH

-- | Given the name of a type constructor, automatically generates an
--   efficient <a>Repr</a> instance. <i>Warning</i>: Generalized tries do
--   not work for <a>infinitely complicated types,</a> for example, a
--   type-system construction of the natural numbers. In these cases, a
--   context reduction stack overflow will occur at compile time when you
--   use the <tt>TKey</tt> instance for that type.
genRepr :: Name -> Q [Dec]

-- | Given a type with an associated <a>Ord</a> instance, generates a
--   representation that will cause its <tt>TMap</tt> implementation to be
--   essentially equivalent to <a>Data.Map</a>.
genOrdRepr :: Name -> Q [Dec]

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)) => TKey k
class Ord k => TrieKey k where { data family TrieMap k :: * -> *; { sizeM s m = foldWithKeyM (\ _ a n -> s a + n) m 0 fromListM s f = foldr (uncurry (insertWithKeyM s f)) emptyM fromAscListM = fromListM fromDistAscListM s = fromAscListM s (const const) } }
instance TKey k => Traversable (TMap k)
instance TKey k => Foldable (TMap k)
instance TKey k => Functor (TMap k)
instance (Repr k, TrieKey (Rep k)) => TKey k

module Data.TrieMap.Representation
class Repr a where { type family Rep a; }
toRep :: Repr a => a -> Rep a
fromRep :: Repr a => Rep a -> a
instance Repr CDouble
instance Repr CFloat
instance Repr CTime
instance Repr CClock
instance Repr CULLong
instance Repr CLLong
instance Repr CULong
instance Repr CLong
instance Repr CUInt
instance Repr CUShort
instance Repr CShort
instance Repr CUChar
instance Repr CSChar
instance Repr CChar
instance Repr CInt
instance RealFloat a[ax80] => Repr (Complex a[ax80])
instance Repr (Maybe a[a5n0])
instance Integral a[ax6I] => Repr (Ratio a[ax6I])
instance Repr (Tree a[ax5T])
instance Repr Bool
instance Repr Double
instance Repr Float
instance (TKey k, Repr a) => Repr (TMap k a)

module Data.TrieMap
class (Repr k, TrieKey (Rep k)) => TKey k
data TMap k a

-- | Find the value at a key. Calls <a>error</a> when the element can not
--   be found.
(!) :: TKey k => TMap k a -> k -> a
(\\) :: TKey k => TMap k a -> TMap k b -> TMap k a

-- | Is the map empty?
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 the value at a key in the map.
--   
--   The function will return the corresponding value as <tt>(<a>Just</a>
--   value)</tt>, or <a>Nothing</a> if the key isn't in the map.
lookup :: TKey k => k -> TMap k a -> Maybe a

-- | The expression <tt>(<a>findWithDefault</a> def k map)</tt> returns the
--   value at key <tt>k</tt> or returns default value <tt>def</tt> when the
--   key is not in the map.
findWithDefault :: TKey k => a -> k -> TMap k a -> a

-- | The empty map.
empty :: TKey k => TMap k a

-- | A map with a single element.
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

-- | The expression <tt>(<a>alter</a> f k map)</tt> alters the value
--   <tt>x</tt> at <tt>k</tt>, or absence thereof. <a>alter</a> can be used
--   to insert, delete, or update a value in a <a>TMap</a>. In short:
--   <tt><a>lookup</a> k (<a>alter</a> f k m) = f (<a>lookup</a> k m)</tt>.
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
symmetricDifference :: TKey k => 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]
keysSet :: TKey k => TMap k a -> TSet 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
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)