monoidmap 0.1.3.0 → 0.1.3.1
raw patch · 3 files changed
+203/−142 lines, 3 filesdep ~monoidmap-internal
Dependency ranges changed: monoidmap-internal
Files
- CHANGELOG.md +7/−0
- components/monoidmap/Data/MonoidMap.hs +194/−140
- monoidmap.cabal +2/−2
CHANGELOG.md view
@@ -1,3 +1,10 @@+# 0.1.3.1++- Revised the inlining of functions exported by `Data.MonoidMap`, so that GHC+ can specialise them at call sites.++- Revised version bounds for dependencies.+ # 0.1.3.0 - Added a manual flag `nothunks`, which is on by default. Switching this flag
components/monoidmap/Data/MonoidMap.hs view
@@ -172,6 +172,8 @@ ( NonNull ) import Data.MonoidMap.Internal.NonNullMap ( NonNullMap (..) )+import Data.MonoidMap.Internal.NonNullMap.Merge+ ( Strategy (withNonNullL, withNonNullR, withNonNullP) ) import Control.Applicative ( Applicative (..) )@@ -201,7 +203,7 @@ import Data.Map.Strict ( Map, lookup ) import Data.Maybe- ( fromMaybe, isJust )+ ( fromJust, isJust ) import Data.Monoid.GCD ( DistributiveGCDMonoid , GCDMonoid@@ -244,13 +246,13 @@ import qualified Data.Group as C import qualified Data.List as L import qualified Data.List.NonEmpty as NE-import qualified Data.Map.Merge.Strict as Map import qualified Data.Map.Strict as Map import qualified Data.Monoid.GCD as C import qualified Data.Monoid.LCM as C import qualified Data.Monoid.Null as C import qualified Data.MonoidMap.Internal.NonNull as NonNull import qualified Data.MonoidMap.Internal.NonNullMap as NonNullMap+import qualified Data.MonoidMap.Internal.NonNullMap.Merge as Merge import qualified Data.Semigroup.Cancellative as C import qualified Data.Set as Set import qualified Data.Traversable as Traversable@@ -601,13 +603,16 @@ where type Item (MonoidMap k v) = (k, v) fromList = fromList+ {-# INLINE fromList #-} toList = toList+ {-# INLINE toList #-} -- | @since 0.0.0.0 instance (Ord k, Read k, MonoidNull v, Read v) => Read (MonoidMap k v) where readPrec = fromMap <$> readPrec+ {-# INLINE readPrec #-} -------------------------------------------------------------------------------- -- Instances: Data@@ -619,12 +624,17 @@ -- | @since 0.0.5.0 instance (Data k, Data v, Ord k, MonoidNull v) => Data (MonoidMap k v) where dataTypeOf _ = dataType+ {-# INLINE dataTypeOf #-} dataCast2 f = gcast2 f+ {-# INLINE dataCast2 #-} gfoldl f z m = z fromList `f` toList m+ {-# INLINE gfoldl #-} gunfold k z c | c == fromListConstr = k (z fromList) | otherwise = error "gunfold MonoidMap: unexpected constructor"+ {-# INLINE gunfold #-} toConstr _ = fromListConstr+ {-# INLINE toConstr #-} dataType :: DataType dataType = mkDataType "Data.MonoidMap.MonoidMap" [fromListConstr]@@ -640,7 +650,9 @@ -- | @since 0.0.0.0 instance (NoThunks k, NoThunks v) => NoThunks (MonoidMap k v) where showTypeOf _ = "MonoidMap"+ {-# INLINE showTypeOf #-} wNoThunks ctx = wNoThunks ctx . toMap+ {-# INLINE wNoThunks #-} #endif --------------------------------------------------------------------------------@@ -652,9 +664,11 @@ Semigroup (MonoidMap k v) where (<>) = append+ {-# INLINE (<>) #-} stimes 0 = const mempty stimes 1 = id stimes n = map (stimes n)+ {-# INLINE stimes #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, Commutative v) =>@@ -665,20 +679,25 @@ LeftReductive (MonoidMap k v) where isPrefixOf = isPrefixOf+ {-# INLINE isPrefixOf #-} stripPrefix = stripPrefix+ {-# INLINE stripPrefix #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, RightReductive v) => RightReductive (MonoidMap k v) where isSuffixOf = isSuffixOf+ {-# INLINE isSuffixOf #-} stripSuffix = stripSuffix+ {-# INLINE stripSuffix #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, Reductive v) => Reductive (MonoidMap k v) where (</>) = minusMaybe+ {-# INLINE (</>) #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, LeftCancellative v) =>@@ -701,12 +720,14 @@ Monoid (MonoidMap k v) where mempty = empty+ {-# INLINE mempty #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v) => MonoidNull (MonoidMap k v) where null = null+ {-# INLINE null #-} -- | @since 0.0.0.0 instance (Ord k, PositiveMonoid v) =>@@ -717,6 +738,9 @@ LeftGCDMonoid (MonoidMap k v) where commonPrefix = commonPrefix+ {-# INLINE commonPrefix #-}+ stripCommonPrefix = stripCommonPrefix+ {-# INLINE stripCommonPrefix #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, LeftDistributiveGCDMonoid v) =>@@ -727,6 +751,9 @@ RightGCDMonoid (MonoidMap k v) where commonSuffix = commonSuffix+ {-# INLINE commonSuffix #-}+ stripCommonSuffix = stripCommonSuffix+ {-# INLINE stripCommonSuffix #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, RightDistributiveGCDMonoid v) =>@@ -737,15 +764,20 @@ OverlappingGCDMonoid (MonoidMap k v) where overlap = overlap+ {-# INLINE overlap #-} stripPrefixOverlap = stripPrefixOverlap+ {-# INLINE stripPrefixOverlap #-} stripSuffixOverlap = stripSuffixOverlap+ {-# INLINE stripSuffixOverlap #-} stripOverlap = stripOverlap+ {-# INLINE stripOverlap #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, GCDMonoid v) => GCDMonoid (MonoidMap k v) where gcd = intersection+ {-# INLINE gcd #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, DistributiveGCDMonoid v) =>@@ -756,6 +788,7 @@ LCMMonoid (MonoidMap k v) where lcm = union+ {-# INLINE lcm #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, DistributiveLCMMonoid v) =>@@ -766,6 +799,7 @@ Monus (MonoidMap k v) where (<\>) = monus+ {-# INLINE (<\>) #-} -------------------------------------------------------------------------------- -- Instances: Group and subclasses@@ -776,8 +810,11 @@ Group (MonoidMap k v) where invert = invert+ {-# INLINE invert #-} (~~) = minus+ {-# INLINE (~~) #-} pow = power+ {-# INLINE pow #-} -- | @since 0.0.0.0 instance (Ord k, MonoidNull v, Abelian v) =>@@ -802,6 +839,7 @@ -- empty :: MonoidMap k v empty = MonoidMap Map.empty+{-# INLINE empty #-} -- | \(O(n \log n)\). Constructs a 'MonoidMap' from a list of key-value pairs. --@@ -834,6 +872,7 @@ -- fromList :: (Ord k, MonoidNull v) => [(k, v)] -> MonoidMap k v fromList = fromListWith (<>)+{-# INLINE fromList #-} -- | \(O(n \log n)\). Constructs a 'MonoidMap' from a list of key-value pairs, -- with a combining function for values.@@ -862,6 +901,7 @@ -- The 'Map.fromListWith' function combines values for duplicate keys in -- /reverse order/, so we must flip the provided combining function. fromMap . Map.fromListWith (flip f)+{-# INLINE fromListWith #-} -- | \(O(n)\). Constructs a 'MonoidMap' from an ordinary 'Map'. --@@ -878,7 +918,7 @@ -- fromMap :: MonoidNull v => Map k v -> MonoidMap k v fromMap = fromNonNullMap . NonNullMap.fromMap-{-# INLINABLE fromMap #-}+{-# INLINE fromMap #-} -- | \(O(n)\). Constructs a 'MonoidMap' from an ordinary 'Map', applying -- the given function to all values.@@ -896,7 +936,7 @@ -- fromMapWith :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> MonoidMap k v2 fromMapWith f = fromNonNullMap . NonNullMap.fromMapWith f-{-# INLINABLE fromMapWith #-}+{-# INLINE fromMapWith #-} -- | \(O(n)\). Constructs a 'MonoidMap' from a 'Set' and a function from -- keys to values.@@ -917,6 +957,7 @@ -- fromSet :: MonoidNull v => (k -> v) -> Set k -> MonoidMap k v fromSet f = fromMap . Map.fromSet f+{-# INLINE fromSet #-} -- | \(O(1)\). Constructs a 'MonoidMap' from a single key-value pair. --@@ -936,6 +977,7 @@ -- singleton :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v singleton k v = set k v mempty+{-# INLINE singleton #-} -------------------------------------------------------------------------------- -- Deconstruction@@ -962,6 +1004,7 @@ -- toList :: MonoidMap k v -> [(k, v)] toList = Map.toAscList . toMap+{-# INLINE toList #-} -- | \(O(1)\). Converts a 'MonoidMap' to an ordinary 'Map'. --@@ -995,7 +1038,8 @@ -- @since 0.0.0.0 -- get :: (Ord k, Monoid v) => k -> MonoidMap k v -> v-get k m = fromMaybe mempty $ Map.lookup k $ toMap m+get k = NonNullMap.get k . toNonNullMap+{-# INLINE get #-} -------------------------------------------------------------------------------- -- Modification@@ -1015,6 +1059,7 @@ set k v (MonoidMap m) = MonoidMap $ case NonNull.nonNull v of Just v0 -> Map.insert k v0 m Nothing -> Map.delete k m+{-# INLINE set #-} -- | \(O(\log n)\). Adjusts the value associated with the given key. --@@ -1034,6 +1079,7 @@ -> MonoidMap k v adjust f k (MonoidMap m) = MonoidMap $ Map.alter (NonNull.nonNull . maybe (f mempty) (NonNull.apply f)) k m+{-# INLINE adjust #-} -------------------------------------------------------------------------------- -- Nullification@@ -1054,6 +1100,7 @@ -- nullify :: Ord k => k -> MonoidMap k v -> MonoidMap k v nullify k (MonoidMap m) = MonoidMap $ Map.delete k m+{-# INLINE nullify #-} -- | \(O\bigl(m \log\bigl(\frac{n}{m}+1\bigr)\bigr), \; 0 < m \leq n\). --@@ -1077,6 +1124,7 @@ -- nullifyKeysIn :: Ord k => Set k -> MonoidMap k v -> MonoidMap k v nullifyKeysIn ks (MonoidMap m) = MonoidMap $ m `Map.withoutKeys` ks+{-# INLINE nullifyKeysIn #-} -- | \(O\bigl(m \log\bigl(\frac{n}{m}+1\bigr)\bigr), \; 0 < m \leq n\). --@@ -1100,6 +1148,7 @@ -- nullifyKeysNotIn :: Ord k => Set k -> MonoidMap k v -> MonoidMap k v nullifyKeysNotIn ks (MonoidMap m) = MonoidMap $ m `Map.restrictKeys` ks+{-# INLINE nullifyKeysNotIn #-} -------------------------------------------------------------------------------- -- Membership@@ -1121,6 +1170,7 @@ -- null :: MonoidMap k v -> Bool null = Map.null . toMap+{-# INLINE null #-} -- | \(O(\log n)\). Returns 'True' if (and only if) the given key is associated -- with a value that is 'C.null'.@@ -1135,6 +1185,7 @@ -- nullKey :: Ord k => k -> MonoidMap k v -> Bool nullKey k = Map.notMember k . toMap+{-# INLINE nullKey #-} -- | \(O(1)\). Returns 'True' if (and only if) the map contains at least one -- value that is not 'C.null'.@@ -1149,6 +1200,7 @@ -- nonNull :: MonoidMap k v -> Bool nonNull = not . null+{-# INLINE nonNull #-} -- | \(O(1)\). Returns a count of all values in the map that are not 'C.null'. --@@ -1162,6 +1214,7 @@ -- nonNullCount :: MonoidMap k v -> Int nonNullCount = Map.size . toMap+{-# INLINE nonNullCount #-} -- | \(O(\log n)\). Returns 'True' if (and only if) the given key is associated -- with a value that is not 'C.null'.@@ -1176,6 +1229,7 @@ -- nonNullKey :: Ord k => k -> MonoidMap k v -> Bool nonNullKey k = Map.member k . toMap+{-# INLINE nonNullKey #-} -- | \(O(n)\). Returns the set of keys associated with values that are not -- 'C.null'.@@ -1190,6 +1244,7 @@ -- nonNullKeys :: MonoidMap k v -> Set k nonNullKeys = Map.keysSet . toMap+{-# INLINE nonNullKeys #-} -------------------------------------------------------------------------------- -- Slicing@@ -1212,6 +1267,7 @@ -- take :: Int -> MonoidMap k v -> MonoidMap k v take i (MonoidMap m) = MonoidMap (Map.take i m)+{-# INLINE take #-} -- | \(O(\log n)\). /Drops/ a slice from a map. --@@ -1230,6 +1286,7 @@ -- drop :: Int -> MonoidMap k v -> MonoidMap k v drop i (MonoidMap m) = MonoidMap (Map.drop i m)+{-# INLINE drop #-} -- | \(O(\log n)\). /Splits/ a map into /two/ slices. --@@ -1257,6 +1314,7 @@ -- splitAt :: Int -> MonoidMap k a -> (MonoidMap k a, MonoidMap k a) splitAt i m = (take i m, drop i m)+{-# INLINE splitAt #-} -------------------------------------------------------------------------------- -- Filtering@@ -1284,6 +1342,7 @@ -- filter :: (v -> Bool) -> MonoidMap k v -> MonoidMap k v filter f (MonoidMap m) = MonoidMap $ Map.filter (NonNull.apply f) m+{-# INLINE filter #-} -- | \(O(n)\). Filters a map according to a predicate on /keys/. --@@ -1307,6 +1366,7 @@ -- filterKeys :: (k -> Bool) -> MonoidMap k v -> MonoidMap k v filterKeys f (MonoidMap m) = MonoidMap $ Map.filterWithKey (\k _ -> f k) m+{-# INLINE filterKeys #-} -- | \(O(n)\). Filters a map according to a predicate on /keys and values/. --@@ -1331,6 +1391,7 @@ filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v filterWithKey f (MonoidMap m) = MonoidMap $ Map.filterWithKey (NonNull.apply . f) m+{-# INLINE filterWithKey #-} -------------------------------------------------------------------------------- -- Partitioning@@ -1368,6 +1429,7 @@ partition :: (v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) partition f (MonoidMap m) = B.bimap MonoidMap MonoidMap $ Map.partition (NonNull.apply f) m+{-# INLINE partition #-} -- | \(O(n)\). Partitions a map according to a predicate on /keys/. --@@ -1402,6 +1464,7 @@ :: (k -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) partitionKeys f (MonoidMap m) = B.bimap MonoidMap MonoidMap $ Map.partitionWithKey (\k _ -> f k) m+{-# INLINE partitionKeys #-} -- | \(O(n)\). Partitions a map according to a predicate on /keys and values/. --@@ -1436,6 +1499,7 @@ :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v) partitionWithKey f (MonoidMap m) = B.bimap MonoidMap MonoidMap $ Map.partitionWithKey (NonNull.apply . f) m+{-# INLINE partitionWithKey #-} -------------------------------------------------------------------------------- -- Mapping@@ -1476,6 +1540,7 @@ -> MonoidMap k v2 map f (MonoidMap m) = MonoidMap $ Map.mapMaybe (NonNull.nonNull . NonNull.apply f) m+{-# INLINE map #-} -- | \(O(n \log n)\). Applies a function to all the keys of a 'MonoidMap' that -- are associated with non-'C.null' values.@@ -1501,6 +1566,7 @@ -> MonoidMap k1 v -> MonoidMap k2 v mapKeys = mapKeysWith (<>)+{-# INLINE mapKeys #-} -- | \(O(n \log n)\). Applies a function to all the keys of a 'MonoidMap' that -- are associated with non-'C.null' values, with a combining function for@@ -1526,6 +1592,7 @@ -> MonoidMap k1 v -> MonoidMap k2 v mapKeysWith combine fk = fromListWith combine . fmap (B.first fk) . toList+{-# INLINE mapKeysWith #-} -- | \(O(n)\). Applies a key-dependent function to all non-'C.null' values of -- a 'MonoidMap'.@@ -1548,6 +1615,7 @@ MonoidMap . runIdentity $ Map.traverseMaybeWithKey (\k v -> Identity $ NonNull.nonNull $ NonNull.apply (f k) v) m+{-# INLINE mapWithKey #-} -------------------------------------------------------------------------------- -- Folding@@ -2038,21 +2106,21 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-append = merge MergeStrategy+append = merge Merge.Strategy { withNonNullL =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- v <> mempty ≡ v , withNonNullR =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- mempty <> v ≡ v , withNonNullP =- withBoth (<>)+ Merge.withBoth (<>) } {-# INLINE append #-} @@ -2370,18 +2438,18 @@ => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)-stripPrefix = mergeA MergeStrategy+stripPrefix = mergeA Merge.Strategy { withNonNullL =- withNonNullA (\v -> C.stripPrefix v mempty)+ Merge.withNonNullA (\v -> C.stripPrefix v mempty) , withNonNullR =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- stripPrefix mempty a ≡ a , withNonNullP =- withBothA C.stripPrefix+ Merge.withBothA C.stripPrefix } {-# INLINE stripPrefix #-} @@ -2463,18 +2531,18 @@ => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)-stripSuffix = mergeA MergeStrategy+stripSuffix = mergeA Merge.Strategy { withNonNullL =- withNonNullA (\v -> C.stripSuffix v mempty)+ Merge.withNonNullA (\v -> C.stripSuffix v mempty) , withNonNullR =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- stripSuffix mempty a ≡ a , withNonNullP =- withBothA C.stripSuffix+ Merge.withBothA C.stripSuffix } {-# INLINE stripSuffix #-} @@ -2523,21 +2591,21 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-commonPrefix = merge MergeStrategy+commonPrefix = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull -- Justification: -- -- commonPrefix a mempty ≡ mempty , withNonNullR =- keepNull+ Merge.keepNull -- Justification: -- -- commonPrefix mempty a ≡ mempty , withNonNullP =- withBoth C.commonPrefix+ Merge.withBoth C.commonPrefix } {-# INLINE commonPrefix #-} @@ -2586,21 +2654,21 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-commonSuffix = merge MergeStrategy+commonSuffix = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull -- Justification: -- -- commonSuffix a mempty ≡ mempty , withNonNullR =- keepNull+ Merge.keepNull -- Justification: -- -- commonSuffix mempty a ≡ mempty , withNonNullP =- withBoth C.commonSuffix+ Merge.withBoth C.commonSuffix } {-# INLINE commonSuffix #-} @@ -2687,7 +2755,29 @@ => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)-stripCommonPrefix = C.stripCommonPrefix+stripCommonPrefix m1 m2 =+ --+ -- This implementation is equivalent to the default implementation of+ -- 'stripCommonPrefix' in 'LeftGCDMonoid'.+ --+ -- As @p@ is a prefix of both maps, stripping @p@ from either map cannot+ -- fail.+ --+ -- However, this approach has two drawbacks: firstly, it uses 'fromJust',+ -- which is a partial function; and secondly, it is inefficient, as for+ -- each key, 'stripPrefix' must repeat the comparison of values already+ -- performed by 'commonPrefix'.+ --+ -- Applying 'C.stripCommonPrefix' pointwise to each pair of values just+ -- once could avoid both problems.+ --+ ( p+ , fromJust (stripPrefix p m1)+ , fromJust (stripPrefix p m2)+ )+ where+ p = commonPrefix m1 m2+{-# INLINE stripCommonPrefix #-} -- | Strips the /greatest common suffix/ from a pair of maps. --@@ -2772,7 +2862,29 @@ => MonoidMap k v -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)-stripCommonSuffix = C.stripCommonSuffix+stripCommonSuffix m1 m2 =+ --+ -- This implementation is equivalent to the default implementation of+ -- 'stripCommonSuffix' in 'RightGCDMonoid'.+ --+ -- As @s@ is a suffix of both maps, stripping @s@ from either map cannot+ -- fail.+ --+ -- However, this approach has two drawbacks: firstly, it uses 'fromJust',+ -- which is a partial function; and secondly, it is inefficient, as for+ -- each key, 'stripSuffix' must repeat the comparison of values already+ -- performed by 'commonSuffix'.+ --+ -- Applying 'C.stripCommonSuffix' pointwise to each pair of values just+ -- once could avoid both problems.+ --+ ( fromJust (stripSuffix s m1)+ , fromJust (stripSuffix s m2)+ , s+ )+ where+ s = commonSuffix m1 m2+{-# INLINE stripCommonSuffix #-} -------------------------------------------------------------------------------- -- Overlap@@ -2842,21 +2954,21 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-overlap = merge MergeStrategy+overlap = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull -- Justification: -- -- overlap a mempty ≡ mempty , withNonNullR =- keepNull+ Merge.keepNull -- Justification: -- -- overlap mempty a ≡ mempty , withNonNullP =- withBoth C.overlap+ Merge.withBoth C.overlap } {-# INLINE overlap #-} @@ -2918,9 +3030,9 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-stripPrefixOverlap = merge MergeStrategy+stripPrefixOverlap = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull -- Justification: -- -- overlap a b <> stripPrefixOverlap a b ≡ b@@ -2929,7 +3041,7 @@ -- stripPrefixOverlap a mempty ≡ mempty , withNonNullR =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- overlap a b <> stripPrefixOverlap a b ≡ b@@ -2938,7 +3050,7 @@ -- stripPrefixOverlap mempty b ≡ b , withNonNullP =- withBoth C.stripPrefixOverlap+ Merge.withBoth C.stripPrefixOverlap } {-# INLINE stripPrefixOverlap #-} @@ -3000,9 +3112,9 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-stripSuffixOverlap = merge MergeStrategy+stripSuffixOverlap = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull -- Justification: -- -- stripSuffixOverlap b a <> overlap a b ≡ a@@ -3011,7 +3123,7 @@ -- stripSuffixOverlap b mempty ≡ mempty , withNonNullR =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- stripSuffixOverlap b a <> overlap a b ≡ a@@ -3020,7 +3132,7 @@ -- stripSuffixOverlap mempty a ≡ a , withNonNullP =- withBoth C.stripSuffixOverlap+ Merge.withBoth C.stripSuffixOverlap } {-# INLINE stripSuffixOverlap #-} @@ -3077,6 +3189,7 @@ , m1 `overlap` m2 , stripPrefixOverlap m1 m2 )+{-# INLINE stripOverlap #-} -------------------------------------------------------------------------------- -- Intersection@@ -3165,21 +3278,21 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-intersection = merge MergeStrategy+intersection = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull -- Justification: -- -- gcd a mempty ≡ mempty , withNonNullR =- keepNull+ Merge.keepNull -- Justification: -- -- gcd mempty b ≡ mempty , withNonNullP =- withBoth C.gcd+ Merge.withBoth C.gcd } {-# INLINE intersection #-} @@ -3270,21 +3383,21 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-union = merge MergeStrategy+union = merge Merge.Strategy { withNonNullL =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- lcm a mempty ≡ a , withNonNullR =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- lcm mempty a ≡ a , withNonNullP =- withBoth C.lcm+ Merge.withBoth C.lcm } {-# INLINE union #-} @@ -3338,15 +3451,15 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-minus = merge MergeStrategy+minus = merge Merge.Strategy { withNonNullL =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- a ~~ mempty ≡ a , withNonNullR =- withNonNull C.invert+ Merge.withNonNull C.invert -- Justification: -- -- a ~~ b ≡ a <> invert b@@ -3354,7 +3467,7 @@ -- mempty ~~ b ≡ invert b , withNonNullP =- withBoth (C.~~)+ Merge.withBoth (C.~~) } {-# INLINE minus #-} @@ -3474,9 +3587,9 @@ => MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v)-minusMaybe = mergeA MergeStrategy+minusMaybe = mergeA Merge.Strategy { withNonNullL =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- According to laws for Reductive:@@ -3498,10 +3611,10 @@ -- a </> mempty ≡ Just a , withNonNullR =- withNonNullA (\v -> mempty </> v)+ Merge.withNonNullA (\v -> mempty </> v) , withNonNullP =- withBothA (</>)+ Merge.withBothA (</>) } {-# INLINE minusMaybe #-} @@ -3608,9 +3721,9 @@ => MonoidMap k v -> MonoidMap k v -> MonoidMap k v-monus = merge MergeStrategy+monus = merge Merge.Strategy { withNonNullL =- keepNonNull+ Merge.keepNonNull -- Justification: -- -- a <> (b <\> a ) ≡ b <> (a <\> b)@@ -3620,13 +3733,13 @@ -- b <\> mempty ≡ b , withNonNullR =- keepNull+ Merge.keepNull -- Justification: -- -- mempty <\> a ≡ mempty , withNonNullP =- withBoth (<\>)+ Merge.withBoth (<\>) } {-# INLINE monus #-} @@ -3778,13 +3891,13 @@ -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3-intersectionWith f = merge MergeStrategy+intersectionWith f = merge Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull , withNonNullR =- keepNull+ Merge.keepNull , withNonNullP =- withBoth f+ Merge.withBoth f } {-# INLINE intersectionWith #-} @@ -3806,13 +3919,13 @@ -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)-intersectionWithA f = mergeA MergeStrategy+intersectionWithA f = mergeA Merge.Strategy { withNonNullL =- keepNull+ Merge.keepNull , withNonNullR =- keepNull+ Merge.keepNull , withNonNullP =- withBothA f+ Merge.withBothA f } {-# INLINE intersectionWithA #-} @@ -3873,13 +3986,13 @@ -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3-unionWith f = merge MergeStrategy+unionWith f = merge Merge.Strategy { withNonNullL =- withNonNull (\v -> f v mempty)+ Merge.withNonNull (\v -> f v mempty) , withNonNullR =- withNonNull (\v -> f mempty v)+ Merge.withNonNull (\v -> f mempty v) , withNonNullP =- withBoth f+ Merge.withBoth f } {-# INLINE unionWith #-} @@ -3901,13 +4014,13 @@ -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)-unionWithA f = mergeA MergeStrategy+unionWithA f = mergeA Merge.Strategy { withNonNullL =- withNonNullA (\v -> f v mempty)+ Merge.withNonNullA (\v -> f v mempty) , withNonNullR =- withNonNullA (\v -> f mempty v)+ Merge.withNonNullA (\v -> f mempty v) , withNonNullP =- withBothA f+ Merge.withBothA f } {-# INLINE unionWithA #-} @@ -3915,84 +4028,25 @@ -- Merging -------------------------------------------------------------------------------- -type WhenOneSideNull f k vx vr- = Map.WhenMissing f k (NonNull vx) (NonNull vr)-type WhenBothNonNull f k v1 v2 vr- = Map.WhenMatched f k (NonNull v1) (NonNull v2) (NonNull vr)--data MergeStrategy f k v1 v2 v3 = MergeStrategy- { withNonNullL :: !(WhenOneSideNull f k v1 v3)- , withNonNullR :: !(WhenOneSideNull f k v2 v3)- , withNonNullP :: !(WhenBothNonNull f k v1 v2 v3)- }- merge :: Ord k- => MergeStrategy Identity k v1 v2 v3+ => Merge.Strategy Identity k v1 v2 v3 -> MonoidMap k v1 -> MonoidMap k v2 -> MonoidMap k v3-merge (MergeStrategy nnl nnr nnp) (MonoidMap m1) (MonoidMap m2) =- MonoidMap $ Map.merge nnl nnr nnp m1 m2+merge s m1 m2 =+ fromNonNullMap $ Merge.merge s (toNonNullMap m1) (toNonNullMap m2) {-# INLINE merge #-} mergeA :: (Applicative f, Ord k)- => MergeStrategy f k v1 v2 v3+ => Merge.Strategy f k v1 v2 v3 -> MonoidMap k v1 -> MonoidMap k v2 -> f (MonoidMap k v3)-mergeA (MergeStrategy nnl nnr nnp) (MonoidMap m1) (MonoidMap m2) =- MonoidMap <$> Map.mergeA nnl nnr nnp m1 m2+mergeA s m1 m2 =+ fromNonNullMap <$> Merge.mergeA s (toNonNullMap m1) (toNonNullMap m2) {-# INLINE mergeA #-}--keepNull- :: Applicative f- => WhenOneSideNull f k v1 v2-keepNull = Map.dropMissing-{-# INLINE keepNull #-}--keepNonNull- :: Applicative f- => WhenOneSideNull f k v v-keepNonNull = Map.preserveMissing-{-# INLINE keepNonNull #-}--withNonNull- :: (Applicative f, MonoidNull v2)- => (v1 -> v2)- -> WhenOneSideNull f k v1 v2-withNonNull f- = Map.mapMaybeMissing- $ \_k v -> NonNull.nonNull $ NonNull.apply f v-{-# INLINE withNonNull #-}--withNonNullA- :: (Applicative f, MonoidNull v2)- => (v1 -> f v2)- -> WhenOneSideNull f k v1 v2-withNonNullA f- = Map.traverseMaybeMissing- $ \_k v -> NonNull.nonNull <$> NonNull.apply f v-{-# INLINE withNonNullA #-}--withBoth- :: (Applicative f, MonoidNull v3)- => (v1 -> v2 -> v3)- -> WhenBothNonNull f k v1 v2 v3-withBoth f- = Map.zipWithMaybeMatched- $ \_k v1 v2 -> NonNull.nonNull $ NonNull.apply2 f v1 v2-{-# INLINE withBoth #-}--withBothA- :: (Applicative f, MonoidNull v3)- => (v1 -> v2 -> f v3)- -> WhenBothNonNull f k v1 v2 v3-withBothA f- = Map.zipWithMaybeAMatched- $ \_k v1 v2 -> NonNull.nonNull <$> NonNull.apply2 f v1 v2-{-# INLINE withBothA #-} -------------------------------------------------------------------------------- -- State
monoidmap.cabal view
@@ -1,6 +1,6 @@ cabal-version: 3.0 name: monoidmap-version: 0.1.3.0+version: 0.1.3.1 homepage: https://github.com/jonathanknowles/monoidmap bug-reports: https://github.com/jonathanknowles/monoidmap/issues license: Apache-2.0@@ -40,7 +40,7 @@ common dependency-monoid-subclasses build-depends:monoid-subclasses >= 1.2.3 && < 1.3 common dependency-monoidmap-internal- build-depends:monoidmap-internal >= 0.5.0.0 && < 0.6+ build-depends:monoidmap-internal >= 0.5.1.0 && < 0.6 common dependency-nothunks if flag(nothunks) build-depends:nothunks >= 0.1.3 && < 0.4