- class Eq k => Map map k | map -> k where
- empty :: map a
- singleton :: k -> a -> map a
- pair :: k -> k -> Maybe (a -> a -> map a)
- fromAssocsWith :: (a -> a -> a) -> [(k, a)] -> map a
- fromAssocsMaybe :: (a -> a -> Maybe a) -> [(k, a)] -> map a
- status :: map a -> Status k a
- nonEmpty :: map a -> Maybe (map a)
- addSize :: map a -> Int# -> Int#
- lookup :: k -> map a -> Maybe a
- lookupCont :: (a -> Maybe b) -> k -> map a -> Maybe b
- alter :: (Maybe a -> Maybe a) -> k -> map a -> map a
- insertWith :: (a -> a) -> k -> a -> map a -> map a
- insertWith' :: (a -> a) -> k -> a -> map a -> map a
- insertMaybe :: (a -> Maybe a) -> k -> a -> map a -> map a
- delete :: k -> map a -> map a
- adjustWith :: (a -> a) -> k -> map a -> map a
- adjustWith' :: (a -> a) -> k -> map a -> map a
- adjustMaybe :: (a -> Maybe a) -> k -> map a -> map a
- venn :: (a -> b -> c) -> map a -> map b -> (map a, map c, map b)
- venn' :: (a -> b -> c) -> map a -> map b -> (map a, map c, map b)
- vennMaybe :: (a -> b -> Maybe c) -> map a -> map b -> (map a, map c, map b)
- union :: (a -> a -> a) -> map a -> map a -> map a
- union' :: (a -> a -> a) -> map a -> map a -> map a
- unionMaybe :: (a -> a -> Maybe a) -> map a -> map a -> map a
- disjointUnion :: map a -> map a -> map a
- intersection :: (a -> b -> c) -> map a -> map b -> map c
- intersection' :: (a -> b -> c) -> map a -> map b -> map c
- intersectionMaybe :: (a -> b -> Maybe c) -> map a -> map b -> map c
- difference :: map a -> map b -> map a
- differenceMaybe :: (a -> b -> Maybe a) -> map a -> map b -> map a
- isSubsetOf :: map a -> map b -> Bool
- isSubmapOf :: (a -> b -> Bool) -> map a -> map b -> Bool
- map :: (a -> b) -> map a -> map b
- map' :: (a -> b) -> map a -> map b
- mapMaybe :: (a -> Maybe b) -> map a -> map b
- mapWithKey :: (k -> a -> b) -> map a -> map b
- mapWithKey' :: (k -> a -> b) -> map a -> map b
- filter :: (a -> Bool) -> map a -> map a
- foldElems :: (a -> b -> b) -> b -> map a -> b
- foldKeys :: (k -> b -> b) -> b -> map a -> b
- foldAssocs :: (k -> a -> b -> b) -> b -> map a -> b
- foldElems' :: (a -> b -> b) -> b -> map a -> b
- foldKeys' :: (k -> b -> b) -> b -> map a -> b
- foldAssocs' :: (k -> a -> b -> b) -> b -> map a -> b
- foldElemsUInt :: (a -> Int# -> Int#) -> Int# -> map a -> Int#
- valid :: map a -> Maybe String

- disjointUnionError :: a
- data Status k a
- vennMaybe' :: Map map k => (a -> b -> Maybe c) -> map a -> map b -> (map a, map c, map b)
- alter' :: Map map k => (Maybe a -> Maybe a) -> k -> map a -> map a
- adjustMaybe' :: Map map k => (a -> Maybe a) -> k -> map a -> map a
- insertMaybe' :: Map map k => (a -> Maybe a) -> k -> a -> map a -> map a
- unionMaybe' :: Map map k => (a -> a -> Maybe a) -> map a -> map a -> map a
- intersectionMaybe' :: Map map k => (a -> b -> Maybe c) -> map a -> map b -> map c
- differenceMaybe' :: Map map k => (a -> b -> Maybe a) -> map a -> map b -> map a
- mapMaybe' :: Map map k => (a -> Maybe b) -> map a -> map b
- isEmpty :: Map map l => map a -> Bool
- isSingleton :: Map map l => map a -> Bool
- insert :: Map map k => k -> a -> map a -> map a
- insert' :: Map map k => k -> a -> map a -> map a
- size :: Map map k => map a -> Int
- insertAssocs :: Map map k => [(k, a)] -> map a -> map a
- insertAssocsWith :: Map map k => (a -> a -> a) -> [(k, a)] -> map a -> map a
- insertAssocsMaybe :: Map map k => (a -> a -> Maybe a) -> [(k, a)] -> map a -> map a
- fromAssocs :: Map map k => [(k, a)] -> map a
- lookupM :: (Map map k, Monad m) => k -> map a -> m a
- keys :: Map map k => map a -> [k]
- elems :: Map map k => map a -> [a]
- assocs :: Map map k => map a -> [(k, a)]
- class Map map k => OrderedMap map k where
- compareKey :: map a -> k -> k -> Ordering
- fromAssocsAscWith :: (a -> a -> a) -> [(k, a)] -> map a
- fromAssocsAscMaybe :: (a -> a -> Maybe a) -> [(k, a)] -> map a
- fromAssocsDescWith :: (a -> a -> a) -> [(k, a)] -> map a
- fromAssocsDescMaybe :: (a -> a -> Maybe a) -> [(k, a)] -> map a
- foldElemsAsc :: (a -> b -> b) -> b -> map a -> b
- foldElemsDesc :: (a -> b -> b) -> b -> map a -> b
- foldKeysAsc :: (k -> b -> b) -> b -> map a -> b
- foldKeysDesc :: (k -> b -> b) -> b -> map a -> b
- foldAssocsAsc :: (k -> a -> b -> b) -> b -> map a -> b
- foldAssocsDesc :: (k -> a -> b -> b) -> b -> map a -> b
- foldElemsAsc' :: (a -> b -> b) -> b -> map a -> b
- foldElemsDesc' :: (a -> b -> b) -> b -> map a -> b
- foldKeysAsc' :: (k -> b -> b) -> b -> map a -> b
- foldKeysDesc' :: (k -> b -> b) -> b -> map a -> b
- foldAssocsAsc' :: (k -> a -> b -> b) -> b -> map a -> b
- foldAssocsDesc' :: (k -> a -> b -> b) -> b -> map a -> b

- fromAssocsAsc :: OrderedMap map k => [(k, a)] -> map a
- fromAssocsDesc :: OrderedMap map k => [(k, a)] -> map a
- insertAssocsAsc :: OrderedMap map k => [(k, a)] -> map a -> map a
- insertAssocsDesc :: OrderedMap map k => [(k, a)] -> map a -> map a
- insertAssocsAscWith :: OrderedMap map k => (a -> a -> a) -> [(k, a)] -> map a -> map a
- insertAssocsDescWith :: OrderedMap map k => (a -> a -> a) -> [(k, a)] -> map a -> map a
- insertAssocsAscMaybe :: OrderedMap map k => (a -> a -> Maybe a) -> [(k, a)] -> map a -> map a
- insertAssocsDescMaybe :: OrderedMap map k => (a -> a -> Maybe a) -> [(k, a)] -> map a -> map a
- elemsAsc :: OrderedMap map k => map a -> [a]
- elemsDesc :: OrderedMap map k => map a -> [a]
- assocsAsc :: OrderedMap map k => map a -> [(k, a)]
- assocsDesc :: OrderedMap map k => map a -> [(k, a)]
- keysAsc :: OrderedMap map k => map a -> [k]
- keysDesc :: OrderedMap map k => map a -> [k]
- isProperSubsetOf :: Map map k => map a -> map b -> Bool
- isProperSubmapOfBy :: Map map k => (a -> b -> Bool) -> map a -> map b -> Bool
- sortAscWith :: OrderedMap map k => map Int -> [k] -> [k]
- sortDescWith :: OrderedMap map k => map Int -> [k] -> [k]
- nubAscWith :: OrderedMap map k => map () -> [k] -> [k]
- nubDescWith :: OrderedMap map k => map () -> [k] -> [k]

# Documentation

class Eq k => Map map k | map -> k whereSource

Type of composable maps. For an example of a composed map see Data.GMap.ListMap

The empty map.

singleton :: k -> a -> map aSource

Create a map with a single association.

pair :: k -> k -> Maybe (a -> a -> map a)Source

Compare two keys and if they are *different* return a function that will create
a map with two associations (when supplied with the corresponding associated values).
If the keys are the same then this function returns `Nothing`

.

fromAssocsWith :: (a -> a -> a) -> [(k, a)] -> map aSource

Create a map from an unordered list of associations Combine repeated keys with the provided function.

fromAssocsMaybe :: (a -> a -> Maybe a) -> [(k, a)] -> map aSource

status :: map a -> Status k aSource

See the `Status`

type.
This function provides a way to find out if a map is empty, a singleton,
or contains more than one association.
It is useful if empty or singleton maps require special treatment.

nonEmpty :: map a -> Maybe (map a)Source

Reject empty maps (return Nothing). Typically used for dealing with nested maps. eg to delete a key from a nested map: 'adjustMaybe (nonEmpty $ delete k2) k1'

addSize :: map a -> Int# -> Int#Source

Add number of key/value pairs in the map to the supplied Int

lookup :: k -> map a -> Maybe aSource

Return the value associated with the supplied key (if any).

lookupCont :: (a -> Maybe b) -> k -> map a -> Maybe bSource

Find the value associated with the supplied key (if any) and return the result of applying the supplied continuation function to that value. Useful for nested lookup.

alter :: (Maybe a -> Maybe a) -> k -> map a -> map aSource

This is a combined insert/modify/delete operation. The argument to the supplied function
is (`Just`

a) if there is a value (a) associated with the supplied key, otherwise `Nothing`

.
If the return value is (`Just`

a'), a' becomes the new value associated with the supplied key.
If the return value is `Nothing`

, the association for the supplied key (if any) is deleted.

insertWith :: (a -> a) -> k -> a -> map a -> map aSource

Insert a new association in the map if there is currently no value associated with the key. If there is a value associated with the key then replace it with the result of applying the supplied function to that value.

insertWith' :: (a -> a) -> k -> a -> map a -> map aSource

Same as `insertWith`

, but applies the supplied function strictly if the search succeeds.
Note that the third argument is not strictly evaluated either way (TODO change this)

insertMaybe :: (a -> Maybe a) -> k -> a -> map a -> map aSource

Similar to `insert`

, but the association is deleted if the supplied function returns `Nothing`

.
(The supplied function is always applied strictly.)

delete :: k -> map a -> map aSource

Delete the association for the supplied key (if any).

adjustWith :: (a -> a) -> k -> map a -> map aSource

Find the value associated with the supplied key (if any) and apply the supplied function to that value.

adjustWith' :: (a -> a) -> k -> map a -> map aSource

Same as `adjust`

but applies the supplied function strictly.

adjustMaybe :: (a -> Maybe a) -> k -> map a -> map aSource

Find the value associated with the supplied key (if any) and apply the supplied function
to that value. Delete the association if the result is `Nothing`

. Replace the old value with
the new value if the result is (`Just`

something).

venn :: (a -> b -> c) -> map a -> map b -> (map a, map c, map b)Source

Returns the left difference, intersection and right difference of the supplied maps

venn' :: (a -> b -> c) -> map a -> map b -> (map a, map c, map b)Source

Same as `venn`

, but the new values in the intersection are evaluated strictly

vennMaybe :: (a -> b -> Maybe c) -> map a -> map b -> (map a, map c, map b)Source

Same as `venn`

, except that values for which the argument function returns nothing
are dropped from the intersection

union :: (a -> a -> a) -> map a -> map a -> map aSource

Evaluate the union of two maps. If the maps contain common keys then combine the values associated with those keys using the supplied function. The value arguments to this function are supplied in the same order as the map arguments.

union' :: (a -> a -> a) -> map a -> map a -> map aSource

Same as `unionWith`

, but the new associated values are evaluated strictly.

unionMaybe :: (a -> a -> Maybe a) -> map a -> map a -> map aSource

Evaluate the union of two maps, but delete combined associations from the result map
if the combining function returns `Nothing`

.

disjointUnion :: map a -> map a -> map aSource

Evaluate the union of two key-disjoint maps. If the arguments are not disjoint the
behaviour is undefined. This is potentially faster than `union`

.

intersection :: (a -> b -> c) -> map a -> map b -> map cSource

Evaluate the intersection of two maps, combining common associations using the supplied function.

intersection' :: (a -> b -> c) -> map a -> map b -> map cSource

Same as `intersection`

, but the new associated values are evaluated strictly.

intersectionMaybe :: (a -> b -> Maybe c) -> map a -> map b -> map cSource

Evaluate the intersection of two maps, but delete combined associations from the result map
if the combining function returns `Nothing`

.

difference :: map a -> map b -> map aSource

Evaluate the difference between two maps. For any key occuring in the second map, the corresponding association (if any) is deleted from the first map. The associated values in the second map are irrelevant.

differenceMaybe :: (a -> b -> Maybe a) -> map a -> map b -> map aSource

Difference with a combining function. If the combining function returns
`Just a`

then the corresponding association is not deleted from the result map
(it is retained with `a`

as the associated value).

isSubsetOf :: map a -> map b -> BoolSource

Returns true if the keys in the first map are a subset of the keys in the second map.
(This includes the case where the key sets are identical). Note that this function does
not examine the associated values (which are irrelevant). See `isSubmapOf`

if you
do want associated values examined.

isSubmapOf :: (a -> b -> Bool) -> map a -> map b -> BoolSource

Returns true if the keys in the first map are a subset of the keys in the second map and the corresponding function always returns true when applied to the values associated with matching keys.

map :: (a -> b) -> map a -> map bSource

Apply the supplied function to every associated value in the map.

map' :: (a -> b) -> map a -> map bSource

Same as `map`

, but the function is applied strictly.

mapMaybe :: (a -> Maybe b) -> map a -> map bSource

Apply the supplied function to every associated value in the map.
If the result is `Nothing`

then the delete the corresponding association.

mapWithKey :: (k -> a -> b) -> map a -> map bSource

Apply the supplied function to every association in the map, and use the result as the new associated value for the corresponding key.

mapWithKey' :: (k -> a -> b) -> map a -> map bSource

Same as `mapWithKey`

, but the function is applied strictly.

filter :: (a -> Bool) -> map a -> map aSource

Delete associations for which the supplied predicate returns `False`

when applied to
the associated value.

foldElems :: (a -> b -> b) -> b -> map a -> bSource

Fold right over the list of elements in an unspecified order.

foldKeys :: (k -> b -> b) -> b -> map a -> bSource

Fold right over the list of keys in an unspecified order.

foldAssocs :: (k -> a -> b -> b) -> b -> map a -> bSource

Fold right over the list of associations in an unspecified order.

foldElems' :: (a -> b -> b) -> b -> map a -> bSource

A strict version of `foldElems`

which should be used for
accumulating functions which are strict in their second argument.

foldKeys' :: (k -> b -> b) -> b -> map a -> bSource

A strict version of `foldKeys`

which should be used for
accumulating functions which are strict in their second argument.

foldAssocs' :: (k -> a -> b -> b) -> b -> map a -> bSource

A strict version of `foldAssocs`

which should be used for
accumulating functions which are strict in their third argument.

foldElemsUInt :: (a -> Int# -> Int#) -> Int# -> map a -> Int#Source

Fold over elements in un-specified order using *unboxed* Int accumulator (with GHC).
Defaults to boxed Int for other Haskells. Typically used for counting functions.
Implementations are free to traverse the map in any order.
The folded function is always applied strictly.

valid :: map a -> Maybe StringSource

Test whatever underlying data structure is used to implement an
instance of this class is valid. Used for debugging.
`Nothing`

indicates the data structure is valid.

Map IntMap Int | |

Map UnitMap () | |

Eq k => Map (ImaginaryOrdMap k) k | |

Eq k => Map (AList k) k | |

Ord k => Map (OrdMap k) k | |

(Eq k, Ord k, OrderedMap mp k) => Map (SList mp k) k | |

Map mp k => Map (CacheKeys mp k) k | |

Map map k => Map (ListMap map k) [k] | ListMap is an instance of Map. |

(Eq k1, Injection t k1 k2, Map map k2) => Map (InjectKeys t k1 k2 map) k1 | InjectKeys is an instance of Map. |

(Map mapL kL, Map mapR kR) => Map (Choice2Map mapL mapR kL kR) (Choice2 kL kR) | |

(Map map1 k1, Map map2 k2) => Map (Tuple2Map map1 map2 k1 k2) (k1, k2) | Tuple2Map is an instance of Map. |

vennMaybe' :: Map map k => (a -> b -> Maybe c) -> map a -> map b -> (map a, map c, map b)Source

Same as `vennMaybe`

except that the new associated values are strictly evaluated.

alter' :: Map map k => (Maybe a -> Maybe a) -> k -> map a -> map aSource

Like `alter`

except that the new associated value is strictly evaluated

adjustMaybe' :: Map map k => (a -> Maybe a) -> k -> map a -> map aSource

Like `adjustMaybe`

except that the new associated value is strictly evaluated

insertMaybe' :: Map map k => (a -> Maybe a) -> k -> a -> map a -> map aSource

Like `insertMaybe`

except that if the key is already present the new associated
value is evaluated strictly. If the key is not present then the supplied value is
*not* evaluated strictly. (TODO Change this)

unionMaybe' :: Map map k => (a -> a -> Maybe a) -> map a -> map a -> map aSource

Like `unionMaybe`

except that the new associated values are strictly evaluated

intersectionMaybe' :: Map map k => (a -> b -> Maybe c) -> map a -> map b -> map cSource

Like `intersectionMaybe`

except that the new associated values are strictly evaluated

differenceMaybe' :: Map map k => (a -> b -> Maybe a) -> map a -> map b -> map aSource

Like `differenceMaybe`

except that the new associated values are strictly evaluated

mapMaybe' :: Map map k => (a -> Maybe b) -> map a -> map bSource

Like `mapMaybe`

except that the new associated values are strictly evaluated

isSingleton :: Map map l => map a -> BoolSource

insert :: Map map k => k -> a -> map a -> map aSource

Write a new association in the map, overwriting any value currently associated with the key.

insert' :: Map map k => k -> a -> map a -> map aSource

Write a new association in the map, overwriting any value currently associated with the key. The new value is evaluated strictly.

insertAssocs :: Map map k => [(k, a)] -> map a -> map aSource

Insert an unordered list of key/value pairs into a map. Repeated keys will be overwritten by the last occurence of the key.

insertAssocsWith :: Map map k => (a -> a -> a) -> [(k, a)] -> map a -> map aSource

insertAssocsMaybe :: Map map k => (a -> a -> Maybe a) -> [(k, a)] -> map a -> map aSource

fromAssocs :: Map map k => [(k, a)] -> map aSource

class Map map k => OrderedMap map k whereSource

Maps which maintain some order on their keys, determined by compareKey.

compareKey :: map a -> k -> k -> OrderingSource

Every function in this class must respect the ordering given by compareKey. The first argument is required for its type only and should not be evaluated.

fromAssocsAscWith :: (a -> a -> a) -> [(k, a)] -> map aSource

Create a map from an ascending list of key/value pairs Combine repeated keys with the provided function.

fromAssocsAscMaybe :: (a -> a -> Maybe a) -> [(k, a)] -> map aSource

fromAssocsDescWith :: (a -> a -> a) -> [(k, a)] -> map aSource

Create a map from a descending list of key/value pairs Combine repeated keys with the provided function.

fromAssocsDescMaybe :: (a -> a -> Maybe a) -> [(k, a)] -> map aSource

foldElemsAsc :: (a -> b -> b) -> b -> map a -> bSource

Right associative fold over the list of elements in ascending order of keys.
See `foldElemsAsc'`

for a strict version of this function.

foldElemsDesc :: (a -> b -> b) -> b -> map a -> bSource

Right associative fold over the list of elements in descending order of keys.
See `foldElemsDesc'`

for a strict version of this function.

foldKeysAsc :: (k -> b -> b) -> b -> map a -> bSource

Right associative fold over the list of keys in ascending order.
See `foldKeysAsc'`

for a strict version of this function.

foldKeysDesc :: (k -> b -> b) -> b -> map a -> bSource

Right associative fold over the list of keys in descending order.
See `foldKeysDesc'`

for a strict version of this function.

foldAssocsAsc :: (k -> a -> b -> b) -> b -> map a -> bSource

Right associative fold over the list of associations in ascending order of keys.
See `foldAssocsAsc'`

for a strict version of this function.

foldAssocsDesc :: (k -> a -> b -> b) -> b -> map a -> bSource

Right associative fold over the list of associations in descending order of keys.
See `foldAssocsDesc'`

for a strict version of this function.

foldElemsAsc' :: (a -> b -> b) -> b -> map a -> bSource

A strict version of `foldElemsAsc`

which should be used for
accumulating functions which are strict in their second argument.

foldElemsDesc' :: (a -> b -> b) -> b -> map a -> bSource

A strict version of `foldElemsDesc`

which should be used for
accumulating functions which are strict in their second argument.

foldKeysAsc' :: (k -> b -> b) -> b -> map a -> bSource

A strict version of `foldKeysAsc`

which should be used for
accumulating functions which are strict in their second argument.

foldKeysDesc' :: (k -> b -> b) -> b -> map a -> bSource

A strict version of `foldKeysDesc`

which should be used for
accumulating functions which are strict in their second argument.

foldAssocsAsc' :: (k -> a -> b -> b) -> b -> map a -> bSource

A strict version of `foldAssocsAsc`

which should be used for
accumulating functions which are strict in their third argument.

foldAssocsDesc' :: (k -> a -> b -> b) -> b -> map a -> bSource

A strict version of `foldAssocsDesc`

which should be used for
accumulating functions which are strict in their third argument.

OrderedMap IntMap Int | |

OrderedMap UnitMap () | |

(Eq k, Ord k) => OrderedMap (ImaginaryOrdMap k) k | |

Ord k => OrderedMap (OrdMap k) k | |

(Eq k, Ord k, OrderedMap mp k) => OrderedMap (SList mp k) k | |

OrderedMap mp k => OrderedMap (CacheKeys mp k) k | |

OrderedMap map k => OrderedMap (ListMap map k) [k] | |

(Eq k1, Injection t k1 k2, OrderedMap map k2) => OrderedMap (InjectKeys t k1 k2 map) k1 | |

(OrderedMap mapL kL, OrderedMap mapR kR) => OrderedMap (Choice2Map mapL mapR kL kR) (Choice2 kL kR) | |

(OrderedMap map1 k1, OrderedMap map2 k2) => OrderedMap (Tuple2Map map1 map2 k1 k2) (k1, k2) |

fromAssocsAsc :: OrderedMap map k => [(k, a)] -> map aSource

fromAssocsDesc :: OrderedMap map k => [(k, a)] -> map aSource

insertAssocsAsc :: OrderedMap map k => [(k, a)] -> map a -> map aSource

Insert an ascending list of associations into a map Duplicate keys are replaced by the rightmost value

insertAssocsDesc :: OrderedMap map k => [(k, a)] -> map a -> map aSource

Insert a descending list of associations into a map Duplicate keys are replaced by the rightmost value

insertAssocsAscWith :: OrderedMap map k => (a -> a -> a) -> [(k, a)] -> map a -> map aSource

Insert an ascending list of associations into a map Duplicate keys are combined with the supplied function

insertAssocsDescWith :: OrderedMap map k => (a -> a -> a) -> [(k, a)] -> map a -> map aSource

Insert a descending list of associations into a map Duplicate keys are combined with the supplied function

insertAssocsAscMaybe :: OrderedMap map k => (a -> a -> Maybe a) -> [(k, a)] -> map a -> map aSource

Same as `insertAssocsAscWith`

except that if Nothing is returned then the key is discarded

insertAssocsDescMaybe :: OrderedMap map k => (a -> a -> Maybe a) -> [(k, a)] -> map a -> map aSource

Same as `insertAssocsDescWith`

except that if Nothing is returned then the key is discarded

elemsAsc :: OrderedMap map k => map a -> [a]Source

List the elements in the map in ascending order of keys.

elemsDesc :: OrderedMap map k => map a -> [a]Source

List the elements in the map in descending order of keys.

assocsAsc :: OrderedMap map k => map a -> [(k, a)]Source

List all associations in the map in ascending order of keys.

assocsDesc :: OrderedMap map k => map a -> [(k, a)]Source

List all associations in the map in descending order of keys.

keysAsc :: OrderedMap map k => map a -> [k]Source

List all keys in the map in ascending order.

keysDesc :: OrderedMap map k => map a -> [k]Source

List all keys in the map in descending order.

isProperSubsetOf :: Map map k => map a -> map b -> BoolSource

Similar to `isSubsetOf`

, but also requires that the size of the second map is
greater than the first (so does not include the case where the key sets are identical).

isProperSubmapOfBy :: Map map k => (a -> b -> Bool) -> map a -> map b -> BoolSource

Similar to `isSubmapOf`

, but also requires that the size of the second map is
greater than the first (so does not include the case where the key sets are identical).

sortAscWith :: OrderedMap map k => map Int -> [k] -> [k]Source

Use a map of the supplied type to sort a list of keys into ascending order Slower than nubAscWith, but retains duplicate keys

sortDescWith :: OrderedMap map k => map Int -> [k] -> [k]Source

Use a map of the supplied type to sort a list of keys into descending order Slower than nubDescWith, but retains duplicate keys

nubAscWith :: OrderedMap map k => map () -> [k] -> [k]Source

Use a map of the supplied type to sort a list of keys into ascending order (eliminating duplicates).

nubDescWith :: OrderedMap map k => map () -> [k] -> [k]Source

Use a map of the supplied type to sort a list of keys into descending order (eliminating duplicates).