Data.Map.IMap

Documentation

data IMap m v

An applicative map that discards mismatched keys ie, it uses intersection for it's applicative instance

It has a case in which every key is occupied and equal

Instances

IsMap m => Functor (IMap m)

Methods

fmap :: (a -> b) -> IMap m a -> IMap m b

(<$) :: a -> IMap m b -> IMap m a

IsMap m => Applicative (IMap m)

Methods

pure :: a -> IMap m a

(<*>) :: IMap m (a -> b) -> IMap m a -> IMap m b

(*>) :: IMap m a -> IMap m b -> IMap m b

(<*) :: IMap m a -> IMap m b -> IMap m a

IsMap m => IsMap (IMap m)

Associated Types

type Key (IMap m :: * -> *) :: *

Methods

fromList :: [(Key (IMap m), v)] -> IMap m v

intersectionWith :: (a -> b -> c) -> IMap m a -> IMap m b -> IMap m c

mapmap :: (a -> b) -> IMap m a -> IMap m b

(Eq (m v), Eq v) => Eq (IMap m v)

Methods

(==) :: IMap m v -> IMap m v -> Bool

(/=) :: IMap m v -> IMap m v -> Bool

(Show (m v), Show v) => Show (IMap m v)

Methods

showsPrec :: Int -> IMap m v -> ShowS

show :: IMap m v -> String

showList :: [IMap m v] -> ShowS

type Key (IMap m)

type Key (IMap m) = Key m

class IsMap m where

A class for maps so IMap can be generic

Minimal complete definition

fromList, intersectionWith, mapmap

Associated Types

type Key m

Methods

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

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

mapmap :: (a -> b) -> m a -> m b

Instances

IsMap IntMap

Associated Types

type Key (IntMap :: * -> *) :: *

Methods

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

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

mapmap :: (a -> b) -> IntMap a -> IntMap b

Ord k => IsMap (Map k)

Associated Types

type Key (Map k :: * -> *) :: *

Methods

fromList :: [(Key (Map k), v)] -> Map k v

intersectionWith :: (a -> b -> c) -> Map k a -> Map k b -> Map k c

mapmap :: (a -> b) -> Map k a -> Map k b

IsMap m => IsMap (IMap m)

Associated Types

type Key (IMap m :: * -> *) :: *

Methods

fromList :: [(Key (IMap m), v)] -> IMap m v

intersectionWith :: (a -> b -> c) -> IMap m a -> IMap m b -> IMap m c

mapmap :: (a -> b) -> IMap m a -> IMap m b

fromList :: IsMap m => [(Key m, v)] -> m v

intersectionWith :: IsMap m => (a -> b -> c) -> m a -> m b -> m c

mapmap :: IsMap m => (a -> b) -> m a -> m b