Dhall.Map

Map type used to represent records and unions

Type

data Map k v

A Map that remembers the original ordering of keys

This is primarily used so that formatting preserves field order

This is done primarily to avoid a dependency on insert-ordered-containers and also to improve performance

Instances

Functor (Map k)

Defined in Dhall.Map

Methods

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

(<$) :: a -> Map k b -> Map k a

Ord k => Foldable (Map k)

Defined in Dhall.Map

Methods

fold :: Monoid m => Map k m -> m

foldMap :: Monoid m => (a -> m) -> Map k a -> m

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

foldr' :: (a -> b -> b) -> b -> Map k a -> b

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

foldl' :: (b -> a -> b) -> b -> Map k a -> b

foldr1 :: (a -> a -> a) -> Map k a -> a

foldl1 :: (a -> a -> a) -> Map k a -> a

toList :: Map k a -> [a]

null :: Map k a -> Bool

length :: Map k a -> Int

elem :: Eq a => a -> Map k a -> Bool

maximum :: Ord a => Map k a -> a

minimum :: Ord a => Map k a -> a

sum :: Num a => Map k a -> a

product :: Num a => Map k a -> a

Ord k => Traversable (Map k)

Defined in Dhall.Map

Methods

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

sequenceA :: Applicative f => Map k (f a) -> f (Map k a)

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

sequence :: Monad m => Map k (m a) -> m (Map k a)

Ord k => IsList (Map k v)

Defined in Dhall.Map

Associated Types

type Item (Map k v) :: Type

Methods

fromList :: [Item (Map k v)] -> Map k v

fromListN :: Int -> [Item (Map k v)] -> Map k v

toList :: Map k v -> [Item (Map k v)]

(Ord k, Eq v) => Eq (Map k v)

Defined in Dhall.Map

Methods

(==) :: Map k v -> Map k v -> Bool

(/=) :: Map k v -> Map k v -> Bool

(Data k, Data v, Ord k) => Data (Map k v)

Defined in Dhall.Map

Methods

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

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

toConstr :: Map k v -> Constr

dataTypeOf :: Map k v -> DataType

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

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

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

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

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

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

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

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

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

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

(Ord k, Ord v) => Ord (Map k v)

>>> fromList [("A",1),("B",2)] < fromList [("B",1),("A",0)]
True

Defined in Dhall.Map

Methods

compare :: Map k v -> Map k v -> Ordering

(<) :: Map k v -> Map k v -> Bool

(<=) :: Map k v -> Map k v -> Bool

(>) :: Map k v -> Map k v -> Bool

(>=) :: Map k v -> Map k v -> Bool

max :: Map k v -> Map k v -> Map k v

min :: Map k v -> Map k v -> Map k v

(Show k, Show v, Ord k) => Show (Map k v)

Defined in Dhall.Map

Methods

showsPrec :: Int -> Map k v -> ShowS

show :: Map k v -> String

showList :: [Map k v] -> ShowS

Generic (Map k v)

Defined in Dhall.Map

Associated Types

type Rep (Map k v) :: Type -> Type

Methods

from :: Map k v -> Rep (Map k v) x

to :: Rep (Map k v) x -> Map k v

Ord k => Semigroup (Map k v)

\x y z -> x <> (y <> z) == (x <> y) <> (z :: Map Int Int)

Defined in Dhall.Map

Methods

(<>) :: Map k v -> Map k v -> Map k v

sconcat :: NonEmpty (Map k v) -> Map k v

stimes :: Integral b => b -> Map k v -> Map k v

Ord k => Monoid (Map k v)

\x -> x <> mempty == (x :: Map Int Int)

\x -> mempty <> x == (x :: Map Int Int)

Defined in Dhall.Map

Methods

mempty :: Map k v

mappend :: Map k v -> Map k v -> Map k v

mconcat :: [Map k v] -> Map k v

(Data k, Data v, Lift k, Lift v, Ord k) => Lift (Map k v)

Defined in Dhall.Map

Methods

lift :: Map k v -> Q Exp

(NFData k, NFData v) => NFData (Map k v)

Defined in Dhall.Map

Methods

rnf :: Map k v -> ()

type Rep (Map k v)

Defined in Dhall.Map

type Rep (Map k v)

type Item (Map k v)

Defined in Dhall.Map

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

Construction

empty :: Ord k => Map k v

Create an empty Map

singleton :: k -> v -> Map k v

Create a Map from a single key-value pair

>>> singleton "A" 1
fromList [("A",1)]

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

Create a Map from a list of key-value pairs

>>> fromList [("B",1),("A",2)]  -- The map preserves order
fromList [("B",1),("A",2)]
>>> fromList [("A",1),("A",2)]  -- For duplicates, later values take precedence
fromList [("A",2)]

Note that this handling of duplicates means that fromList is not a monoid homomorphism:

>>> fromList [(1, True)] <> fromList [(1, False)]
fromList [(1,True)]
>>> fromList ([(1, True)] <> [(1, False)])
fromList [(1,False)]

fromListWithKey :: Ord k => (k -> v -> v -> v) -> [(k, v)] -> Map k v

Create a Map from a list of key-value pairs with a combining function.

>>> fromListWithKey (\k v1 v2 -> k ++ v1 ++ v2) [("B","v1"),("A","v2"),("B","v3")]
fromList [("B","Bv3v1"),("A","v2")]

Constructing unordered Maps

unorderedSingleton :: k -> v -> Map k v

Create a Map from a single key-value pair.

Any further operations on this map will not retain the order of the keys.

>>> unorderedSingleton "A" 1
fromList [("A",1)]

unorderedFromList :: Ord k => [(k, v)] -> Map k v

Create a Map from a list of key-value pairs

Any further operations on this map will not retain the order of the keys.

>>> unorderedFromList []
fromList []
>>> unorderedFromList [("B",1),("A",2)]  -- The map /doesn't/ preserve order
fromList [("A",2),("B",1)]
>>> unorderedFromList [("A",1),("A",2)]  -- For duplicates, later values take precedence
fromList [("A",2)]

Sorting

sort :: Map k v -> Map k v

Sort the keys of a Map, forgetting the original ordering

sort (sort x) = sort x

>>> sort (fromList [("B",1),("A",2)])
fromList [("A",2),("B",1)]

isSorted :: Eq k => Map k v -> Bool

Check if the keys of a Map are already sorted

isSorted (sort m) = True

>>> isSorted (fromList [("B",1),("A",2)])  -- Sortedness is based only on keys
False
>>> isSorted (fromList [("A",2),("B",1)])
True

Insertion

insert :: Ord k => k -> v -> Map k v -> Map k v

Insert a key-value pair into a Map, overriding any previous value stored underneath the same key, if present

insert = insertWith (\v _ -> v)

>>> insert "C" 1 (fromList [("B",2),("A",3)])  -- Values are inserted on left
fromList [("C",1),("B",2),("A",3)]
>>> insert "C" 1 (fromList [("C",2),("A",3)])  -- New value takes precedence
fromList [("C",1),("A",3)]

insertWith :: Ord k => (v -> v -> v) -> k -> v -> Map k v -> Map k v

Insert a key-value pair into a Map, using the supplied function to combine the new value with any old value underneath the same key, if present

>>> insertWith (+) "C" 1 (fromList [("B",2),("A",3)])  -- No collision
fromList [("C",1),("B",2),("A",3)]
>>> insertWith (+) "C" 1 (fromList [("C",2),("A",3)])  -- Collision
fromList [("C",3),("A",3)]

Deletion/Update

delete :: Ord k => k -> Map k v -> Map k v

Delete a key from a Map if present, otherwise return the original Map

>>> delete "B" (fromList [("C",1),("B",2),("A",3)])
fromList [("C",1),("A",3)]
>>> delete "D" (fromList [("C",1),("B",2),("A",3)])
fromList [("C",1),("B",2),("A",3)]

filter :: Ord k => (a -> Bool) -> Map k a -> Map k a

Keep all values that satisfy the given predicate

>>> filter even (fromList [("C",3),("B",2),("A",1)])
fromList [("B",2)]
>>> filter odd (fromList [("C",3),("B",2),("A",1)])
fromList [("C",3),("A",1)]

restrictKeys :: Ord k => Map k a -> Set k -> Map k a

Restrict a Map to only those keys found in a Data.Set.Set.

>>> restrictKeys (fromList [("A",1),("B",2)]) (Data.Set.fromList ["A"])
fromList [("A",1)]

withoutKeys :: Ord k => Map k a -> Set k -> Map k a

Remove all keys in a Data.Set.Set from a Map

>>> withoutKeys (fromList [("A",1),("B",2)]) (Data.Set.fromList ["A"])
fromList [("B",2)]

mapMaybe :: Ord k => (a -> Maybe b) -> Map k a -> Map k b

Transform all values in a Map using the supplied function, deleting the key if the function returns Nothing

>>> mapMaybe Data.Maybe.listToMaybe (fromList [("C",[1]),("B",[]),("A",[3])])
fromList [("C",1),("A",3)]

Query

lookup :: Ord k => k -> Map k v -> Maybe v

Retrieve a key from a Map

lookup k mempty = empty

lookup k (x <> y) = lookup k y <|> lookup k x

>>> lookup "A" (fromList [("B",1),("A",2)])
Just 2
>>> lookup "C" (fromList [("B",1),("A",2)])
Nothing

member :: Ord k => k -> Map k v -> Bool

Check if a key belongs to a Map

member k mempty = False

member k (x <> y) = member k x || member k y

>>> member "A" (fromList [("B",1),("A",2)])
True
>>> member "C" (fromList [("B",1),("A",2)])
False

uncons :: Ord k => Map k v -> Maybe (k, v, Map k v)

Retrieve the first key, value of the Map, if present, and also returning the rest of the Map.

uncons mempty = empty

uncons (singleton k v) = (k, v, mempty)

>>> uncons (fromList [("C",1),("B",2),("A",3)])
Just ("C",1,fromList [("B",2),("A",3)])
>>> uncons (fromList [])
Nothing

size :: Map k v -> Int

>>> size (fromList [("A",1)])
1

Combine

union :: Ord k => Map k v -> Map k v -> Map k v

Combine two Maps, preferring keys from the first Map

union = unionWith (\v _ -> v)

>>> union (fromList [("D",1),("C",2)]) (fromList [("B",3),("A",4)])
fromList [("D",1),("C",2),("B",3),("A",4)]
>>> union (fromList [("D",1),("C",2)]) (fromList [("C",3),("A",4)])
fromList [("D",1),("C",2),("A",4)]

unionWith :: Ord k => (v -> v -> v) -> Map k v -> Map k v -> Map k v

Combine two Maps using a combining function for colliding keys

>>> unionWith (+) (fromList [("D",1),("C",2)]) (fromList [("B",3),("A",4)])
fromList [("D",1),("C",2),("B",3),("A",4)]
>>> unionWith (+) (fromList [("D",1),("C",2)]) (fromList [("C",3),("A",4)])
fromList [("D",1),("C",5),("A",4)]

outerJoin :: Ord k => (a -> c) -> (b -> c) -> (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c

A generalised unionWith.

>>> outerJoin Left Left (\k a b -> Right (k, a, b)) (fromList [("A",1),("B",2)]) (singleton "A" 3)
fromList [("A",Right ("A",1,3)),("B",Left 2)]

This function is much inspired by the Data.Semialign.Semialign class.

intersection :: Ord k => Map k a -> Map k b -> Map k a

Combine two Map on their shared keys, keeping the value from the first Map

intersection = intersectionWith (\v _ -> v)

>>> intersection (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])
fromList [("B",2)]

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

Combine two Maps on their shared keys, using the supplied function to combine values from the first and second Map

>>> intersectionWith (+) (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])
fromList [("B",5)]

difference :: Ord k => Map k a -> Map k b -> Map k a

Compute the difference of two Maps by subtracting all keys from the second Map from the first Map

>>> difference (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])
fromList [("C",1)]

Traversals

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

Transform the values of a Map using their corresponding key

mapWithKey (pure id) = id

mapWithKey (liftA2 (.) f g) = mapWithKey f . mapWithKey g

mapWithKey f mempty = mempty

mapWithKey f (x <> y) = mapWithKey f x <> mapWithKey f y

>>> mapWithKey (,) (fromList [("B",1),("A",2)])
fromList [("B",("B",1)),("A",("A",2))]

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

Traverse all of the key-value pairs in a Map, in their original order

>>> traverseWithKey (,) (fromList [("B",1),("A",2)])
("BA",fromList [("B",1),("A",2)])

unorderedTraverseWithKey :: Ord k => Applicative f => (k -> a -> f b) -> Map k a -> f (Map k b)

Same as traverseWithKey, except that the order of effects is not necessarily the same as the order of the keys

unorderedTraverseWithKey_ :: Ord k => Applicative f => (k -> a -> f ()) -> Map k a -> f ()

Traverse all of the key-value pairs in a Map, not preserving their original order, where the result of the computation can be forgotten.

Note that this is a strict traversal, fully traversing the map even when the Applicative is lazy in the remaining elements.

foldMapWithKey :: (Monoid m, Ord k) => (k -> a -> m) -> Map k a -> m

Fold all of the key-value pairs in a Map, in their original order

>>> foldMapWithKey (,) (fromList [("B",[1]),("A",[2])])
("BA",[1,2])

Conversions

toList :: Ord k => Map k v -> [(k, v)]

Convert a Map to a list of key-value pairs in the original order of keys

>>> toList (fromList [("B",1),("A",2)])
[("B",1),("A",2)]

toAscList :: Map k v -> [(k, v)]

Convert a Map to a list of key-value pairs in ascending order of keys

toMap :: Map k v -> Map k v

Convert a Dhall.Map.Map to a Data.Map.Map

>>> toMap (fromList [("B",1),("A",2)]) -- Order is lost upon conversion
fromList [("A",2),("B",1)]

keys :: Map k v -> [k]

Return the keys from a Map in their original order

>>> keys (fromList [("B",1),("A",2)])
["B","A"]

keysSet :: Map k v -> Set k

Return the Data.Set.Set of the keys

>>> keysSet (fromList [("B",1),("A",2)])
fromList ["A","B"]

elems :: Ord k => Map k v -> [v]

Return the values from a Map in their original order.

>>> elems (fromList [("B",1),("A",2)])
[1,2]