| Copyright | © 2022–2024 Jonathan Knowles |
|---|---|
| License | Apache-2.0 |
| Safe Haskell | None |
| Language | Haskell2010 |
Data.MonoidMap
Description
Synopsis
- data MonoidMap k v
- empty :: MonoidMap k v
- fromList :: (Ord k, MonoidNull v) => [(k, v)] -> MonoidMap k v
- fromListWith :: (Ord k, MonoidNull v) => (v -> v -> v) -> [(k, v)] -> MonoidMap k v
- fromMap :: MonoidNull v => Map k v -> MonoidMap k v
- singleton :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v
- toList :: MonoidMap k v -> [(k, v)]
- toMap :: MonoidMap k v -> Map k v
- get :: (Ord k, Monoid v) => k -> MonoidMap k v -> v
- set :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v -> MonoidMap k v
- adjust :: (Ord k, MonoidNull v) => (v -> v) -> k -> MonoidMap k v -> MonoidMap k v
- nullify :: Ord k => k -> MonoidMap k v -> MonoidMap k v
- null :: MonoidMap k v -> Bool
- nullKey :: Ord k => k -> MonoidMap k v -> Bool
- nonNull :: MonoidMap k v -> Bool
- nonNullCount :: MonoidMap k v -> Int
- nonNullKey :: Ord k => k -> MonoidMap k v -> Bool
- nonNullKeys :: MonoidMap k v -> Set k
- take :: Int -> MonoidMap k v -> MonoidMap k v
- drop :: Int -> MonoidMap k v -> MonoidMap k v
- splitAt :: Int -> MonoidMap k a -> (MonoidMap k a, MonoidMap k a)
- filter :: (v -> Bool) -> MonoidMap k v -> MonoidMap k v
- filterKeys :: (k -> Bool) -> MonoidMap k v -> MonoidMap k v
- filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v
- partition :: (v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
- partitionKeys :: (k -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
- partitionWithKey :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
- map :: MonoidNull v2 => (v1 -> v2) -> MonoidMap k v1 -> MonoidMap k v2
- mapKeys :: (Ord k2, MonoidNull v) => (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v
- mapKeysWith :: (Ord k2, MonoidNull v) => (v -> v -> v) -> (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v
- append :: (Ord k, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- minus :: (Ord k, MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- minusMaybe :: (Ord k, MonoidNull v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)
- monus :: (Ord k, MonoidNull v, Monus v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- invert :: (MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v
- power :: (Integral i, MonoidNull v, Group v) => MonoidMap k v -> i -> MonoidMap k v
- isSubmapOf :: (Ord k, Monoid v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Bool
- isSubmapOfBy :: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) -> MonoidMap k v1 -> MonoidMap k v2 -> Bool
- disjoint :: (Ord k, GCDMonoid v, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> Bool
- disjointBy :: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) -> MonoidMap k v1 -> MonoidMap k v2 -> Bool
- intersection :: (Ord k, MonoidNull v, GCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- intersectionWith :: (Ord k, MonoidNull v3) => (v1 -> v2 -> v3) -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3
- intersectionWithA :: (Applicative f, Ord k, MonoidNull v3) => (v1 -> v2 -> f v3) -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)
- union :: (Ord k, MonoidNull v, LCMMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- unionWith :: (Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> v3) -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3
- unionWithA :: (Applicative f, Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> f v3) -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)
- isPrefixOf :: (Ord k, Monoid v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Bool
- stripPrefix :: (Ord k, MonoidNull v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)
- commonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripCommonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)
- isSuffixOf :: (Ord k, Monoid v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Bool
- stripSuffix :: (Ord k, MonoidNull v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)
- commonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripCommonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)
- overlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripPrefixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripSuffixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)
Introduction
This module provides the MonoidMap type, which:
- models a total function with
+
Data.MonoidMap monoidmap-0.0.1.4: Monoidal map typeCopyright © 2022–2024 Jonathan Knowles License Apache-2.0 Safe Haskell None Language Haskell2010 Data.MonoidMap
Description
Synopsis
- data MonoidMap k v
- empty :: MonoidMap k v
- fromList :: (Ord k, MonoidNull v) => [(k, v)] -> MonoidMap k v
- fromListWith :: (Ord k, MonoidNull v) => (v -> v -> v) -> [(k, v)] -> MonoidMap k v
- fromMap :: MonoidNull v => Map k v -> MonoidMap k v
- singleton :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v
- toList :: MonoidMap k v -> [(k, v)]
- toMap :: MonoidMap k v -> Map k v
- get :: (Ord k, Monoid v) => k -> MonoidMap k v -> v
- set :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v -> MonoidMap k v
- adjust :: (Ord k, MonoidNull v) => (v -> v) -> k -> MonoidMap k v -> MonoidMap k v
- nullify :: Ord k => k -> MonoidMap k v -> MonoidMap k v
- null :: MonoidMap k v -> Bool
- nullKey :: Ord k => k -> MonoidMap k v -> Bool
- nonNull :: MonoidMap k v -> Bool
- nonNullCount :: MonoidMap k v -> Int
- nonNullKey :: Ord k => k -> MonoidMap k v -> Bool
- nonNullKeys :: MonoidMap k v -> Set k
- take :: Int -> MonoidMap k v -> MonoidMap k v
- drop :: Int -> MonoidMap k v -> MonoidMap k v
- splitAt :: Int -> MonoidMap k a -> (MonoidMap k a, MonoidMap k a)
- filter :: (v -> Bool) -> MonoidMap k v -> MonoidMap k v
- filterKeys :: (k -> Bool) -> MonoidMap k v -> MonoidMap k v
- filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v
- partition :: (v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
- partitionKeys :: (k -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
- partitionWithKey :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
- map :: MonoidNull v2 => (v1 -> v2) -> MonoidMap k v1 -> MonoidMap k v2
- mapKeys :: (Ord k2, MonoidNull v) => (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v
- mapKeysWith :: (Ord k2, MonoidNull v) => (v -> v -> v) -> (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v
- append :: (Ord k, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- minus :: (Ord k, MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- minusMaybe :: (Ord k, MonoidNull v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)
- monus :: (Ord k, MonoidNull v, Monus v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- invert :: (MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v
- power :: (Integral i, MonoidNull v, Group v) => MonoidMap k v -> i -> MonoidMap k v
- isSubmapOf :: (Ord k, Monoid v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Bool
- isSubmapOfBy :: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) -> MonoidMap k v1 -> MonoidMap k v2 -> Bool
- disjoint :: (Ord k, GCDMonoid v, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> Bool
- disjointBy :: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) -> MonoidMap k v1 -> MonoidMap k v2 -> Bool
- intersection :: (Ord k, MonoidNull v, GCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- intersectionWith :: (Ord k, MonoidNull v3) => (v1 -> v2 -> v3) -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3
- intersectionWithA :: (Applicative f, Ord k, MonoidNull v3) => (v1 -> v2 -> f v3) -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)
- union :: (Ord k, MonoidNull v, LCMMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- unionWith :: (Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> v3) -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3
- unionWithA :: (Applicative f, Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> f v3) -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)
- isPrefixOf :: (Ord k, Monoid v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Bool
- stripPrefix :: (Ord k, MonoidNull v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)
- commonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripCommonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)
- isSuffixOf :: (Ord k, Monoid v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Bool
- stripSuffix :: (Ord k, MonoidNull v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)
- commonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripCommonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)
- overlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripPrefixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripSuffixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
- stripOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)
Introduction
This module provides the
MonoidMaptype, which:- models a total function with
finite support
- from keys to monoidal values, with a default value
- of
mempty. - encodes key-value mappings with a minimal encoding that
- only includes values not equal to
mempty. - provides a comprehensive set of
+ from keys to monoidal values, with a default value
+ of
mempty. - encodes key-value mappings with a minimal encoding that
+ only includes values not equal to
mempty. - provides a comprehensive set of monoidal operations for transforming, combining, and comparing maps.
The documentation in this module serves as reference guide to the
MonoidMaptype and its operations.See the
READMEfile for:Relationship between keys and values
A
MonoidMapof key typekand value typevassociates every - possible key of typekwith a value of typev:get:: (Ordk,Monoidv) => k ->MonoidMapk v -> v + possible key of typekwith a value of typev:get:: (Ordk,Monoidv) => k ->MonoidMapk v -> vThe
emptymap associates every keykwith a default value of -mempty:∀ k.
getkempty==mempty+mempty:∀ k.
getkempty==memptyComparison with standard
MaptypeThe
MonoidMaptype differs from the standardMaptype in how it relates keys to values:Type Models a total function with finite support Mapk vfrom keys of type k-to values of typeMaybevMonoidMapk v+to values of typeMaybevMonoidMapk vfrom keys of type kto values of typev.This difference can be illustrated by comparing the type signatures of - operations to query a key for its value, for both types:
Map.lookup:: k ->Mapk v ->Maybev -MonoidMap.get::Monoidv => k ->MonoidMapk v -> v -Whereas a standard
Maphas a default value ofNothing, aMonoidMaphas - a default value ofmempty:∀ k.
Map.lookupkMap.empty==Nothing-∀ k.MonoidMap.getkMonoidMap.empty==mempty-In practice, the standard
Maptype usesMaybeto indicate the presence + operations to query a key for its value, for both types:Map.lookup:: k ->Mapk v ->Maybev +MonoidMap.get::Monoidv => k ->MonoidMapk v -> v +Whereas a standard
Maphas a default value ofNothing, aMonoidMaphas + a default value ofmempty:∀ k.
Map.lookupkMap.empty==Nothing+∀ k.MonoidMap.getkMonoidMap.empty==mempty+In practice, the standard
Maptype usesMaybeto indicate the presence or absence of a value for a particular key. This representation is necessary because theMaptype imposes no constraints on value types.However, monoidal types already have a natural way to represent null or - empty values: the
memptyconstant, which represents the neutral or - identity element of aMonoid.Consequently, using a standard
Mapwith a monoidal value type gives rise + empty values: thememptyconstant, which represents the neutral or + identity element of aMonoid.Consequently, using a standard
Mapwith a monoidal value type gives rise to two distinct representations for null or empty values:Map.lookupk mInterpretation -Nothing+NothingMapmhas no entry for keyk.-Justmempty+JustmemptyMapmhas an entry for keyk, but the value is empty.In constrast, the
MonoidMaptype provides a single, canonical @@ -49,694 +49,694 @@MonoidMap.getk m-Nothing+Nothing⟼ -mempty+mempty-Justv +Justv-v==mempty+v==mempty⟼ -mempty+mempty-Justv +Justv-v/=mempty+v/=mempty⟼ vEncoding
A
MonoidMaponly encodes mappings from keys to values that are not equal - tomempty.The total function \(T\) modelled by a
MonoidMapis encoded as a + tomempty.The total function \(T\) modelled by a
MonoidMapis encoded as a support map \(S\), where \(S\) is the finite subset of key-value - mappings in \(T\) for which values are not equal tomempty(denoted by + mappings in \(T\) for which values are not equal tomempty(denoted by \(\varnothing\)):\( \quad S = \{ (k, v) \in T \ | \ v \ne \varnothing \} \)
Automatic minimisation
All
MonoidMapoperations perform automatic minimisation of the support - map, so thatmemptyvalues do not appear in:Constraints on values
MonoidMapoperations require the monoidal value type to be an instance of + map, so thatmemptyvalues do not appear in:Constraints on values
MonoidMapoperations require the monoidal value type to be an instance ofMonoidNull.Instances of
MonoidNullmust provide anullindicator function that - satisfies the following law:∀ v.
MonoidNull.nullv==(v==mempty) + satisfies the following law:∀ v.
MonoidNull.nullv==(v==mempty)MonoidMapoperations use thenullindicator function to detect and - excludememptyvalues from the support map.Note that it is not generally necessary for the value type to be an - instance of
Eq.Monoidal operations
The
MonoidMaptype provides a comprehensive set of monoidal operations - for transforming, combining, and comparing maps.Instances for several subclasses of
SemigroupandMonoidare - provided, including classes from the following libraries:At the root of this hierarchy of subclasses is the
Semigroupclass, whose + excludememptyvalues from the support map.Note that it is not generally necessary for the value type to be an + instance of
Eq.Monoidal operations
The
MonoidMaptype provides a comprehensive set of monoidal operations + for transforming, combining, and comparing maps.Instances for several subclasses of
SemigroupandMonoidare + provided, including classes from the following libraries:At the root of this hierarchy of subclasses is the
Semigroupclass, whose instance forMonoidMapis defined in terms of the underlying value type, - so that applying(<>)to a pair of maps is equivalent to applying(<>)- to all pairs of values for matching keys:∀ k.
getk (m1<>m2)==getk m1<>getk m2 -In general, operations for subclasses of
SemigroupandMonoidare - defined analogously to theSemigroupinstance, so that:- unary operations on individual maps are defined in terms of their
+ so that applying
(<>)to a pair of maps is equivalent to applying(<>)+ to all pairs of values for matching keys:∀ k.
getk (m1<>m2)==getk m1<>getk m2 +In general, operations for subclasses of
SemigroupandMonoidare + defined analogously to theSemigroupinstance, so that:- unary operations on individual maps are defined in terms of their distributive application to all values.
- binary operations on pairs of maps are defined in terms of their - distributive application to all pairs of values for matching keys.
Unary monoidal operations typically satisfy a property similar to:
∀ k.
getk (f m)==f (getk m) -Binary monoidal operations typically satisfy a property similar to:
∀ k.
getk (f m1 m2)==f (getk m1) (getk m2) + distributive application to all pairs of values for matching keys.
Unary monoidal operations typically satisfy a property similar to:
∀ k.
getk (f m)==f (getk m) +Binary monoidal operations typically satisfy a property similar to:
∀ k.
getk (f m1 m2)==f (getk m1) (getk m2)Defining monoidal operations in this way makes it possible to transform, combine, and compare maps in ways that are consistent with the algebraic - properties of the underlying monoidal value type.
Type
Instances
General operations
Construction
\ No newline at end of file +fromList :: (Ord k, MonoidNull v) => [(k, v)] -> MonoidMap k v #
\(O(n \log n)\). Constructs a
MonoidMapfrom a list of key-value pairs.If the list contains more than one value for the same key, values are - combined together in the order that they appear with the
(<>)operator.Satisfies the following property for all possible keys
k:getk (fromListkvs)==-foldMapsnd(filter((==k) . fst) kvs) -Satisfies the following round-trip property:
fromList(toListm)==m -Examples
Type
Instances
Bifoldable MonoidMap Eq2 MonoidMap Show2 MonoidMap Eq k => Eq1 (MonoidMap k) Show k => Show1 (MonoidMap k) Foldable (MonoidMap k) Defined in Data.MonoidMap.Internal
Methods
fold :: Monoid m => MonoidMap k m -> m #
foldMap :: Monoid m => (a -> m) -> MonoidMap k a -> m #
foldMap' :: Monoid m => (a -> m) -> MonoidMap k a -> m #
foldr :: (a -> b -> b) -> b -> MonoidMap k a -> b #
foldr' :: (a -> b -> b) -> b -> MonoidMap k a -> b #
foldl :: (b -> a -> b) -> b -> MonoidMap k a -> b #
foldl' :: (b -> a -> b) -> b -> MonoidMap k a -> b #
foldr1 :: (a -> a -> a) -> MonoidMap k a -> a #
foldl1 :: (a -> a -> a) -> MonoidMap k a -> a #
toList :: MonoidMap k a -> [a] #
null :: MonoidMap k a -> Bool #
length :: MonoidMap k a -> Int #
elem :: Eq a => a -> MonoidMap k a -> Bool #
maximum :: Ord a => MonoidMap k a -> a #
minimum :: Ord a => MonoidMap k a -> a #
(Ord k, MonoidNull v, Commutative v) => Commutative (MonoidMap k v) Defined in Data.MonoidMap.Internal
(NFData k, NFData v) => NFData (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v) => Monoid (MonoidMap k v) (Ord k, MonoidNull v) => Semigroup (MonoidMap k v) (Ord k, MonoidNull v) => IsList (MonoidMap k v) Defined in Data.MonoidMap.Internal
Associated Types
type Item (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, Read k, MonoidNull v, Read v) => Read (MonoidMap k v) (Show k, Show v) => Show (MonoidMap k v) (Eq k, Eq v) => Eq (MonoidMap k v) (Ord k, MonoidNull v, Abelian v) => Abelian (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, Group v) => Group (MonoidMap k v) (Ord k, MonoidNull v, DistributiveGCDMonoid v) => DistributiveGCDMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, GCDMonoid v) => GCDMonoid (MonoidMap k v) (Ord k, MonoidNull v, LeftDistributiveGCDMonoid v) => LeftDistributiveGCDMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, LeftGCDMonoid v) => LeftGCDMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, RightDistributiveGCDMonoid v) => RightDistributiveGCDMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, RightGCDMonoid v) => RightGCDMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, DistributiveLCMMonoid v) => DistributiveLCMMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, LCMMonoid v) => LCMMonoid (MonoidMap k v) (Ord k, MonoidNull v, Monus v) => Monus (MonoidMap k v) (Ord k, MonoidNull v, OverlappingGCDMonoid v) => OverlappingGCDMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
Methods
stripPrefixOverlap :: MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
stripSuffixOverlap :: MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
overlap :: MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
stripOverlap :: MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
(Ord k, MonoidNull v) => MonoidNull (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, PositiveMonoid v) => PositiveMonoid (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, Cancellative v) => Cancellative (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, LeftCancellative v) => LeftCancellative (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, LeftReductive v) => LeftReductive (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, Reductive v) => Reductive (MonoidMap k v) (Ord k, MonoidNull v, RightCancellative v) => RightCancellative (MonoidMap k v) Defined in Data.MonoidMap.Internal
(Ord k, MonoidNull v, RightReductive v) => RightReductive (MonoidMap k v) Defined in Data.MonoidMap.Internal
(NoThunks k, NoThunks v) => NoThunks (MonoidMap k v) type Item (MonoidMap k v) Defined in Data.MonoidMap.Internal
General operations
Construction
fromList :: (Ord k, MonoidNull v) => [(k, v)] -> MonoidMap k v #
\(O(n \log n)\). Constructs a
MonoidMapfrom a list of key-value pairs.If the list contains more than one value for the same key, values are + combined together in the order that they appear with the
(<>)operator.Satisfies the following property for all possible keys
k:getk (fromListkvs)==+foldMapsnd(filter((==k) . fst) kvs) +Satisfies the following round-trip property:
fromList(toListm)==m +Examples
Arguments
:: (Ord k, MonoidNull v) => (v -> v -> v) Function with which to combine values for duplicate keys.
-> [(k, v)] -> MonoidMap k v \(O(n \log n)\). Constructs a
MonoidMapfrom a list of key-value pairs, +Arguments
:: (Ord k, MonoidNull v) => (v -> v -> v) Function with which to combine values for duplicate keys.
-> [(k, v)] -> MonoidMap k v \(O(n \log n)\). Constructs a
MonoidMapfrom a list of key-value pairs, with a combining function for values.If the list contains more than one value for the same key, values are combined together in the order that they appear with the given combining - function.
Satisfies the following property for all possible keys
k:getk (fromListWithf kvs)==-maybemempty(foldl1f) - (nonEmpty(snd<$>filter((==k) . fst) kvs)) -fromMap :: MonoidNull v => Map k v -> MonoidMap k v #
\(O(n)\). Constructs a
MonoidMapfrom an ordinaryMap.Satisfies the following property for all possible keys
k:getk (fromMapm)==findWithDefaultmemptykm + function.Satisfies the following property for all possible keys
k:getk (fromListWithf kvs)==+maybemempty(foldl1f) + (nonEmpty(snd<$>filter((==k) . fst) kvs)) +fromMap :: MonoidNull v => Map k v -> MonoidMap k v #
singleton :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v #
singleton :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v #
Deconstruction
toList :: MonoidMap k v -> [(k, v)] #
\(O(n)\). Converts a
MonoidMapto a list of key-value pairs, where the - keys are in ascending order.The result only includes entries with values that are not
null.Satisfies the following round-trip property:
fromList(toListm)==m -The resulting list is sorted in ascending key order:
sortOnfst(toListm)==toListm + keys are in ascending order.The result only includes entries with values that are not
null.Satisfies the following round-trip property:
fromList(toListm)==m +The resulting list is sorted in ascending key order:
sortOnfst(toListm)==toListmLookup
Modification
Membership
Lookup
Modification
Membership
nonNull :: MonoidMap k v -> Bool #
\(O(1)\). Returns
Trueif (and only if) the map contains at least one - value that is notnull.Satisfies the following property:
nonNullm==(∃ k.nonNullKeyk m) -nonNullCount :: MonoidMap k v -> Int #
\(O(1)\). Returns a count of all values in the map that are not
null.Satisfies the following property:
nonNullCountm==size(nonNullKeysm) -nonNullKey :: Ord k => k -> MonoidMap k v -> Bool #
\(O(\log n)\). Returns
Trueif (and only if) the given key is associated - with a value that is notnull.Satisfies the following property:
nonNullKeyk m==not(null(getk m)) +MonoidNull.nonNull :: MonoidMap k v -> Bool #
\(O(1)\). Returns
Trueif (and only if) the map contains at least one + value that is notnull.Satisfies the following property:
nonNullm==(∃ k.nonNullKeyk m) +nonNullCount :: MonoidMap k v -> Int #
\(O(1)\). Returns a count of all values in the map that are not
null.Satisfies the following property:
nonNullCountm==size(nonNullKeysm) +nonNullKey :: Ord k => k -> MonoidMap k v -> Bool #
nonNullKeys :: MonoidMap k v -> Set k #
\(O(n)\). Returns the set of keys associated with values that are not -
null.Satisfies the following property:
k
`member`(nonNullKeysm)==nonNullKeyk m -Slicing
splitAt :: Int -> MonoidMap k a -> (MonoidMap k a, MonoidMap k a) #
\(O(\log n)\). Splits a map into two slices.
This function is equivalent to a combination of
takeanddrop:splitAtn m==(taken m,dropn m) -The resulting maps can be combined to reproduce the original map:
splitAtn m&- \(m1, m2) -> m1<>m2==m -The resulting maps have disjoint sets of non-
nullentries:splitAtn m&+null.Satisfies the following property:
k
`member`(nonNullKeysm)==nonNullKeyk m +Slicing
splitAt :: Int -> MonoidMap k a -> (MonoidMap k a, MonoidMap k a) #
\(O(\log n)\). Splits a map into two slices.
This function is equivalent to a combination of
takeanddrop:splitAtn m==(taken m,dropn m) +The resulting maps can be combined to reproduce the original map:
splitAtn m&+ \(m1, m2) -> m1<>m2==m +The resulting maps have disjoint sets of non-
nullentries:splitAtn m&\(m1, m2) ->disjoint(nonNullKeysm1) (nonNullKeysm2) -Filtering
Filtering
filter :: (v -> Bool) -> MonoidMap k v -> MonoidMap k v #
\(O(n)\). Filters a map according to a predicate on values.
Satisfies the following property for all possible keys
k:getk (filterf m)==if f (getk m) thengetk m - elsemempty+ elsememptyThe resulting map is identical to that obtained by constructing a map from a - filtered list of key-value pairs:
filterf m==fromList(filter(f .snd) (toListm)) -filterKeys :: (k -> Bool) -> MonoidMap k v -> MonoidMap k v #
filterKeys :: (k -> Bool) -> MonoidMap k v -> MonoidMap k v #
\(O(n)\). Filters a map according to a predicate on keys.
Satisfies the following property for all possible keys
k:getk (filterKeysf m)==if f k thengetk m - elsemempty+ elsememptyThe resulting map is identical to that obtained by constructing a map from a - filtered list of key-value pairs:
filterf m==fromList(filter(f .fst) (toListm)) -filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v #
filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v #
\(O(n)\). Filters a map according to a predicate on keys and values.
Satisfies the following property for all possible keys
k:getk (filterWithKeyf m)==if f k (getk m) thengetk m - elsemempty+ elsememptyThe resulting map is identical to that obtained by constructing a map from a - filtered list of key-value pairs:
filterWithKeyf m==fromList(filter(uncurryf) (toListm)) -Partitioning
Partitioning
partition :: (v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) #
\(O(n)\). Partitions a map according to a predicate on values.
Satisfies the following property:
partitionf m==(filterf m - ,filter(not. f) m + ,filter(not. f) m ) -The resulting maps can be combined to reproduce the original map:
partitionf m&\(m1, m2) -> - m1<>m2==m -The resulting maps have disjoint sets of non-
nullentries:partitionf m&\(m1, m2) -> +The resulting maps can be combined to reproduce the original map:
partitionf m&\(m1, m2) -> + m1<>m2==m +The resulting maps have disjoint sets of non-
nullentries:partitionf m&\(m1, m2) ->disjoint(nonNullKeysm1) (nonNullKeysm2) -partitionKeys :: (k -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) #
\(O(n)\). Partitions a map according to a predicate on keys.
Satisfies the following property:
partitionKeysf m==+partitionKeys :: (k -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) #
\(O(n)\). Partitions a map according to a predicate on keys.
Satisfies the following property:
partitionKeysf m==(filterKeysf m - ,filterKeys(not. f) m + ,filterKeys(not. f) m ) -The resulting maps can be combined to reproduce the original map:
partitionKeysf m&\(m1, m2) -> - m1<>m2==m -The resulting maps have disjoint sets of non-
nullentries:partitionKeysf m&\(m1, m2) -> +The resulting maps can be combined to reproduce the original map:
partitionKeysf m&\(m1, m2) -> + m1<>m2==m +The resulting maps have disjoint sets of non-
nullentries:partitionKeysf m&\(m1, m2) ->disjoint(nonNullKeysm1) (nonNullKeysm2) -partitionWithKey :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) #
\(O(n)\). Partitions a map according to a predicate on keys and values.
Satisfies the following property:
partitionWithKeyf m==+partitionWithKey :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) #
\(O(n)\). Partitions a map according to a predicate on keys and values.
Satisfies the following property:
partitionWithKeyf m==(filterWithKeyf m - ,filterWithKey((fmap.fmap)notf) m + ,filterWithKey((fmap.fmap)notf) m ) -The resulting maps can be combined to reproduce the original map:
partitionWithKeyf m&\(m1, m2) -> - m1<>m2==m -The resulting maps have disjoint sets of non-
nullentries:partitionWithKeyf m&\(m1, m2) -> +The resulting maps can be combined to reproduce the original map:
partitionWithKeyf m&\(m1, m2) -> + m1<>m2==m +The resulting maps have disjoint sets of non-
nullentries:partitionWithKeyf m&\(m1, m2) ->disjoint(nonNullKeysm1) (nonNullKeysm2) -Mapping
map :: MonoidNull v2 => (v1 -> v2) -> MonoidMap k v1 -> MonoidMap k v2 #
\(O(n)\). Applies a function to all non-
nullvalues of aMonoidMap.Satisfies the following properties for all functions
f:(
getk m==mempty) ==> (getk (mapf m)==mempty) -(getk m/=mempty) ==> (getk (mapf m)==f (getk m)) -Conditional properties
If applying function
ftomemptyproducesmempty, then the - following additional properties hold:(f
mempty==mempty) +Mapping
map :: MonoidNull v2 => (v1 -> v2) -> MonoidMap k v1 -> MonoidMap k v2 #
\(O(n)\). Applies a function to all non-
nullvalues of aMonoidMap.Satisfies the following properties for all functions
f:(
getk m==mempty) ==> (getk (mapf m)==mempty) +(getk m/=mempty) ==> (getk (mapf m)==f (getk m)) +Conditional properties
If applying function
ftomemptyproducesmempty, then the + following additional properties hold:(f
mempty==mempty) ==> - (∀ k.getk (mapf m)==f (getk m)) -(f
mempty==mempty) + (∀ k.getk (mapf m)==f (getk m)) +(f
mempty==mempty) ==> - (∀ g.map(f . g) m==mapf (mapg m)) -mapKeys :: (Ord k2, MonoidNull v) => (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v #
\(O(n \log n)\). Applies a function to all the keys of a
MonoidMapthat are associated with non-nullvalues.If the resultant map would contain more than one value for the same key, - values are combined together in ascending key order with the
(<>)- operator.Satisfies the following property for all possible keys
k:getk (mapKeysf m)==+ values are combined together in ascending key order with the(<>)+ operator.Satisfies the following property for all possible keys
k:getk (mapKeysf m)==foldMap(`get`m) - (filter((==) k . f) (nonNullKeysm)) -Arguments
:: (Ord k2, MonoidNull v) => (v -> v -> v) Function with which to combine values for duplicate keys.
-> (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v \(O(n \log n)\). Applies a function to all the keys of a
MonoidMapthat + (filter((==) k . f) (nonNullKeysm)) +Arguments
:: (Ord k2, MonoidNull v) => (v -> v -> v) Function with which to combine values for duplicate keys.
-> (k1 -> k2) -> MonoidMap k1 v -> MonoidMap k2 v \(O(n \log n)\). Applies a function to all the keys of a
MonoidMapthat are associated with non-nullvalues, with a combining function for values.If the resultant map would contain more than one value for the same key, values are combined together in ascending key order with the given - combining function.
Satisfies the following property:
mapKeysWithc f==fromListWithc .fmap(firstf) .toList+ combining function.Satisfies the following property:
mapKeysWithc f==fromListWithc .fmap(firstf) .toListMonoidal operations
See the section on monoidal operations within - the introduction.
Association
append :: (Ord k, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Appends a pair of maps together.
Uses the
Semigroupoperator(<>)to append each value in the first map - to its matching value in the second map.Satisfies the following property for all possible keys
k:getk (appendm1 m2)==getk m1<>getk m2 -This function provides the definition of
(<>)for theMonoidMapinstance - ofSemigroup.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "abc"), (2, "ij" ), (3, "p" ) ] + the introduction.Association
append :: (Ord k, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Appends a pair of maps together.
Uses the
Semigroupoperator(<>)to append each value in the first map + to its matching value in the second map.Satisfies the following property for all possible keys
k:getk (appendm1 m2)==getk m1<>getk m2 +This function provides the definition of
(<>)for theMonoidMapinstance + ofSemigroup.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "abc"), (2, "ij" ), (3, "p" ) ] >>> m2 =fromList[ (2, " k"), (3, "qr"), (4, "xyz")] >>> m3 =fromList[(1, "abc"), (2, "ijk"), (3, "pqr"), (4, "xyz")] ->>>
appendm1 m2==m3 -True->>> m1 =
fromList[("a", 4), ("b", 2), ("c", 1) ] +>>>
appendm1 m2==m3 +True+>>> m1 =
fromList[("a", 4), ("b", 2), ("c", 1) ] >>> m2 =fromList[ ("b", 1), ("c", 2), ("d", 4)] >>> m3 =fromList[("a", 4), ("b", 3), ("c", 3), ("d", 4)] ->>>
appendm1 m2==m3 -True-Subtraction
minus :: (Ord k, MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Performs group subtraction of the second map from the first.
Uses the
Groupsubtraction operator(~~)to subtract each value in the - second map from its matching value in the first map.Satisfies the following property for all possible keys
k:getk (m1`minus`m2)==getk m1~~getk m2 +>>>
appendm1 m2==m3 +True+Subtraction
minus :: (Ord k, MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Performs group subtraction of the second map from the first.
Uses the
Groupsubtraction operator(~~)to subtract each value in the + second map from its matching value in the first map.Satisfies the following property for all possible keys
k:getk (m1`minus`m2)==getk m1~~getk m2This function provides the definition of
(~~)for theMonoidMap- instance ofGroup.Examples
With
SumIntegervalues, this function performs normal + instance ofGroup.Examples
With
SumIntegervalues, this function performs normal integer subtraction of matching values:>>> m1 =
fromList[("a", (-1)), ("b", 0 ), ("c", 1)] >>> m2 =fromList[("a", 1 ), ("b", 1 ), ("c", 1)] >>> m3 =fromList[("a", (-2)), ("b", (-1)), ("c", 0)] ->>> m1
`minus`m2==m3 -True+>>> m1
`minus`m2==m3 +True>>> m1 =
fromList[("a", (-1)), ("b", 0 ), ("c", 1 )] >>> m2 =fromList[("a", (-1)), ("b", (-1)), ("c", (-1))] >>> m3 =fromList[("a", 0 ), ("b", 1 ), ("c", 2 )] ->>> m1
`minus`m2==m3 -True-minusMaybe :: (Ord k, MonoidNull v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v) #
minusMaybe :: (Ord k, MonoidNull v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v) #
Performs reductive subtraction of the second map from the first.
Uses the
Reductivesubtraction operator(</>)to subtract each value in the second map from its matching value in the first map.This function produces a result if (and only if) for all possible keys
k, it is possible to subtract the value forkin the second map - from the value forkin the first map:isJust(m1`minusMaybe`m2) -==(∀ k.isJust(getk m1</>getk m2)) -Otherwise, this function returns
Nothing.This function satisfies the following property:
all- (\r ->Just(getk r)==getk m1</>getk m2) + from the value forkin the first map:isJust(m1`minusMaybe`m2) +==(∀ k.isJust(getk m1</>getk m2)) +Otherwise, this function returns
Nothing.This function satisfies the following property:
all+ (\r ->Just(getk r)==getk m1</>getk m2) (m1`minusMaybe`m2)This function provides the definition of
(</>)for theMonoidMap- instance ofReductive.Examples
With
SetNaturalvalues, this function performs set + instance ofReductive.Examples
With
SetNaturalvalues, this function performs set subtraction of matching values, succeeding if (and only if) each value - from the second map is a subset of its matching value from the first map:f xs =
fromList(fromList<$>xs) + from the second map is a subset of its matching value from the first map:f xs =
fromList(fromList<$>xs)>>> m1 = f [("a", [0,1,2]), ("b", [0,1,2])] >>> m2 = f [("a", [ ]), ("b", [0,1,2])] >>> m3 = f [("a", [0,1,2]), ("b", [ ])] ->>> m1
`minusMaybe`m2==Justm3 -True+>>> m1
`minusMaybe`m2==Justm3 +True>>> m1 = f [("a", [0,1,2]), ("b", [0,1,2]), ("c", [0,1,2])] >>> m2 = f [("a", [0 ]), ("b", [ 1 ]), ("c", [ 2])] >>> m3 = f [("a", [ 1,2]), ("b", [0, 2]), ("c", [0,1 ])] ->>> m1
`minusMaybe`m2==Justm3 -True+>>> m1
`minusMaybe`m2==Justm3 +True>>> m1 = f [("a", [0,1,2 ]), ("b", [0,1,2 ]), ("c", [0,1,2 ])] >>> m2 = f [("a", [ 2,3,4]), ("b", [ 1,2,3,4]), ("c", [0,1,2,3,4])] ->>> m1
`minusMaybe`m2==Nothing-True->>> m1
`minusMaybe`m2==Nothing+True+With
SumNaturalvalues, this function performs ordinary subtraction of matching values, succeeding if (and only if) each value from the second map is less than or equal to its matching value from the first map:>>> m1 =
fromList[("a", 2), ("b", 3), ("c", 5), ("d", 8)] >>> m2 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 0)] >>> m3 =fromList[("a", 2), ("b", 3), ("c", 5), ("d", 8)] ->>> m1
`minusMaybe`m2==Justm3 -True+>>> m1
`minusMaybe`m2==Justm3 +True>>> m1 =
fromList[("a", 2), ("b", 3), ("c", 5), ("d", 8)] >>> m2 =fromList[("a", 1), ("b", 2), ("c", 3), ("d", 5)] >>> m3 =fromList[("a", 1), ("b", 1), ("c", 2), ("d", 3)] ->>> m1
`minusMaybe`m2==Justm3 -True+>>> m1
`minusMaybe`m2==Justm3 +True>>> m1 =
fromList[("a", 2), ("b", 3), ("c", 5), ("d", 8)] >>> m2 =fromList[("a", 2), ("b", 3), ("c", 5), ("d", 8)] >>> m3 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 0)] ->>> m1
`minusMaybe`m2==Justm3 -True+>>> m1
`minusMaybe`m2==Justm3 +True>>> m1 =
fromList[("a", 2), ("b", 3), ("c", 5), ("d", 8)] >>> m2 =fromList[("a", 3), ("b", 3), ("c", 5), ("d", 8)] ->>> m1
`minusMaybe`m2==Nothing-True-monus :: (Ord k, MonoidNull v, Monus v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Performs monus subtraction of the second map from the first.
Uses the
Monussubtraction operator(<\>)to subtract each value in - the second map from its matching value in the first map.Satisfies the following property for all possible keys
k:getk (m1`monus`m2)==getk m1<\>getk m2 +>>> m1
`minusMaybe`m2==Nothing+True+monus :: (Ord k, MonoidNull v, Monus v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Performs monus subtraction of the second map from the first.
Uses the
Monussubtraction operator(<\>)to subtract each value in + the second map from its matching value in the first map.Satisfies the following property for all possible keys
k:getk (m1`monus`m2)==getk m1<\>getk m2This function provides the definition of
(<\>)for theMonoidMap- instance ofMonus.Examples
With
SetNaturalvalues, this function performs set - subtraction of matching values:f xs =
fromList(fromList<$>xs) + instance ofMonus.Examples
With
SetNaturalvalues, this function performs set + subtraction of matching values:f xs =
fromList(fromList<$>xs)>>> m1 = f [("a", [0,1,2]), ("b", [0,1,2])] >>> m2 = f [("a", [ ]), ("b", [0,1,2])] >>> m3 = f [("a", [0,1,2]), ("b", [ ])] ->>> m1
`monus`m2==m3 -True+>>> m1
`monus`m2==m3 +True>>> m1 = f [("a", [0,1,2]), ("b", [0,1,2]), ("c", [0,1,2])] >>> m2 = f [("a", [0 ]), ("b", [ 1 ]), ("c", [ 2])] >>> m3 = f [("a", [ 1,2]), ("b", [0, 2]), ("c", [0,1 ])] ->>> m1
`monus`m2==m3 -True+>>> m1
`monus`m2==m3 +True>>> m1 = f [("a", [0,1,2 ]), ("b", [0,1,2 ]), ("c", [0,1,2 ])] >>> m2 = f [("a", [ 2,3,4]), ("b", [ 1,2,3,4]), ("c", [0,1,2,3,4])] >>> m3 = f [("a", [0,1 ]), ("b", [0 ]), ("c", [ ])] ->>> m1
`monus`m2==m3 -True->>> m1
`monus`m2==m3 +True+With
SumNaturalvalues, this function performs truncated subtraction of matching values:>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 0)] >>> m3 =fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] ->>> m1
`monus`m2==m3 -True+>>> m1
`monus`m2==m3 +True>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 1), ("b", 1), ("c", 1), ("d", 1)] >>> m3 =fromList[("a", 0), ("b", 0), ("c", 1), ("d", 2)] ->>> m1
`monus`m2==m3 -True+>>> m1
`monus`m2==m3 +True>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 2), ("b", 2), ("c", 2), ("d", 2)] >>> m3 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 1)] ->>> m1
`monus`m2==m3 -True+>>> m1
`monus`m2==m3 +True>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 4), ("b", 4), ("c", 4), ("d", 4)] >>> m3 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 0)] ->>> m1
`monus`m2==m3 -True-Inversion
Inversion
invert :: (MonoidNull v, Group v) => MonoidMap k v -> MonoidMap k v #
Exponentiation
Exponentiation
power :: (Integral i, MonoidNull v, Group v) => MonoidMap k v -> i -> MonoidMap k v #
Performs exponentiation of every value in a map.
Uses the
Groupexponentiation methodpowto raise every value in a map + to the power of the given exponent.Satisfies the following property for all possible keys
k:getk (m`power`i)==getk m`pow`iThis function provides the definition of
powfor theMonoidMap- instance ofGroup.Examples
With
SumNaturalvalues, this function + instance ofGroup.Examples
With
SumNaturalvalues, this function performs ordinary multiplication of all values by the given exponent:>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 0), ("b", 2), ("c", 4), ("d", 6)] ->>> m1
`power`2==m2 -True+>>> m1
`power`2==m2 +True>>> m1 =
fromList[("a", 0), ("b", 1 ), ("c", 2 ), ("d", 3 )] >>> m2 =fromList[("a", 0), ("b", (-1)), ("c", (-2)), ("d", (-3))] ->>> m1
`power`(-1)==m2 -True-Comparison
isSubmapOf :: (Ord k, Monoid v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not the first map is a submap of the second.
Map
m1is a submap of mapm2if (and only if)m1can be - subtracted fromm2with theminusMaybeoperation:m1
`isSubmapOf`m2==isJust(m2`minusMaybe`m1) +>>> m1
`power`(-1)==m2 +True+Comparison
isSubmapOf :: (Ord k, Monoid v, Reductive v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not the first map is a submap of the second.
Map
m1is a submap of mapm2if (and only if)m1can be + subtracted fromm2with theminusMaybeoperation:m1
`isSubmapOf`m2==isJust(m2`minusMaybe`m1)Equivalently, map
m1is a submap of mapm2if (and only if) for all possible keysk, the value forkinm1can be - subtracted from the value forkinm2with the(</>)operator:m1
`isSubmapOf`m2==(∀ k.isJust(getk m2</>getk m1)) -Arguments
:: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) Function with which to compare values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> Bool Indicates whether or not the first map is a submap of the second, using - the given function to compare values for matching keys.
Satisfies the following property:
isSubmapOfByf m1 m2==-all(\k -> f (getk m1) (getk m2)) (nonNullKeysm1) -Conditional totality
If the given comparison function
falways evaluates toTrue- when its first argument ismempty:∀ v. f
memptyv -Then the following property holds:
isSubmapOfByf m1 m2==(∀ k. f (getk m1) (getk m2)) -disjoint :: (Ord k, GCDMonoid v, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not a pair of maps are disjoint.
Maps
m1andm2are disjoint if (and only if) their intersection - is empty:disjointm1 m2==(intersectionm1 m2==mempty) + subtracted from the value forkinm2with the(</>)operator:m1
`isSubmapOf`m2==(∀ k.isJust(getk m2</>getk m1)) +Arguments
:: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) Function with which to compare values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> Bool Indicates whether or not the first map is a submap of the second, using + the given function to compare values for matching keys.
Satisfies the following property:
isSubmapOfByf m1 m2==+all(\k -> f (getk m1) (getk m2)) (nonNullKeysm1) +Conditional totality
If the given comparison function
falways evaluates toTrue+ when its first argument ismempty:∀ v. f
memptyv +Then the following property holds:
isSubmapOfByf m1 m2==(∀ k. f (getk m1) (getk m2)) +disjoint :: (Ord k, GCDMonoid v, MonoidNull v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not a pair of maps are disjoint.
Maps
m1andm2are disjoint if (and only if) their intersection + is empty:disjointm1 m2==(intersectionm1 m2==mempty)Equivalently, maps
m1andm2are disjoint if (and only if) for all possible keysk, the values forkinm1andm2- have agcdthat isnull:disjointm1 m2==(∀ k.null(gcd(getk m1) (getk m2))) -Arguments
:: (Ord k, Monoid v1, Monoid v2) => (v1 -> v2 -> Bool) Function with which to test pairs of values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> Bool Indicates whether or not a pair of maps are disjoint using the given + indicator function to test pairs of values for matching keys.
Satisfies the following property:
disjointByf m1 m2==+all(\k -> f (getk m1) (getk m2)) (intersection(nonNullKeysm1) (nonNullKeysm2)) -Conditional totality
If the given indicator function
falways evaluates toTrue- when either or both of its arguments aremempty:∀ v. (f v
mempty)&&(fmemptyv) -Then the following property holds:
disjointByf m1 m2==(∀ k. f (getk m1) (getk m2)) -Intersection
intersection :: (Ord k, MonoidNull v, GCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the intersection of two maps.
The intersection of maps
m1andm2is the greatest single map +Conditional totality
If the given indicator function
falways evaluates toTrue+ when either or both of its arguments aremempty:∀ v. (f v
mempty)&&(fmemptyv) +Then the following property holds:
disjointByf m1 m2==(∀ k. f (getk m1) (getk m2)) +Intersection
intersection :: (Ord k, MonoidNull v, GCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the intersection of two maps.
The intersection of maps
m1andm2is the greatest single mapmthat is a submap of bothm1andm2:intersectionm1 m2`isSubmapOf`m1intersectionm1 m2`isSubmapOf`m2 -The intersection is unique:
and+The intersection is unique:
and[intersectionm1 m2`isSubmapOf`m , m`isSubmapOf`m1 , m`isSubmapOf`m2 ] ==> - (m==intersectionm1 m2) -The following property holds for all possible keys
k:getk (intersectionm1 m2)==gcd(getk m1) (getk m2) + (m==intersectionm1 m2) +The following property holds for all possible keys
k:getk (intersectionm1 m2)==gcd(getk m1) (getk m2)This function provides the definition of
gcdfor theMonoidMap- instance ofGCDMonoid.Examples
With
ProductNaturalvalues, this function + instance ofGCDMonoid.Examples
With
ProductNaturalvalues, this function computes the greatest common divisor of each pair of matching values:>>> m1 =
fromList[("a", 2), ("b", 6), ("c", 15), ("d", 35)] >>> m2 =fromList[("a", 6), ("b", 15), ("c", 35), ("d", 77)] >>> m3 =fromList[("a", 2), ("b", 3), ("c", 5), ("d", 7)] ->>>
intersectionm1 m2==m3 -True-With
SumNaturalvalues, this function +>>>
intersectionm1 m2==m3 +True+With
SumNaturalvalues, this function computes the minimum of each pair of matching values:>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 3), ("b", 2), ("c", 1), ("d", 0)] >>> m3 =fromList[("a", 0), ("b", 1), ("c", 1), ("d", 0)] ->>>
intersectionm1 m2==m3 -True-With
SetNaturalvalues, this function computes the - set intersection of each pair of matching values:f xs =
fromList(fromList<$>xs) +>>>
intersectionm1 m2==m3 +True+With
SetNaturalvalues, this function computes the + set intersection of each pair of matching values:f xs =
fromList(fromList<$>xs)>>> m1 = f [("a", [0,1,2]), ("b", [0,1,2 ]), ("c", [0,1,2 ])] >>> m2 = f [("a", [0,1,2]), ("b", [ 1,2,3]), ("c", [ 2,3,4])] >>> m3 = f [("a", [0,1,2]), ("b", [ 1,2 ]), ("c", [ 2 ])] ->>>
intersectionm1 m2==m3 -True-Arguments
:: (Ord k, MonoidNull v3) => (v1 -> v2 -> v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3 Computes the intersection of a pair of maps using the given function - to combine values for matching keys.
Satisfies the following property for all possible keys
k:getk (intersectionWithf m1 m2)==+>>>
intersectionm1 m2==m3 +True+Arguments
:: (Ord k, MonoidNull v3) => (v1 -> v2 -> v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3 Computes the intersection of a pair of maps using the given function + to combine values for matching keys.
Satisfies the following property for all possible keys
k:getk (intersectionWithf m1 m2)==if k`member`intersection(nonNullKeysm1) (nonNullKeysm2) then f (getk m1) (getk m2) - elsemempty-Conditional totality
If the given combining function
falways producesmemptywhen - either or both of its arguments aremempty:(f v
mempty==mempty)&&-(fmemptyv==mempty) -Then the following property holds for all possible keys
k:getk (intersectionWithf m1 m2)==f (getk m1) (getk m2) -Examples
With the
minfunction applied toSum-Naturalvalues:>>> m1 =
fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1) ] + elsemempty+Conditional totality
If the given combining function
falways producesmemptywhen + either or both of its arguments aremempty:(f v
mempty==mempty)&&+(fmemptyv==mempty) +Then the following property holds for all possible keys
k:getk (intersectionWithf m1 m2)==f (getk m1) (getk m2) +Examples
Arguments
:: (Applicative f, Ord k, MonoidNull v3) => (v1 -> v2 -> f v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3) An applicative version of
intersectionWith.Satisfies the following property:
runIdentity(intersectionWithA((fmap.fmap)Identityf) m1 m2) -==(intersectionWithf m1 m2) -Union
union :: (Ord k, MonoidNull v, LCMMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the union of two maps.
The union of maps
m1andm2is the smallest single mapm+>>>
intersectionWithminm1 m2==m3 +True+Arguments
:: (Applicative f, Ord k, MonoidNull v3) => (v1 -> v2 -> f v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3) An applicative version of
intersectionWith.Satisfies the following property:
runIdentity(intersectionWithA((fmap.fmap)Identityf) m1 m2) +==(intersectionWithf m1 m2) +Union
union :: (Ord k, MonoidNull v, LCMMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the union of two maps.
The union of maps
m1andm2is the smallest single mapmthat includes bothm1andm2as submaps:m1
`isSubmapOf`unionm1 m2 m2`isSubmapOf`unionm1 m2 -The union is unique:
and+The union is unique:
and[ m1`isSubmapOf`m , m2`isSubmapOf`m , m`isSubmapOf`unionm1 m2 ] ==> - (m==unionm1 m2) -The following property holds for all possible keys
k:getk (unionm1 m2)==lcm(getk m1) (getk m2) + (m==unionm1 m2) +The following property holds for all possible keys
k:getk (unionm1 m2)==lcm(getk m1) (getk m2)This function provides the definition of
lcmfor theMonoidMap- instance ofLCMMonoid.Examples
With
ProductNaturalvalues, this function + instance ofLCMMonoid.Examples
With
ProductNaturalvalues, this function computes the least common multiple of each pair of matching values:>>> m1 =
fromList[("a", 2), ("b", 6), ("c", 15), ("d", 35)] >>> m2 =fromList[("a", 6), ("b", 15), ("c", 35), ("d", 77)] >>> m3 =fromList[("a", 6), ("b", 30), ("c", 105), ("d", 385)] ->>>
unionm1 m2==m3 -True-With
SumNaturalvalues, this function +>>>
unionm1 m2==m3 +True+With
SumNaturalvalues, this function computes the maximum of each pair of matching values:>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 3), ("b", 2), ("c", 1), ("d", 0)] >>> m3 =fromList[("a", 3), ("b", 2), ("c", 2), ("d", 3)] ->>>
unionm1 m2==m3 -True-With
SetNaturalvalues, this function computes the - set union of each pair of matching values:f xs =
fromList(fromList<$>xs) +>>>
unionm1 m2==m3 +True+With
SetNaturalvalues, this function computes the + set union of each pair of matching values:f xs =
fromList(fromList<$>xs)>>> m1 = f [("a", [0,1,2]), ("b", [0,1,2 ]), ("c", [0,1,2 ])] >>> m2 = f [("a", [0,1,2]), ("b", [ 1,2,3]), ("c", [ 2,3,4])] >>> m3 = f [("a", [0,1,2]), ("b", [0,1,2,3]), ("c", [0,1,2,3,4])] ->>>
unionm1 m2==m3 -True-Arguments
:: (Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3 Computes the union of a pair of maps using the given function to combine + values for matching keys.
Satisfies the following property for all possible keys
k:getk (unionWithf m1 m2)==if k`member`union(nonNullKeysm1) (nonNullKeysm2) then f (getk m1) (getk m2) - elsemempty-Conditional totality
If the given combining function
falways producesmemptywhen - both of its arguments aremempty:f
memptymempty==mempty-Then the following property holds for all possible keys
k:getk (unionWithf m1 m2)==f (getk m1) (getk m2) -Examples
With the
maxfunction applied toSum-Naturalvalues:>>> m1 =
fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1) ] + elsemempty+Conditional totality
If the given combining function
falways producesmemptywhen + both of its arguments aremempty:f
memptymempty==mempty+Then the following property holds for all possible keys
k:getk (unionWithf m1 m2)==f (getk m1) (getk m2) +Examples
Arguments
:: (Applicative f, Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> f v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3) An applicative version of
unionWith.Satisfies the following property:
runIdentity(unionWithA((fmap.fmap)Identityf) m1 m2) -==(unionWithf m1 m2) -Prefixes
isPrefixOf :: (Ord k, Monoid v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Bool #
Arguments
:: (Applicative f, Ord k, Monoid v1, Monoid v2, MonoidNull v3) => (v1 -> v2 -> f v3) Function with which to combine values for matching keys.
-> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3) An applicative version of
unionWith.Satisfies the following property:
runIdentity(unionWithA((fmap.fmap)Identityf) m1 m2) +==(unionWithf m1 m2) +Prefixes
isPrefixOf :: (Ord k, Monoid v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not the first map is a prefix of the second.
MonoidMapm1is a prefix ofMonoidMapm2if (and only if) for all possible keysk, the value forkinm1is a - prefix of the value forkinm2:m1
`isPrefixOf`m2==(∀ k.getk m1`isPrefixOf`getk m2) + prefix of the value forkinm2:m1
`isPrefixOf`m2==(∀ k.getk m1`isPrefixOf`getk m2)This function provides the definition of
isPrefixOffor theMonoidMap- instance ofLeftReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "a" ), (2, "p" ), (3, "x" )] + instance ofLeftReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "a" ), (2, "p" ), (3, "x" )] >>> m2 =fromList[(1, "abc"), (2, "pqr"), (3, "xyz")] >>> m1`isPrefixOf`m2 -True+True>>> m1 =
fromList[ (2, "p" ) ] >>> m2 =fromList[(1, "abc"), (2, "pqr"), (3, "xyz")] >>> m1`isPrefixOf`m2 -True+True>>> m1 =
fromList[(1, "abc"), (2, "p" ), (3, "x" )] >>> m2 =fromList[(1, "a" ), (2, "pqr"), (3, "xyz")] >>> m1`isPrefixOf`m2 -False->>> m1 =
fromList[("a", 1), ("b", 1), ("c", 1)] +False+>>> m1 =
fromList[("a", 1), ("b", 1), ("c", 1)] >>> m2 =fromList[("a", 2), ("b", 4), ("c", 8)] >>> m1`isPrefixOf`m2 -True+True>>> m1 =
fromList[ ("b", 1) ] >>> m2 =fromList[("a", 2), ("b", 4), ("c", 8)] >>> m1`isPrefixOf`m2 -True+True>>> m1 =
fromList[("a", 2), ("b", 1), ("c", 1)] >>> m2 =fromList[("a", 1), ("b", 4), ("c", 8)] >>> m1`isPrefixOf`m2 -False-stripPrefix :: (Ord k, MonoidNull v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v) #
Strips a prefix from a
MonoidMap.If map
m1is a prefix of mapm2, thenstripPrefixm1+False+stripPrefix :: (Ord k, MonoidNull v, LeftReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v) #
Strips a prefix from a
MonoidMap.If map
m1is a prefix of mapm2, thenstripPrefixm1m2will produce a reduced map where prefixm1is stripped fromm2.Properties
The
stripPrefixfunction, when applied to mapsm1andm2, - produces a result if (and only if)m1is a prefix ofm2:isJust(stripPrefixm1 m2)==m1`isPrefixOf`m2 + produces a result if (and only if)m1is a prefix ofm2:isJust(stripPrefixm1 m2)==m1`isPrefixOf`m2The value for any key
kin the result is identical to the result of stripping the value forkin mapm1from the value fork- in mapm2:all- (\r ->Just(getk r)==stripPrefix(getk m1) (getk m2)) + in mapm2:all+ (\r ->Just(getk r)==stripPrefix(getk m1) (getk m2)) (stripPrefixm1 m2)If we append prefix
m1to the left-hand side of the result, we can - always recover the original mapm2:all- (\r -> m1<>r==m2) + always recover the original mapm2:all+ (\r -> m1<>r==m2) (stripPrefixm1 m2)This function provides the definition of
stripPrefixfor theMonoidMap- instance ofLeftReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "" ), (2, "i" ), (3, "pq" ), (4, "xyz")] + instance ofLeftReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "" ), (2, "i" ), (3, "pq" ), (4, "xyz")] >>> m2 =fromList[(1, "abc"), (2, "ijk"), (3, "pqr"), (4, "xyz")] >>> m3 =fromList[(1, "abc"), (2, "jk"), (3, "r"), (4, "")] ->>>
stripPrefixm1 m2==Justm3 -True->>>
stripPrefixm2 m1==Nothing-True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] +>>>
stripPrefixm1 m2==Justm3 +True+>>>
stripPrefixm2 m1==Nothing+True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 3), ("b", 3), ("c", 3), ("d", 3)] >>> m3 =fromList[("a", 3), ("b", 2), ("c", 1), ("d", 0)] ->>>
stripPrefixm1 m2==Justm3 -True->>>
stripPrefixm2 m1==Nothing-True-commonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the greatest common prefix of two maps.
Satisfies the following property for all possible keys
k:getk (commonPrefixm1 m2) -==commonPrefix(getk m1) (getk m2) +>>>
stripPrefixm1 m2==Justm3 +True+>>>
stripPrefixm2 m1==Nothing+True+commonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the greatest common prefix of two maps.
Satisfies the following property for all possible keys
k:getk (commonPrefixm1 m2) +==commonPrefix(getk m1) (getk m2)This function provides the definition of
commonPrefixfor the -MonoidMapinstance ofLeftGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "b++"), (3, "cc+"), (4, "ddd")] +MonoidMapinstance ofLeftGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "b++"), (3, "cc+"), (4, "ddd")] >>> m2 =fromList[(1, "---"), (2, "b--"), (3, "cc-"), (4, "ddd")] >>> m3 =fromList[(1, "" ), (2, "b" ), (3, "cc" ), (4, "ddd")] ->>>
commonPrefixm1 m2==m3 -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] +>>>
commonPrefixm1 m2==m3 +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 2), ("b", 2), ("c", 2), ("d", 2)] >>> m3 =fromList[("a", 0), ("b", 1), ("c", 2), ("d", 2)] ->>>
commonPrefixm1 m2==m3 -True-stripCommonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
Strips the greatest common prefix from a pair of maps.
Given two maps
m1andm2,stripCommonPrefixproduces a +>>>
commonPrefixm1 m2==m3 +True+stripCommonPrefix :: (Ord k, MonoidNull v, LeftGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
Strips the greatest common prefix from a pair of maps.
Given two maps
m1andm2,stripCommonPrefixproduces a tuple(p, r1, r2), where:pis the greatest common prefix ofm1andm2r1is the remainder of stripping prefixpfromm1r2is the remainder of stripping prefixpfromm2
The resulting prefix
pcan be appended to the left-hand side of either remainderr1orr2to reproduce either of the original mapsm1orm2respectively:stripCommonPrefixm1 m2 -&\(p, r1, _) -> p<>r1==m1 +&\(p, r1, _) -> p<>r1==m1stripCommonPrefixm1 m2 -&\(p, _, r2) -> p<>r2==m2 +&\(p, _, r2) -> p<>r2==m2Prefix
pis identical to the result of applyingcommonPrefixtom1andm2:stripCommonPrefixm1 m2 -&\(p, _, _) -> p==commonPrefixm1 m2 +&\(p, _, _) -> p==commonPrefixm1 m2Remainders
r1andr2are identical to the results of applyingstripPrefixtopandm1or topandm2respectively:stripCommonPrefixm1 m2 -&\(p, r1, _) ->Justr1==stripPrefixp m1 +&\(p, r1, _) ->Justr1==stripPrefixp m1stripCommonPrefixm1 m2 -&\(p, _, r2) ->Justr2==stripPrefixp m2 +&\(p, _, r2) ->Justr2==stripPrefixp m2This function provides the definition of
stripCommonPrefixfor the -MonoidMapinstance ofLeftGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "a++"), (3, "aa+"), (4, "aaa")] +MonoidMapinstance ofLeftGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "a++"), (3, "aa+"), (4, "aaa")] >>> m2 =fromList[(1, "---"), (2, "a--"), (3, "aa-"), (4, "aaa")]>>> p =
fromList[(1, "" ), (2, "a" ), (3, "aa" ), (4, "aaa")] >>> r1 =fromList[(1, "+++"), (2, "++"), (3, "+"), (4, "")] >>> r2 =fromList[(1, "---"), (2, "--"), (3, "-"), (4, "")] ->>>
stripCommonPrefixm1 m2==(p, r1, r2) -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] +>>>
stripCommonPrefixm1 m2==(p, r1, r2) +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] >>> m2 =fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1), ("e", 0)]>>> p =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 1), ("e", 0)] >>> r1 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 2), ("e", 4)] >>> r2 =fromList[("a", 4), ("b", 2), ("c", 0), ("d", 0), ("e", 0)] ->>>
stripCommonPrefixm1 m2==(p, r1, r2) -True-Suffixes
isSuffixOf :: (Ord k, Monoid v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not the first map is a suffix of the second.
MonoidMapm1is a suffix ofMonoidMapm2if (and only if) +>>>
stripCommonPrefixm1 m2==(p, r1, r2) +True+Suffixes
isSuffixOf :: (Ord k, Monoid v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Bool #
Indicates whether or not the first map is a suffix of the second.
MonoidMapm1is a suffix ofMonoidMapm2if (and only if) for all possible keysk, the value forkinm1is a - suffix of the value forkinm2:m1
`isSuffixOf`m2==(∀ k.getk m1`isSuffixOf`getk m2) + suffix of the value forkinm2:m1
`isSuffixOf`m2==(∀ k.getk m1`isSuffixOf`getk m2)This function provides the definition of
isSuffixOffor theMonoidMap- instance ofRightReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "c"), (2, "r"), (3, "z")] + instance ofRightReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "c"), (2, "r"), (3, "z")] >>> m2 =fromList[(1, "abc"), (2, "pqr"), (3, "xyz")] >>> m1`isSuffixOf`m2 -True+True>>> m1 =
fromList[ (2, "r") ] >>> m2 =fromList[(1, "abc"), (2, "pqr"), (3, "xyz")] >>> m1`isSuffixOf`m2 -True+True>>> m1 =
fromList[(1, "abc"), (2, "r"), (3, "z")] >>> m2 =fromList[(1, "c"), (2, "pqr"), (3, "xyz")] >>> m1`isSuffixOf`m2 -False->>> m1 =
fromList[("a", 1), ("b", 1), ("c", 1)] +False+>>> m1 =
fromList[("a", 1), ("b", 1), ("c", 1)] >>> m2 =fromList[("a", 2), ("b", 4), ("c", 8)] >>> m1`isSuffixOf`m2 -True+True>>> m1 =
fromList[ ("b", 1) ] >>> m2 =fromList[("a", 2), ("b", 4), ("c", 8)] >>> m1`isSuffixOf`m2 -True+True>>> m1 =
fromList[("a", 2), ("b", 1), ("c", 1)] >>> m2 =fromList[("a", 1), ("b", 4), ("c", 8)] >>> m1`isSuffixOf`m2 -False-stripSuffix :: (Ord k, MonoidNull v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v) #
Strips a suffix from a
MonoidMap.If map
m1is a suffix of mapm2, thenstripSuffixm1+False+stripSuffix :: (Ord k, MonoidNull v, RightReductive v) => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v) #
Strips a suffix from a
MonoidMap.If map
m1is a suffix of mapm2, thenstripSuffixm1m2will produce a reduced map where suffixm1is stripped fromm2.Properties
The
stripSuffixfunction, when applied to mapsm1andm2, - produces a result if (and only if)m1is a suffix ofm2:isJust(stripSuffixm1 m2)==m1`isSuffixOf`m2 + produces a result if (and only if)m1is a suffix ofm2:isJust(stripSuffixm1 m2)==m1`isSuffixOf`m2The value for any key
kin the result is identical to the result of stripping the value forkin mapm1from the value fork- in mapm2:all- (\r ->Just(getk r)==stripSuffix(getk m1) (getk m2)) + in mapm2:all+ (\r ->Just(getk r)==stripSuffix(getk m1) (getk m2)) (stripSuffixm1 m2)If we append suffix
m1to the right-hand side of the result, we can - always recover the original mapm2:all- (\r -> r<>m1==m2) + always recover the original mapm2:all+ (\r -> r<>m1==m2) (stripSuffixm1 m2)This function provides the definition of
stripSuffixfor theMonoidMap- instance ofRightReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, ""), (2, "k"), (3, "qr"), (4, "xyz")] + instance ofRightReductive.Examples
With
Stringvalues:>>> m1 =
fromList[(1, ""), (2, "k"), (3, "qr"), (4, "xyz")] >>> m2 =fromList[(1, "abc"), (2, "ijk"), (3, "pqr"), (4, "xyz")] >>> m3 =fromList[(1, "abc"), (2, "ij" ), (3, "p" ), (4, "" )] ->>>
stripSuffixm1 m2==Justm3 -True->>>
stripSuffixm2 m1==Nothing-True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] +>>>
stripSuffixm1 m2==Justm3 +True+>>>
stripSuffixm2 m1==Nothing+True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 3), ("b", 3), ("c", 3), ("d", 3)] >>> m3 =fromList[("a", 3), ("b", 2), ("c", 1), ("d", 0)] ->>>
stripSuffixm1 m2==Justm3 -True->>>
stripSuffixm2 m1==Nothing-True-commonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the greatest common suffix of two maps.
Satisfies the following property for all possible keys
k:getk (commonSuffixm1 m2) -==commonSuffix(getk m1) (getk m2) +>>>
stripSuffixm1 m2==Justm3 +True+>>>
stripSuffixm2 m1==Nothing+True+commonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the greatest common suffix of two maps.
Satisfies the following property for all possible keys
k:getk (commonSuffixm1 m2) +==commonSuffix(getk m1) (getk m2)This function provides the definition of
commonSuffixfor the -MonoidMapinstance ofRightGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "++b"), (3, "+cc"), (4, "ddd")] +MonoidMapinstance ofRightGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "++b"), (3, "+cc"), (4, "ddd")] >>> m2 =fromList[(1, "---"), (2, "--b"), (3, "-cc"), (4, "ddd")] >>> m3 =fromList[(1, ""), (2, "b"), (3, "cc"), (4, "ddd")] ->>>
commonSuffixm1 m2==m3 -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] +>>>
commonSuffixm1 m2==m3 +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3)] >>> m2 =fromList[("a", 2), ("b", 2), ("c", 2), ("d", 2)] >>> m3 =fromList[("a", 0), ("b", 1), ("c", 2), ("d", 2)] ->>>
commonSuffixm1 m2==m3 -True-stripCommonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
Strips the greatest common suffix from a pair of maps.
Given two maps
m1andm2,stripCommonSuffixproduces a +>>>
commonSuffixm1 m2==m3 +True+stripCommonSuffix :: (Ord k, MonoidNull v, RightGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
Strips the greatest common suffix from a pair of maps.
Given two maps
m1andm2,stripCommonSuffixproduces a tuple(r1, r2, s), where:sis the greatest common suffix ofm1andm2r1is the remainder of stripping suffixsfromm1r2is the remainder of stripping suffixsfromm2
The resulting suffix
scan be appended to the right-hand side of either remainderr1orr2to reproduce either of the original mapsm1orm2respectively:stripCommonSuffixm1 m2 -&\(r1, _, s) -> r1<>s==m1 +&\(r1, _, s) -> r1<>s==m1stripCommonSuffixm1 m2 -&\(_, r2, s) -> r2<>s==m2 +&\(_, r2, s) -> r2<>s==m2Suffix
sis identical to the result of applyingcommonSuffixtom1andm2:stripCommonSuffixm1 m2 -&\(_, _, s) -> s==commonSuffixm1 m2 +&\(_, _, s) -> s==commonSuffixm1 m2Remainders
r1andr2are identical to the results of applyingstripSuffixtosandm1or tosandm2respectively:stripCommonSuffixm1 m2 -&\(r1, _, s) ->Justr1==stripSuffixs m1 +&\(r1, _, s) ->Justr1==stripSuffixs m1stripCommonSuffixm1 m2 -&\(_, r2, s) ->Justr2==stripSuffixs m2 +&\(_, r2, s) ->Justr2==stripSuffixs m2This function provides the definition of
stripCommonSuffixfor the -MonoidMapinstance ofRightGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "++a"), (3, "+aa"), (4, "aaa")] +MonoidMapinstance ofRightGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1, "+++"), (2, "++a"), (3, "+aa"), (4, "aaa")] >>> m2 =fromList[(1, "---"), (2, "--a"), (3, "-aa"), (4, "aaa")]>>> r1 =
fromList[(1, "+++"), (2, "++" ), (3, "+" ), (4, "" )] >>> r2 =fromList[(1, "---"), (2, "--" ), (3, "-" ), (4, "" )] >>> s =fromList[(1, ""), (2, "a"), (3, "aa"), (4, "aaa")] ->>>
stripCommonSuffixm1 m2==(r1, r2, s) -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] +>>>
stripCommonSuffixm1 m2==(r1, r2, s) +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] >>> m2 =fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1), ("e", 0)]>>> r1 =
fromList[("a", 0), ("b", 0), ("c", 0), ("d", 2), ("e", 4)] >>> r2 =fromList[("a", 4), ("b", 2), ("c", 0), ("d", 0), ("e", 0)] >>> s =fromList[("a", 0), ("b", 1), ("c", 2), ("d", 1), ("e", 0)] ->>>
stripCommonSuffixm1 m2==(r1, r2, s) -True-Overlap
overlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Overlap
overlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Finds the greatest overlap of two maps.
The greatest overlap
oof mapsm1andm2is the unique + greatest map that is both a suffix ofm1and a prefix ofm2:m1
==r1<>o +m2==o<>r2Where:
r1is the remainder obtained by stripping suffix overlapofromm1.(see
stripSuffixOverlap)r2is the remainder obtained by stripping prefix overlap -ofromm2.(see
stripPrefixOverlap)
This function satisfies the following property:
getk (overlapm1 m2)==overlap(getk m1) (getk m2) +ofromm2.(see
stripPrefixOverlap)This function satisfies the following property:
getk (overlapm1 m2)==overlap(getk m1) (getk m2)This function provides the definition of
overlapfor theMonoidMap- instance ofOverlappingGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1,"abc" ), (2,"abcd" ), (3,"abcde "), (4,"abcdef")] + instance ofOverlappingGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1,"abc" ), (2,"abcd" ), (3,"abcde "), (4,"abcdef")] >>> m2 =fromList[(1, "def"), (2, "cdef"), (3," bcdef"), (4,"abcdef")] >>> m3 =fromList[(1, "" ), (2, "cd" ), (3," bcde" ), (4,"abcdef")] ->>>
overlapm1 m2==m3 -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] +>>>
overlapm1 m2==m3 +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] >>> m2 =fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1), ("e", 0)] >>> m3 =fromList[("a", 0), ("b", 1), ("c", 2), ("d", 1), ("e", 0)] ->>>
overlapm1 m2==m3 -True-stripPrefixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
stripPrefixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Strips from the second map its greatest prefix overlap with suffixes of the first map.
Evaluating
stripPrefixOverlapm1m2produces the remainder -r2:m1
==r1<>o -m2==o<>r2 +r2:m1
==r1<>o +m2==o<>r2Where
ois the greatest overlap of mapsm1andm2: the unique greatest map that is both a suffix ofm1and a prefix ofm2.This function satisfies the following property:
getk (stripPrefixOverlapm1 m2) -==stripPrefixOverlap(getk m1) (getk m2) +==stripPrefixOverlap(getk m1) (getk m2)This function provides the definition of
stripPrefixOverlapfor the -MonoidMapinstance ofOverlappingGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1,"abc" ), (2,"abcd" ), (3,"abcde" ), (4,"abcdef")] +MonoidMapinstance ofOverlappingGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1,"abc" ), (2,"abcd" ), (3,"abcde" ), (4,"abcdef")] >>> m2 =fromList[(1, "def"), (2, "cdef"), (3, "bcdef"), (4,"abcdef")] >>> m3 =fromList[(1, "def"), (2, "ef"), (3, "f"), (4, "")] ->>>
stripPrefixOverlapm1 m2==m3 -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] +>>>
stripPrefixOverlapm1 m2==m3 +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] >>> m2 =fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1), ("e", 0)] >>> m3 =fromList[("a", 4), ("b", 2), ("c", 0), ("d", 0), ("e", 0)] ->>>
stripPrefixOverlapm1 m2==m3 -True-stripSuffixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Strips from the second map its greatest suffix overlap with prefixes +
>>>
stripPrefixOverlapm1 m2==m3 +True+stripSuffixOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v #
Strips from the second map its greatest suffix overlap with prefixes of the first map.
Evaluating
stripSuffixOverlapm2m1produces the remainder -r1:m1
==r1<>o -m2==o<>r2 +r1:m1
==r1<>o +m2==o<>r2Where
ois the greatest overlap of mapsm1andm2: the unique greatest map that is both a suffix ofm1and a prefix ofm2.This function satisfies the following property:
getk (stripSuffixOverlapm2 m1) -==stripSuffixOverlap(getk m2) (getk m1) +==stripSuffixOverlap(getk m2) (getk m1)This function provides the definition of
stripSuffixOverlapfor the -MonoidMapinstance ofOverlappingGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1,"abc" ), (2,"abcd" ), (3,"abcde" ), (4,"abcdef")] +MonoidMapinstance ofOverlappingGCDMonoid.Examples
With
Stringvalues:>>> m1 =
fromList[(1,"abc" ), (2,"abcd" ), (3,"abcde" ), (4,"abcdef")] >>> m2 =fromList[(1, "def"), (2, "cdef"), (3, "bcdef"), (4,"abcdef")] >>> m3 =fromList[(1,"abc" ), (2,"ab" ), (3,"a" ), (4,"" )] ->>>
stripSuffixOverlapm2 m1==m3 -True->>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] +>>>
stripSuffixOverlapm2 m1==m3 +True+>>> m1 =
fromList[("a", 0), ("b", 1), ("c", 2), ("d", 3), ("e", 4)] >>> m2 =fromList[("a", 4), ("b", 3), ("c", 2), ("d", 1), ("e", 0)] >>> m3 =fromList[("a", 0), ("b", 0), ("c", 0), ("d", 2), ("e", 4)] ->>>
stripSuffixOverlapm2 m1==m3 -True-stripOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
Finds the greatest overlap of two maps and strips it from both maps.
Evaluating
stripOverlapm1m2produces the tuple -(r1, o, r2), where:m1
==r1<>o -m2==o<>r2 +>>>
stripSuffixOverlapm2 m1==m3 +True+stripOverlap :: (Ord k, MonoidNull v, OverlappingGCDMonoid v) => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v) #
Finds the greatest overlap of two maps and strips it from both maps.
Evaluating
stripOverlapm1m2produces the tuple +(r1, o, r2), where:m1
==r1<>o +m2==o<>r2Where:
ois the greatest overlap of mapsm1andm2: the unique greatest map that is both a suffix ofm1and a prefix ofm2.(see
overlap)r1is the remainder obtained by stripping suffix overlapofromm1.(see
stripSuffixOverlap)r2is the remainder obtained by stripping prefix overlap -ofromm2.(see
stripPrefixOverlap)
This function satisfies the following property:
stripOverlapm1 m2==+ofromm2.(see
stripPrefixOverlap)This function satisfies the following property:
stripOverlapm1 m2==(stripSuffixOverlapm2 m1 ,overlapm1 m2 ,stripPrefixOverlapm1 m2 )This function provides the definition of
stripOverlapfor the -MonoidMapinstance ofOverlappingGCDMonoid.MonoidMapinstance ofOverlappingGCDMonoid.
Index
| adjust | Data.MonoidMap |
| append | Data.MonoidMap |
| commonPrefix | Data.MonoidMap |
| commonSuffix | Data.MonoidMap |
| disjoint | Data.MonoidMap |
| disjointBy | Data.MonoidMap |
| drop | Data.MonoidMap |
| empty | Data.MonoidMap |
| filter | Data.MonoidMap |
| filterKeys | Data.MonoidMap |
| filterWithKey | Data.MonoidMap |
| fromList | Data.MonoidMap |
| fromListWith | Data.MonoidMap |
| fromMap | Data.MonoidMap |
| get | Data.MonoidMap |
| intersection | Data.MonoidMap |
| intersectionWith | Data.MonoidMap |
| intersectionWithA | Data.MonoidMap |
| invert | Data.MonoidMap |
| isPrefixOf | Data.MonoidMap |
| isSubmapOf | Data.MonoidMap |
| isSubmapOfBy | Data.MonoidMap |
| isSuffixOf | Data.MonoidMap |
| map | Data.MonoidMap |
| mapKeys | Data.MonoidMap |
| mapKeysWith | Data.MonoidMap |
| minus | Data.MonoidMap |
| minusMaybe | Data.MonoidMap |
| MonoidMap | Data.MonoidMap |
| monus | Data.MonoidMap |
| nonNull | Data.MonoidMap |
| nonNullCount | Data.MonoidMap |
| nonNullKey | Data.MonoidMap |
| nonNullKeys | Data.MonoidMap |
| null | Data.MonoidMap |
| nullify | Data.MonoidMap |
| nullKey | Data.MonoidMap |
| overlap | Data.MonoidMap |
| partition | Data.MonoidMap |
| partitionKeys | Data.MonoidMap |
| partitionWithKey | Data.MonoidMap |
| power | Data.MonoidMap |
| set | Data.MonoidMap |
| singleton | Data.MonoidMap |
| splitAt | Data.MonoidMap |
| stripCommonPrefix | Data.MonoidMap |
| stripCommonSuffix | Data.MonoidMap |
| stripOverlap | Data.MonoidMap |
| stripPrefix | Data.MonoidMap |
| stripPrefixOverlap | Data.MonoidMap |
| stripSuffix | Data.MonoidMap |
| stripSuffixOverlap | Data.MonoidMap |
| take | Data.MonoidMap |
| toList | Data.MonoidMap |
| toMap | Data.MonoidMap |
| union | Data.MonoidMap |
| unionWith | Data.MonoidMap |
| unionWithA | Data.MonoidMap |
Index
| adjust | Data.MonoidMap |
| append | Data.MonoidMap |
| commonPrefix | Data.MonoidMap |
| commonSuffix | Data.MonoidMap |
| disjoint | Data.MonoidMap |
| disjointBy | Data.MonoidMap |
| drop | Data.MonoidMap |
| empty | Data.MonoidMap |
| filter | Data.MonoidMap |
| filterKeys | Data.MonoidMap |
| filterWithKey | Data.MonoidMap |
| fromList | Data.MonoidMap |
| fromListWith | Data.MonoidMap |
| fromMap | Data.MonoidMap |
| get | Data.MonoidMap |
| intersection | Data.MonoidMap |
| intersectionWith | Data.MonoidMap |
| intersectionWithA | Data.MonoidMap |
| invert | Data.MonoidMap |
| isPrefixOf | Data.MonoidMap |
| isSubmapOf | Data.MonoidMap |
| isSubmapOfBy | Data.MonoidMap |
| isSuffixOf | Data.MonoidMap |
| map | Data.MonoidMap |
| mapKeys | Data.MonoidMap |
| mapKeysWith | Data.MonoidMap |
| minus | Data.MonoidMap |
| minusMaybe | Data.MonoidMap |
| MonoidMap | Data.MonoidMap |
| monus | Data.MonoidMap |
| nonNull | Data.MonoidMap |
| nonNullCount | Data.MonoidMap |
| nonNullKey | Data.MonoidMap |
| nonNullKeys | Data.MonoidMap |
| null | Data.MonoidMap |
| nullify | Data.MonoidMap |
| nullKey | Data.MonoidMap |
| overlap | Data.MonoidMap |
| partition | Data.MonoidMap |
| partitionKeys | Data.MonoidMap |
| partitionWithKey | Data.MonoidMap |
| power | Data.MonoidMap |
| set | Data.MonoidMap |
| singleton | Data.MonoidMap |
| splitAt | Data.MonoidMap |
| stripCommonPrefix | Data.MonoidMap |
| stripCommonSuffix | Data.MonoidMap |
| stripOverlap | Data.MonoidMap |
| stripPrefix | Data.MonoidMap |
| stripPrefixOverlap | Data.MonoidMap |
| stripSuffix | Data.MonoidMap |
| stripSuffixOverlap | Data.MonoidMap |
| take | Data.MonoidMap |
| toList | Data.MonoidMap |
| toMap | Data.MonoidMap |
| union | Data.MonoidMap |
| unionWith | Data.MonoidMap |
| unionWithA | Data.MonoidMap |
monoidmap-0.0.1.3: Monoidal map type
Monoidal map type with support for semigroup and monoid subclasses.
Modules
monoidmap-0.0.1.3
- Data
monoidmap-0.0.1.4: Monoidal map type
Monoidal map type with support for semigroup and monoid subclasses.
Modules
monoidmap-0.0.1.4
- Data