Data.TrieMap

Map type

class (Repr k, TrieKey (Rep k) (TrieMap (Rep k))) => TKey k

Instances

(Repr k, TrieKey (Rep k) (TrieMap (Rep k))) => TKey k

data TMap k a

Instances

TKey k => Functor (TMap k)

TKey k => Foldable (TMap k)

TKey k => Traversable (TMap k)

TKey k => ReprT (TMap k)

(Eq k, TKey k, Eq a) => Eq (TMap k a)

(Ord k, TKey k, Ord a) => Ord (TMap k a)

(Show k, Show a, TKey k) => Show (TMap k a)

TKey k => Monoid (TMap k a)

Operators

(!) :: TKey k => TMap k a -> k -> a

(\\) :: TKey k => TMap k a -> TMap k b -> TMap k a

Query

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

Construction

empty :: TKey k => TMap k a

singleton :: TKey k => k -> a -> TMap k a

Insertion

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/Update

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

Combine

Union

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

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

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

Traversal

Map

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

Traverse

traverseWithKey :: (TKey k, Applicative f) => (k -> a -> f b) -> TMap k a -> f (TMap k b)

Fold

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

Conversion

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

Lists

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

Ordered lists

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

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)

Submap

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

Indexed

predecessor :: TKey k => k -> TMap k a -> Maybe (Int, k, a)

predecessor k a returns the index, key, and value of the immediate predecessor of k in the map. The predecessor is the element with the largest key < k.

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

Min/Max

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)