Data.HashMap.Strict.InsOrd

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

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

Documentation

data InsOrdHashMap k v

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

Instances

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

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

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

Functor (InsOrdHashMap k)

Foldable (InsOrdHashMap k)

Traversable (InsOrdHashMap k)

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

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

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

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

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

(Eq k, Hashable k, Read k, Read v) => Read (InsOrdHashMap k v)

(Show k, Show v) => Show (InsOrdHashMap k v)

(ToJSONKey k, ToJSON v) => ToJSON (InsOrdHashMap k v)

(Eq k, Hashable k, FromJSONKey k, FromJSON v) => FromJSON (InsOrdHashMap k v)

(Eq k, Hashable k) => Monoid (InsOrdHashMap k v)

(Hashable k, Hashable v) => Hashable (InsOrdHashMap k v)

hashWithSalt salt . toHashMap = hashWithSalt salt.

(Eq k, Hashable k) => Semigroup (InsOrdHashMap k v)

(Eq k, Hashable k) => Ixed (InsOrdHashMap k v)

(Eq k, Hashable k) => At (InsOrdHashMap k a)

type Item (InsOrdHashMap k v) = (k, v)

type Index (InsOrdHashMap k v) = k

type IxValue (InsOrdHashMap k v) = v

Construction

empty :: InsOrdHashMap k v

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

Basic interface

null :: InsOrdHashMap k v -> Bool

size :: InsOrdHashMap k v -> Int

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

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

lookupDefault

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

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

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

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

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

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

Combine

union :: (Eq k, Hashable k) => InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v

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

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

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

Transformations

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

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

Order preserving mapping of keys.

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

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

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

Difference and intersection

difference :: (Eq k, Hashable k) => InsOrdHashMap k v -> InsOrdHashMap k w -> InsOrdHashMap k v

intersection :: (Eq k, Hashable k) => InsOrdHashMap k v -> InsOrdHashMap k w -> InsOrdHashMap k v

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

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

Folds

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

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

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

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

Filter

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

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

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

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

Conversions

keys :: InsOrdHashMap k v -> [k]

elems :: InsOrdHashMap k v -> [v]

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

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

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

toHashMap :: InsOrdHashMap k v -> HashMap k v

fromHashMap :: HashMap k v -> InsOrdHashMap k v

Aeson extras

class FromJSONKey a where

See https://github.com/bos/aeson/pull/341

Minimal complete definition

parseJSONKey

Methods

parseJSONKey :: Text -> Parser a

parseJSONKeyList :: Text -> Parser [a]

Default implementation parses into singleton list. String :(

Instances

FromJSONKey Char

FromJSONKey Int

FromJSONKey Text

FromJSONKey a => FromJSONKey [a]

class ToJSONKey a where

Minimal complete definition

toJSONKey

Methods

toJSONKey :: a -> Text

toJSONKeyList :: [a] -> Text

Default implementations picks first element, if exists; otherwise evaluates to "".

Instances

ToJSONKey Char

ToJSONKey Int

ToJSONKey Text

ToJSONKey a => ToJSONKey [a]

Lenses

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

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

unorderedTraversal :: Traversal (InsOrdHashMap k a) (InsOrdHashMap k b) a b

Debugging

valid :: InsOrdHashMap k v -> Bool

Test if the internal map structure is valid.