insert-ordered-containers-0.2.1.0: Associative containers retating insertion order for traversals.

Safe HaskellTrustworthy
LanguageHaskell2010

Data.HashMap.Strict.InsOrd

Contents

Description

InsOrdHashMap is like HashMap, but it folds and traverses in insertion order.

This module interface mimics Data.HashMap.Strict, with some additions.

Synopsis

Documentation

data InsOrdHashMap k v Source #

HashMap which tries it's best to remember insertion order of elements.

Instances

(Eq k, Hashable k) => FunctorWithIndex k (InsOrdHashMap k) Source # 

Methods

imap :: (k -> a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b #

imapped :: (Indexable k p, Settable f) => p a (f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) #

(Eq k, Hashable k) => FoldableWithIndex k (InsOrdHashMap k) Source # 

Methods

ifoldMap :: Monoid m => (k -> a -> m) -> InsOrdHashMap k a -> m #

ifolded :: (Indexable k p, Contravariant f, Applicative f) => p a (f a) -> InsOrdHashMap k a -> f (InsOrdHashMap k a) #

ifoldr :: (k -> a -> b -> b) -> b -> InsOrdHashMap k a -> b #

ifoldl :: (k -> b -> a -> b) -> b -> InsOrdHashMap k a -> b #

ifoldr' :: (k -> a -> b -> b) -> b -> InsOrdHashMap k a -> b #

ifoldl' :: (k -> b -> a -> b) -> b -> InsOrdHashMap k a -> b #

(Eq k, Hashable k) => TraversableWithIndex k (InsOrdHashMap k) Source # 

Methods

itraverse :: Applicative f => (k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) #

itraversed :: (Indexable k p, Applicative f) => p a (f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) #

Functor (InsOrdHashMap k) Source # 

Methods

fmap :: (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b #

(<$) :: a -> InsOrdHashMap k b -> InsOrdHashMap k a #

Foldable (InsOrdHashMap k) Source # 

Methods

fold :: Monoid m => InsOrdHashMap k m -> m #

foldMap :: Monoid m => (a -> m) -> InsOrdHashMap k a -> m #

foldr :: (a -> b -> b) -> b -> InsOrdHashMap k a -> b #

foldr' :: (a -> b -> b) -> b -> InsOrdHashMap k a -> b #

foldl :: (b -> a -> b) -> b -> InsOrdHashMap k a -> b #

foldl' :: (b -> a -> b) -> b -> InsOrdHashMap k a -> b #

foldr1 :: (a -> a -> a) -> InsOrdHashMap k a -> a #

foldl1 :: (a -> a -> a) -> InsOrdHashMap k a -> a #

toList :: InsOrdHashMap k a -> [a] #

null :: InsOrdHashMap k a -> Bool #

length :: InsOrdHashMap k a -> Int #

elem :: Eq a => a -> InsOrdHashMap k a -> Bool #

maximum :: Ord a => InsOrdHashMap k a -> a #

minimum :: Ord a => InsOrdHashMap k a -> a #

sum :: Num a => InsOrdHashMap k a -> a #

product :: Num a => InsOrdHashMap k a -> a #

Traversable (InsOrdHashMap k) Source # 

Methods

traverse :: Applicative f => (a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) #

sequenceA :: Applicative f => InsOrdHashMap k (f a) -> f (InsOrdHashMap k a) #

mapM :: Monad m => (a -> m b) -> InsOrdHashMap k a -> m (InsOrdHashMap k b) #

sequence :: Monad m => InsOrdHashMap k (m a) -> m (InsOrdHashMap k a) #

ToJSONKey k => ToJSON1 (InsOrdHashMap k) Source # 

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> InsOrdHashMap k a -> Value #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [InsOrdHashMap k a] -> Value #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> InsOrdHashMap k a -> Encoding #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [InsOrdHashMap k a] -> Encoding #

(Eq k, Hashable k, FromJSONKey k) => FromJSON1 (InsOrdHashMap k) Source # 

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (InsOrdHashMap k a) #

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [InsOrdHashMap k a] #

(Eq k, Hashable k) => Apply (InsOrdHashMap k) Source # 

Methods

(<.>) :: InsOrdHashMap k (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b #

(.>) :: InsOrdHashMap k a -> InsOrdHashMap k b -> InsOrdHashMap k b #

(<.) :: InsOrdHashMap k a -> InsOrdHashMap k b -> InsOrdHashMap k a #

(Eq k, Hashable k) => Bind (InsOrdHashMap k) Source # 

Methods

(>>-) :: InsOrdHashMap k a -> (a -> InsOrdHashMap k b) -> InsOrdHashMap k b #

join :: InsOrdHashMap k (InsOrdHashMap k a) -> InsOrdHashMap k a #

(Eq k, Hashable k) => IsList (InsOrdHashMap k v) Source # 

Associated Types

type Item (InsOrdHashMap k v) :: * #

(Eq k, Eq v) => Eq (InsOrdHashMap k v) Source # 

Methods

(==) :: InsOrdHashMap k v -> InsOrdHashMap k v -> Bool #

(/=) :: InsOrdHashMap k v -> InsOrdHashMap k v -> Bool #

(Hashable k, Eq k, Data v, Data k) => Data (InsOrdHashMap k v) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InsOrdHashMap k v -> c (InsOrdHashMap k v) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InsOrdHashMap k v) #

toConstr :: InsOrdHashMap k v -> Constr #

dataTypeOf :: InsOrdHashMap k v -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (InsOrdHashMap k v)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InsOrdHashMap k v)) #

gmapT :: (forall b. Data b => b -> b) -> InsOrdHashMap k v -> InsOrdHashMap k v #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r #

gmapQ :: (forall d. Data d => d -> u) -> InsOrdHashMap k v -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InsOrdHashMap k v -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InsOrdHashMap k v -> m (InsOrdHashMap k v) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InsOrdHashMap k v -> m (InsOrdHashMap k v) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InsOrdHashMap k v -> m (InsOrdHashMap k v) #

(Eq k, Hashable k, Read k, Read v) => Read (InsOrdHashMap k v) Source # 
(Show k, Show v) => Show (InsOrdHashMap k v) Source # 
(Eq k, Hashable k) => Semigroup (InsOrdHashMap k v) Source # 
(Eq k, Hashable k) => Monoid (InsOrdHashMap k v) Source # 
(Hashable k, Hashable v) => Hashable (InsOrdHashMap k v) Source #

hashWithSalt salt . toHashMap = hashWithSalt salt.

Methods

hashWithSalt :: Int -> InsOrdHashMap k v -> Int #

hash :: InsOrdHashMap k v -> Int #

(ToJSONKey k, ToJSON v) => ToJSON (InsOrdHashMap k v) Source # 
(Eq k, Hashable k, FromJSONKey k, FromJSON v) => FromJSON (InsOrdHashMap k v) Source # 
(Eq k, Hashable k) => Ixed (InsOrdHashMap k v) Source # 
(Eq k, Hashable k) => At (InsOrdHashMap k a) Source # 

Methods

at :: Index (InsOrdHashMap k a) -> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a))) #

type Item (InsOrdHashMap k v) Source # 
type Item (InsOrdHashMap k v) = (k, v)
type Index (InsOrdHashMap k v) Source # 
type Index (InsOrdHashMap k v) = k
type IxValue (InsOrdHashMap k v) Source # 
type IxValue (InsOrdHashMap k v) = v

Construction

singleton :: Hashable k => k -> v -> InsOrdHashMap k v Source #

Basic interface

member :: (Eq k, Hashable k) => k -> InsOrdHashMap k a -> Bool Source #

lookup :: (Eq k, Hashable k) => k -> InsOrdHashMap k v -> Maybe v Source #

lookupDefault Source #

Arguments

:: (Eq k, Hashable k) 
=> v

Default value to return.

-> k 
-> InsOrdHashMap k v 
-> v 

insert :: (Eq k, Hashable k) => k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

insertWith :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

delete :: (Eq k, Hashable k) => k -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

adjust :: (Eq k, Hashable k) => (v -> v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

update :: (Eq k, Hashable k) => (a -> Maybe a) -> k -> InsOrdHashMap k a -> InsOrdHashMap k a Source #

alter :: (Eq k, Hashable k) => (Maybe v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

Combine

unionWith :: (Eq k, Hashable k) => (v -> v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

The union of two maps. If a key occurs in both maps, the provided function (first argument) will be used to compute the result.

Ordered traversal will go thru keys in the first map first.

unionWithKey :: (Eq k, Hashable k) => (k -> v -> v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

unions :: (Eq k, Hashable k, Foldable f) => f (InsOrdHashMap k v) -> InsOrdHashMap k v Source #

Transformations

map :: (v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2 Source #

mapKeys :: (Eq k', Hashable k') => (k -> k') -> InsOrdHashMap k v -> InsOrdHashMap k' v Source #

Order preserving mapping of keys.

traverseKeys :: (Eq k', Hashable k', Applicative f) => (k -> f k') -> InsOrdHashMap k v -> f (InsOrdHashMap k' v) Source #

mapWithKey :: (k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2 Source #

traverseWithKey :: Applicative f => (k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) Source #

Unordered

unorderedTraverse :: Applicative f => (a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) Source #

More efficient than traverse, when traversing in insertion order is not important.

unorderedTraverseWithKey :: Applicative f => (k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b) Source #

More efficient than traverseWithKey, when traversing in insertion order is not important.

Difference and intersection

intersectionWith :: (Eq k, Hashable k) => (v1 -> v2 -> v3) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2 -> InsOrdHashMap k v3 Source #

intersectionWithKey :: (Eq k, Hashable k) => (k -> v1 -> v2 -> v3) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2 -> InsOrdHashMap k v3 Source #

Folds

foldl' :: (a -> v -> a) -> a -> InsOrdHashMap k v -> a Source #

foldlWithKey' :: (a -> k -> v -> a) -> a -> InsOrdHashMap k v -> a Source #

foldr :: (v -> a -> a) -> a -> InsOrdHashMap k v -> a Source #

foldrWithKey :: (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a Source #

foldMapWithKey :: Monoid m => (k -> a -> m) -> InsOrdHashMap k a -> m Source #

Unordered

unorderedFoldMap :: Monoid m => (a -> m) -> InsOrdHashMap k a -> m Source #

More efficient than foldMap, when folding in insertion order is not important.

unorderedFoldMapWithKey :: Monoid m => (k -> a -> m) -> InsOrdHashMap k a -> m Source #

More efficient than foldMapWithKey, when folding in insertion order is not important.

Filter

filter :: (v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

filterWithKey :: (k -> v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v Source #

mapMaybe :: (v1 -> Maybe v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2 Source #

mapMaybeWithKey :: (k -> v1 -> Maybe v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2 Source #

Conversions

keys :: InsOrdHashMap k v -> [k] Source #

elems :: InsOrdHashMap k v -> [v] Source #

toList :: InsOrdHashMap k v -> [(k, v)] Source #

toRevList :: InsOrdHashMap k v -> [(k, v)] Source #

fromList :: forall k v. (Eq k, Hashable k) => [(k, v)] -> InsOrdHashMap k v Source #

Lenses

hashMap :: Iso (InsOrdHashMap k a) (InsOrdHashMap k b) (HashMap k a) (HashMap k b) Source #

This is a slight lie, as roundtrip doesn't preserve ordering.

Debugging

valid :: InsOrdHashMap k v -> Bool Source #

Test if the internal map structure is valid.