Data.IntMap.BinTree.Strict

Documentation

moduleName :: String

error' :: String -> a

type Key = Int

type IntMap v = Tree v

data Tree v

Constructors

Empty

Node !Key !v !(Tree v) !(Tree v)

Lt !Key !v !(Tree v)

Gt !Key !v !(Tree v)

Leaf !Key !v

Instances

Functor Tree

Foldable Tree

Traversable Tree

Eq v => Eq (Tree v)

Show v => Show (Tree v)

Binary v => Binary (Tree v)

NFData v => NFData (Tree v)

Typeable (* -> *) Tree

traverseWithKey :: Applicative t => (Key -> a -> t b) -> Tree a -> t (Tree b)

mkNode :: Key -> v -> Tree v -> Tree v -> Tree v

unNode :: Tree v -> (Key, v, Tree v, Tree v)

split' :: Key -> Tree v -> (Maybe v, Tree v, Tree v)

join' :: Maybe (Key, v) -> Tree v -> Tree v -> Tree v

lookup :: Key -> Tree v -> Maybe v

insertWith :: (v -> v -> v) -> Key -> v -> Tree v -> Tree v

delete :: Key -> Tree v -> Tree v

find :: Key -> Tree v -> v

findWithDefault :: v -> Key -> Tree v -> v

member :: Key -> Tree v -> Bool

notMember :: Key -> Tree v -> Bool

insert :: Key -> v -> Tree v -> Tree v

empty :: Tree v

null :: Tree v -> Bool

size :: Tree v -> Int

sizeWithLimit :: Int -> Tree v -> Maybe Int

retuns the size of a tree or Nothing if size t > limit

limits the computation time to O(limit), not O(size)

union :: Tree v -> Tree v -> Tree v

unionWith :: (v -> v -> v) -> Tree v -> Tree v -> Tree v

unionWithKey' :: (Key -> v -> v -> v) -> Tree v -> Tree v -> Tree v

unionsWith :: (v -> v -> v) -> [Tree v] -> Tree v

difference :: Tree a -> Tree b -> Tree a

differenceWith :: (a -> b -> Maybe a) -> Tree a -> Tree b -> Tree a

differenceWithKey' :: (Key -> a -> b -> Maybe a) -> Tree a -> Tree b -> Tree a

intersection :: Tree a -> Tree b -> Tree a

intersectionWith :: (a -> b -> c) -> Tree a -> Tree b -> Tree c

intersectionWithKey' :: (Key -> a -> b -> c) -> Tree a -> Tree b -> Tree c

equal :: Eq v => Tree v -> Tree v -> Bool

map :: (a -> b) -> Tree a -> Tree b

mapWithKey :: (Key -> a -> b) -> Tree a -> Tree b

filter :: (a -> Bool) -> Tree a -> Tree a

filterWithKey :: (Key -> a -> Bool) -> Tree a -> Tree a

foldr :: (a -> b -> b) -> b -> Tree a -> b

foldr' :: (a -> b -> b) -> b -> Tree a -> b

foldrWithKey :: (Key -> a -> b -> b) -> b -> Tree a -> b

foldrWithKey' :: (Key -> a -> b -> b) -> b -> Tree a -> b

foldl :: (b -> a -> b) -> b -> Tree a -> b

foldl' :: (b -> a -> b) -> b -> Tree a -> b

foldlWithKey :: (b -> Key -> a -> b) -> b -> Tree a -> b

foldlWithKey' :: (b -> Key -> a -> b) -> b -> Tree a -> b

fromList :: [(Key, v)] -> Tree v

fromSet :: (Key -> v) -> IntSet -> Tree v

fromAscList :: [(Key, v)] -> Tree v

toTr :: Int -> Tree v -> [(Key, v)] -> Tree v

scan :: Int -> [(Key, v)] -> (Tree v, [(Key, v)])

toAscList :: Tree v -> [(Key, v)]

toList :: Tree v -> [(Key, v)]

assocs :: Tree v -> [(Key, v)]

elems :: Tree v -> [v]

keys :: Tree v -> [Key]

minView :: Tree v -> Maybe (v, Tree v)

minViewWithKey :: Tree v -> Maybe ((Key, v), Tree v)

maxView :: Tree v -> Maybe (v, Tree v)

maxViewWithKey :: Tree v -> Maybe ((Key, v), Tree v)

first :: (a -> c) -> (a, b) -> (c, b)

unionWithKey :: (Key -> v -> v -> v) -> Tree v -> Tree v -> Tree v

intersectionWithKey :: (Key -> a -> b -> c) -> Tree a -> Tree b -> Tree c

differenceWithKey :: (Key -> a -> b -> Maybe a) -> Tree a -> Tree b -> Tree a