monoidal-containers 0.3.1.0 → 0.4.0.0

raw patch · 5 files changed

+1081/−34 lines, 5 filesdep +aesondep ~basedep ~containersPVP ok

version bump matches the API change (PVP)

Dependencies added: aeson

Dependency ranges changed: base, containers

API changes (from Hackage documentation)

Files

• Changelog.md +22/−0
• monoidal-containers.cabal +7/−5
• src/Data/HashMap/Monoidal.hs +41/−11
• src/Data/Map/Monoidal.hs +506/−9
• src/Data/Map/Monoidal/Strict.hs +505/−9

@@ -0,0 +1,22 @@+# Monoidal containers++# 0.4.0.0++General changes:+ + * Added support for `unordered-containers < 0.2.8`+ * Added many more functions in `Data.Map.[Strict.]Monoid`++Weakened `Monoid` constraints to `Semigroup` whenever possible as enabled by the+[Semigroup-Monoid+proposal](https://prime.haskell.org/wiki/Libraries/Proposals/SemigroupMonoid).+This includes,++ * the `Monoid` instance of `MonoidalHashMap` and `MonoidalMap`+ * the `IsList` instance of `MonoidalHashMap` and `MonoidalMap`+ * the `modifyDef` and `mapKeys` functions of `MonoidalHashMap`+++# 0.3 and earlier++Pre-history

@@ -1,5 +1,5 @@ name:                monoidal-containers-version:             0.3.1.0+version:             0.4.0.0 synopsis:            Containers with monoidal accumulation description:     Containers with merging via monoidal accumulation. The 'Monoid' instances@@ -12,7 +12,7 @@     the @Monoid@ @Map@ instance looks like,     .     @-    instance (Ord k, Monoid a) => Monoid (MonoidalMap k a)+    instance (Ord k, Semigroup a) => Monoid (MonoidalMap k a)     @ homepage:            http://github.com/bgamari/monoidal-containers license:             BSD3@@ -23,7 +23,8 @@ category:            Data build-type:          Simple cabal-version:       >=1.10-tested-with:         GHC ==7.6.3, GHC ==7.8.4, GHC ==8.0.2, GHC ==8.2.2, GHC ==8.4.1+extra-source-files:  Changelog.md+tested-with:         GHC ==7.8.4, GHC ==8.0.2, GHC ==8.2.2, GHC ==8.4.3, GHC ==8.6.1  source-repository head   type:                git@@ -38,8 +39,9 @@                        GeneralizedNewtypeDeriving,                        DeriveTraversable,                        DeriveDataTypeable-  build-depends:       base >=4.5 && <4.12,-                       containers >=0.5 && <0.6,+  build-depends:       base >=4.5 && <4.13,+                       aeson >=1.0 && <1.5,+                       containers >=0.5 && <0.7,                        deepseq >=1.3 && <1.5,                        unordered-containers >= 0.2 && < 0.3,                        hashable >= 1.2 && < 1.3,

@@ -30,6 +30,8 @@     , keys     , delete     , mapKeys+    , insert+    , insertOrReplace     , modify     , modifyDef     , map@@ -51,14 +53,20 @@ import Control.DeepSeq import qualified Data.HashMap.Strict as M import Data.Hashable (Hashable)+#if MIN_VERSION_unordered_containers(0,2,8)+import Data.Hashable.Lifted (Hashable1)+#endif import Control.Lens import Control.Newtype  -- | A 'HashMap' with monoidal accumulation newtype MonoidalHashMap k a = MonoidalHashMap { getMonoidalHashMap :: M.HashMap k a }-    deriving (Show, Read, Functor, Eq, NFData,-              Foldable, Traversable,-              Data, Typeable)+    deriving ( Show, Read, Functor, Eq, NFData+             , Foldable, Traversable, Data, Typeable, Hashable+#if MIN_VERSION_unordered_containers(0,2,8)+             , Hashable1+#endif+             )  type instance Index (MonoidalHashMap k a) = k type instance IxValue (MonoidalHashMap k a) = a@@ -96,11 +104,11 @@     MonoidalHashMap a <> MonoidalHashMap b = MonoidalHashMap $ M.unionWith (<>) a b     {-# INLINE (<>) #-} -instance (Eq k, Hashable k, Monoid a) => Monoid (MonoidalHashMap k a) where+instance (Eq k, Hashable k, Semigroup a) => Monoid (MonoidalHashMap k a) where     mempty = MonoidalHashMap mempty     {-# INLINE mempty #-} #if !(MIN_VERSION_base(4,11,0))-    mappend (MonoidalHashMap a) (MonoidalHashMap b) = MonoidalHashMap $ M.unionWith mappend a b+    mappend (MonoidalHashMap a) (MonoidalHashMap b) = MonoidalHashMap $ M.unionWith (<>) a b     {-# INLINE mappend #-} #endif @@ -111,9 +119,9 @@     {-# INLINE unpack #-}  #if MIN_VERSION_base(4,7,0)-instance (Eq k, Hashable k, Monoid a) => Exts.IsList (MonoidalHashMap k a) where+instance (Eq k, Hashable k, Semigroup a) => Exts.IsList (MonoidalHashMap k a) where     type Item (MonoidalHashMap k a) = (k, a)-    fromList = MonoidalHashMap . M.fromListWith mappend+    fromList = MonoidalHashMap . M.fromListWith (<>)     {-# INLINE fromList #-}     toList = M.toList . unpack     {-# INLINE toList #-}@@ -171,8 +179,8 @@  -- | /O(n*log n)/. Construct a map with the supplied mappings. If the list -- contains duplicate mappings, values will be merged using (mappend newVal oldVal).-fromList :: (Eq k, Hashable k, Monoid a) => [(k,a)] -> MonoidalHashMap k a-fromList = pack . M.fromListWith mappend+fromList :: (Eq k, Hashable k, Semigroup a) => [(k,a)] -> MonoidalHashMap k a+fromList = pack . M.fromListWith (<>) {-# INLINE fromList #-}  -- | /O(n*log n)/.  Return a list of this map's elements. The list is produced@@ -181,6 +189,28 @@ toList = M.toList . unpack {-# INLINE toList #-} +-- | /O(log n)/. Insert a value on some key, if it exists -- mappend+-- to the existing one.+insert :: (Semigroup a, Hashable k, Eq k)+       => a+       -> k+       -> MonoidalHashMap k a+       -> MonoidalHashMap k a+insert x k = pack+           . M.insertWith (<>) k x+           . unpack++-- | /O(log n)/. Insert a value on some key with a function, if value+-- under key exists -- replace it.+insertOrReplace :: (Semigroup a, Hashable k, Eq k)+                => a+                -> k+                -> MonoidalHashMap k a+                -> MonoidalHashMap k a+insertOrReplace x k = pack+                    . M.insert k x+                    . unpack+ -- | /O(log n)/. Modify a value on some key with a function, if value -- under key doesn't exist -- use mempty. modify :: (Monoid a, Hashable k, Eq k)@@ -194,7 +224,7 @@  -- | /O(log n)/. Modify a value on some key with a function, providing -- a default value if that key doesn't exist.-modifyDef :: (Monoid a, Hashable k, Eq k)+modifyDef :: (Semigroup a, Hashable k, Eq k)           => a -> (a -> a)           -> k -> MonoidalHashMap k a           -> MonoidalHashMap k a@@ -205,7 +235,7 @@  -- | /O(n)/. Map a function to each key of a map, if it will result -- in duplicated mappings, their values will be merged in unspecified order-mapKeys :: (Monoid a, Hashable k, Eq k, Hashable k', Eq k')+mapKeys :: (Semigroup a, Hashable k, Eq k, Hashable k', Eq k')         => (k -> k') -> MonoidalHashMap k a -> MonoidalHashMap k' a mapKeys f = fromList           . fmap (\(k, v) -> (f k, v))

@@ -1,10 +1,12 @@ {-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE StandaloneDeriving #-}  -- | This module provides a 'Data.Map' variant which uses the value's -- 'Monoid' instance to accumulate conflicting entries when merging@@ -26,8 +28,108 @@     , assocs     , elems     , keys+    , (!)+    , (\\)+    , adjust+    , adjustWithKey+    , alter+    , delete+    , deleteAt+    , deleteFindMax+    , deleteFindMin+    , deleteMax+    , deleteMin+    , difference+    , differenceWith+    , differenceWithKey+    , elemAt+    , empty+    , filter+    , filterWithKey+    , findIndex+    , findMax+    , findMin+    , foldMapWithKey+    , foldl+    , foldl'+    , foldlWithKey+    , foldlWithKey'+    , foldr+    , foldr'+    , foldrWithKey+    , foldrWithKey'+    , fromAscList+    , fromAscListWith+    , fromAscListWithKey+    , fromDistinctAscList+    , fromList+    , fromListWith+    , fromListWithKey+    , fromSet+    , insert+    , insertLookupWithKey+    , insertWith+    , insertWithKey+    , intersectionWith+    , intersectionWithKey+    , isProperSubmapOf+    , isProperSubmapOfBy+    , isSubmapOf+    , isSubmapOfBy+    , keysSet+    , lookup+    , lookupGE+    , lookupGT+    , lookupIndex+    , lookupLE+    , lookupLT+    , map+    , mapAccum+    , mapAccumRWithKey+    , mapAccumWithKey+    , mapEither+    , mapEitherWithKey+    , mapKeys+    , mapKeysMonotonic+    , mapKeysWith+    , mapMaybe+    , mapMaybeWithKey+    , mapWithKey+    , maxView+    , maxViewWithKey+    , mergeWithKey+    , minView+    , minViewWithKey+    , null+    , partition+    , partitionWithKey+    , split+    , splitLookup+    , splitRoot+    , toAscList+    , toDescList+    , toList+    , traverseWithKey+    , unionWith+    , unionWithKey+    , unionsWith+    , update+    , updateAt+    , updateLookupWithKey+    , updateMax+    , updateMaxWithKey+    , updateMin+    , updateMinWithKey+    , updateWithKey+    , valid+    -- , showTree+    -- , showTreeWith     ) where +import Prelude hiding (null, lookup, map, foldl, foldr, filter)++import Data.Coerce (coerce)+import Data.Set (Set) import Data.Semigroup import Data.Foldable (Foldable) import Data.Traversable (Traversable)@@ -36,20 +138,31 @@ import Data.Typeable (Typeable)  #if MIN_VERSION_base(4,7,0)-import GHC.Exts (IsList(..))+import qualified GHC.Exts as IsList #endif  import Control.DeepSeq import qualified Data.Map as M import Control.Lens import Control.Newtype+import Data.Aeson(FromJSON, ToJSON, FromJSON1, ToJSON1)+#if MIN_VERSION_containers(0,5,9)+import Data.Functor.Classes+#endif  -- | A 'Map' with monoidal accumulation newtype MonoidalMap k a = MonoidalMap { getMonoidalMap :: M.Map k a }     deriving (Show, Read, Functor, Eq, Ord, NFData,               Foldable, Traversable,+              FromJSON, ToJSON, FromJSON1, ToJSON1,               Data, Typeable) +#if MIN_VERSION_containers(0,5,9)+deriving instance (Ord k) => Eq1 (MonoidalMap k)+deriving instance (Ord k) => Ord1 (MonoidalMap k)+deriving instance (Show k) => Show1 (MonoidalMap k)+#endif+ type instance Index (MonoidalMap k a) = k type instance IxValue (MonoidalMap k a) = a instance Ord k => Ixed (MonoidalMap k a) where@@ -67,9 +180,9 @@  instance Each (MonoidalMap k a) (MonoidalMap k b) a b -instance Ord k => FunctorWithIndex k (MonoidalMap k)-instance Ord k => FoldableWithIndex k (MonoidalMap k)-instance Ord k => TraversableWithIndex k (MonoidalMap k) where+instance FunctorWithIndex k (MonoidalMap k)+instance FoldableWithIndex k (MonoidalMap k)+instance TraversableWithIndex k (MonoidalMap k) where     itraverse f (MonoidalMap m) = fmap MonoidalMap $ itraverse f m     {-# INLINE itraverse #-} @@ -93,11 +206,11 @@     MonoidalMap a <> MonoidalMap b = MonoidalMap $ M.unionWith (<>) a b     {-# INLINE (<>) #-} -instance (Ord k, Monoid a) => Monoid (MonoidalMap k a) where+instance (Ord k, Semigroup a) => Monoid (MonoidalMap k a) where     mempty = MonoidalMap mempty     {-# INLINE mempty #-} #if !(MIN_VERSION_base(4,11,0))-    mappend (MonoidalMap a) (MonoidalMap b) = MonoidalMap $ M.unionWith mappend a b+    mappend (MonoidalMap a) (MonoidalMap b) = MonoidalMap $ M.unionWith (<>) a b     {-# INLINE mappend #-} #endif @@ -108,16 +221,16 @@     {-# INLINE unpack #-}  #if MIN_VERSION_base(4,7,0)-instance (Ord k, Monoid a) => IsList (MonoidalMap k a) where+instance (Ord k, Semigroup a) => IsList.IsList (MonoidalMap k a) where     type Item (MonoidalMap k a) = (k, a)-    fromList = MonoidalMap . M.fromListWith mappend+    fromList = MonoidalMap . M.fromListWith (<>)     {-# INLINE fromList #-}     toList = M.toList . unpack     {-# INLINE toList #-} #endif  -- | /O(1)/. A map with a single element.-singleton :: Ord k => k -> a -> MonoidalMap k a+singleton :: k -> a -> MonoidalMap k a singleton k a = MonoidalMap $ M.singleton k a {-# INLINE singleton #-} @@ -165,3 +278,387 @@ keys :: MonoidalMap k a -> [k] keys = M.keys . unpack {-# INLINE keys #-}++++(!) :: forall k a. Ord k => MonoidalMap k a -> k -> a+(!) = coerce ((M.!) :: M.Map k a -> k -> a)+infixl 9 !++(\\) :: forall k a b. Ord k => MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+(\\) = coerce ((M.\\) :: M.Map k a -> M.Map k b -> M.Map k a)+infixl 9 \\ --++null :: forall k a. MonoidalMap k a -> Bool+null = coerce (M.null :: M.Map k a -> Bool)+{-# INLINE null #-}++lookup :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe a+lookup = coerce (M.lookup :: k -> M.Map k a -> Maybe a)+{-# INLINE lookup #-}++lookupLT :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupLT = coerce (M.lookupLT :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupLT #-}++lookupGT :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupGT = coerce (M.lookupGT :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupGT #-}++lookupLE :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupLE = coerce (M.lookupLE :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupLE #-}++lookupGE :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupGE = coerce (M.lookupGE :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupGE #-}++empty :: forall k a. MonoidalMap k a+empty = coerce (M.empty :: M.Map k a)+{-# INLINE empty #-}++insert :: forall k a. Ord k => k -> a -> MonoidalMap k a -> MonoidalMap k a+insert = coerce (M.insert :: k -> a -> M.Map k a -> M.Map k a)+{-# INLINE insert #-}++insertWith :: forall k a. Ord k => (a -> a -> a) -> k -> a -> MonoidalMap k a -> MonoidalMap k a+insertWith = coerce (M.insertWith :: (a -> a -> a) -> k -> a -> M.Map k a -> M.Map k a)+{-# INLINE insertWith #-}++insertWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> k -> a -> MonoidalMap k a -> MonoidalMap k a+insertWithKey = coerce (M.insertWithKey :: (k -> a -> a -> a) -> k -> a -> M.Map k a -> M.Map k a)+{-# INLINE insertWithKey #-}++insertLookupWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> k -> a -> MonoidalMap k a -> (Maybe a, MonoidalMap k a)+insertLookupWithKey = coerce (M.insertLookupWithKey :: (k -> a -> a -> a) -> k -> a -> M.Map k a -> (Maybe a, M.Map k a))+{-# INLINE insertLookupWithKey #-}++adjust :: forall k a. Ord k => (a -> a) -> k -> MonoidalMap k a -> MonoidalMap k a+adjust = coerce (M.adjust :: (a -> a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE adjust #-}++adjustWithKey :: forall k a. Ord k => (k -> a -> a) -> k -> MonoidalMap k a -> MonoidalMap k a+adjustWithKey = coerce (M.adjustWithKey :: (k -> a -> a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE adjustWithKey #-}++update :: forall k a. Ord k => (a -> Maybe a) -> k -> MonoidalMap k a -> MonoidalMap k a+update = coerce (M.update :: (a -> Maybe a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE update #-}++updateWithKey :: forall k a. Ord k => (k -> a -> Maybe a) -> k -> MonoidalMap k a -> MonoidalMap k a+updateWithKey = coerce (M.updateWithKey :: (k -> a -> Maybe a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE updateWithKey #-}++updateLookupWithKey :: forall k a. Ord k => (k -> a -> Maybe a) -> k -> MonoidalMap k a -> (Maybe a, MonoidalMap k a)+updateLookupWithKey = coerce (M.updateLookupWithKey :: (k -> a -> Maybe a) -> k -> M.Map k a -> (Maybe a, M.Map k a))+{-# INLINE updateLookupWithKey #-}++alter :: forall k a. Ord k => (Maybe a -> Maybe a) -> k -> MonoidalMap k a -> MonoidalMap k a+alter = coerce (M.alter :: (Maybe a -> Maybe a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE alter #-}++unionWith :: forall k a. Ord k => (a -> a -> a) -> MonoidalMap k a -> MonoidalMap k a -> MonoidalMap k a+unionWith = coerce (M.unionWith :: (a -> a -> a) -> M.Map k a -> M.Map k a -> M.Map k a)+{-# INLINE unionWith #-}++unionWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> MonoidalMap k a -> MonoidalMap k a -> MonoidalMap k a+unionWithKey = coerce (M.unionWithKey :: (k -> a -> a -> a) -> M.Map k a -> M.Map k a -> M.Map k a)+{-# INLINE unionWithKey #-}++unionsWith :: forall k a. Ord k => (a -> a -> a) -> [MonoidalMap k a] -> MonoidalMap k a+unionsWith = coerce (M.unionsWith :: (a -> a -> a) -> [M.Map k a] -> M.Map k a)+{-# INLINE unionsWith #-}++difference :: forall k a b. Ord k => MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+difference = (\\)+{-# INLINE difference #-}++differenceWith :: forall k a b. Ord k => (a -> b -> Maybe a) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+differenceWith = coerce (M.differenceWith :: (a -> b -> Maybe a) -> M.Map k a -> M.Map k b -> M.Map k a)+{-# INLINE differenceWith #-}++differenceWithKey :: forall k a b. Ord k => (k -> a -> b -> Maybe a) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+differenceWithKey = coerce (M.differenceWithKey :: (k -> a -> b -> Maybe a) -> M.Map k a -> M.Map k b -> M.Map k a)+{-# INLINE differenceWithKey #-}++intersectionWith :: forall k a b c. Ord k => (a -> b -> c) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k c+intersectionWith = coerce (M.intersectionWith :: (a -> b -> c) -> M.Map k a -> M.Map k b -> M.Map k c)+{-# INLINE intersectionWith #-}++intersectionWithKey :: forall k a b c. Ord k => (k -> a -> b -> c) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k c+intersectionWithKey = coerce (M.intersectionWithKey :: (k -> a -> b -> c) -> M.Map k a -> M.Map k b -> M.Map k c)+{-# INLINE intersectionWithKey #-}++mergeWithKey :: forall k a b c. Ord k => (k -> a -> b -> Maybe c) -> (MonoidalMap k a -> MonoidalMap k c) -> (MonoidalMap k b -> MonoidalMap k c) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k c+mergeWithKey = coerce (M.mergeWithKey :: (k -> a -> b -> Maybe c) -> (M.Map k a -> M.Map k c) -> (M.Map k b -> M.Map k c) -> M.Map k a -> M.Map k b -> M.Map k c)+{-# INLINE mergeWithKey #-}++map :: (a -> b) -> MonoidalMap k a -> MonoidalMap k b+map = fmap+{-# INLINE map #-}++mapWithKey :: forall k a  b. (k -> a -> b) -> MonoidalMap k a -> MonoidalMap k b+mapWithKey = coerce (M.mapWithKey :: (k -> a -> b) -> M.Map k a -> M.Map k b)+{-# INLINE mapWithKey #-}++traverseWithKey :: Applicative t => (k -> a -> t b) -> MonoidalMap k a -> t (MonoidalMap k b)+traverseWithKey = itraverse+{-# INLINE traverseWithKey #-}++mapAccum :: forall k a b c. (a -> b -> (a, c)) -> a -> MonoidalMap k b -> (a, MonoidalMap k c)+mapAccum = coerce (M.mapAccum :: (a -> b -> (a, c)) -> a -> M.Map k b -> (a, M.Map k c))+{-# INLINE mapAccum #-}++mapAccumWithKey :: forall k a b c. (a -> k -> b -> (a, c)) -> a -> MonoidalMap k b -> (a, MonoidalMap k c)+mapAccumWithKey = coerce (M.mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> M.Map k b -> (a, M.Map k c))+{-# INLINE mapAccumWithKey #-}++mapAccumRWithKey :: forall k a b c. (a -> k -> b -> (a, c)) -> a -> MonoidalMap k b -> (a, MonoidalMap k c)+mapAccumRWithKey = coerce (M.mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> M.Map k b -> (a, M.Map k c))+{-# INLINE mapAccumRWithKey #-}++mapKeys :: forall k1 k2 a. Ord k2 => (k1 -> k2) -> MonoidalMap k1 a -> MonoidalMap k2 a+mapKeys = coerce (M.mapKeys :: (k1 -> k2) -> M.Map k1 a -> M.Map k2 a)+{-# INLINE mapKeys #-}++mapKeysWith :: forall k1 k2 a. Ord k2 => (a -> a -> a) -> (k1 -> k2) -> MonoidalMap k1 a -> MonoidalMap k2 a+mapKeysWith = coerce (M.mapKeysWith :: (a -> a -> a) -> (k1 -> k2) -> M.Map k1 a -> M.Map k2 a)+{-# INLINE mapKeysWith #-}++mapKeysMonotonic :: forall k1 k2 a. (k1 -> k2) -> MonoidalMap k1 a -> MonoidalMap k2 a+mapKeysMonotonic = coerce (M.mapKeysMonotonic :: (k1 -> k2) -> M.Map k1 a -> M.Map k2 a)+{-# INLINE mapKeysMonotonic #-}++foldr :: forall k a b. (a -> b -> b) -> b -> MonoidalMap k a -> b+foldr = coerce (M.foldr :: (a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldr #-}++foldl :: forall k a b. (a -> b -> a) -> a -> MonoidalMap k b -> a+foldl = coerce (M.foldl :: (a -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldl #-}++foldrWithKey :: forall k a b. (k -> a -> b -> b) -> b -> MonoidalMap k a -> b+foldrWithKey = coerce (M.foldrWithKey :: (k -> a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldrWithKey #-}++foldlWithKey :: forall k a b. (a -> k -> b -> a) -> a -> MonoidalMap k b -> a+foldlWithKey = coerce (M.foldlWithKey :: (a -> k -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldlWithKey #-}++foldMapWithKey :: forall k a m. Monoid m => (k -> a -> m) -> MonoidalMap k a -> m+foldMapWithKey = coerce (M.foldMapWithKey :: Monoid m => (k -> a -> m) -> M.Map k a -> m)+{-# INLINE foldMapWithKey #-}++foldr' :: forall k a b. (a -> b -> b) -> b -> MonoidalMap k a -> b+foldr' = coerce (M.foldr' :: (a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldr' #-}++foldl' :: forall k a b. (a -> b -> a) -> a -> MonoidalMap k b -> a+foldl' = coerce (M.foldl' :: (a -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldl' #-}++foldrWithKey' :: forall k a b. (k -> a -> b -> b) -> b -> MonoidalMap k a -> b+foldrWithKey' = coerce (M.foldrWithKey' :: (k -> a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldrWithKey' #-}++foldlWithKey' :: forall k a b. (a -> k -> b -> a) -> a -> MonoidalMap k b -> a+foldlWithKey' = coerce (M.foldlWithKey' :: (a -> k -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldlWithKey' #-}++keysSet :: forall k a. MonoidalMap k a -> Set k+keysSet = coerce (M.keysSet :: M.Map k a -> Set k)+{-# INLINE keysSet #-}++fromSet :: forall k a. (k -> a) -> Set k -> MonoidalMap k a+fromSet = coerce (M.fromSet :: (k -> a) -> Set k -> M.Map k a)+{-# INLINE fromSet #-}++toList :: forall k a. MonoidalMap k a -> [(k, a)]+toList = coerce (M.toList :: M.Map k a -> [(k, a)])+{-# INLINE toList #-}++fromList :: forall k a. Ord k => [(k, a)] -> MonoidalMap k a+fromList = coerce (M.fromList :: [(k, a)] -> M.Map k a)+{-# INLINE fromList #-}++fromListWith :: forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromListWith = coerce (M.fromListWith :: (a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromListWith #-}++fromListWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromListWithKey = coerce (M.fromListWithKey :: (k -> a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromListWithKey #-}++toAscList :: forall k a. MonoidalMap k a -> [(k, a)]+toAscList = coerce (M.toAscList :: M.Map k a -> [(k, a)])+{-# INLINE toAscList #-}++toDescList :: forall k a. MonoidalMap k a -> [(k, a)]+toDescList = coerce (M.toDescList :: M.Map k a -> [(k, a)])+{-# INLINE toDescList #-}++fromAscList :: forall k a. Eq k => [(k, a)] -> MonoidalMap k a+fromAscList = coerce (M.fromAscList :: [(k, a)] -> M.Map k a)+{-# INLINE fromAscList #-}++fromAscListWith :: forall k a. Eq k => (a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromAscListWith = coerce (M.fromAscListWith :: (a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromAscListWith #-}++fromAscListWithKey :: forall k a. Eq k => (k -> a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromAscListWithKey = coerce (M.fromAscListWithKey :: (k -> a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromAscListWithKey #-}++fromDistinctAscList :: forall k a. [(k, a)] -> MonoidalMap k a+fromDistinctAscList = coerce (M.fromDistinctAscList :: [(k, a)] -> M.Map k a)+{-# INLINE fromDistinctAscList #-}++filter :: forall k a. (a -> Bool) -> MonoidalMap k a -> MonoidalMap k a+filter = coerce (M.filter :: (a -> Bool) -> M.Map k a -> M.Map k a)+{-# INLINE filter #-}++filterWithKey :: forall k a. (k -> a -> Bool) -> MonoidalMap k a -> MonoidalMap k a+filterWithKey = coerce (M.filterWithKey :: (k -> a -> Bool) -> M.Map k a -> M.Map k a)+{-# INLINE filterWithKey #-}++partition :: forall k a. (a -> Bool) -> MonoidalMap k a -> (MonoidalMap k a, MonoidalMap k a)+partition = coerce (M.partition :: (a -> Bool) -> M.Map k a -> (M.Map k a, M.Map k a))+{-# INLINE partition #-}++partitionWithKey :: forall k a. (k -> a -> Bool) -> MonoidalMap k a -> (MonoidalMap k a, MonoidalMap k a)+partitionWithKey = coerce (M.partitionWithKey :: (k -> a -> Bool) -> M.Map k a -> (M.Map k a, M.Map k a))+{-# INLINE partitionWithKey #-}++mapMaybe :: forall k a b. (a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b+mapMaybe = coerce (M.mapMaybe :: (a -> Maybe b) -> M.Map k a -> M.Map k b)+{-# INLINE mapMaybe #-}++mapMaybeWithKey :: forall k a b. (k -> a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b+mapMaybeWithKey = coerce (M.mapMaybeWithKey :: (k -> a -> Maybe b) -> M.Map k a -> M.Map k b)+{-# INLINE mapMaybeWithKey #-}++mapEither :: forall k a b c. (a -> Either b c) -> MonoidalMap k a -> (MonoidalMap k b, MonoidalMap k c)+mapEither = coerce (M.mapEither :: (a -> Either b c) -> M.Map k a -> (M.Map k b, M.Map k c))+{-# INLINE mapEither #-}++mapEitherWithKey :: forall k a b c. (k -> a -> Either b c) -> MonoidalMap k a -> (MonoidalMap k b, MonoidalMap k c)+mapEitherWithKey = coerce (M.mapEitherWithKey :: (k -> a -> Either b c) -> M.Map k a -> (M.Map k b, M.Map k c))+{-# INLINE mapEitherWithKey #-}++split :: forall k a. Ord k => k -> MonoidalMap k a -> (MonoidalMap k a, MonoidalMap k a)+split = coerce (M.split :: k -> M.Map k a -> (M.Map k a, M.Map k a))+{-# INLINE split #-}++splitLookup :: forall k a. Ord k => k -> MonoidalMap k a -> (MonoidalMap k a, Maybe a, MonoidalMap k a)+splitLookup = coerce (M.splitLookup :: k -> M.Map k a -> (M.Map k a, Maybe a, M.Map k a))+{-# INLINE splitLookup #-}++splitRoot :: forall k a. MonoidalMap k a -> [MonoidalMap k a]+splitRoot = coerce (M.splitRoot :: M.Map k a -> [M.Map k a])+{-# INLINE splitRoot #-}++isSubmapOf :: forall k a. (Ord k, Eq a) => MonoidalMap k a -> MonoidalMap k a -> Bool+isSubmapOf = coerce (M.isSubmapOf :: M.Map k a -> M.Map k a -> Bool)+{-# INLINE isSubmapOf #-}++isSubmapOfBy :: forall k a b. Ord k => (a -> b -> Bool) -> MonoidalMap k a -> MonoidalMap k b -> Bool+isSubmapOfBy = coerce (M.isSubmapOfBy :: (a -> b -> Bool) -> M.Map k a -> M.Map k b -> Bool)+{-# INLINE isSubmapOfBy #-}++isProperSubmapOf :: forall k a. (Ord k, Eq a) => MonoidalMap k a -> MonoidalMap k a -> Bool+isProperSubmapOf = coerce (M.isProperSubmapOf :: M.Map k a -> M.Map k a -> Bool)+{-# INLINE isProperSubmapOf #-}++isProperSubmapOfBy :: forall k a b. Ord k => (a -> b -> Bool) -> MonoidalMap k a -> MonoidalMap k b -> Bool+isProperSubmapOfBy = coerce (M.isProperSubmapOfBy :: (a -> b -> Bool) -> M.Map k a -> M.Map k b -> Bool)+{-# INLINE isProperSubmapOfBy #-}++lookupIndex :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe Int+lookupIndex = coerce (M.lookupIndex :: k -> M.Map k a -> Maybe Int)+{-# INLINE lookupIndex #-}++findIndex :: forall k a. Ord k => k -> MonoidalMap k a -> Int+findIndex = coerce (M.findIndex :: k -> M.Map k a -> Int)+{-# INLINE findIndex #-}++elemAt :: forall k a. Int -> MonoidalMap k a -> (k, a)+elemAt = coerce (M.elemAt :: Int -> M.Map k a -> (k, a))+{-# INLINE elemAt #-}++updateAt :: forall k a. (k -> a -> Maybe a) -> Int -> MonoidalMap k a -> MonoidalMap k a+updateAt = coerce (M.updateAt :: (k -> a -> Maybe a) -> Int -> M.Map k a -> M.Map k a)+{-# INLINE updateAt #-}++deleteAt :: forall k a. Int -> MonoidalMap k a -> MonoidalMap k a+deleteAt = coerce (M.deleteAt :: Int -> M.Map k a -> M.Map k a)+{-# INLINE deleteAt #-}++findMin :: forall k a. MonoidalMap k a -> (k, a)+findMin = coerce (M.findMin :: M.Map k a -> (k, a))+{-# INLINE findMin #-}++findMax :: forall k a. MonoidalMap k a -> (k, a)+findMax = coerce (M.findMax :: M.Map k a -> (k, a))+{-# INLINE findMax #-}++deleteMin :: forall k a. MonoidalMap k a -> MonoidalMap k a+deleteMin = coerce (M.deleteMin :: M.Map k a -> M.Map k a)+{-# INLINE deleteMin #-}++deleteMax :: forall k a. MonoidalMap k a -> MonoidalMap k a+deleteMax = coerce (M.deleteMax :: M.Map k a -> M.Map k a)+{-# INLINE deleteMax #-}++deleteFindMin :: forall k a. MonoidalMap k a -> ((k, a), MonoidalMap k a)+deleteFindMin = coerce (M.deleteFindMin :: M.Map k a -> ((k, a), M.Map k a))+{-# INLINE deleteFindMin #-}++deleteFindMax :: forall k a. MonoidalMap k a -> ((k, a), MonoidalMap k a)+deleteFindMax = coerce (M.deleteFindMax :: M.Map k a -> ((k, a), M.Map k a))+{-# INLINE deleteFindMax #-}++updateMin :: forall k a. (a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMin = coerce (M.updateMin :: (a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMin #-}++updateMax :: forall k a. (a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMax = coerce (M.updateMax :: (a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMax #-}++updateMinWithKey :: forall k a. (k -> a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMinWithKey = coerce (M.updateMinWithKey :: (k -> a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMinWithKey #-}++updateMaxWithKey :: forall k a. (k -> a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMaxWithKey = coerce (M.updateMaxWithKey :: (k -> a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMaxWithKey #-}++minView :: forall k a. MonoidalMap k a -> Maybe (a, MonoidalMap k a)+minView = coerce (M.minView :: M.Map k a -> Maybe (a, M.Map k a))+{-# INLINE minView #-}++maxView :: forall k a. MonoidalMap k a -> Maybe (a, MonoidalMap k a)+maxView = coerce (M.maxView :: M.Map k a -> Maybe (a, M.Map k a))+{-# INLINE maxView #-}++minViewWithKey :: forall k a. MonoidalMap k a -> Maybe ((k, a), MonoidalMap k a)+minViewWithKey = coerce (M.minViewWithKey :: M.Map k a -> Maybe ((k, a), M.Map k a))+{-# INLINE minViewWithKey #-}++maxViewWithKey :: forall k a. MonoidalMap k a -> Maybe ((k, a), MonoidalMap k a)+maxViewWithKey = coerce (M.maxViewWithKey :: M.Map k a -> Maybe ((k, a), M.Map k a))+{-# INLINE maxViewWithKey #-}++-- showTree :: forall k a. (Show k, Show a) => MonoidalMap k a -> String+-- showTree = coerce (M.showTree :: (Show k, Show a) => M.Map k a -> String)+-- {-# INLINE showTree #-}++-- showTreeWith :: forall k a. (k -> a -> String) -> Bool -> Bool -> MonoidalMap k a -> String+-- showTreeWith = coerce (M.showTreeWith :: (k -> a -> String) -> Bool -> Bool -> M.Map k a -> String)+-- {-# INLINE showTreeWith #-}++valid :: forall k a. Ord k => MonoidalMap k a -> Bool+valid = coerce (M.valid :: Ord k => M.Map k a -> Bool)+{-# INLINE valid #-}++

@@ -5,6 +5,8 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StandaloneDeriving #-}  -- | This module provides a 'Data.Map' variant which uses the value's -- 'Monoid' instance to accumulate conflicting entries when merging@@ -26,30 +28,141 @@     , assocs     , elems     , keys+    , (!)+    , (\\)+    , adjust+    , adjustWithKey+    , alter+    , delete+    , deleteAt+    , deleteFindMax+    , deleteFindMin+    , deleteMax+    , deleteMin+    , difference+    , differenceWith+    , differenceWithKey+    , elemAt+    , empty+    , filter+    , filterWithKey+    , findIndex+    , findMax+    , findMin+    , foldMapWithKey+    , foldl+    , foldl'+    , foldlWithKey+    , foldlWithKey'+    , foldr+    , foldr'+    , foldrWithKey+    , foldrWithKey'+    , fromAscList+    , fromAscListWith+    , fromAscListWithKey+    , fromDistinctAscList+    , fromList+    , fromListWith+    , fromListWithKey+    , fromSet+    , insert+    , insertLookupWithKey+    , insertWith+    , insertWithKey+    , intersectionWith+    , intersectionWithKey+    , isProperSubmapOf+    , isProperSubmapOfBy+    , isSubmapOf+    , isSubmapOfBy+    , keysSet+    , lookup+    , lookupGE+    , lookupGT+    , lookupIndex+    , lookupLE+    , lookupLT+    , map+    , mapAccum+    , mapAccumRWithKey+    , mapAccumWithKey+    , mapEither+    , mapEitherWithKey+    , mapKeys+    , mapKeysMonotonic+    , mapKeysWith+    , mapMaybe+    , mapMaybeWithKey+    , mapWithKey+    , maxView+    , maxViewWithKey+    , mergeWithKey+    , minView+    , minViewWithKey+    , null+    , partition+    , partitionWithKey+    , split+    , splitLookup+    , splitRoot+    , toAscList+    , toDescList+    , toList+    , traverseWithKey+    , unionWith+    , unionWithKey+    , unionsWith+    , update+    , updateAt+    , updateLookupWithKey+    , updateMax+    , updateMaxWithKey+    , updateMin+    , updateMinWithKey+    , updateWithKey+    , valid+    -- , showTree+    -- , showTreeWith     ) where +import Prelude hiding (null, lookup, map, foldl, foldr, filter)++import Data.Coerce (coerce) import Data.Semigroup import Data.Foldable (Foldable) import Data.Traversable (Traversable) import Control.Applicative (Applicative, pure) import Data.Data (Data) import Data.Typeable (Typeable)+import Data.Set (Set)  #if MIN_VERSION_base(4,7,0)-import GHC.Exts (IsList(..))+import qualified GHC.Exts  as IsList #endif  import Control.DeepSeq import qualified Data.Map.Strict as M import Control.Lens import Control.Newtype+import Data.Aeson(FromJSON, ToJSON, FromJSON1, ToJSON1)+#if MIN_VERSION_containers(0,5,9)+import Data.Functor.Classes+#endif  -- | A 'Map' with monoidal accumulation newtype MonoidalMap k a = MonoidalMap { getMonoidalMap :: M.Map k a }     deriving (Show, Read, Functor, Eq, Ord, NFData,               Foldable, Traversable,+              FromJSON, ToJSON, FromJSON1, ToJSON1,               Data, Typeable) +#if MIN_VERSION_containers(0,5,9)+deriving instance (Ord k) => Eq1 (MonoidalMap k)+deriving instance (Ord k) => Ord1 (MonoidalMap k)+deriving instance (Show k) => Show1 (MonoidalMap k)+#endif+ type instance Index (MonoidalMap k a) = k type instance IxValue (MonoidalMap k a) = a instance Ord k => Ixed (MonoidalMap k a) where@@ -67,9 +180,9 @@  instance Each (MonoidalMap k a) (MonoidalMap k b) a b -instance Ord k => FunctorWithIndex k (MonoidalMap k)-instance Ord k => FoldableWithIndex k (MonoidalMap k)-instance Ord k => TraversableWithIndex k (MonoidalMap k) where+instance FunctorWithIndex k (MonoidalMap k)+instance FoldableWithIndex k (MonoidalMap k)+instance TraversableWithIndex k (MonoidalMap k) where     itraverse f (MonoidalMap m) = fmap MonoidalMap $ itraverse f m     {-# INLINE itraverse #-} @@ -93,11 +206,11 @@     MonoidalMap a <> MonoidalMap b = MonoidalMap $ M.unionWith (<>) a b     {-# INLINE (<>) #-} -instance (Ord k, Semigroup a, Monoid a) => Monoid (MonoidalMap k a) where+instance (Ord k, Semigroup a) => Monoid (MonoidalMap k a) where     mempty = MonoidalMap mempty     {-# INLINE mempty #-} #if !(MIN_VERSION_base(4,11,0))-    mappend (MonoidalMap a) (MonoidalMap b) = MonoidalMap $ M.unionWith mappend a b+    mappend (MonoidalMap a) (MonoidalMap b) = MonoidalMap $ M.unionWith (<>) a b     {-# INLINE mappend #-} #endif @@ -108,16 +221,16 @@     {-# INLINE unpack #-}  #if MIN_VERSION_base(4,7,0)-instance (Ord k, Monoid a) => IsList (MonoidalMap k a) where+instance (Ord k, Semigroup a) => IsList.IsList (MonoidalMap k a) where     type Item (MonoidalMap k a) = (k, a)-    fromList = MonoidalMap . M.fromListWith mappend+    fromList = MonoidalMap . M.fromListWith (<>)     {-# INLINE fromList #-}     toList = M.toList . unpack     {-# INLINE toList #-} #endif  -- | /O(1)/. A map with a single element.-singleton :: Ord k => k -> a -> MonoidalMap k a+singleton :: k -> a -> MonoidalMap k a singleton k a = MonoidalMap $ M.singleton k a {-# INLINE singleton #-} @@ -165,3 +278,386 @@ keys :: MonoidalMap k a -> [k] keys = M.keys . unpack {-# INLINE keys #-}+++(!) :: forall k a. Ord k => MonoidalMap k a -> k -> a+(!) = coerce ((M.!) :: M.Map k a -> k -> a)+infixl 9 !++(\\) :: forall k a b. Ord k => MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+(\\) = coerce ((M.\\) :: M.Map k a -> M.Map k b -> M.Map k a)+infixl 9 \\ --++null :: forall k a. MonoidalMap k a -> Bool+null = coerce (M.null :: M.Map k a -> Bool)+{-# INLINE null #-}++lookup :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe a+lookup = coerce (M.lookup :: k -> M.Map k a -> Maybe a)+{-# INLINE lookup #-}++lookupLT :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupLT = coerce (M.lookupLT :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupLT #-}++lookupGT :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupGT = coerce (M.lookupGT :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupGT #-}++lookupLE :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupLE = coerce (M.lookupLE :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupLE #-}++lookupGE :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe (k, a)+lookupGE = coerce (M.lookupGE :: k -> M.Map k a -> Maybe (k,a))+{-# INLINE lookupGE #-}++empty :: forall k a. MonoidalMap k a+empty = coerce (M.empty :: M.Map k a)+{-# INLINE empty #-}++insert :: forall k a. Ord k => k -> a -> MonoidalMap k a -> MonoidalMap k a+insert = coerce (M.insert :: k -> a -> M.Map k a -> M.Map k a)+{-# INLINE insert #-}++insertWith :: forall k a. Ord k => (a -> a -> a) -> k -> a -> MonoidalMap k a -> MonoidalMap k a+insertWith = coerce (M.insertWith :: (a -> a -> a) -> k -> a -> M.Map k a -> M.Map k a)+{-# INLINE insertWith #-}++insertWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> k -> a -> MonoidalMap k a -> MonoidalMap k a+insertWithKey = coerce (M.insertWithKey :: (k -> a -> a -> a) -> k -> a -> M.Map k a -> M.Map k a)+{-# INLINE insertWithKey #-}++insertLookupWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> k -> a -> MonoidalMap k a -> (Maybe a, MonoidalMap k a)+insertLookupWithKey = coerce (M.insertLookupWithKey :: (k -> a -> a -> a) -> k -> a -> M.Map k a -> (Maybe a, M.Map k a))+{-# INLINE insertLookupWithKey #-}++adjust :: forall k a. Ord k => (a -> a) -> k -> MonoidalMap k a -> MonoidalMap k a+adjust = coerce (M.adjust :: (a -> a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE adjust #-}++adjustWithKey :: forall k a. Ord k => (k -> a -> a) -> k -> MonoidalMap k a -> MonoidalMap k a+adjustWithKey = coerce (M.adjustWithKey :: (k -> a -> a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE adjustWithKey #-}++update :: forall k a. Ord k => (a -> Maybe a) -> k -> MonoidalMap k a -> MonoidalMap k a+update = coerce (M.update :: (a -> Maybe a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE update #-}++updateWithKey :: forall k a. Ord k => (k -> a -> Maybe a) -> k -> MonoidalMap k a -> MonoidalMap k a+updateWithKey = coerce (M.updateWithKey :: (k -> a -> Maybe a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE updateWithKey #-}++updateLookupWithKey :: forall k a. Ord k => (k -> a -> Maybe a) -> k -> MonoidalMap k a -> (Maybe a, MonoidalMap k a)+updateLookupWithKey = coerce (M.updateLookupWithKey :: (k -> a -> Maybe a) -> k -> M.Map k a -> (Maybe a, M.Map k a))+{-# INLINE updateLookupWithKey #-}++alter :: forall k a. Ord k => (Maybe a -> Maybe a) -> k -> MonoidalMap k a -> MonoidalMap k a+alter = coerce (M.alter :: (Maybe a -> Maybe a) -> k -> M.Map k a -> M.Map k a)+{-# INLINE alter #-}++unionWith :: forall k a. Ord k => (a -> a -> a) -> MonoidalMap k a -> MonoidalMap k a -> MonoidalMap k a+unionWith = coerce (M.unionWith :: (a -> a -> a) -> M.Map k a -> M.Map k a -> M.Map k a)+{-# INLINE unionWith #-}++unionWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> MonoidalMap k a -> MonoidalMap k a -> MonoidalMap k a+unionWithKey = coerce (M.unionWithKey :: (k -> a -> a -> a) -> M.Map k a -> M.Map k a -> M.Map k a)+{-# INLINE unionWithKey #-}++unionsWith :: forall k a. Ord k => (a -> a -> a) -> [MonoidalMap k a] -> MonoidalMap k a+unionsWith = coerce (M.unionsWith :: (a -> a -> a) -> [M.Map k a] -> M.Map k a)+{-# INLINE unionsWith #-}++difference :: forall k a b. Ord k => MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+difference = (\\)+{-# INLINE difference #-}++differenceWith :: forall k a b. Ord k => (a -> b -> Maybe a) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+differenceWith = coerce (M.differenceWith :: (a -> b -> Maybe a) -> M.Map k a -> M.Map k b -> M.Map k a)+{-# INLINE differenceWith #-}++differenceWithKey :: forall k a b. Ord k => (k -> a -> b -> Maybe a) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k a+differenceWithKey = coerce (M.differenceWithKey :: (k -> a -> b -> Maybe a) -> M.Map k a -> M.Map k b -> M.Map k a)+{-# INLINE differenceWithKey #-}++intersectionWith :: forall k a b c. Ord k => (a -> b -> c) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k c+intersectionWith = coerce (M.intersectionWith :: (a -> b -> c) -> M.Map k a -> M.Map k b -> M.Map k c)+{-# INLINE intersectionWith #-}++intersectionWithKey :: forall k a b c. Ord k => (k -> a -> b -> c) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k c+intersectionWithKey = coerce (M.intersectionWithKey :: (k -> a -> b -> c) -> M.Map k a -> M.Map k b -> M.Map k c)+{-# INLINE intersectionWithKey #-}++mergeWithKey :: forall k a b c. Ord k => (k -> a -> b -> Maybe c) -> (MonoidalMap k a -> MonoidalMap k c) -> (MonoidalMap k b -> MonoidalMap k c) -> MonoidalMap k a -> MonoidalMap k b -> MonoidalMap k c+mergeWithKey = coerce (M.mergeWithKey :: (k -> a -> b -> Maybe c) -> (M.Map k a -> M.Map k c) -> (M.Map k b -> M.Map k c) -> M.Map k a -> M.Map k b -> M.Map k c)+{-# INLINE mergeWithKey #-}++map :: (a -> b) -> MonoidalMap k a -> MonoidalMap k b+map = fmap+{-# INLINE map #-}++mapWithKey :: forall k a  b. (k -> a -> b) -> MonoidalMap k a -> MonoidalMap k b+mapWithKey = coerce (M.mapWithKey :: (k -> a -> b) -> M.Map k a -> M.Map k b)+{-# INLINE mapWithKey #-}++traverseWithKey :: Applicative t => (k -> a -> t b) -> MonoidalMap k a -> t (MonoidalMap k b)+traverseWithKey = itraverse+{-# INLINE traverseWithKey #-}++mapAccum :: forall k a b c. (a -> b -> (a, c)) -> a -> MonoidalMap k b -> (a, MonoidalMap k c)+mapAccum = coerce (M.mapAccum :: (a -> b -> (a, c)) -> a -> M.Map k b -> (a, M.Map k c))+{-# INLINE mapAccum #-}++mapAccumWithKey :: forall k a b c. (a -> k -> b -> (a, c)) -> a -> MonoidalMap k b -> (a, MonoidalMap k c)+mapAccumWithKey = coerce (M.mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> M.Map k b -> (a, M.Map k c))+{-# INLINE mapAccumWithKey #-}++mapAccumRWithKey :: forall k a b c. (a -> k -> b -> (a, c)) -> a -> MonoidalMap k b -> (a, MonoidalMap k c)+mapAccumRWithKey = coerce (M.mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> M.Map k b -> (a, M.Map k c))+{-# INLINE mapAccumRWithKey #-}++mapKeys :: forall k1 k2 a. Ord k2 => (k1 -> k2) -> MonoidalMap k1 a -> MonoidalMap k2 a+mapKeys = coerce (M.mapKeys :: (k1 -> k2) -> M.Map k1 a -> M.Map k2 a)+{-# INLINE mapKeys #-}++mapKeysWith :: forall k1 k2 a. Ord k2 => (a -> a -> a) -> (k1 -> k2) -> MonoidalMap k1 a -> MonoidalMap k2 a+mapKeysWith = coerce (M.mapKeysWith :: (a -> a -> a) -> (k1 -> k2) -> M.Map k1 a -> M.Map k2 a)+{-# INLINE mapKeysWith #-}++mapKeysMonotonic :: forall k1 k2 a. (k1 -> k2) -> MonoidalMap k1 a -> MonoidalMap k2 a+mapKeysMonotonic = coerce (M.mapKeysMonotonic :: (k1 -> k2) -> M.Map k1 a -> M.Map k2 a)+{-# INLINE mapKeysMonotonic #-}++foldr :: forall k a b. (a -> b -> b) -> b -> MonoidalMap k a -> b+foldr = coerce (M.foldr :: (a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldr #-}++foldl :: forall k a b. (a -> b -> a) -> a -> MonoidalMap k b -> a+foldl = coerce (M.foldl :: (a -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldl #-}++foldrWithKey :: forall k a b. (k -> a -> b -> b) -> b -> MonoidalMap k a -> b+foldrWithKey = coerce (M.foldrWithKey :: (k -> a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldrWithKey #-}++foldlWithKey :: forall k a b. (a -> k -> b -> a) -> a -> MonoidalMap k b -> a+foldlWithKey = coerce (M.foldlWithKey :: (a -> k -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldlWithKey #-}++foldMapWithKey :: forall k a m. Monoid m => (k -> a -> m) -> MonoidalMap k a -> m+foldMapWithKey = coerce (M.foldMapWithKey :: Monoid m => (k -> a -> m) -> M.Map k a -> m)+{-# INLINE foldMapWithKey #-}++foldr' :: forall k a b. (a -> b -> b) -> b -> MonoidalMap k a -> b+foldr' = coerce (M.foldr' :: (a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldr' #-}++foldl' :: forall k a b. (a -> b -> a) -> a -> MonoidalMap k b -> a+foldl' = coerce (M.foldl' :: (a -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldl' #-}++foldrWithKey' :: forall k a b. (k -> a -> b -> b) -> b -> MonoidalMap k a -> b+foldrWithKey' = coerce (M.foldrWithKey' :: (k -> a -> b -> b) -> b -> M.Map k a -> b)+{-# INLINE foldrWithKey' #-}++foldlWithKey' :: forall k a b. (a -> k -> b -> a) -> a -> MonoidalMap k b -> a+foldlWithKey' = coerce (M.foldlWithKey' :: (a -> k -> b -> a) -> a -> M.Map k b -> a)+{-# INLINE foldlWithKey' #-}++keysSet :: forall k a. MonoidalMap k a -> Set k+keysSet = coerce (M.keysSet :: M.Map k a -> Set k)+{-# INLINE keysSet #-}++fromSet :: forall k a. (k -> a) -> Set k -> MonoidalMap k a+fromSet = coerce (M.fromSet :: (k -> a) -> Set k -> M.Map k a)+{-# INLINE fromSet #-}++toList :: forall k a. MonoidalMap k a -> [(k, a)]+toList = coerce (M.toList :: M.Map k a -> [(k, a)])+{-# INLINE toList #-}++fromList :: forall k a. Ord k => [(k, a)] -> MonoidalMap k a+fromList = coerce (M.fromList :: [(k, a)] -> M.Map k a)+{-# INLINE fromList #-}++fromListWith :: forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromListWith = coerce (M.fromListWith :: (a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromListWith #-}++fromListWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromListWithKey = coerce (M.fromListWithKey :: (k -> a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromListWithKey #-}++toAscList :: forall k a. MonoidalMap k a -> [(k, a)]+toAscList = coerce (M.toAscList :: M.Map k a -> [(k, a)])+{-# INLINE toAscList #-}++toDescList :: forall k a. MonoidalMap k a -> [(k, a)]+toDescList = coerce (M.toDescList :: M.Map k a -> [(k, a)])+{-# INLINE toDescList #-}++fromAscList :: forall k a. Eq k => [(k, a)] -> MonoidalMap k a+fromAscList = coerce (M.fromAscList :: [(k, a)] -> M.Map k a)+{-# INLINE fromAscList #-}++fromAscListWith :: forall k a. Eq k => (a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromAscListWith = coerce (M.fromAscListWith :: (a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromAscListWith #-}++fromAscListWithKey :: forall k a. Eq k => (k -> a -> a -> a) -> [(k, a)] -> MonoidalMap k a+fromAscListWithKey = coerce (M.fromAscListWithKey :: (k -> a -> a -> a) -> [(k, a)] -> M.Map k a)+{-# INLINE fromAscListWithKey #-}++fromDistinctAscList :: forall k a. [(k, a)] -> MonoidalMap k a+fromDistinctAscList = coerce (M.fromDistinctAscList :: [(k, a)] -> M.Map k a)+{-# INLINE fromDistinctAscList #-}++filter :: forall k a. (a -> Bool) -> MonoidalMap k a -> MonoidalMap k a+filter = coerce (M.filter :: (a -> Bool) -> M.Map k a -> M.Map k a)+{-# INLINE filter #-}++filterWithKey :: forall k a. (k -> a -> Bool) -> MonoidalMap k a -> MonoidalMap k a+filterWithKey = coerce (M.filterWithKey :: (k -> a -> Bool) -> M.Map k a -> M.Map k a)+{-# INLINE filterWithKey #-}++partition :: forall k a. (a -> Bool) -> MonoidalMap k a -> (MonoidalMap k a, MonoidalMap k a)+partition = coerce (M.partition :: (a -> Bool) -> M.Map k a -> (M.Map k a, M.Map k a))+{-# INLINE partition #-}++partitionWithKey :: forall k a. (k -> a -> Bool) -> MonoidalMap k a -> (MonoidalMap k a, MonoidalMap k a)+partitionWithKey = coerce (M.partitionWithKey :: (k -> a -> Bool) -> M.Map k a -> (M.Map k a, M.Map k a))+{-# INLINE partitionWithKey #-}++mapMaybe :: forall k a b. (a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b+mapMaybe = coerce (M.mapMaybe :: (a -> Maybe b) -> M.Map k a -> M.Map k b)+{-# INLINE mapMaybe #-}++mapMaybeWithKey :: forall k a b. (k -> a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b+mapMaybeWithKey = coerce (M.mapMaybeWithKey :: (k -> a -> Maybe b) -> M.Map k a -> M.Map k b)+{-# INLINE mapMaybeWithKey #-}++mapEither :: forall k a b c. (a -> Either b c) -> MonoidalMap k a -> (MonoidalMap k b, MonoidalMap k c)+mapEither = coerce (M.mapEither :: (a -> Either b c) -> M.Map k a -> (M.Map k b, M.Map k c))+{-# INLINE mapEither #-}++mapEitherWithKey :: forall k a b c. (k -> a -> Either b c) -> MonoidalMap k a -> (MonoidalMap k b, MonoidalMap k c)+mapEitherWithKey = coerce (M.mapEitherWithKey :: (k -> a -> Either b c) -> M.Map k a -> (M.Map k b, M.Map k c))+{-# INLINE mapEitherWithKey #-}++split :: forall k a. Ord k => k -> MonoidalMap k a -> (MonoidalMap k a, MonoidalMap k a)+split = coerce (M.split :: k -> M.Map k a -> (M.Map k a, M.Map k a))+{-# INLINE split #-}++splitLookup :: forall k a. Ord k => k -> MonoidalMap k a -> (MonoidalMap k a, Maybe a, MonoidalMap k a)+splitLookup = coerce (M.splitLookup :: k -> M.Map k a -> (M.Map k a, Maybe a, M.Map k a))+{-# INLINE splitLookup #-}++splitRoot :: forall k a. MonoidalMap k a -> [MonoidalMap k a]+splitRoot = coerce (M.splitRoot :: M.Map k a -> [M.Map k a])+{-# INLINE splitRoot #-}++isSubmapOf :: forall k a. (Ord k, Eq a) => MonoidalMap k a -> MonoidalMap k a -> Bool+isSubmapOf = coerce (M.isSubmapOf :: M.Map k a -> M.Map k a -> Bool)+{-# INLINE isSubmapOf #-}++isSubmapOfBy :: forall k a b. Ord k => (a -> b -> Bool) -> MonoidalMap k a -> MonoidalMap k b -> Bool+isSubmapOfBy = coerce (M.isSubmapOfBy :: (a -> b -> Bool) -> M.Map k a -> M.Map k b -> Bool)+{-# INLINE isSubmapOfBy #-}++isProperSubmapOf :: forall k a. (Ord k, Eq a) => MonoidalMap k a -> MonoidalMap k a -> Bool+isProperSubmapOf = coerce (M.isProperSubmapOf :: M.Map k a -> M.Map k a -> Bool)+{-# INLINE isProperSubmapOf #-}++isProperSubmapOfBy :: forall k a b. Ord k => (a -> b -> Bool) -> MonoidalMap k a -> MonoidalMap k b -> Bool+isProperSubmapOfBy = coerce (M.isProperSubmapOfBy :: (a -> b -> Bool) -> M.Map k a -> M.Map k b -> Bool)+{-# INLINE isProperSubmapOfBy #-}++lookupIndex :: forall k a. Ord k => k -> MonoidalMap k a -> Maybe Int+lookupIndex = coerce (M.lookupIndex :: k -> M.Map k a -> Maybe Int)+{-# INLINE lookupIndex #-}++findIndex :: forall k a. Ord k => k -> MonoidalMap k a -> Int+findIndex = coerce (M.findIndex :: k -> M.Map k a -> Int)+{-# INLINE findIndex #-}++elemAt :: forall k a. Int -> MonoidalMap k a -> (k, a)+elemAt = coerce (M.elemAt :: Int -> M.Map k a -> (k, a))+{-# INLINE elemAt #-}++updateAt :: forall k a. (k -> a -> Maybe a) -> Int -> MonoidalMap k a -> MonoidalMap k a+updateAt = coerce (M.updateAt :: (k -> a -> Maybe a) -> Int -> M.Map k a -> M.Map k a)+{-# INLINE updateAt #-}++deleteAt :: forall k a. Int -> MonoidalMap k a -> MonoidalMap k a+deleteAt = coerce (M.deleteAt :: Int -> M.Map k a -> M.Map k a)+{-# INLINE deleteAt #-}++findMin :: forall k a. MonoidalMap k a -> (k, a)+findMin = coerce (M.findMin :: M.Map k a -> (k, a))+{-# INLINE findMin #-}++findMax :: forall k a. MonoidalMap k a -> (k, a)+findMax = coerce (M.findMax :: M.Map k a -> (k, a))+{-# INLINE findMax #-}++deleteMin :: forall k a. MonoidalMap k a -> MonoidalMap k a+deleteMin = coerce (M.deleteMin :: M.Map k a -> M.Map k a)+{-# INLINE deleteMin #-}++deleteMax :: forall k a. MonoidalMap k a -> MonoidalMap k a+deleteMax = coerce (M.deleteMax :: M.Map k a -> M.Map k a)+{-# INLINE deleteMax #-}++deleteFindMin :: forall k a. MonoidalMap k a -> ((k, a), MonoidalMap k a)+deleteFindMin = coerce (M.deleteFindMin :: M.Map k a -> ((k, a), M.Map k a))+{-# INLINE deleteFindMin #-}++deleteFindMax :: forall k a. MonoidalMap k a -> ((k, a), MonoidalMap k a)+deleteFindMax = coerce (M.deleteFindMax :: M.Map k a -> ((k, a), M.Map k a))+{-# INLINE deleteFindMax #-}++updateMin :: forall k a. (a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMin = coerce (M.updateMin :: (a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMin #-}++updateMax :: forall k a. (a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMax = coerce (M.updateMax :: (a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMax #-}++updateMinWithKey :: forall k a. (k -> a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMinWithKey = coerce (M.updateMinWithKey :: (k -> a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMinWithKey #-}++updateMaxWithKey :: forall k a. (k -> a -> Maybe a) -> MonoidalMap k a -> MonoidalMap k a+updateMaxWithKey = coerce (M.updateMaxWithKey :: (k -> a -> Maybe a) -> M.Map k a -> M.Map k a)+{-# INLINE updateMaxWithKey #-}++minView :: forall k a. MonoidalMap k a -> Maybe (a, MonoidalMap k a)+minView = coerce (M.minView :: M.Map k a -> Maybe (a, M.Map k a))+{-# INLINE minView #-}++maxView :: forall k a. MonoidalMap k a -> Maybe (a, MonoidalMap k a)+maxView = coerce (M.maxView :: M.Map k a -> Maybe (a, M.Map k a))+{-# INLINE maxView #-}++minViewWithKey :: forall k a. MonoidalMap k a -> Maybe ((k, a), MonoidalMap k a)+minViewWithKey = coerce (M.minViewWithKey :: M.Map k a -> Maybe ((k, a), M.Map k a))+{-# INLINE minViewWithKey #-}++maxViewWithKey :: forall k a. MonoidalMap k a -> Maybe ((k, a), MonoidalMap k a)+maxViewWithKey = coerce (M.maxViewWithKey :: M.Map k a -> Maybe ((k, a), M.Map k a))+{-# INLINE maxViewWithKey #-}++-- showTree :: forall k a. (Show k, Show a) => MonoidalMap k a -> String+-- showTree = coerce (M.showTree :: (Show k, Show a) => M.Map k a -> String)+-- {-# INLINE showTree #-}++-- showTreeWith :: forall k a. (k -> a -> String) -> Bool -> Bool -> MonoidalMap k a -> String+-- showTreeWith = coerce (M.showTreeWith :: (k -> a -> String) -> Bool -> Bool -> M.Map k a -> String)+-- {-# INLINE showTreeWith #-}++valid :: forall k a. Ord k => MonoidalMap k a -> Bool+valid = coerce (M.valid :: Ord k => M.Map k a -> Bool)+{-# INLINE valid #-}++