monoidmap-internal 0.2.0.0 → 0.3.0.0

raw patch · 30 files changed

+222/−10303 lines, 30 filesdep −QuickCheckdep −groupsdep −hspecPVP ok

version bump matches the API change (PVP)

Dependencies removed: QuickCheck, groups, hspec, hspec-quickcheck-classes, pretty-show, quickcheck-classes, quickcheck-groups, quickcheck-monoid-subclasses, quickcheck-quid, text

API changes (from Hackage documentation)

Files

• CHANGELOG.md +27/−0
• components/monoidmap-internal/Data/MonoidMap/Internal.hs +194/−3678
• components/monoidmap-internal/Data/MonoidMap/Internal/Unsafe.hs +0/−50
• components/monoidmap-test/Data/MonoidMap/Internal/AccessSpec.hs +0/−172
• components/monoidmap-test/Data/MonoidMap/Internal/ClassSpec.hs +0/−336
• components/monoidmap-test/Data/MonoidMap/Internal/ComparisonSpec.hs +0/−278
• components/monoidmap-test/Data/MonoidMap/Internal/ConversionSpec.hs +0/−267
• components/monoidmap-test/Data/MonoidMap/Internal/DistributivitySpec.hs +0/−230
• components/monoidmap-test/Data/MonoidMap/Internal/ExampleSpec.hs +0/−1861
• components/monoidmap-test/Data/MonoidMap/Internal/FilterSpec.hs +0/−163
• components/monoidmap-test/Data/MonoidMap/Internal/FoldSpec.hs +0/−194
• components/monoidmap-test/Data/MonoidMap/Internal/IntersectionSpec.hs +0/−193
• components/monoidmap-test/Data/MonoidMap/Internal/MapSpec.hs +0/−300
• components/monoidmap-test/Data/MonoidMap/Internal/MembershipSpec.hs +0/−162
• components/monoidmap-test/Data/MonoidMap/Internal/PartitionSpec.hs +0/−173
• components/monoidmap-test/Data/MonoidMap/Internal/PrefixSpec.hs +0/−80
• components/monoidmap-test/Data/MonoidMap/Internal/SingletonSpec.hs +0/−148
• components/monoidmap-test/Data/MonoidMap/Internal/SliceSpec.hs +0/−139
• components/monoidmap-test/Data/MonoidMap/Internal/SuffixSpec.hs +0/−80
• components/monoidmap-test/Data/MonoidMap/Internal/TraversalSpec.hs +0/−194
• components/monoidmap-test/Data/MonoidMap/Internal/UnionSpec.hs +0/−192
• components/monoidmap-test/Data/MonoidMap/Internal/ValiditySpec.hs +0/−745
• components/monoidmap-test/Spec.hs +0/−1
• components/monoidmap-test/SpecHook.hs +0/−6
• components/monoidmap-test/Test/Combinators/NonZero.hs +0/−44
• components/monoidmap-test/Test/Combinators/OftenEqual.hs +0/−38
• components/monoidmap-test/Test/Common.hs +0/−323
• components/monoidmap-test/Test/Hspec/Unit.hs +0/−128
• components/monoidmap-test/Test/Key.hs +0/−48
• monoidmap-internal.cabal +1/−80

@@ -1,3 +1,30 @@+# 0.3.0.0++- Moved the `MonoidMap` type, its instances, and all of its functions to+  the `Data.MonoidMap` module of the `monoidmap` package. These are no+  longer exported by `Data.MonoidMap.Internal`.++- Removed the `Data.MonoidMap.Internal.Unsafe` module, including the+  `unsafeFromMap` function.++- Changed `fromMap`, `fromMapWith`, and their alternative implementations+  to return values of type `Map k (NonNull v)` instead of `MonoidMap k v`.++- Stopped exporting the data constructor of `NonNull`, and removed its+  `getNonNull` field.++- Changed the role of the type parameter of `NonNull` from+  `representational` to `nominal`.++- Added the `NonNullMap` type, and exported the `maybeNonNull`,+  `applyNonNull`, `applyNonNull2`, and `fromNonNullMap` functions.++- Made `NonNull` an instance of `NFData`.++- Moved the test suite to the `monoidmap` package.++- Removed the dependency on `groups`.+ # 0.2.0.0  - Changed the role of the value type parameter of `MonoidMap` from

@@ -1,3679 +1,195 @@ {-# LANGUAGE RoleAnnotations #-}-{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}-{-# OPTIONS_GHC -fno-warn-unused-imports #-}-{-# OPTIONS_HADDOCK not-home #-}-{- HLINT ignore "Avoid lambda" -}-{- HLINT ignore "Avoid lambda using `infix`" -}-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0------ Provides /internal/ operations for the 'MonoidMap' type.----module Data.MonoidMap.Internal-    (-    -- * Types-      MonoidMap (..)-    , NonNull (..)--    -- * General operations--    -- ** Construction-    , empty-    , fromList-    , fromListWith-    , fromMap-    , fromMapWith-    , fromSet-    , singleton--    -- ** Construction (Internal)-    , fromMap_filter-    , fromMap_filter_if_any_null-    , fromMap_mapMaybe-    , fromMapWith_mapMaybe-    , fromMapWith_map_filter-    , fromMapWith_map_filter_if_any_null--    -- ** Deconstruction-    , toList-    , toMap--    -- ** Lookup-    , get--    -- ** Modification-    , set-    , adjust--    -- ** Nullification-    , nullify-    , nullifyKeysIn-    , nullifyKeysNotIn--    -- ** Membership-    , null-    , nullKey-    , nonNull-    , nonNullCount-    , nonNullKey-    , nonNullKeys--    -- ** Slicing-    , take-    , drop-    , splitAt--    -- ** Filtering-    , filter-    , filterKeys-    , filterWithKey--    -- ** Partitioning-    , partition-    , partitionKeys-    , partitionWithKey--    -- ** Mapping-    , map-    , mapKeys-    , mapKeysWith-    , mapWithKey--    -- ** Folding-    , foldl-    , foldl'-    , foldr-    , foldr'-    , foldlWithKey-    , foldlWithKey'-    , foldrWithKey-    , foldrWithKey'-    , foldMapWithKey-    , foldMapWithKey'--    -- ** Traversal-    , traverse-    , traverseWithKey-    , mapAccumL-    , mapAccumLWithKey-    , mapAccumR-    , mapAccumRWithKey--    -- * Monoidal operations--    -- ** Association-    , append--    -- ** Subtraction-    , minus-    , minusMaybe-    , monus--    -- ** Inversion-    , invert--    -- ** Exponentiation-    , power--    -- ** Comparison-    , isSubmapOf-    , isSubmapOfBy-    , disjoint-    , disjointBy--    -- ** Intersection-    , intersection-    , intersectionWith-    , intersectionWithA--    -- ** Union-    , union-    , unionWith-    , unionWithA--    -- ** Prefixes-    , isPrefixOf-    , stripPrefix-    , commonPrefix-    , stripCommonPrefix--    -- ** Suffixes-    , isSuffixOf-    , stripSuffix-    , commonSuffix-    , stripCommonSuffix--    -- ** Overlap-    , overlap-    , stripPrefixOverlap-    , stripSuffixOverlap-    , stripOverlap-    )-    where--import Prelude hiding-    ( drop-    , filter-    , foldl-    , foldl'-    , foldr-    , lookup-    , map-    , null-    , splitAt-    , subtract-    , take-    , traverse-    )--import Control.Applicative-    ( Applicative (..) )-import Control.DeepSeq-    ( NFData )-import Data.Bifoldable-    ( Bifoldable )-import Data.Coerce-    ( coerce )-import Data.Data-    ( Constr-    , Data (dataCast2, dataTypeOf, gfoldl, gunfold, toConstr)-    , DataType-    , Fixity (Prefix)-    , gcast2-    , mkConstr-    , mkDataType-    )-import Data.Function-    ( (&) )-import Data.Functor.Classes-    ( Eq1, Eq2, Show1, Show2 )-import Data.Functor.Identity-    ( Identity (..) )-import Data.Group-    ( Abelian, Group )-import Data.Map.Strict-    ( Map, lookup )-import Data.Maybe-    ( fromMaybe, isJust )-import Data.Monoid.GCD-    ( DistributiveGCDMonoid-    , GCDMonoid-    , LeftDistributiveGCDMonoid-    , LeftGCDMonoid-    , OverlappingGCDMonoid-    , RightDistributiveGCDMonoid-    , RightGCDMonoid-    )-import Data.Monoid.LCM-    ( DistributiveLCMMonoid, LCMMonoid )-import Data.Monoid.Monus-    ( Monus (..) )-import Data.Monoid.Null-    ( MonoidNull, PositiveMonoid )-import Data.Semigroup-    ( stimes )-import Data.Semigroup.Cancellative-    ( Cancellative-    , Commutative-    , LeftCancellative-    , LeftReductive-    , Reductive (..)-    , RightCancellative-    , RightReductive-    )-import Data.Set-    ( Set )-import Data.Typeable-    ( Typeable )-import GHC.Exts-    ( IsList (Item) )-import NoThunks.Class-    ( NoThunks )-import Text.Read-    ( Read (..) )--import qualified Data.Bifunctor as B-import qualified Data.Foldable as F-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.Set as Set-import qualified GHC.Exts as GHC-import qualified Data.Traversable as Traversable--import qualified Data.Group as C-import qualified Data.Monoid.GCD as C-import qualified Data.Monoid.LCM as C-import qualified Data.Monoid.Null as C-import qualified Data.Semigroup.Cancellative as C------------------------------------------------------------------------------------- Type-----------------------------------------------------------------------------------newtype MonoidMap k v = MonoidMap (Map k (NonNull v))-    deriving (Eq, Show, NFData, NoThunks, Typeable)-        via Map k v-    deriving (Eq1, Show1, Foldable)-        via Map k-    deriving (Eq2, Show2, Bifoldable)-        via Map---- Without an explicit type role annotation, the following roles would be--- inferred:------     type role MonoidMap nominal representational------ These roles would be inherited from 'Map', which has these roles:------     type role Map nominal representational------ A representational role for the value type of a 'Map' is fine, because the--- validity of a 'Map' does not depend on any property of its value type.------ However, the validity of a 'MonoidMap' does depend on a property of its--- value type: its 'mempty' value. A representational role would allow users--- to coerce between value types with the same representation but different--- 'mempty' values.------ For example, users could coerce a 'MonoidMap' k ('Sum' 'Int') to a--- 'MonoidMap' k ('Product' 'Int'), and thereby construct a map that contains--- 'mempty' values.------ So we must instead choose a nominal role for the value type of 'MonoidMap'.----type role MonoidMap nominal nominal---- Internal alias used when extra brevity is required.-type MM = MonoidMap------------------------------------------------------------------------------------- Non-null values-----------------------------------------------------------------------------------newtype NonNull v = UnsafeNonNull {getNonNull :: v}--maybeNonNull :: MonoidNull v => v -> Maybe (NonNull v)-maybeNonNull !v-    | C.null  v = Nothing-    | otherwise = Just (UnsafeNonNull v)-{-# INLINE maybeNonNull #-}--applyNonNull :: (v -> a) -> (NonNull v -> a)-applyNonNull = coerce-{-# INLINE applyNonNull #-}--applyNonNull2 :: (v1 -> v2 -> a) -> (NonNull v1 -> NonNull v2 -> a)-applyNonNull2 = coerce-{-# INLINE applyNonNull2 #-}------------------------------------------------------------------------------------- Instances-----------------------------------------------------------------------------------instance (Ord k, MonoidNull v) =>-    IsList (MonoidMap k v)-  where-    type Item (MonoidMap k v) = (k, v)-    fromList = fromList-    toList = toList--instance (Ord k, Read k, MonoidNull v, Read v) =>-    Read (MonoidMap k v)-  where-    readPrec = fromMap <$> readPrec------------------------------------------------------------------------------------- Instances: Data------------------------------------------------------------------------------------- This implementation is closely based on the 'Data' instance for 'Map'--- provided by the 'containers' package (version 0.8).----instance (Data k, Data v, Ord k, MonoidNull v) => Data (MonoidMap k v) where-    dataTypeOf _ = dataType-    dataCast2 f = gcast2 f-    gfoldl f z m = z fromList `f` toList m-    gunfold k z c-        | c == fromListConstr = k (z fromList)-        | otherwise = error "gunfold MonoidMap: unexpected constructor"-    toConstr _ = fromListConstr--dataType :: DataType-dataType = mkDataType "Data.MonoidMap.Internal.MonoidMap" [fromListConstr]--fromListConstr :: Constr-fromListConstr = mkConstr dataType "fromList" [] Prefix------------------------------------------------------------------------------------- Instances: Semigroup and subclasses-----------------------------------------------------------------------------------instance (Ord k, MonoidNull v) =>-    Semigroup (MonoidMap k v)-  where-    (<>) = append-    stimes 0 = const mempty-    stimes 1 = id-    stimes n = map (stimes n)--instance (Ord k, MonoidNull v, Commutative v) =>-    Commutative (MonoidMap k v)--instance (Ord k, MonoidNull v, LeftReductive v) =>-    LeftReductive (MonoidMap k v)-  where-    isPrefixOf = isPrefixOf-    stripPrefix = stripPrefix--instance (Ord k, MonoidNull v, RightReductive v) =>-    RightReductive (MonoidMap k v)-  where-    isSuffixOf = isSuffixOf-    stripSuffix = stripSuffix--instance (Ord k, MonoidNull v, Reductive v) =>-    Reductive (MonoidMap k v)-  where-    (</>) = minusMaybe--instance (Ord k, MonoidNull v, LeftCancellative v) =>-    LeftCancellative (MonoidMap k v)--instance (Ord k, MonoidNull v, RightCancellative v) =>-    RightCancellative (MonoidMap k v)--instance (Ord k, MonoidNull v, Cancellative v) =>-    Cancellative (MonoidMap k v)------------------------------------------------------------------------------------- Instances: Monoid and subclasses-----------------------------------------------------------------------------------instance (Ord k, MonoidNull v) =>-    Monoid (MonoidMap k v)-  where-    mempty = empty--instance (Ord k, MonoidNull v) =>-    MonoidNull (MonoidMap k v)-  where-    null = null--instance (Ord k, PositiveMonoid v) =>-    PositiveMonoid (MonoidMap k v)--instance (Ord k, MonoidNull v, LeftGCDMonoid v) =>-    LeftGCDMonoid (MonoidMap k v)-  where-    commonPrefix = commonPrefix--instance (Ord k, MonoidNull v, LeftDistributiveGCDMonoid v) =>-    LeftDistributiveGCDMonoid (MonoidMap k v)--instance (Ord k, MonoidNull v, RightGCDMonoid v) =>-    RightGCDMonoid (MonoidMap k v)-  where-    commonSuffix = commonSuffix--instance (Ord k, MonoidNull v, RightDistributiveGCDMonoid v) =>-    RightDistributiveGCDMonoid (MonoidMap k v)--instance (Ord k, MonoidNull v, OverlappingGCDMonoid v) =>-    OverlappingGCDMonoid (MonoidMap k v)-  where-    overlap = overlap-    stripPrefixOverlap = stripPrefixOverlap-    stripSuffixOverlap = stripSuffixOverlap-    stripOverlap = stripOverlap--instance (Ord k, MonoidNull v, GCDMonoid v) =>-    GCDMonoid (MonoidMap k v)-  where-    gcd = intersection--instance (Ord k, MonoidNull v, DistributiveGCDMonoid v) =>-    DistributiveGCDMonoid (MonoidMap k v)--instance (Ord k, MonoidNull v, LCMMonoid v) =>-    LCMMonoid (MonoidMap k v)-  where-    lcm = union--instance (Ord k, MonoidNull v, DistributiveLCMMonoid v) =>-    DistributiveLCMMonoid (MonoidMap k v)--instance (Ord k, MonoidNull v, Monus v) =>-    Monus (MonoidMap k v)-  where-    (<\>) = monus------------------------------------------------------------------------------------- Instances: Group and subclasses-----------------------------------------------------------------------------------instance (Ord k, MonoidNull v, Group v) =>-    Group (MonoidMap k v)-  where-    invert = invert-    (~~) = minus-    pow = power--instance (Ord k, MonoidNull v, Abelian v) =>-    Abelian (MonoidMap k v)------------------------------------------------------------------------------------- Construction------------------------------------------------------------------------------------- | \(O(1)\). The empty 'MonoidMap'.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k 'empty' '==' 'mempty'--- @------ Provides the definition of 'mempty' for the 'MonoidMap' instance of--- 'Monoid'.----empty :: MonoidMap k v-empty = MonoidMap Map.empty---- | \(O(n \log n)\). Constructs a 'MonoidMap' from 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@__:------ @--- 'get' k ('fromList' kvs) '=='---     'foldMap' 'snd' ('L.filter' (('==' k) . fst) kvs)--- @------ Satisfies the following round-trip property:------ @--- 'fromList' ('toList' m) '==' m--- @------ === __Examples__------ With 'String' values:------ @--- >>> 'fromList' [(1,"a"), (2,"x"), (1,"b"), (2,"y"), (1,"c"), (2,"z")]--- 'fromList' [(1,"abc"), (2,"xyz")]--- @----fromList :: (Ord k, MonoidNull v) => [(k, v)] -> MonoidMap k v-fromList = fromListWith (<>)---- | \(O(n \log n)\). Constructs a 'MonoidMap' from 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@__:------ @--- 'get' k ('fromListWith' f kvs) '=='---     'maybe' 'mempty' ('F.foldl1' f)---         ('NE.nonEmpty' ('snd' '<$>' 'L.filter' (('==' k) . fst) kvs))--- @----fromListWith-    :: (Ord k, MonoidNull v)-    => (v -> v -> v)-    -- ^ Function with which to combine values for duplicate keys.-    -> [(k, v)]-    -> MonoidMap k v-fromListWith f =-    -- 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)---- | \(O(n)\). Constructs a 'MonoidMap' from an ordinary 'Map'.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('fromMap' m) '==' 'Map'.'Map.findWithDefault' 'mempty' k m--- @------ This function performs canonicalisation of 'C.null' values, and has a time--- complexity that is linear in the size of the map.----fromMap :: MonoidNull v => Map k v -> MonoidMap k v-fromMap = fromMap_filter_if_any_null-{-# INLINABLE fromMap #-}--fromMap_filter :: MonoidNull v => Map k v -> MonoidMap k v-fromMap_filter = coerce . Map.filter (\(!v) -> not (C.null v))-{-# INLINABLE fromMap_filter #-}--fromMap_filter_if_any_null :: MonoidNull v => Map k v -> MonoidMap k v-fromMap_filter_if_any_null m-    | F.any (\(!v) -> C.null v) m =-        coerce $ Map.filter (\(!v) -> not (C.null v)) m-    | otherwise =-        coerce m-{-# INLINABLE fromMap_filter_if_any_null #-}--fromMap_mapMaybe :: MonoidNull v => Map k v -> MonoidMap k v-fromMap_mapMaybe = MonoidMap . Map.mapMaybe maybeNonNull-{-# INLINABLE fromMap_mapMaybe #-}---- | \(O(n)\). Constructs a 'MonoidMap' from an ordinary 'Map', applying---   the given function to all values.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('fromMapWith' f m) '==' 'maybe' 'mempty' f ('Map'.'Map.lookup' k m)--- @------ This function performs canonicalisation of 'C.null' values, and has a time--- complexity that is linear in the size of the map.------ @since 0.0.4.0----fromMapWith :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> MonoidMap k v2-fromMapWith = fromMapWith_mapMaybe-{-# INLINABLE fromMapWith #-}--fromMapWith_mapMaybe-    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> MonoidMap k v2-fromMapWith_mapMaybe f = MonoidMap . Map.mapMaybe (maybeNonNull . f)-{-# INLINABLE fromMapWith_mapMaybe #-}--fromMapWith_map_filter-    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> MonoidMap k v2-fromMapWith_map_filter f = fromMap_filter . Map.map f-{-# INLINABLE fromMapWith_map_filter #-}--fromMapWith_map_filter_if_any_null-    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> MonoidMap k v2-fromMapWith_map_filter_if_any_null f = fromMap_filter_if_any_null . Map.map f-{-# INLINABLE fromMapWith_map_filter_if_any_null #-}---- | \(O(n)\). Constructs a 'MonoidMap' from a 'Set' and a function from---   keys to values.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('fromSet' f ks) '=='---     if 'Set'.'Set.member' k ks---     then f k---     else 'mempty'--- @------ This function performs canonicalisation of 'C.null' values, and has a time--- complexity that is linear in the 'Set.size' of the set.------ @since 0.0.2.0----fromSet :: MonoidNull v => (k -> v) -> Set k -> MonoidMap k v-fromSet f = fromMap . Map.fromSet f---- | \(O(1)\). Constructs a 'MonoidMap' from a single key-value pair.------ Satisfies the following property:------ @--- 'get' k ('singleton' k v) '==' v--- @------ Nullifying the value for key __@k@__ produces an 'empty' map:------ @--- 'nullify' k ('singleton' k v) '==' 'empty'--- @----singleton :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v-singleton k v = set k v mempty------------------------------------------------------------------------------------- Deconstruction------------------------------------------------------------------------------------- | \(O(n)\). Converts a 'MonoidMap' to a list of key-value pairs, where the---   keys are in ascending order.------ The result only includes entries with values that are not 'C.null'.------ Satisfies the following round-trip property:------ @--- 'fromList' ('toList' m) '==' m--- @------ The resulting list is sorted in ascending key order:------ @--- 'L.sortOn' 'fst' ('toList' m) '==' 'toList' m--- @----toList :: MonoidMap k v -> [(k, v)]-toList = Map.toAscList . toMap---- | \(O(1)\). Converts a 'MonoidMap' to an ordinary 'Map'.------ The result only includes entries with values that are not 'C.null'.------ Satisfies the following round-trip property:------ @--- 'fromMap' ('toMap' m) '==' m--- @----toMap :: forall k v. MonoidMap k v -> Map k v-toMap = coerce------------------------------------------------------------------------------------- Lookup------------------------------------------------------------------------------------- | \(O(\log n)\). Gets the value associated with the given key.------ By default, every key in an 'empty' map is associated with a value of--- 'mempty':------ @--- ∀ k. 'get' k 'empty' '==' 'mempty'--- @----get :: (Ord k, Monoid v) => k -> MonoidMap k v -> v-get k m = fromMaybe mempty $ Map.lookup k $ toMap m------------------------------------------------------------------------------------- Modification------------------------------------------------------------------------------------- | \(O(\log n)\). Sets the value associated with the given key.------ Satisfies the following property:------ @--- 'get' k ('set' k v m) '==' v--- @----set :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v -> MonoidMap k v-set k v (MonoidMap m) = MonoidMap $ case maybeNonNull v of-    Just v0 -> Map.insert k v0 m-    Nothing -> Map.delete k    m---- | \(O(\log n)\). Adjusts the value associated with the given key.------ Satisfies the following property:------ @--- 'adjust' f k m '==' 'set' k (f ('get' k m)) m--- @----adjust-    :: (Ord k, MonoidNull v)-    => (v -> v)-    -> k-    -> MonoidMap k v-    -> MonoidMap k v-adjust f k (MonoidMap m) = MonoidMap $-    Map.alter (maybeNonNull . maybe (f mempty) (applyNonNull f)) k m------------------------------------------------------------------------------------- Nullification------------------------------------------------------------------------------------- | \(O(\log n)\). Sets the value associated with the given key to 'mempty'.------ Satisfies the following property:------ @--- 'get' k1 ('nullify' k2 m) '=='---     if k1 '==' k2---     then 'mempty'---     else 'get' k1 m--- @----nullify :: Ord k => k -> MonoidMap k v -> MonoidMap k v-nullify k (MonoidMap m) = MonoidMap $ Map.delete k m---- | \(O\bigl(m \log\bigl(\frac{n}{m}+1\bigr)\bigr), \; 0 < m \leq n\).------ Sets the values associated with all keys in the given set to 'mempty'.------ Satisfies the following properties:------ @--- 'get' k ('nullifyKeysIn' ks m) '=='---     if 'Set'.'Set.member' k ks---     then 'mempty'---     else 'get' k m--- @------ @--- 'nullifyKeysIn' ks m '=='---     'fromMap' ('Map'.'Map.withoutKeys' ('toMap' m) ks)--- @------ @since 0.0.6.0----nullifyKeysIn :: Ord k => Set k -> MonoidMap k v -> MonoidMap k v-nullifyKeysIn ks (MonoidMap m) = MonoidMap $ m `Map.withoutKeys` ks---- | \(O\bigl(m \log\bigl(\frac{n}{m}+1\bigr)\bigr), \; 0 < m \leq n\).------ Sets the values associated with all keys not in the given set to 'mempty'.------ Satisfies the following properties:------ @--- 'get' k ('nullifyKeysNotIn' ks m) '=='---     if 'Set'.'Set.notMember' k ks---     then 'mempty'---     else 'get' k m--- @------ @--- 'nullifyKeysNotIn' ks m '=='---     'fromMap' ('Map'.'Map.restrictKeys' ('toMap' m) ks)--- @------ @since 0.0.6.0----nullifyKeysNotIn :: Ord k => Set k -> MonoidMap k v -> MonoidMap k v-nullifyKeysNotIn ks (MonoidMap m) = MonoidMap $ m `Map.restrictKeys` ks------------------------------------------------------------------------------------- Membership------------------------------------------------------------------------------------- | \(O(1)\). Returns 'True' if (and only if) all values in the map are---   'C.null'.------ Satisfies the following property:------ @--- 'null' m '==' (∀ k. 'nullKey' k m)--- @------ Provides the definition of 'C.null' for the 'MonoidMap' instance of--- 'MonoidNull'.----null :: MonoidMap k v -> Bool-null = Map.null . toMap---- | \(O(\log n)\). Returns 'True' if (and only if) the given key is associated---   with a value that is 'C.null'.------ Satisfies the following property:------ @--- 'nullKey' k m '==' 'C.null' ('get' k m)--- @----nullKey :: Ord k => k -> MonoidMap k v -> Bool-nullKey k = Map.notMember k . toMap---- | \(O(1)\). Returns 'True' if (and only if) the map contains at least one---   value that is not 'C.null'.------ Satisfies the following property:------ @--- 'nonNull' m '==' (∃ k. 'nonNullKey' k m)--- @----nonNull :: MonoidMap k v -> Bool-nonNull = not . null---- | \(O(1)\). Returns a count of all values in the map that are not 'C.null'.------ Satisfies the following property:------ @--- 'nonNullCount' m '==' 'Set.size' ('nonNullKeys' m)--- @----nonNullCount :: MonoidMap k v -> Int-nonNullCount = Map.size . toMap---- | \(O(\log n)\). Returns 'True' if (and only if) the given key is associated---   with a value that is not 'C.null'.------ Satisfies the following property:------ @--- 'nonNullKey' k m '==' 'not' ('C.null' ('get' k m))--- @----nonNullKey :: Ord k => k -> MonoidMap k v -> Bool-nonNullKey k = Map.member k . toMap---- | \(O(n)\). Returns the set of keys associated with values that are not---   'C.null'.------ Satisfies the following property:------ @--- k '`Set.member`' ('nonNullKeys' m) '==' 'nonNullKey' k m--- @----nonNullKeys :: MonoidMap k v -> Set k-nonNullKeys = Map.keysSet . toMap------------------------------------------------------------------------------------- Slicing------------------------------------------------------------------------------------- | \(O(\log n)\). /Takes/ a slice from a map.------ This function takes a given number of non-'C.null' entries from a map,--- producing a new map from the entries that were /taken/.------ Entries are taken in /key order/, beginning with the /smallest/ keys.------ Satifies the following property:------ @--- 'take' n '==' 'fromList' . 'Prelude.take' n . 'toList'--- @----take :: Int -> MonoidMap k v -> MonoidMap k v-take i (MonoidMap m) = MonoidMap (Map.take i m)---- | \(O(\log n)\). /Drops/ a slice from a map.------ This function drops a given number of non-'C.null' entries from a map,--- producing a new map from the entries that /remain/.------ Entries are dropped in /key order/, beginning with the /smallest/ keys.------ Satifies the following property:------ @--- 'drop' n '==' 'fromList' . 'Prelude.drop' n . 'toList'--- @----drop :: Int -> MonoidMap k v -> MonoidMap k v-drop i (MonoidMap m) = MonoidMap (Map.drop i m)---- | \(O(\log n)\). /Splits/ a map into /two/ slices.------ This function is equivalent to a combination of 'take' and 'drop':------ @--- 'splitAt' n m '==' ('take' n m, 'drop' n m)--- @------ The resulting maps can be combined to reproduce the original map:------ @--- 'splitAt' n m '&'---     \\(m1, m2) -> m1 '<>' m2 '==' m--- @------ The resulting maps have disjoint sets of non-'C.null' entries:------ @--- 'splitAt' n m '&'---     \\(m1, m2) -> 'Set.disjoint' ('nonNullKeys' m1) ('nonNullKeys' m2)--- @----splitAt :: Int -> MonoidMap k a -> (MonoidMap k a, MonoidMap k a)-splitAt i m = (take i m, drop i m)------------------------------------------------------------------------------------- Filtering------------------------------------------------------------------------------------- | \(O(n)\). Filters a map according to a predicate on /values/.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('filter' f m) '=='---     if f ('get' k m)---     then 'get' k m---     else 'mempty'--- @------ The resulting map is identical to that obtained by constructing a map from a--- filtered list of key-value pairs:------ @--- 'filter' f m '==' 'fromList' ('L.filter' (f . 'snd') ('toList' m))--- @----filter :: (v -> Bool) -> MonoidMap k v -> MonoidMap k v-filter f (MonoidMap m) = MonoidMap $ Map.filter (applyNonNull f) m---- | \(O(n)\). Filters a map according to a predicate on /keys/.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('filterKeys' f m) '=='---     if f k---     then 'get' k m---     else 'mempty'--- @------ The resulting map is identical to that obtained by constructing a map from a--- filtered list of key-value pairs:------ @--- 'filter' f m '==' 'fromList' ('L.filter' (f . 'fst') ('toList' m))--- @----filterKeys :: (k -> Bool) -> MonoidMap k v -> MonoidMap k v-filterKeys f (MonoidMap m) = MonoidMap $ Map.filterWithKey (\k _ -> f k) m---- | \(O(n)\). Filters a map according to a predicate on /keys and values/.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('filterWithKey' f m) '=='---     if f k ('get' k m)---     then 'get' k m---     else 'mempty'--- @------ The resulting map is identical to that obtained by constructing a map from a--- filtered list of key-value pairs:------ @--- 'filterWithKey' f m '==' 'fromList' ('L.filter' ('uncurry' f) ('toList' m))--- @----filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v-filterWithKey f (MonoidMap m) =-    MonoidMap $ Map.filterWithKey (applyNonNull . f) m------------------------------------------------------------------------------------- Partitioning------------------------------------------------------------------------------------- | \(O(n)\). Partitions a map according to a predicate on /values/.------ Satisfies the following property:------ @--- 'partition' f m '=='---     ( 'filter'  \   \   f  m---     , 'filter' ('not' . f) m---     )--- @------ The resulting maps can be combined to reproduce the original map:------ @--- 'partition' f m '&' \\(m1, m2) ->---     m1 '<>' m2 '==' m--- @------ The resulting maps have disjoint sets of non-'C.null' entries:------ @--- 'partition' f m '&' \\(m1, m2) ->---     'Set.disjoint'---         ('nonNullKeys' m1)---         ('nonNullKeys' m2)--- @----partition :: (v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)-partition f (MonoidMap m) =-    B.bimap MonoidMap MonoidMap $ Map.partition (applyNonNull f) m---- | \(O(n)\). Partitions a map according to a predicate on /keys/.------ Satisfies the following property:------ @--- 'partitionKeys' f m '=='---     ( 'filterKeys'  \   \   f  m---     , 'filterKeys' ('not' . f) m---     )--- @------ The resulting maps can be combined to reproduce the original map:------ @--- 'partitionKeys' f m '&' \\(m1, m2) ->---     m1 '<>' m2 '==' m--- @------ The resulting maps have disjoint sets of non-'C.null' entries:------ @--- 'partitionKeys' f m '&' \\(m1, m2) ->---     'Set.disjoint'---         ('nonNullKeys' m1)---         ('nonNullKeys' m2)--- @----partitionKeys-    :: (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---- | \(O(n)\). Partitions a map according to a predicate on /keys and values/.------ Satisfies the following property:------ @--- 'partitionWithKey' f m '=='---     ( 'filterWithKey'   \    \   \    \  \   \ f  m---     , 'filterWithKey' (('fmap' . 'fmap') 'not' f) m---     )--- @------ The resulting maps can be combined to reproduce the original map:------ @--- 'partitionWithKey' f m '&' \\(m1, m2) ->---     m1 '<>' m2 '==' m--- @------ The resulting maps have disjoint sets of non-'C.null' entries:------ @--- 'partitionWithKey' f m '&' \\(m1, m2) ->---     'Set.disjoint'---         ('nonNullKeys' m1)---         ('nonNullKeys' m2)--- @----partitionWithKey-    :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)-partitionWithKey f (MonoidMap m) =-    B.bimap MonoidMap MonoidMap $ Map.partitionWithKey (applyNonNull . f) m------------------------------------------------------------------------------------- Mapping------------------------------------------------------------------------------------- | \(O(n)\). Applies a function to all non-'C.null' values of a 'MonoidMap'.------ Satisfies the following properties for all functions __@f@__:------ @--- ('get' k m '==' 'mempty') ==> ('get' k ('map' f m) '==' 'mempty'     )--- ('get' k m '/=' 'mempty') ==> ('get' k ('map' f m) '==' f ('get' k m))--- @------ === Conditional properties------ If applying function __@f@__ to 'mempty' produces 'mempty', then the--- following additional properties hold:------ @--- (f 'mempty' '==' 'mempty')---     ==>---     (∀ k. 'get' k ('map' f m) '==' f ('get' k m))--- @------ @--- (f 'mempty' '==' 'mempty')---     ==>---     (∀ g. 'map' (f . g) m '==' 'map' f ('map' g m))--- @----map-    :: MonoidNull v2-    => (v1 -> v2)-    -> MonoidMap k v1-    -> MonoidMap k v2-map f (MonoidMap m) =-    MonoidMap $ Map.mapMaybe (maybeNonNull . applyNonNull f) m---- | \(O(n \log n)\). Applies a function to all the keys of a 'MonoidMap' that---   are associated with non-'C.null' 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 '(<>)'--- operator.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('mapKeys' f m) '=='---     'F.foldMap'---         ('`get`' m)---         ('Set.filter' (('==') k . f) ('nonNullKeys' m))--- @----mapKeys-    :: (Ord k2, MonoidNull v)-    => (k1 -> k2)-    -> MonoidMap k1 v-    -> MonoidMap k2 v-mapKeys = mapKeysWith (<>)---- | \(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---   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:------ @--- 'mapKeysWith' c f '==' 'fromListWith' c . 'fmap' ('B.first' f) . 'toList'--- @----mapKeysWith-    :: (Ord k2, MonoidNull v)-    => (v -> v -> v)-    -- ^ Function with which to combine values for duplicate keys.-    -> (k1 -> k2)-    -> MonoidMap k1 v-    -> MonoidMap k2 v-mapKeysWith combine fk = fromListWith combine . fmap (B.first fk) . toList---- | \(O(n)\). Applies a key-dependent function to all non-'C.null' values of---   a 'MonoidMap'.------ Satisfies the following properties for all functions __@f@__:------ @--- ('nonNullKey' k m) ==> ('get' k ('mapWithKey' f m) '==' f k ('get' k m))--- (   'nullKey' k m) ==> ('get' k ('mapWithKey' f m) '==' 'mempty'       )--- @------ @since 0.0.3.0----mapWithKey-    :: MonoidNull v2-    => (k -> v1 -> v2)-    -> MonoidMap k v1-    -> MonoidMap k v2-mapWithKey f (MonoidMap m) =-    MonoidMap . runIdentity $-    Map.traverseMaybeWithKey-        (\k v -> Identity $ maybeNonNull $ applyNonNull (f k) v) m------------------------------------------------------------------------------------- Lazy folding------------------------------------------------------------------------------------- | \(O(n)\). Folds over the values in the map using the given---   left-associative binary operator.------ Satisfies the following property:------ @--- 'foldl' f r m '==' 'Map'.'Map.foldl' f r ('toMap' m)--- @------ @since 0.0.1.7----foldl :: (r -> v -> r) -> r -> MonoidMap k v -> r-foldl =-    (coerce-        :: ((r -> v -> r) -> r ->       Map k v -> r)-        -> ((r -> v -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldl-{-# INLINE foldl #-}---- | \(O(n)\). Folds over the values in the map using the given---   right-associative binary operator.------ Satisfies the following property:------ @--- 'foldr' f r m '==' 'Map'.'Map.foldr' f r ('toMap' m)--- @------ @since 0.0.1.7----foldr :: (v -> r -> r) -> r -> MonoidMap k v -> r-foldr =-    (coerce-        :: ((v -> r -> r) -> r ->       Map k v -> r)-        -> ((v -> r -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldr-{-# INLINE foldr #-}---- | \(O(n)\). Folds over the keys and values in the map using the given---   left-associative binary operator.------ Satisfies the following property:------ @--- 'foldlWithKey' f r m '==' 'Map'.'Map.foldlWithKey' f r ('toMap' m)--- @------ @since 0.0.1.7----foldlWithKey :: (r -> k -> v -> r) -> r -> MonoidMap k v -> r-foldlWithKey =-    (coerce-        :: ((r -> k -> v -> r) -> r ->       Map k v -> r)-        -> ((r -> k -> v -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldlWithKey-{-# INLINE foldlWithKey #-}---- | \(O(n)\). Folds over the keys and values in the map using the given---   right-associative binary operator.------ Satisfies the following property:------ @--- 'foldrWithKey' f r m '==' 'Map'.'Map.foldrWithKey' f r ('toMap' m)--- @------ @since 0.0.1.7----foldrWithKey :: (k -> v -> r -> r) -> r -> MonoidMap k v -> r-foldrWithKey =-    (coerce-        :: ((k -> v -> r -> r) -> r ->       Map k v -> r)-        -> ((k -> v -> r -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldrWithKey-{-# INLINE foldrWithKey #-}---- | \(O(n)\). Folds over the keys and values in the map using the given---   monoid.------ Satisfies the following property:------ @--- 'foldMapWithKey' f m '==' 'Map'.'Map.foldMapWithKey' f ('toMap' m)--- @------ @since 0.0.1.7----foldMapWithKey :: Monoid r => (k -> v -> r) -> MonoidMap k v -> r-foldMapWithKey =-    (coerce-        :: ((k -> v -> r) ->       Map k v -> r)-        -> ((k -> v -> r) -> MonoidMap k v -> r)-    )-    Map.foldMapWithKey-{-# INLINE foldMapWithKey #-}------------------------------------------------------------------------------------- Strict folding------------------------------------------------------------------------------------- | \(O(n)\). A strict version of 'foldl'.------ Each application of the operator is evaluated before using the result in the--- next application. This function is strict in the starting value.------ @since 0.0.1.7----foldl' :: (r -> v -> r) -> r -> MonoidMap k v -> r-foldl' =-    (coerce-        :: ((r -> v -> r) -> r ->       Map k v -> r)-        -> ((r -> v -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldl'-{-# INLINE foldl' #-}---- | \(O(n)\). A strict version of 'foldr'.------ Each application of the operator is evaluated before using the result in the--- next application. This function is strict in the starting value.------ @since 0.0.1.7----foldr' :: (v -> r -> r) -> r -> MonoidMap k v -> r-foldr' =-    (coerce-        :: ((v -> r -> r) -> r ->       Map k v -> r)-        -> ((v -> r -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldr'-{-# INLINE foldr' #-}---- | \(O(n)\). A strict version of 'foldlWithKey'.------ Each application of the operator is evaluated before using the result in the--- next application. This function is strict in the starting value.------ @since 0.0.1.7----foldlWithKey' :: (r -> k -> v -> r) -> r -> MonoidMap k v -> r-foldlWithKey' =-    (coerce-        :: ((r -> k -> v -> r) -> r ->       Map k v -> r)-        -> ((r -> k -> v -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldlWithKey'-{-# INLINE foldlWithKey' #-}---- | \(O(n)\). A strict version of 'foldrWithKey'.------ Each application of the operator is evaluated before using the result in the--- next application. This function is strict in the starting value.------ @since 0.0.1.7----foldrWithKey' :: (k -> v -> r -> r) -> r -> MonoidMap k v -> r-foldrWithKey' =-    (coerce-        :: ((k -> v -> r -> r) -> r ->       Map k v -> r)-        -> ((k -> v -> r -> r) -> r -> MonoidMap k v -> r)-    )-    Map.foldrWithKey'-{-# INLINE foldrWithKey' #-}---- | \(O(n)\). A strict version of 'foldMapWithKey'.------ Each application of `mappend` is evaluated before using the result in the--- next application.------ @since 0.0.1.8----foldMapWithKey' :: Monoid r => (k -> v -> r) -> MonoidMap k v -> r-foldMapWithKey' f = foldlWithKey' (\r k v -> r <> f k v) mempty-{-# INLINE foldMapWithKey' #-}------------------------------------------------------------------------------------- Traversal------------------------------------------------------------------------------------- | \(O(n)\). Traverses over the values of a map using the given function.------ Satisfies the following property:------ @--- 'traverse' f m '=='--- 'fmap' 'fromMap' ('Traversable'.'Traversable.traverse' f ('toMap' m))--- @------ @since 0.0.1.9----traverse-    :: Applicative t-    => MonoidNull v2-    => (v1 -> t v2)-    -> MonoidMap k v1-    -> t (MonoidMap k v2)-traverse f = traverseWithKey (const f)-{-# INLINE traverse #-}---- | \(O(n)\). Traverses over the keys and values of a map using the given---   function.------ Satisfies the following property:------ @--- 'traverseWithKey' f m '=='--- 'fmap' 'fromMap' ('Map'.'Map.traverseWithKey' f ('toMap' m))--- @------ @since 0.0.1.9----traverseWithKey-    :: Applicative t-    => MonoidNull v2-    => (k -> v1 -> t v2)-    -> MonoidMap k v1-    -> t (MonoidMap k v2)-traverseWithKey f (MonoidMap m) =-    MonoidMap <$>-    Map.traverseMaybeWithKey-        (\k v -> maybeNonNull <$> applyNonNull (f k) v) m-{-# INLINE traverseWithKey #-}---- | \(O(n)\). Threads an accumulating argument through the map in ascending---   order of keys.------ Satisfies the following property:------ @--- 'mapAccumL' f s m '=='--- 'fmap' 'fromMap' ('Traversable'.'Traversable.mapAccumL' f s ('toMap' m))--- @------ @since 0.0.1.9----mapAccumL-    :: MonoidNull v2-    => (s -> v1 -> (s, v2))-    -> s-    -> MonoidMap k v1-    -> (s, MonoidMap k v2)-mapAccumL f s m =-    (coerce-        :: ((v1 -> StateL s  v2 ) -> MM k v1 -> StateL s (MM k v2))-        -> ((v1 -> s ->  (s, v2)) -> MM k v1 -> s ->  (s, MM k v2))-    )-    traverse (flip f) m s-{-# INLINE mapAccumL #-}---- | \(O(n)\). Threads an accumulating argument through the map in descending---   order of keys.------ Satisfies the following property:------ @--- 'mapAccumR' f s m '=='--- 'fmap' 'fromMap' ('Traversable'.'Traversable.mapAccumR' f s ('toMap' m))--- @------ @since 0.0.1.9----mapAccumR-    :: MonoidNull v2-    => (s -> v1 -> (s, v2))-    -> s-    -> MonoidMap k v1-    -> (s, MonoidMap k v2)-mapAccumR f s m =-    (coerce-        :: ((v1 -> StateR s  v2 ) -> MM k v1 -> StateR s (MM k v2))-        -> ((v1 -> s ->  (s, v2)) -> MM k v1 -> s ->  (s, MM k v2))-    )-    traverse (flip f) m s-{-# INLINE mapAccumR #-}---- | \(O(n)\). Threads an accumulating argument through the map in ascending---   order of keys.------ Satisfies the following property:------ @--- 'mapAccumLWithKey' f s m '=='--- 'fmap' 'fromMap' ('Map'.'Map.mapAccumWithKey' f s ('toMap' m))--- @------ @since 0.0.1.9----mapAccumLWithKey-    :: MonoidNull v2-    => (s -> k -> v1 -> (s, v2))-    -> s-    -> MonoidMap k v1-    -> (s, MonoidMap k v2)-mapAccumLWithKey f s0 m =-    (coerce-        :: ((k -> v1 -> StateL s  v2 ) -> MM k v1 -> StateL s (MM k v2))-        -> ((k -> v1 -> s ->  (s, v2)) -> MM k v1 -> s ->  (s, MM k v2))-    )-    traverseWithKey (\k v1 s -> f s k v1) m s0-{-# INLINE mapAccumLWithKey #-}---- | \(O(n)\). Threads an accumulating argument through the map in descending---   order of keys.------ Satisfies the following property:------ @--- 'mapAccumRWithKey' f s m '=='--- 'fmap' 'fromMap' ('Map'.'Map.mapAccumRWithKey' f s ('toMap' m))--- @------ @since 0.0.1.9----mapAccumRWithKey-    :: MonoidNull v2-    => (s -> k -> v1 -> (s, v2))-    -> s-    -> MonoidMap k v1-    -> (s, MonoidMap k v2)-mapAccumRWithKey f s0 m =-    (coerce-        :: ((k -> v1 -> StateR s  v2 ) -> MM k v1 -> StateR s (MM k v2))-        -> ((k -> v1 -> s ->  (s, v2)) -> MM k v1 -> s ->  (s, MM k v2))-    )-    traverseWithKey (\k v1 s -> f s k v1) m s0-{-# INLINE mapAccumRWithKey #-}------------------------------------------------------------------------------------- Comparison------------------------------------------------------------------------------------- | Indicates whether or not the first map is a /submap/ of the second.------ Map __@m1@__ is a submap of map __@m2@__ if (and only if) __@m1@__ can be--- subtracted from __@m2@__ with the 'minusMaybe' operation:------ @--- m1 '`isSubmapOf`' m2 '==' 'isJust' (m2 '`minusMaybe`' m1)--- @------ Equivalently, map __@m1@__ is a submap of map __@m2@__ if (and only if) for--- all possible keys __@k@__, the value for __@k@__ in __@m1@__ can be--- subtracted from the value for __@k@__ in __@m2@__ with the '(</>)' operator:------ @--- m1 '`isSubmapOf`' m2 '==' (∀ k. 'isJust' ('get' k m2 '</>' 'get' k m1))--- @----isSubmapOf-    :: (Ord k, Monoid v, Reductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Bool-isSubmapOf = isSubmapOfBy $ \v1 v2 -> isJust (v2 </> v1)-{-# INLINE isSubmapOf #-}---- | 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:------ @--- 'isSubmapOfBy' f m1 m2 '=='---     'all' (\\k -> f ('get' k m1) ('get' k m2)) ('nonNullKeys' m1)--- @------ === Conditional totality------ /If/ the given comparison function __@f@__ /always/ evaluates to 'True'--- when its first argument is 'mempty':------ @--- ∀ v. f 'mempty' v--- @------ /Then/ the following property holds:------ @--- 'isSubmapOfBy' f m1 m2 '==' (∀ k. f ('get' k m1) ('get' k m2))--- @----isSubmapOfBy-    :: (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-isSubmapOfBy leq m1 m2 =-    all-        (\k -> get k m1 `leq` get k m2)-        (nonNullKeys m1)-{-# INLINE isSubmapOfBy #-}---- | Indicates whether or not a pair of maps are /disjoint/.------ Maps __@m1@__ and __@m2@__ are disjoint if (and only if) their intersection--- is empty:------ @--- 'disjoint' m1 m2 '==' ('intersection' m1 m2 '==' 'mempty')--- @------ Equivalently, maps __@m1@__ and __@m2@__ are disjoint if (and only if) for--- all possible keys __@k@__, the values for __@k@__ in __@m1@__ and __@m2@__--- have a 'C.gcd' that is 'C.null':------ @--- 'disjoint' m1 m2 '==' (∀ k. 'C.null' ('C.gcd' ('get' k m1) ('get' k m2)))--- @----disjoint-    :: (Ord k, GCDMonoid v, MonoidNull v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Bool-disjoint = disjointBy (\v1 v2 -> C.null (C.gcd v1 v2))-{-# INLINE disjoint #-}---- | 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:------ @--- 'disjointBy' f m1 m2 '=='---     'all'---         (\\k -> f ('get' k m1) ('get' k m2))---         ('Set.intersection' ('nonNullKeys' m1) ('nonNullKeys' m2))--- @------ === Conditional totality------ /If/ the given indicator function __@f@__ /always/ evaluates to 'True'--- when /either/ or /both/ of its arguments are 'mempty':------ @--- ∀ v. (f v 'mempty') '&&' (f 'mempty' v)--- @------ /Then/ the following property holds:------ @--- 'disjointBy' f m1 m2 '==' (∀ k. f ('get' k m1) ('get' k m2))--- @----disjointBy-    :: (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-disjointBy f m1 m2 =-    all-        (\k -> f (get k m1) (get k m2))-        (Set.intersection (nonNullKeys m1) (nonNullKeys m2))-{-# INLINE disjointBy #-}------------------------------------------------------------------------------------- Association------------------------------------------------------------------------------------- | Appends a pair of maps together.------ Uses the 'Semigroup' operator '(<>)' 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@__:------ @--- 'get' k ('append' m1 m2) '==' 'get' k m1 '<>' 'get' k m2--- @------ This function provides the definition of '(<>)' for the 'MonoidMap' instance--- of 'Semigroup'.------ === __Examples__------ With 'String' values:------ @--- >>> 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")]--- @--- @--- >>> 'append' m1 m2 '==' m3--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values:------ @--- >>> 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)]--- @--- @--- >>> 'append' m1 m2 '==' m3--- 'True'--- @----append-    :: (Ord k, MonoidNull v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-append = merge MergeStrategy-    { withNonNullL =-        keepNonNull-        -- Justification:-        ---        -- v <> mempty ≡ v--    , withNonNullR =-        keepNonNull-        -- Justification:-        ---        -- mempty <> v ≡ v--    , withNonNullP =-        withBoth (<>)-    }-{-# INLINE append #-}------------------------------------------------------------------------------------- Prefixes and suffixes------------------------------------------------------------------------------------- | Indicates whether or not the first map is a /prefix/ of the second.------ 'MonoidMap' __@m1@__ is a /prefix/ of 'MonoidMap' __@m2@__ if (and only if)--- for all possible keys __@k@__, the value for __@k@__ in __@m1@__ is a--- /prefix/ of the value for __@k@__ in __@m2@__:------ @--- m1 '`isPrefixOf`' m2 '==' (∀ k. 'get' k m1 '`C.isPrefixOf`' 'get' k m2)--- @------ This function provides the definition of 'C.isPrefixOf' for the 'MonoidMap'--- instance of 'LeftReductive'.------ === __Examples__------ With 'String' values:------ @--- >>> m1 = 'fromList' [(1, "a"  ), (2, "p"  ), (3, "x"  )]--- >>> m2 = 'fromList' [(1, "abc"), (2, "pqr"), (3, "xyz")]--- >>> m1 '`isPrefixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [            (2, "p"  )            ]--- >>> m2 = 'fromList' [(1, "abc"), (2, "pqr"), (3, "xyz")]--- >>> m1 '`isPrefixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [(1, "abc"), (2, "p"  ), (3, "x"  )]--- >>> m2 = 'fromList' [(1, "a"  ), (2, "pqr"), (3, "xyz")]--- >>> m1 '`isPrefixOf`' m2--- 'False'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values:------ @--- >>> m1 = 'fromList' [("a", 1), ("b", 1), ("c", 1)]--- >>> m2 = 'fromList' [("a", 2), ("b", 4), ("c", 8)]--- >>> m1 '`isPrefixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [          ("b", 1)          ]--- >>> m2 = 'fromList' [("a", 2), ("b", 4), ("c", 8)]--- >>> m1 '`isPrefixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [("a", 2), ("b", 1), ("c", 1)]--- >>> m2 = 'fromList' [("a", 1), ("b", 4), ("c", 8)]--- >>> m1 '`isPrefixOf`' m2--- 'False'--- @----isPrefixOf-    :: (Ord k, Monoid v, LeftReductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Bool-isPrefixOf = isSubmapOfBy C.isPrefixOf-    -- Note that in practice, it's sufficient to check the following property:-    ---    -- @-    -- m1 '`isPrefixOf`' m2 '=='-    --     'all'-    --         (\\k -> 'get' k m1 '`C.isPrefixOf`' 'get' k m2)-    --         ('nonNullKeys' m1)-    -- @-    ---    -- ==== Justification-    ---    -- According to the laws for 'LeftReductive':-    ---    -- @-    -- ∀ a b. b '`C.isPrefixOf`' (b '<>' a)-    -- @-    ---    -- Substituting 'mempty' for @b@:-    ---    -- @-    -- ∀ a. 'mempty' '`C.isPrefixOf`' ('mempty' '<>' a)-    -- @-    ---    -- According to the left identity law for 'Monoid':-    ---    -- @-    -- ∀ a. 'mempty' '<>' a '==' a-    -- @-    ---    -- We can therefore assert that:-    ---    -- @-    -- ∀ a. 'mempty' '`C.isPrefixOf`' a-    -- @-    ---    -- Since 'mempty' is /always/ a valid prefix, we only need to consider-    -- values in 'm1' that are /not/ 'mempty'.-    ---    -- The 'nonNullKeys' function, when applied to 'm1', gives us /precisely/-    -- the set of keys that are not associated with 'mempty' in 'm1':-    ---    -- @-    -- (k '`Data.Set.member`' 'nonNullKeys' m1) '==' ('get' k m1 '/=' 'mempty')-    -- @-    ---{-# INLINE isPrefixOf #-}---- | Indicates whether or not the first map is a /suffix/ of the second.------ 'MonoidMap' __@m1@__ is a /suffix/ of 'MonoidMap' __@m2@__ if (and only if)--- for all possible keys __@k@__, the value for __@k@__ in __@m1@__ is a--- /suffix/ of the value for __@k@__ in __@m2@__:------ @--- m1 '`isSuffixOf`' m2 '==' (∀ k. 'get' k m1 '`C.isSuffixOf`' 'get' k m2)--- @------ This function provides the definition of 'C.isSuffixOf' for the 'MonoidMap'--- instance of 'RightReductive'.------ === __Examples__------ With 'String' values:------ @--- >>> m1 = 'fromList' [(1,   "c"), (2,   "r"), (3,   "z")]--- >>> m2 = 'fromList' [(1, "abc"), (2, "pqr"), (3, "xyz")]--- >>> m1 '`isSuffixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [            (2,   "r")            ]--- >>> m2 = 'fromList' [(1, "abc"), (2, "pqr"), (3, "xyz")]--- >>> m1 '`isSuffixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [(1, "abc"), (2,   "r"), (3,   "z")]--- >>> m2 = 'fromList' [(1,   "c"), (2, "pqr"), (3, "xyz")]--- >>> m1 '`isSuffixOf`' m2--- 'False'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values:------ @--- >>> m1 = 'fromList' [("a", 1), ("b", 1), ("c", 1)]--- >>> m2 = 'fromList' [("a", 2), ("b", 4), ("c", 8)]--- >>> m1 '`isSuffixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [          ("b", 1)          ]--- >>> m2 = 'fromList' [("a", 2), ("b", 4), ("c", 8)]--- >>> m1 '`isSuffixOf`' m2--- 'True'--- @------ @--- >>> m1 = 'fromList' [("a", 2), ("b", 1), ("c", 1)]--- >>> m2 = 'fromList' [("a", 1), ("b", 4), ("c", 8)]--- >>> m1 '`isSuffixOf`' m2--- 'False'--- @----isSuffixOf-    :: (Ord k, Monoid v, RightReductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Bool-isSuffixOf = isSubmapOfBy C.isSuffixOf-    -- Note that in practice, it's sufficient to check the following property:-    ---    -- @-    -- m1 '`isSuffixOf`' m2 '=='-    --     'all'-    --         (\\k -> 'get' k m1 '`C.isSuffixOf`' 'get' k m2)-    --         ('nonNullKeys' m1)-    -- @-    ---    -- ==== Justification-    ---    -- According to the laws for 'RightReductive':-    ---    -- @-    -- ∀ a b. b '`C.isSuffixOf`' (a '<>' b)-    -- @-    ---    -- Substituting 'mempty' for @b@:-    ---    -- @-    -- ∀ a. 'mempty' '`C.isSuffixOf`' (a '<>' 'mempty')-    -- @-    ---    -- According to the right identity law for 'Monoid':-    ---    -- @-    -- ∀ a. a '<>' 'mempty' '==' a-    -- @-    ---    -- We can therefore assert that:-    ---    -- @-    -- ∀ a. 'mempty' '`C.isSuffixOf`' a-    -- @-    ---    -- Since 'mempty' is /always/ a valid suffix, we only need to consider-    -- values in 'm1' that are /not/ 'mempty'.-    ---    -- The 'nonNullKeys' function, when applied to 'm1', gives us /precisely/-    -- the set of keys that are not associated with 'mempty' in 'm1':-    ---    -- @-    -- (k '`Data.Set.member`' 'nonNullKeys' m1) '==' ('get' k m1 '/=' 'mempty')-    -- @-    ---{-# INLINE isSuffixOf #-}---- | Strips a /prefix/ from a 'MonoidMap'.------ If map __@m1@__ is a /prefix/ of map __@m2@__, then 'stripPrefix' __@m1@__--- __@m2@__ will produce a /reduced/ map where prefix __@m1@__ is /stripped/--- from __@m2@__.------ === Properties------ The 'stripPrefix' function, when applied to maps __@m1@__ and __@m2@__,--- produces a result if (and only if) __@m1@__ is a prefix of __@m2@__:------ @--- 'isJust' ('stripPrefix' m1 m2) '==' m1 '`isPrefixOf`' m2--- @------ The value for any key __@k@__ in the result is /identical/ to the result of--- stripping the value for __@k@__ in map __@m1@__ from the value for __@k@__--- in map __@m2@__:------ @--- 'all'---    (\\r -> 'Just' ('get' k r) '==' 'C.stripPrefix' ('get' k m1) ('get' k m2))---    ('stripPrefix' m1 m2)--- @------ If we append prefix __@m1@__ to the /left-hand/ side of the result, we can--- always recover the original map __@m2@__:------ @--- 'all'---    (\\r -> m1 '<>' r '==' m2)---    ('stripPrefix' m1 m2)--- @------ This function provides the definition of 'C.stripPrefix' for the 'MonoidMap'--- instance of 'LeftReductive'.------ === __Examples__------ With 'String' values:------ @--- >>> __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,    "")]--- @--- @--- >>> 'stripPrefix' __m1__ __m2__ '==' 'Just' __m3__--- 'True'--- @--- @--- >>> 'stripPrefix' __m2__ __m1__ '==' 'Nothing'--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> __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)]--- @--- @--- >>> 'stripPrefix' __m1__ __m2__ '==' 'Just' __m3__--- 'True'--- @--- @--- >>> 'stripPrefix' __m2__ __m1__ '==' 'Nothing'--- 'True'--- @----stripPrefix-    :: (Ord k, MonoidNull v, LeftReductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Maybe (MonoidMap k v)-stripPrefix = mergeA MergeStrategy-    { withNonNullL =-        withNonNullA (\v -> C.stripPrefix v mempty)--    , withNonNullR =-        keepNonNull-        -- Justification:-        ---        -- stripPrefix mempty a ≡ a--    , withNonNullP =-        withBothA C.stripPrefix-    }-{-# INLINE stripPrefix #-}---- | Strips a /suffix/ from a 'MonoidMap'.------ If map __@m1@__ is a /suffix/ of map __@m2@__, then 'stripSuffix' __@m1@__--- __@m2@__ will produce a /reduced/ map where suffix __@m1@__ is /stripped/--- from __@m2@__.------ === Properties------ The 'stripSuffix' function, when applied to maps __@m1@__ and __@m2@__,--- produces a result if (and only if) __@m1@__ is a suffix of __@m2@__:------ @--- 'isJust' ('stripSuffix' m1 m2) '==' m1 '`isSuffixOf`' m2--- @------ The value for any key __@k@__ in the result is /identical/ to the result of--- stripping the value for __@k@__ in map __@m1@__ from the value for __@k@__--- in map __@m2@__:------ @--- 'all'---    (\\r -> 'Just' ('get' k r) '==' 'C.stripSuffix' ('get' k m1) ('get' k m2))---    ('stripSuffix' m1 m2)--- @------ If we append suffix __@m1@__ to the /right-hand/ side of the result, we can--- always recover the original map __@m2@__:------ @--- 'all'---    (\\r -> r '<>' m1 '==' m2)---    ('stripSuffix' m1 m2)--- @------ This function provides the definition of 'C.stripSuffix' for the 'MonoidMap'--- instance of 'RightReductive'.------ === __Examples__------ With 'String' values:------ @--- >>> __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, ""   )]--- @--- @--- >>> 'stripSuffix' __m1__ __m2__ '==' 'Just' __m3__--- 'True'--- @--- @--- >>> 'stripSuffix' __m2__ __m1__ '==' 'Nothing'--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> __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)]--- @--- @--- >>> 'stripSuffix' __m1__ __m2__ '==' 'Just' __m3__--- 'True'--- @--- @--- >>> 'stripSuffix' __m2__ __m1__ '==' 'Nothing'--- 'True'--- @----stripSuffix-    :: (Ord k, MonoidNull v, RightReductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Maybe (MonoidMap k v)-stripSuffix = mergeA MergeStrategy-    { withNonNullL =-        withNonNullA (\v -> C.stripSuffix v mempty)--    , withNonNullR =-        keepNonNull-        -- Justification:-        ---        -- stripSuffix mempty a ≡ a--    , withNonNullP =-        withBothA C.stripSuffix-    }-{-# INLINE stripSuffix #-}---- | Finds the /greatest common prefix/ of two maps.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('commonPrefix' m1 m2)---     '==' 'C.commonPrefix' ('get' k m1) ('get' k m2)--- @------ This function provides the definition of 'C.commonPrefix' for the--- 'MonoidMap' instance of 'LeftGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> __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")]--- @--- @--- >>> 'commonPrefix' __m1__ __m2__ '==' __m3__--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> __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)]--- @--- @--- >>> 'commonPrefix' __m1__ __m2__ '==' __m3__--- 'True'--- @----commonPrefix-    :: (Ord k, MonoidNull v, LeftGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-commonPrefix = merge MergeStrategy-    { withNonNullL =-        keepNull-        -- Justification:-        ---        -- commonPrefix a mempty ≡ mempty--    , withNonNullR =-        keepNull-        -- Justification:-        ---        -- commonPrefix mempty a ≡ mempty--    , withNonNullP =-        withBoth C.commonPrefix-    }-{-# INLINE commonPrefix #-}---- | Finds the /greatest common suffix/ of two maps.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('commonSuffix' m1 m2)---     '==' 'C.commonSuffix' ('get' k m1) ('get' k m2)--- @------ This function provides the definition of 'C.commonSuffix' for the--- 'MonoidMap' instance of 'RightGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> __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")]--- @--- @--- >>> 'commonSuffix' __m1__ __m2__ '==' __m3__--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> __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)]--- @--- @--- >>> 'commonSuffix' __m1__ __m2__ '==' __m3__--- 'True'--- @----commonSuffix-    :: (Ord k, MonoidNull v, RightGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-commonSuffix = merge MergeStrategy-    { withNonNullL =-        keepNull-        -- Justification:-        ---        -- commonSuffix a mempty ≡ mempty--    , withNonNullR =-        keepNull-        -- Justification:-        ---        -- commonSuffix mempty a ≡ mempty--    , withNonNullP =-        withBoth C.commonSuffix-    }-{-# INLINE commonSuffix #-}---- | Strips the /greatest common prefix/ from a pair of maps.------ Given two maps __@m1@__ and __@m2@__, 'stripCommonPrefix' produces a--- tuple __@(p, r1, r2)@__, where:------  - __@p@__ is the /greatest common prefix/ of __@m1@__ and __@m2@__---  - __@r1@__ is the /remainder/ of stripping prefix __@p@__ from __@m1@__---  - __@r2@__ is the /remainder/ of stripping prefix __@p@__ from __@m2@__------ The resulting prefix __@p@__ can be appended to the /left-hand/ side of--- either remainder __@r1@__ or __@r2@__ to /reproduce/ either of the original--- maps __@m1@__ or __@m2@__ respectively:------ @--- 'stripCommonPrefix' m1 m2---    '&' \\(p, r1, _) -> p '<>' r1 '==' m1--- 'stripCommonPrefix' m1 m2---    '&' \\(p, _, r2) -> p '<>' r2 '==' m2--- @------ Prefix __@p@__ is /identical/ to the result of applying 'commonPrefix' to--- __@m1@__ and __@m2@__:------ @--- 'stripCommonPrefix' m1 m2---    '&' \\(p, _, _) -> p '==' 'commonPrefix' m1 m2--- @------ Remainders __@r1@__ and __@r2@__ are /identical/ to the results of applying--- 'stripPrefix' to __@p@__ and __@m1@__ or to __@p@__ and __@m2@__--- respectively:------ @--- 'stripCommonPrefix' m1 m2---    '&' \\(p, r1, _) -> 'Just' r1 '==' 'stripPrefix' p m1--- 'stripCommonPrefix' m1 m2---    '&' \\(p, _, r2) -> 'Just' r2 '==' 'stripPrefix' p m2--- @------ This function provides the definition of 'C.stripCommonPrefix' for the--- 'MonoidMap' instance of 'LeftGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> 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,    "")]--- @--- @--- >>> 'stripCommonPrefix' m1 m2 '==' (p, r1, r2)--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values:------ @--- >>> 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)]--- @--- @--- >>> 'stripCommonPrefix' m1 m2 '==' (p, r1, r2)--- 'True'--- @----stripCommonPrefix-    :: (Ord k, MonoidNull v, LeftGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)-stripCommonPrefix = C.stripCommonPrefix---- | Strips the /greatest common suffix/ from a pair of maps.------ Given two maps __@m1@__ and __@m2@__, 'stripCommonSuffix' produces a--- tuple __@(r1, r2, s)@__, where:------  - __@s@__ is the /greatest common suffix/ of __@m1@__ and __@m2@__---  - __@r1@__ is the /remainder/ of stripping suffix __@s@__ from __@m1@__---  - __@r2@__ is the /remainder/ of stripping suffix __@s@__ from __@m2@__------ The resulting suffix __@s@__ can be appended to the /right-hand/ side of--- either remainder __@r1@__ or __@r2@__ to /reproduce/ either of the original--- maps __@m1@__ or __@m2@__ respectively:------ @--- 'stripCommonSuffix' m1 m2---    '&' \\(r1, _, s) -> r1 '<>' s '==' m1--- 'stripCommonSuffix' m1 m2---    '&' \\(_, r2, s) -> r2 '<>' s '==' m2--- @------ Suffix __@s@__ is /identical/ to the result of applying 'commonSuffix' to--- __@m1@__ and __@m2@__:------ @--- 'stripCommonSuffix' m1 m2---    '&' \\(_, _, s) -> s '==' 'commonSuffix' m1 m2--- @------ Remainders __@r1@__ and __@r2@__ are /identical/ to the results of applying--- 'stripSuffix' to __@s@__ and __@m1@__ or to __@s@__ and __@m2@__--- respectively:------ @--- 'stripCommonSuffix' m1 m2---    '&' \\(r1, _, s) -> 'Just' r1 '==' 'stripSuffix' s m1--- 'stripCommonSuffix' m1 m2---    '&' \\(_, r2, s) -> 'Just' r2 '==' 'stripSuffix' s m2--- @------ This function provides the definition of 'C.stripCommonSuffix' for the--- 'MonoidMap' instance of 'RightGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> 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")]--- @--- @--- >>> 'stripCommonSuffix' m1 m2 '==' (r1, r2, s)--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values:------ @--- >>> 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)]--- @--- @--- >>> 'stripCommonSuffix' m1 m2 '==' (r1, r2, s)--- 'True'--- @----stripCommonSuffix-    :: (Ord k, MonoidNull v, RightGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)-stripCommonSuffix = C.stripCommonSuffix------------------------------------------------------------------------------------- Overlap------------------------------------------------------------------------------------- | Finds the /greatest overlap/ of two maps.------ The /greatest overlap/ __@o@__ of maps __@m1@__ and __@m2@__ is the /unique/--- greatest map that is both a /suffix/ of __@m1@__ and a /prefix/ of __@m2@__:------ @--- m1 '==' r1 '<>' o \  \--- m2 '=='    \  \ o '<>' r2--- @------ Where:------  - __@r1@__ is the /remainder/ obtained by stripping /suffix overlap/---    __@o@__ from __@m1@__.------      (see 'stripSuffixOverlap')------  - __@r2@__ is the /remainder/ obtained by stripping /prefix overlap/---    __@o@__ from __@m2@__.------      (see 'stripPrefixOverlap')------ This function satisfies the following property:------ @--- 'get' k ('overlap' m1 m2) '==' 'C.overlap' ('get' k m1) ('get' k m2)--- @------ This function provides the definition of 'C.overlap' for the 'MonoidMap'--- instance of 'OverlappingGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> 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")]--- @--- @--- >>> 'overlap' m1 m2 '==' m3--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> 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)]--- @--- @--- >>> 'overlap' m1 m2 '==' m3--- 'True'--- @----overlap-    :: (Ord k, MonoidNull v, OverlappingGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-overlap = merge MergeStrategy-    { withNonNullL =-        keepNull-        -- Justification:-        ---        -- overlap a mempty ≡ mempty--    , withNonNullR =-        keepNull-        -- Justification:-        ---        -- overlap mempty a ≡ mempty--    , withNonNullP =-        withBoth C.overlap-    }-{-# INLINE overlap #-}---- | /Strips/ from the second map its /greatest prefix overlap/ with suffixes---   of the first map.------ Evaluating 'stripPrefixOverlap' __@m1@__ __@m2@__ produces the /remainder/--- __@r2@__:------ @--- m1 '==' r1 '<>' o \  \--- m2 '=='    \  \ o '<>' r2--- @------ Where __@o@__ is the /greatest overlap/ of maps __@m1@__ and __@m2@__: the--- /unique/ greatest map that is both a /suffix/ of __@m1@__ and a /prefix/ of--- __@m2@__.------ This function satisfies the following property:------ @--- 'get' k ('stripPrefixOverlap' m1 m2)---     '==' 'C.stripPrefixOverlap' ('get' k m1) ('get' k m2)--- @------ This function provides the definition of 'C.stripPrefixOverlap' for the--- 'MonoidMap' instance of 'OverlappingGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> 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,      "")]--- @--- @--- >>> 'stripPrefixOverlap' m1 m2 '==' m3--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> 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)]--- @--- @--- >>> 'stripPrefixOverlap' m1 m2 '==' m3--- 'True'--- @----stripPrefixOverlap-    :: (Ord k, MonoidNull v, OverlappingGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-stripPrefixOverlap = merge MergeStrategy-    { withNonNullL =-        keepNull-        -- Justification:-        ---        -- overlap a b      <> stripPrefixOverlap a b      ≡ b-        -- overlap a mempty <> stripPrefixOverlap a mempty ≡ mempty-        --           mempty <> stripPrefixOverlap a mempty ≡ mempty-        --                     stripPrefixOverlap a mempty ≡ mempty--    , withNonNullR =-        keepNonNull-        -- Justification:-        ---        -- overlap a      b <> stripPrefixOverlap a      b ≡ b-        -- overlap mempty b <> stripPrefixOverlap mempty b ≡ b-        --         mempty   <> stripPrefixOverlap mempty b ≡ b-        --                     stripPrefixOverlap mempty b ≡ b--    , withNonNullP =-        withBoth C.stripPrefixOverlap-    }-{-# INLINE stripPrefixOverlap #-}---- | /Strips/ from the second map its /greatest suffix overlap/ with prefixes---   of the first map.------ Evaluating 'stripSuffixOverlap' __@m2@__ __@m1@__ produces the /remainder/--- __@r1@__:------ @--- m1 '==' r1 '<>' o \  \--- m2 '=='    \  \ o '<>' r2--- @------ Where __@o@__ is the /greatest overlap/ of maps __@m1@__ and __@m2@__: the--- /unique/ greatest map that is both a /suffix/ of __@m1@__ and a /prefix/ of--- __@m2@__.------ This function satisfies the following property:------ @--- 'get' k ('stripSuffixOverlap' m2 m1)---     '==' 'C.stripSuffixOverlap' ('get' k m2) ('get' k m1)--- @------ This function provides the definition of 'C.stripSuffixOverlap' for the--- 'MonoidMap' instance of 'OverlappingGCDMonoid'.------ === __Examples__------ With 'String' values:------ @--- >>> 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,""      )]--- @--- @--- >>> 'stripSuffixOverlap' m2 m1 '==' m3--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural' values:------ @--- >>> 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)]--- @--- @--- >>> 'stripSuffixOverlap' m2 m1 '==' m3--- 'True'--- @----stripSuffixOverlap-    :: (Ord k, MonoidNull v, OverlappingGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-stripSuffixOverlap = merge MergeStrategy-    { withNonNullL =-        keepNull-        -- Justification:-        ---        -- stripSuffixOverlap b a      <> overlap a      b ≡ a-        -- stripSuffixOverlap b mempty <> overlap mempty b ≡ mempty-        -- stripSuffixOverlap b mempty <>         mempty   ≡ mempty-        -- stripSuffixOverlap b mempty                     ≡ mempty--    , withNonNullR =-        keepNonNull-        -- Justification:-        ---        -- stripSuffixOverlap b      a <> overlap a b      ≡ a-        -- stripSuffixOverlap mempty a <> overlap a mempty ≡ a-        -- stripSuffixOverlap mempty a <>           mempty ≡ a-        -- stripSuffixOverlap mempty a                     ≡ a--    , withNonNullP =-        withBoth C.stripSuffixOverlap-    }-{-# INLINE stripSuffixOverlap #-}---- | Finds the /greatest overlap/ of two maps and /strips/ it from both maps.------ Evaluating 'stripOverlap' __@m1@__ __@m2@__ produces the tuple--- __@(r1, o, r2)@__, where:------ @--- m1 '==' r1 '<>' o \  \--- m2 '=='    \  \ o '<>' r2--- @------ Where:------  - __@o@__ is the /greatest overlap/ of maps __@m1@__ and __@m2@__: the---    /unique/ greatest map that is both a /suffix/ of __@m1@__ and a /prefix/---    of __@m2@__.------      (see 'overlap')------  - __@r1@__ is the /remainder/ obtained by stripping /suffix overlap/---    __@o@__ from __@m1@__.------      (see 'stripSuffixOverlap')------  - __@r2@__ is the /remainder/ obtained by stripping /prefix overlap/---    __@o@__ from __@m2@__.------      (see 'stripPrefixOverlap')------ This function satisfies the following property:------ @--- 'stripOverlap' m1 m2 '=='---    ( 'stripSuffixOverlap' m2 m1---    , 'overlap' m1 m2---    , 'stripPrefixOverlap' m1 m2---    )--- @------ This function provides the definition of 'C.stripOverlap' for the--- 'MonoidMap' instance of 'OverlappingGCDMonoid'.----stripOverlap-    :: (Ord k, MonoidNull v, OverlappingGCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> (MonoidMap k v, MonoidMap k v, MonoidMap k v)-stripOverlap m1 m2 =-    ( stripSuffixOverlap m2 m1-    , m1 `overlap` m2-    , stripPrefixOverlap m1 m2-    )------------------------------------------------------------------------------------- Intersection------------------------------------------------------------------------------------- | Finds the /intersection/ of two maps.------ The intersection of maps __@m1@__ and __@m2@__ is the greatest single map--- __@m@__ that is a /submap/ of both __@m1@__ /and/ __@m2@__:------ @--- 'intersection' m1 m2 '`isSubmapOf`' m1--- 'intersection' m1 m2 '`isSubmapOf`' m2--- @------ The intersection is /unique/:------ @--- 'and'---     [ 'intersection' m1 m2 '`isSubmapOf`' m---     , \            \       \            \ m '`isSubmapOf`' m1---     , \            \       \            \ m '`isSubmapOf`' m2---     ]--- ==>---     (m '==' 'intersection' m1 m2)--- @------ The following property holds for all possible keys __@k@__:------ @--- 'get' k ('intersection' m1 m2) '==' 'C.gcd' ('get' k m1) ('get' k m2)--- @------ This function provides the definition of 'C.gcd' for the 'MonoidMap'--- instance of 'GCDMonoid'.------ === __Examples__------ With 'Data.Monoid.Product' 'Numeric.Natural.Natural' values, 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)]--- @--- @--- >>> 'intersection' m1 m2 '==' m3--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values, 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)]--- @--- @--- >>> 'intersection' m1 m2 '==' m3--- 'True'--- @------ With 'Set' 'Numeric.Natural.Natural' values, this function computes the--- /set/ /intersection/ of each pair of matching values:------ @--- f xs = 'fromList' ('Set.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    ])]--- @--- @--- >>> 'intersection' m1 m2 '==' m3--- 'True'--- @----intersection-    :: (Ord k, MonoidNull v, GCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-intersection = merge MergeStrategy-    { withNonNullL =-        keepNull-        -- Justification:-        ---        -- gcd a mempty ≡ mempty--    , withNonNullR =-        keepNull-        -- Justification:-        ---        -- gcd mempty b ≡ mempty--    , withNonNullP =-        withBoth C.gcd-    }-{-# INLINE intersection #-}------------------------------------------------------------------------------------- Union------------------------------------------------------------------------------------- | Finds the /union/ of two maps.------ The union of maps __@m1@__ and __@m2@__ is the smallest single map __@m@__--- that includes both __@m1@__ /and/ __@m2@__ as /submaps/:------ @--- m1 '`isSubmapOf`' 'union' m1 m2--- m2 '`isSubmapOf`' 'union' m1 m2--- @------ The union is /unique/:------ @--- 'and'---     [ m1 '`isSubmapOf`' m---     , m2 '`isSubmapOf`' m---     ,    \            \ m '`isSubmapOf`' 'union' m1 m2---     ]--- ==>---     (m '==' 'union' m1 m2)--- @------ The following property holds for all possible keys __@k@__:------ @--- 'get' k ('union' m1 m2) '==' 'C.lcm' ('get' k m1) ('get' k m2)--- @------ This function provides the definition of 'C.lcm' for the 'MonoidMap'--- instance of 'LCMMonoid'.------ === __Examples__------ With 'Data.Monoid.Product' 'Numeric.Natural.Natural' values, 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)]--- @--- @--- >>> 'union' m1 m2 '==' m3--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values, 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)]--- @--- @--- >>> 'union' m1 m2 '==' m3--- 'True'--- @------ With 'Set' 'Numeric.Natural.Natural' values, this function computes the--- /set/ /union/ of each pair of matching values:------ @--- f xs = 'fromList' ('Set.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])]--- @--- @--- >>> 'union' m1 m2 '==' m3--- 'True'--- @----union-    :: (Ord k, MonoidNull v, LCMMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-union = merge MergeStrategy-    { withNonNullL =-        keepNonNull-        -- Justification:-        ---        -- lcm a mempty ≡ a--    , withNonNullR =-        keepNonNull-        -- Justification:-        ---        -- lcm mempty a ≡ a--    , withNonNullP =-        withBoth C.lcm-    }-{-# INLINE union #-}------------------------------------------------------------------------------------- Subtraction------------------------------------------------------------------------------------- | Performs /group subtraction/ of the second map from the first.------ Uses the 'Group' subtraction operator '(C.~~)' 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@__:------ @--- 'get' k (m1 '`minus`' m2) '==' 'get' k m1 'C.~~' 'get' k m2--- @------ This function provides the definition of '(C.~~)' for the 'MonoidMap'--- instance of 'Group'.------ === __Examples__------ With 'Data.Monoid.Sum' 'Integer' values, 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 = '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'--- @----minus-    :: (Ord k, MonoidNull v, Group v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-minus = merge MergeStrategy-    { withNonNullL =-        keepNonNull-        -- Justification:-        ---        -- a ~~ mempty ≡ a--    , withNonNullR =-        withNonNull C.invert-        -- Justification:-        ---        -- a      ~~ b ≡ a      <> invert b-        -- mempty ~~ b ≡ mempty <> invert b-        -- mempty ~~ b ≡           invert b--    , withNonNullP =-        withBoth (C.~~)-    }-{-# INLINE minus #-}---- | Performs /reductive subtraction/ of the second map from the first.------ Uses the 'Reductive' subtraction 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 for __@k@__ in the second map--- from the value for __@k@__ in the first map:------ @--- 'isJust' (m1 '`minusMaybe`' m2)---     '==' (∀ k. 'isJust' ('get' k m1 '</>' 'get' k m2))--- @------ Otherwise, this function returns 'Nothing'.------ This function satisfies the following property:------ @--- 'all'---    (\\r -> 'Just' ('get' k r) '==' 'get' k m1 '</>' 'get' k m2)---    (m1 '`minusMaybe`' m2)--- @------ This function provides the definition of '(</>)' for the 'MonoidMap'--- instance of 'Reductive'.------ === __Examples__------ With 'Set' 'Numeric.Natural.Natural' values, 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' ('Set.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 '==' 'Just' 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 '`minusMaybe`' m2 '==' 'Just' 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])]--- @--- @--- >>> m1 '`minusMaybe`' m2 '==' 'Nothing'--- 'True'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values, 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 '==' 'Just' m3--- '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 '==' 'Just' m3--- '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 '==' 'Just' m3--- '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'--- @----minusMaybe-    :: (Ord k, MonoidNull v, Reductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Maybe (MonoidMap k v)-minusMaybe = mergeA MergeStrategy-    { withNonNullL =-        keepNonNull-        -- Justification:-        ---        -- According to laws for Reductive:-        -- maybe a (b      <>) (a </> b     ) ≡       a-        -- maybe a (mempty <>) (a </> mempty) ≡       a-        -- maybe a (id       ) (a </> mempty) ≡       a-        --                     (a </> mempty) ∈ {Just a, Nothing}-        ---        -- According to laws for LeftReductive and RightReductive:-        -- isJust (a </> b     ) ≡ b      `isPrefixOf` a ≡ b      `isSuffixOf` a-        -- isJust (a </> mempty) ≡ mempty `isPrefixOf` a ≡ mempty `isSuffixOf` a-        ---        -- According to laws for LeftReductive and RightReductive:-        -- b      `isPrefixOf` (b      <> a)-        -- mempty `isPrefixOf` (mempty <> a)-        -- mempty `isPrefixOf`            a-        ---        -- Therefore:-        -- a </> mempty ≡ Just a--    , withNonNullR =-        withNonNullA (\v -> mempty </> v)--    , withNonNullP =-        withBothA (</>)-    }-{-# INLINE minusMaybe #-}---- | Performs /monus subtraction/ of the second map from the first.------ Uses the 'Monus' subtraction 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@__:------ @--- 'get' k (m1 '`monus`' m2) '==' 'get' k m1 '<\>' 'get' k m2--- @------ This function provides the definition of '(<\>)' for the 'MonoidMap'--- instance of 'Monus'.------ === __Examples__------ With 'Set' 'Numeric.Natural.Natural' values, this function performs /set/--- /subtraction/ of matching values:------ @--- f xs = 'fromList' ('Set.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 = 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 = 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'--- @------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values, 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 = '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 = '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 = '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'--- @----monus-    :: (Ord k, MonoidNull v, Monus v)-    => MonoidMap k v-    -> MonoidMap k v-    -> MonoidMap k v-monus = merge MergeStrategy-    { withNonNullL =-        keepNonNull-        -- Justification:-        ---        -- a      <> (b <\> a     ) ≡ b <> (a      <\> b)-        -- mempty <> (b <\> mempty) ≡ b <> (mempty <\> a)-        --            b <\> mempty  ≡ b <> (mempty <\> a)-        --            b <\> mempty  ≡ b <>  mempty-        --            b <\> mempty  ≡ b--    , withNonNullR =-        keepNull-        -- Justification:-        ---        -- mempty <\> a ≡ mempty--    , withNonNullP =-        withBoth (<\>)-    }-{-# INLINE monus #-}------------------------------------------------------------------------------------- Inversion------------------------------------------------------------------------------------- | Inverts every value in a map.------ Applies the 'Group' method 'C.invert' to every value in a map.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k ('invert' m) '==' 'C.invert' ('get' k m)--- @------ This function provides the definition of 'C.invert' for the 'MonoidMap'--- instance of 'Group'.------ === __Examples__------ With 'Data.Monoid.Sum' 'Integer' values, this function performs negation--- of values:------ @--- >>> m1 = 'fromList' [("a", (-1)), ("b", 0), ("c",   1) ]--- >>> m2 = 'fromList' [("a",   1 ), ("b", 0), ("c", (-1))]--- @--- @--- >>> 'negate' m1 '==' m2--- 'True'--- @----invert-    :: (MonoidNull v, Group v)-    => MonoidMap k v-    -> MonoidMap k v-invert = map C.invert-{-# INLINE invert #-}------------------------------------------------------------------------------------- Exponentiation------------------------------------------------------------------------------------- | Performs exponentiation of every value in a map.------ Uses the 'Group' exponentiation method 'C.pow' to raise every value in a map--- to the power of the given exponent.------ Satisfies the following property for all possible keys __@k@__:------ @--- 'get' k (m '`power`' i) '==' 'get' k m '`C.pow`' i--- @------ This function provides the definition of 'C.pow' for the 'MonoidMap'--- instance of 'Group'.------ === __Examples__------ With 'Data.Monoid.Sum' 'Numeric.Natural.Natural' values, 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 = 'fromList' [("a", 0), ("b",   1 ), ("c",   2 ), ("d",   3 )]--- >>> m2 = 'fromList' [("a", 0), ("b", (-1)), ("c", (-2)), ("d", (-3))]--- @--- @--- >>> m1 '`power`' (-1) '==' m2--- 'True'--- @----power-    :: (Integral i, MonoidNull v, Group v)-    => MonoidMap k v-    -> i-    -> MonoidMap k v-power m i = map (`C.pow` i) m-{-# INLINE power #-}------------------------------------------------------------------------------------- Intersection------------------------------------------------------------------------------------- | 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@__:------ @--- 'get' k ('intersectionWith' f m1 m2) '=='---     if k '`Set.member`'---         'Set.intersection'---             ('nonNullKeys' m1)---             ('nonNullKeys' m2)---     then f ('get' k m1) ('get' k m2)---     else 'mempty'--- @------ === Conditional totality------ /If/ the given combining function __@f@__ /always/ produces 'mempty' when--- /either/ or /both/ of its arguments are 'mempty':------ @--- (f v      'mempty' '==' 'mempty') '&&'--- (f 'mempty' v      '==' 'mempty')--- @------ /Then/ the following property holds for all possible keys __@k@__:------ @--- 'get' k ('intersectionWith' f m1 m2) '==' f ('get' k m1) ('get' k m2)--- @------ === __Examples__------ With the 'Prelude.min' function applied to 'Data.Monoid.Sum'--- 'Numeric.Natural.Natural' values:------ @--- >>> m1 = 'fromList' [("a", 4), ("b", 3), ("c", 2), ("d", 1)          ]--- >>> m2 = 'fromList' [          ("b", 1), ("c", 2), ("d", 3), ("e", 4)]--- >>> m3 = 'fromList' [          ("b", 1), ("c", 2), ("d", 1)          ]--- @--- @--- >>> 'intersectionWith' 'Prelude.min' m1 m2 '==' m3--- 'True'--- @----intersectionWith-    :: (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-intersectionWith f = merge MergeStrategy-    { withNonNullL =-        keepNull-    , withNonNullR =-        keepNull-    , withNonNullP =-        withBoth f-    }-{-# INLINE intersectionWith #-}---- | An /applicative/ version of 'intersectionWith'.------ Satisfies the following property:------ @--- 'runIdentity' ('intersectionWithA' (('fmap' . 'fmap') 'Identity' f) m1 m2)---          '==' ('intersectionWith'    \    \   \    \  \        \ f  m1 m2)--- @----intersectionWithA-    :: (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)-intersectionWithA f = mergeA MergeStrategy-    { withNonNullL =-        keepNull-    , withNonNullR =-        keepNull-    , withNonNullP =-        withBothA f-    }-{-# INLINE intersectionWithA #-}------------------------------------------------------------------------------------- Union------------------------------------------------------------------------------------- | 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@__:------ @--- 'get' k ('unionWith' f m1 m2) '=='---     if k '`Set.member`'---         'Set.union'---             ('nonNullKeys' m1)---             ('nonNullKeys' m2)---     then f ('get' k m1) ('get' k m2)---     else 'mempty'--- @------ === Conditional totality------ /If/ the given combining function __@f@__ /always/ produces 'mempty' when--- /both/ of its arguments are 'mempty':------ @--- f 'mempty' 'mempty' '==' 'mempty'--- @------ /Then/ the following property holds for all possible keys __@k@__:------ @--- 'get' k ('unionWith' f m1 m2) '==' f ('get' k m1) ('get' k m2)--- @------ === __Examples__------ With the 'Prelude.max' function applied to 'Data.Monoid.Sum'--- 'Numeric.Natural.Natural' values:------ @--- >>> m1 = 'fromList' [("a", 4), ("b", 3), ("c", 2), ("d", 1)          ]--- >>> m2 = 'fromList' [          ("b", 1), ("c", 2), ("d", 3), ("e", 4)]--- >>> m3 = 'fromList' [("a", 4), ("b", 3), ("c", 2), ("d", 3), ("e", 4)]--- @--- @--- >>> 'unionWith' 'Prelude.max' m1 m2 '==' m3--- 'True'--- @----unionWith-    :: (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-unionWith f = merge MergeStrategy-    { withNonNullL =-        withNonNull (\v -> f v mempty)-    , withNonNullR =-        withNonNull (\v -> f mempty v)-    , withNonNullP =-        withBoth f-    }-{-# INLINE unionWith #-}---- | An /applicative/ version of 'unionWith'.------ Satisfies the following property:------ @--- 'runIdentity' ('unionWithA' (('fmap' . 'fmap') 'Identity' f) m1 m2)---          '==' ('unionWith'    \    \   \    \  \        \ f  m1 m2)--- @----unionWithA-    :: (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)-unionWithA f = mergeA MergeStrategy-    { withNonNullL =-        withNonNullA (\v -> f v mempty)-    , withNonNullR =-        withNonNullA (\v -> f mempty v)-    , withNonNullP =-        withBothA f-    }-{-# INLINE unionWithA #-}------------------------------------------------------------------------------------- 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-    -> 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-{-# INLINE merge #-}--mergeA-    :: (Applicative f, Ord k)-    => MergeStrategy 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-{-# 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 -> maybeNonNull $ applyNonNull f v-{-# INLINE withNonNull #-}--withNonNullA-    :: (Applicative f, MonoidNull v2)-    => (v1 -> f v2)-    -> WhenOneSideNull f k v1 v2-withNonNullA f-    = Map.traverseMaybeMissing-    $ \_k v -> maybeNonNull <$> applyNonNull 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 -> maybeNonNull $ applyNonNull2 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 -> maybeNonNull <$> applyNonNull2 f v1 v2-{-# INLINE withBothA #-}------------------------------------------------------------------------------------- State-----------------------------------------------------------------------------------newtype StateL s a = StateL (s -> (s, a))-newtype StateR s a = StateR (s -> (s, a))--instance Functor (StateL s) where-    fmap f (StateL kx) =-        StateL $ \s -> let (s', x) = kx s in (s', f x)--instance Functor (StateR s) where-    fmap f (StateR kx) =-        StateR $ \s -> let (s', x) = kx s in (s', f x)--instance Applicative (StateL s) where-    pure a = StateL $-        \s -> (s, a)-    StateL kf <*> StateL kx = StateL $-        \s ->-            let (s' , f  ) = kf s-                (s'',   x) = kx s'-            in  (s'', f x)-    liftA2 f (StateL kx) (StateL ky) = StateL $-        \s ->-            let (s' ,   x  ) = kx s-                (s'',     y) = ky s'-            in  (s'', f x y)--instance Applicative (StateR s) where-    pure a = StateR $-        \s -> (s, a)-    StateR kf <*> StateR kx = StateR $-        \s ->-            let (s',    x) = kx s-                (s'', f  ) = kf s'-            in  (s'', f x)-    liftA2 f (StateR kx) (StateR ky) = StateR $-        \s ->-            let (s' ,     y) = ky s-                (s'',   x  ) = kx s'-            in  (s'', f x y)+{- HLINT ignore "Avoid lambda" -}+{- HLINT ignore "Avoid lambda using `infix`" -}+{- HLINT ignore "Redundant bracket" -}+{- HLINT ignore "Use camelCase" -}++-- |+-- Copyright: © 2022–2026 Jonathan Knowles+-- License: Apache-2.0+--+-- Provides /internal/ support for the @monoidmap@ package.+--+-- This module defines the 'NonNull' type of values that are not 'C.null',+-- and functions for constructing maps of 'NonNull' values from ordinary maps.+--+module Data.MonoidMap.Internal+    (+    -- * Types+      NonNull+    , NonNullMap (..)++    -- * Non-null values+    , maybeNonNull+    , applyNonNull+    , applyNonNull2++    -- * Non-null maps+    , fromNonNullMap++    -- * Construction+    , fromMap+    , fromMapWith++    -- ** Implementations+    , fromMap_filter+    , fromMap_filter_if_any_null+    , fromMap_mapMaybe+    , fromMapWith_mapMaybe+    , fromMapWith_map_filter+    , fromMapWith_map_filter_if_any_null+    )+    where++import Prelude++import Control.DeepSeq+    ( NFData )+import Data.Bifoldable+    ( Bifoldable )+import Data.Coerce+    ( coerce )+import Data.Functor.Classes+    ( Eq1, Eq2, Show1, Show2 )+import Data.Map.Strict+    ( Map )+import Data.Monoid.Null+    ( MonoidNull )+import NoThunks.Class+    ( NoThunks )++import qualified Data.Foldable as F+import qualified Data.Map.Strict as Map+import qualified Data.Monoid.Null as C++--------------------------------------------------------------------------------+-- Non-null values+--------------------------------------------------------------------------------++newtype NonNull v = UnsafeNonNull v+    deriving newtype NFData++-- Without an explicit type role annotation, the following role would be+-- inferred:+--+--     type role NonNull representational+--+-- However, the validity of a 'NonNull' value depends on a property of its+-- type: its 'mempty' value. A representational role would allow users to+-- coerce between types with the same representation but different 'mempty'+-- values, even without access to the 'NonNull' constructor.+--+-- For example, users could coerce a 'NonNull' ('Sum' 'Int') to a 'NonNull'+-- ('Product' 'Int'), and thereby construct a 'NonNull' value that is 'mempty'.+--+-- So we must instead choose a nominal role.+--+type role NonNull nominal++maybeNonNull :: MonoidNull v => v -> Maybe (NonNull v)+maybeNonNull !v+    | C.null  v = Nothing+    | otherwise = Just (UnsafeNonNull v)+{-# INLINE maybeNonNull #-}++applyNonNull :: (v -> a) -> (NonNull v -> a)+applyNonNull = coerce+{-# INLINE applyNonNull #-}++applyNonNull2 :: (v1 -> v2 -> a) -> (NonNull v1 -> NonNull v2 -> a)+applyNonNull2 = coerce+{-# INLINE applyNonNull2 #-}++fromNonNullMap :: Map k (NonNull v) -> Map k v+fromNonNullMap = coerce+{-# INLINE fromNonNullMap #-}++-- | /Unsafely/ converts an ordinary map into a map of non-null values.+--+-- This function /expects/ but does /not/ check that no value in the given map+-- is 'C.null'. It must only be applied to maps that satisfy this condition.+--+unsafeToNonNullMap :: Map k v -> Map k (NonNull v)+unsafeToNonNullMap = coerce+{-# INLINE unsafeToNonNullMap #-}++--------------------------------------------------------------------------------+-- Non-null maps+--------------------------------------------------------------------------------++-- A map of non-null values.+--+-- Types with the same representation as 'NonNullMap' (such as 'MonoidMap')+-- can derive their instances via this type, without needing access to the+-- constructor of 'NonNull'.+--+newtype NonNullMap k v = NonNullMap (Map k (NonNull v))+    deriving (Eq, Show, NFData, NoThunks) via Map k v+    deriving (Eq1, Show1, Foldable) via Map k+    deriving (Eq2, Show2, Bifoldable) via Map++-- Strictly speaking, this type role annotation is redundant, as:+--+-- - The type parameter 'k' already has a nominal role inherited from 'Map'.+-- - The type parameter 'v' already has a nominal role inherited from 'NonNull'.+--+-- But we reassert these roles here, so that they cannot be silently weakened+-- by a future change to the representation of 'NonNullMap'.+--+type role NonNullMap nominal nominal++--------------------------------------------------------------------------------+-- Construction+--------------------------------------------------------------------------------++-- | Constructs a map of non-null values from an ordinary 'Map', removing all+--   'C.null' values.+--+-- This function selects which of the @fromMap_*@ implementations below is used+-- by the public @fromMap@ function of the @monoidmap@ package.+--+fromMap :: MonoidNull v => Map k v -> Map k (NonNull v)+fromMap = fromMap_filter_if_any_null+{-# INLINE fromMap #-}++fromMap_filter :: MonoidNull v => Map k v -> Map k (NonNull v)+fromMap_filter = unsafeToNonNullMap . Map.filter (\(!v) -> not (C.null v))+{-# INLINABLE fromMap_filter #-}++fromMap_filter_if_any_null :: MonoidNull v => Map k v -> Map k (NonNull v)+fromMap_filter_if_any_null m+    | F.any (\(!v) -> C.null v) m =+        unsafeToNonNullMap $ Map.filter (\(!v) -> not (C.null v)) m+    | otherwise =+        unsafeToNonNullMap m+{-# INLINABLE fromMap_filter_if_any_null #-}++fromMap_mapMaybe :: MonoidNull v => Map k v -> Map k (NonNull v)+fromMap_mapMaybe = Map.mapMaybe maybeNonNull+{-# INLINABLE fromMap_mapMaybe #-}++-- | Constructs a map of non-null values from an ordinary 'Map', applying the+--   given function to all values, and removing all 'C.null' values.+--+-- This function selects which of the @fromMapWith_*@ implementations below is+-- used by the public @fromMapWith@ function of the @monoidmap@ package.+--+fromMapWith+    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> Map k (NonNull v2)+fromMapWith = fromMapWith_mapMaybe+{-# INLINE fromMapWith #-}++fromMapWith_mapMaybe+    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> Map k (NonNull v2)+fromMapWith_mapMaybe f = Map.mapMaybe (maybeNonNull . f)+{-# INLINABLE fromMapWith_mapMaybe #-}++fromMapWith_map_filter+    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> Map k (NonNull v2)+fromMapWith_map_filter f = fromMap_filter . Map.map f+{-# INLINABLE fromMapWith_map_filter #-}++fromMapWith_map_filter_if_any_null+    :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> Map k (NonNull v2)+fromMapWith_map_filter_if_any_null f = fromMap_filter_if_any_null . Map.map f+{-# INLINABLE fromMapWith_map_filter_if_any_null #-}

@@ -1,50 +0,0 @@-{-# OPTIONS_GHC -fno-warn-unused-imports #-}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0------ Provides /unsafe/ operations for the 'MonoidMap' type.----module Data.MonoidMap.Internal.Unsafe-    (-    -- * Construction-      unsafeFromMap-    )-    where--import Prelude--import Data.Coerce-    ( coerce )-import Data.Map.Strict-    ( Map )-import Data.MonoidMap.Internal-    ( MonoidMap (..), NonNull (..), fromMap )--import qualified Data.Foldable as F-import qualified Data.Monoid.Null as Null-import qualified Data.MonoidMap.Internal as Internal------------------------------------------------------------------------------------- Unsafe construction------------------------------------------------------------------------------------- | \(O(1)\). /Unsafely/ constructs a 'MonoidMap' from an ordinary 'Map'.------ Constructs a 'MonoidMap' in /constant time/, without imposing the burden--- of a canonicalisation step to remove 'null' values.------ When applied to a given 'Map' @m@, this function /expects/ but does /not/--- check the following pre-condition:------ @--- 'F.all' ('not' . 'Null.null') m--- @------ Not satisfying this pre-condition will result in undefined behaviour.------ See 'fromMap' for a safe version of this function.----unsafeFromMap :: Map k v -> MonoidMap k v-unsafeFromMap = coerce

@@ -1,172 +0,0 @@-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.AccessSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Function-    ( (&) )-import Data.MonoidMap.Internal-    ( MonoidMap )-import Data.Proxy-    ( Proxy (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesAll-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun, Property, applyFun, cover, (===) )--import qualified Data.Monoid.Null as Null-import qualified Data.MonoidMap.Internal as MonoidMap-import qualified Data.Set as Set--spec :: Spec-spec = describe "Accessors" $ do--    forM_ testValueTypesAll $-        \(TestValueType p) -> specFor (Proxy @Key) p--specFor :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specFor = makeSpec $ do--    describe "Get" $ do-        it "prop_get_nonNullKey" $-            prop_get_nonNullKey-                @k @v & property-        it "prop_get_nonNullKeys" $-            prop_get_nonNullKeys-                @k @v & property--    describe "Set" $ do-        it "prop_set_get" $-            prop_set_get-                @k @v & property-        it "prop_set_nonNullKey" $-            prop_set_nonNullKey-                @k @v & property-        it "prop_set_nonNullKeys" $-            prop_set_nonNullKeys-                @k @v & property-        it "prop_set_toList" $-            prop_set_toList-                @k @v & property--    describe "Adjust" $ do-        it "prop_adjust_get_set" $-            prop_adjust_get_set-                @k @v & property------------------------------------------------------------------------------------- Get-----------------------------------------------------------------------------------prop_get_nonNullKey-    :: Test k v => MonoidMap k v -> k -> Property-prop_get_nonNullKey m k =-    MonoidMap.nonNullKey k m === (MonoidMap.get k m /= mempty)-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"-    & cover 2-        (not (MonoidMap.nonNullKey k m))-        "not (MonoidMap.nonNullKey k m)"--prop_get_nonNullKeys-    :: Test k v => MonoidMap k v -> k -> Property-prop_get_nonNullKeys m k =-    Set.member k (MonoidMap.nonNullKeys m) === (MonoidMap.get k m /= mempty)-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"-    & cover 2-        (not (MonoidMap.nonNullKey k m))-        "not (MonoidMap.nonNullKey k m)"------------------------------------------------------------------------------------- Set-----------------------------------------------------------------------------------prop_set_get-    :: Test k v => MonoidMap k v -> k -> v -> Property-prop_set_get m k v =-    MonoidMap.get k (MonoidMap.set k v m) === v-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"-    & cover 2-        (not (MonoidMap.nonNullKey k m))-        "not (MonoidMap.nonNullKey k m)"--prop_set_nonNullKey-    :: Test k v => MonoidMap k v -> k -> v -> Property-prop_set_nonNullKey m k v =-    MonoidMap.nonNullKey k (MonoidMap.set k v m) ===-        (v /= mempty)-    & cover 2-        (v == mempty)-        "v == mempty"-    & cover 2-        (v /= mempty)-        "v /= mempty"--prop_set_nonNullKeys-    :: Test k v => MonoidMap k v -> k -> v -> Property-prop_set_nonNullKeys m k v =-    Set.member k (MonoidMap.nonNullKeys (MonoidMap.set k v m)) ===-        (v /= mempty)-    & cover 2-        (v == mempty)-        "v == mempty"-    & cover 2-        (v /= mempty)-        "v /= mempty"--prop_set_toList-    :: Test k v => MonoidMap k v -> k -> v -> Property-prop_set_toList m k v =-    filter ((== k) . fst) (MonoidMap.toList (MonoidMap.set k v m)) ===-        [(k, v) | v /= mempty]-    & cover 2-        (v == mempty)-        "v == mempty"-    & cover 2-        (v /= mempty)-        "v /= mempty"------------------------------------------------------------------------------------- Adjust-----------------------------------------------------------------------------------prop_adjust_get_set-    :: Test k v => MonoidMap k v -> Fun v v -> k -> Property-prop_adjust_get_set m (applyFun -> f) k =-    MonoidMap.adjust f k m === MonoidMap.set k (f (MonoidMap.get k m)) m-    & cover 1-        (MonoidMap.nullKey k m && Null.null (f mempty))-        "MonoidMap.nullKey k m && Null.null (f mempty)"-    & cover 1-        (MonoidMap.nullKey k m && not (Null.null (f mempty)))-        "MonoidMap.nullKey k m && not (Null.null (f mempty))"-    & cover 0.1-        (MonoidMap.nonNullKey k m && Null.null (f (MonoidMap.get k m)))-        "MonoidMap.nonNullKey k m && Null.null (f (MonoidMap.get k m))"-    & cover 0.1-        (MonoidMap.nonNullKey k m && not (Null.null (f (MonoidMap.get k m))))-        "MonoidMap.nonNullKey k m && not (Null.null (f (MonoidMap.get k m)))"

@@ -1,336 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.ClassSpec-    where--import Prelude--import Data.Monoid-    ( Product (..), Sum (..) )-import Data.MonoidMap.Internal-    ( MonoidMap )-import Data.Proxy-    ( Proxy (..) )-import Data.Set-    ( Set )-import Data.Typeable-    ( Typeable, typeRep )-import Numeric.Natural-    ( Natural )-import Test.Combinators.NonZero-    ( NonZero, genNonZero, shrinkNonZero )-import Test.Common ()-import Test.Hspec-    ( Spec, describe )-import Test.Key-    ( Key1, Key2, Key4, Key8 )-import Test.QuickCheck-    ( Arbitrary (..) )-import Test.QuickCheck.Classes-    ( eqLaws-    , isListLaws-    , monoidLaws-    , semigroupLaws-    , semigroupMonoidLaws-    , showReadLaws-    )-import Test.QuickCheck.Classes.Group-    ( groupLaws )-import Test.Hspec.QuickCheck.Classes-    ( testLaws )-import Test.QuickCheck.Classes.Monoid.GCD-    ( distributiveGCDMonoidLaws-    , gcdMonoidLaws-    , leftDistributiveGCDMonoidLaws-    , leftGCDMonoidLaws-    , overlappingGCDMonoidLaws-    , rightDistributiveGCDMonoidLaws-    , rightGCDMonoidLaws-    )-import Test.QuickCheck.Classes.Monoid.LCM-    ( distributiveLCMMonoidLaws, lcmMonoidLaws )-import Test.QuickCheck.Classes.Monoid.Monus-    ( monusLaws )-import Test.QuickCheck.Classes.Monoid.Null-    ( monoidNullLaws, positiveMonoidLaws )-import Test.QuickCheck.Classes.Semigroup.Cancellative-    ( cancellativeLaws-    , commutativeLaws-    , leftCancellativeLaws-    , leftReductiveLaws-    , reductiveLaws-    , rightCancellativeLaws-    , rightReductiveLaws-    )--spec :: Spec-spec = do-    describe "Class laws" $ do-        -- Test against a variety of key sizes:-        specLawsFor (Proxy @Key1)-        specLawsFor (Proxy @Key2)-        specLawsFor (Proxy @Key4)-        specLawsFor (Proxy @Key8)--specLawsFor-    :: forall k. () =>-        ( Arbitrary k-        , Ord k-        , Read k-        , Show k-        , Typeable k-        )-    => Proxy k-    -> Spec-specLawsFor keyType = do-    let description = "Class laws for key type " <> show (typeRep keyType)-    describe description $ do-        testLaws @(MonoidMap k String)-            [ eqLaws-            , isListLaws-            , leftCancellativeLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , rightCancellativeLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Product Integer))-            [ commutativeLaws-            , eqLaws-            , isListLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , reductiveLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Product Natural))-            [ commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        -- Here we restrict the generator and shrinker so that they can never-        -- produce zero values, to avoid running into cases of ArithException-        -- caused by operations that may produce zero demoninators:-        testLaws @(MonoidMap k (NonZero (Product Rational)))-            [ commutativeLaws-            , eqLaws-            , groupLaws-            , isListLaws-            , monoidLaws-            , monoidNullLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Sum Integer))-            [ cancellativeLaws-            , commutativeLaws-            , eqLaws-            , groupLaws-            , isListLaws-            , leftCancellativeLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , reductiveLaws-            , rightCancellativeLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Sum Natural))-            [ cancellativeLaws-            , commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftCancellativeLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightCancellativeLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Set ()))-            [ commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Set k))-            [ commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Set Ordering))-            [ commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (Set Int))-            [ commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]-        testLaws @(MonoidMap k (MonoidMap k (Sum Natural)))-            [ cancellativeLaws-            , commutativeLaws-            , distributiveGCDMonoidLaws-            , distributiveLCMMonoidLaws-            , eqLaws-            , gcdMonoidLaws-            , lcmMonoidLaws-            , isListLaws-            , leftCancellativeLaws-            , leftDistributiveGCDMonoidLaws-            , leftGCDMonoidLaws-            , leftReductiveLaws-            , monoidLaws-            , monoidNullLaws-            , monusLaws-            , overlappingGCDMonoidLaws-            , positiveMonoidLaws-            , reductiveLaws-            , rightCancellativeLaws-            , rightDistributiveGCDMonoidLaws-            , rightGCDMonoidLaws-            , rightReductiveLaws-            , semigroupLaws-            , semigroupMonoidLaws-            , showReadLaws-            ]------------------------------------------------------------------------------------- Arbitrary instances-----------------------------------------------------------------------------------instance (Arbitrary a, Eq a, Num a) => Arbitrary (NonZero a) where-    arbitrary = genNonZero arbitrary-    shrink = shrinkNonZero shrink

@@ -1,278 +0,0 @@-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.ComparisonSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Function-    ( (&) )-import Data.Maybe-    ( isJust )-import Data.Monoid.Cancellative-    ( Reductive (..) )-import Data.Monoid.GCD-    ( GCDMonoid )-import Data.MonoidMap.Internal-    ( MonoidMap )-import Data.Proxy-    ( Proxy (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesGCDMonoid-    , testValueTypesAll-    , testValueTypesReductive-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun (..), Property, applyFun2, cover, expectFailure, (.||.), (===) )--import qualified Data.Monoid.GCD as GCDMonoid-    ( GCDMonoid (..) )-import qualified Data.Monoid.Null as Null-    ( MonoidNull (..) )-import qualified Data.MonoidMap.Internal as MonoidMap-import qualified Data.Set as Set--spec :: Spec-spec = describe "Comparison" $ do--    forM_ testValueTypesGCDMonoid $-        \(TestValueType p) -> specGCDMonoid-            (Proxy @Key) p--    forM_ testValueTypesReductive $-        \(TestValueType p) -> specReductive-            (Proxy @Key) p--    forM_ testValueTypesAll $-        \(TestValueType p) -> specMonoidNull-            (Proxy @Key) p--specGCDMonoid-    :: forall k v. (Test k v, GCDMonoid v) => Proxy k -> Proxy v -> Spec-specGCDMonoid = makeSpec $ do-    it "prop_disjoint_gcd" $-        prop_disjoint_gcd-            @k @v & property-    it "prop_disjoint_intersection" $-        prop_disjoint_intersection-            @k @v & property--specReductive-    :: forall k v. (Test k v, Reductive v) => Proxy k -> Proxy v -> Spec-specReductive = makeSpec $ do-    it "prop_isSubmapOf_minusMaybe" $-        prop_isSubmapOf_minusMaybe-            @k @v & property-    it "prop_isSubmapOf_reduce" $-        prop_isSubmapOf_reduce-            @k @v & property--specMonoidNull-    :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specMonoidNull = makeSpec $ do-    it "prop_disjointBy_get_total" $-        prop_disjointBy_get_total-            @k @v & property-    it "prop_disjointBy_get_total_failure" $-        prop_disjointBy_get_total_failure-            @k @v & property-    it "prop_isSubmapOfBy_get_total" $-        prop_isSubmapOfBy_get_total-            @k @v & property-    it "prop_isSubmapOfBy_get_total_failure" $-        prop_isSubmapOfBy_get_total_failure-            @k @v & property--prop_disjoint_gcd-    :: (Test k v, GCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_disjoint_gcd m1 m2 k =-    MonoidMap.disjoint m1 m2 ==>-        (Null.null (GCDMonoid.gcd (MonoidMap.get k m1) (MonoidMap.get k m2)))-    & cover 8-        (MonoidMap.disjoint m1 m2)-        "MonoidMap.disjoint m1 m2"-    & cover 8-        (not (MonoidMap.disjoint m1 m2))-        "not (MonoidMap.disjoint m1 m2)"--prop_disjoint_intersection-    :: (Test k v, GCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Property-prop_disjoint_intersection m1 m2 =-    MonoidMap.disjoint m1 m2 === (MonoidMap.intersection m1 m2 == mempty)-    & cover 8-        (MonoidMap.disjoint m1 m2)-        "MonoidMap.disjoint m1 m2"-    & cover 8-        (not (MonoidMap.disjoint m1 m2))-        "not (MonoidMap.disjoint m1 m2)"--prop_disjointBy_get_total-    :: Test k v-    => Fun (v, v) Bool-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_disjointBy_get_total (applyFun2 -> f0) m1 m2 k =-    MonoidMap.disjointBy f m1 m2-        ==>-        f (MonoidMap.get k m1) (MonoidMap.get k m2)-    & cover 8-        (m1 /= mempty && m2 /= mempty && MonoidMap.disjointBy f m1 m2)-        "m1 /= mempty && m2 /= mempty && MonoidMap.disjointBy f m1 m2"-    & cover 2-        (keyWithinIntersection)-        "keyWithinIntersection"-    & cover 2-        (not keyWithinIntersection)-        "not keyWithinIntersection"-  where-    keyWithinIntersection =-        k `Set.member` Set.intersection-            (MonoidMap.nonNullKeys m1)-            (MonoidMap.nonNullKeys m2)-    f v1 v2-        | Null.null v1 = True-        | Null.null v2 = True-        | otherwise = f0 v1 v2--prop_disjointBy_get_total_failure-    :: Test k v-    => Fun (v, v) Bool-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_disjointBy_get_total_failure (applyFun2 -> f) m1 m2 k =-    expectFailure $-    MonoidMap.disjointBy f m1 m2-        ==>-        f (MonoidMap.get k m1) (MonoidMap.get k m2)--prop_isSubmapOf_minusMaybe-    :: (Test k v, Reductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Property-prop_isSubmapOf_minusMaybe m1 m2 =-    MonoidMap.isSubmapOf m1 m2-        ==> isJust (m2 `MonoidMap.minusMaybe` m1)-    & cover 0.01-        (nonTrivialSubmap)-        "nonTrivialSubmap"-  where-    nonTrivialSubmap =-        MonoidMap.isSubmapOf m1 m2-        && m1 /= mempty-        && m2 /= mempty-        && m1 /= m2--prop_isSubmapOf_reduce-    :: (Test k v, Reductive v)-    => MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_isSubmapOf_reduce m1 m2 k =-    MonoidMap.isSubmapOf m1 m2-        ==> isJust (MonoidMap.get k m2 </> MonoidMap.get k m1)-    & cover 0.001-        (nonTrivialSubmap && nonNullKeyL && nonNullKeyR)-        "nonTrivialSubmap && nonNullKeyL && nonNullKeyR"-    & cover 0.001-        (nonTrivialSubmap && nullKeyL && nonNullKeyR)-        "nonTrivialSubmap && nullKeyL && nonNullKeyR"-    & cover 0.001-        (nonTrivialSubmap && nullKeyL && nullKeyR)-        "nonTrivialSubmap && nullKeyL && nullKeyR"-  where-    nonTrivialSubmap =-        MonoidMap.isSubmapOf m1 m2-        && m1 /= mempty-        && m2 /= mempty-        && m1 /= m2-    nonNullKeyL = MonoidMap.nonNullKey k m1-    nonNullKeyR = MonoidMap.nonNullKey k m2-    nullKeyL = MonoidMap.nullKey k m1-    nullKeyR = MonoidMap.nullKey k m2--prop_isSubmapOfBy_get_total-    :: Test k v-    => Fun (v, v) Bool-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_isSubmapOfBy_get_total (applyFun2 -> f0) m1 m2 k =-    MonoidMap.isSubmapOfBy f m1 m2-        ==>-        f (MonoidMap.get k m1) (MonoidMap.get k m2)-    & cover 0.01-        (nonTrivialSubmap && nonNullKeyL && nonNullKeyR)-        "nonTrivialSubmap && nonNullKeyL && nonNullKeyR"-    & cover 0.1-        (nonTrivialSubmap && nullKeyL && nonNullKeyR)-        "nonTrivialSubmap && nullKeyL && nonNullKeyR"-    & cover 0.1-        (nonTrivialSubmap && nonNullKeyL && nullKeyR)-        "nonTrivialSubmap && nonNullKeyL && nullKeyR"-    & cover 0.1-        (nonTrivialSubmap && nullKeyL && nullKeyR)-        "nonTrivialSubmap && nullKeyL && nullKeyR"-  where-    f v1 v2-        | Null.null v1 = True-        | otherwise = f0 v1 v2-    nonTrivialSubmap =-        MonoidMap.isSubmapOfBy f m1 m2-        && m1 /= mempty-        && m2 /= mempty-        && m1 /= m2-    nonNullKeyL = MonoidMap.nonNullKey k m1-    nonNullKeyR = MonoidMap.nonNullKey k m2-    nullKeyL = MonoidMap.nullKey k m1-    nullKeyR = MonoidMap.nullKey k m2--prop_isSubmapOfBy_get_total_failure-    :: Test k v-    => Fun (v, v) Bool-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_isSubmapOfBy_get_total_failure (applyFun2 -> f) m1 m2 k =-    expectFailure $-    MonoidMap.isSubmapOfBy f m1 m2-        ==>-        f (MonoidMap.get k m1) (MonoidMap.get k m2)------------------------------------------------------------------------------------- Utilities-----------------------------------------------------------------------------------infixr 3 ==>-(==>) :: Bool -> Bool -> Property-a ==> b = not a .||. b

@@ -1,267 +0,0 @@-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.ConversionSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Function-    ( (&) )-import Data.Map.Strict-    ( Map )-import Data.MonoidMap.Internal-    ( MonoidMap, nonNullCount )-import Data.Proxy-    ( Proxy (..) )-import Data.Set-    ( Set )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesAll-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun (..), Property, applyFun, applyFun2, cover, (===) )--import qualified Data.Foldable as F-import qualified Data.List as List-import qualified Data.List.NonEmpty as NE-import qualified Data.Map.Strict as Map-import qualified Data.Monoid.Null as Null-import qualified Data.MonoidMap.Internal as MonoidMap-import qualified Data.Set as Set--spec :: Spec-spec = describe "Conversions" $ do--    forM_ testValueTypesAll $-        \(TestValueType p) -> specFor (Proxy @Key) p--specFor :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specFor = makeSpec $ do--    describe "Conversion to and from lists" $ do-        it "prop_fromList_get" $-            prop_fromList_get-                @k @v & property-        it "prop_fromList_toMap" $-            prop_fromList_toMap-                @k @v & property-        it "prop_fromList_toList" $-            prop_fromList_toList-                @k @v & property-        it "prop_toList_fromList" $-            prop_toList_fromList-                @k @v & property-        it "prop_toList_sort" $-            prop_toList_sort-                @k @v & property-        it "prop_fromListWith_get" $-            prop_fromListWith_get-                @k @v & property--    describe "Conversion to and from ordinary maps" $ do-        it "prop_fromMap_get" $-            prop_fromMap_get-                @k @v & property-        it "prop_fromMap_toMap" $-            prop_fromMap_toMap-                @k @v & property-        it "prop_fromMapWith_fromMap" $-            prop_fromMapWith_fromMap-                @k @v & property-        it "prop_fromMapWith_get" $-            prop_fromMapWith_get-                @k @v & property-        it "prop_toMap_fromMap" $-            prop_toMap_fromMap-                @k @v & property--    describe "Conversion from sets" $ do-        it "prop_fromSet_get" $-            prop_fromSet_get-                @k @v & property------------------------------------------------------------------------------------- Conversion to and from lists-----------------------------------------------------------------------------------prop_fromList_get-    :: Test k v => [(k, v)] -> k -> Property-prop_fromList_get kvs k =-    MonoidMap.get k (MonoidMap.fromList kvs)-        ===-        F.foldMap snd (filter ((== k) . fst) kvs)-    & cover 2-        (matchingKeyCount == 0)-        "matchingKeyCount == 0"-    & cover 2-        (matchingKeyCount == 1)-        "matchingKeyCount == 1"-    & cover 2-        (matchingKeyCount == 2)-        "matchingKeyCount == 2"-    & cover 2-        (matchingKeyCount >= 3)-        "matchingKeyCount >= 3"-  where-    matchingKeyCount =-        length $ filter ((== k) . fst) kvs--prop_fromList_toMap-    :: Test k v => [(k, v)] -> Property-prop_fromList_toMap kvs =-    MonoidMap.toMap m === Map.filter (/= mempty) o-    & cover 2-        (MonoidMap.nonNull m && nonNullCount m /= Map.size o)-        "MonoidMap.nonNull m && nonNullCount m /= Map.size o"-    & cover 2-        (MonoidMap.nonNull m && nonNullCount m == Map.size o)-        "MonoidMap.nonNull m && nonNullCount m == Map.size o"-  where-    m = MonoidMap.fromList kvs-    o = Map.fromListWith (flip (<>)) kvs--prop_fromList_toList-    :: Test k v => [(k, v)] -> Property-prop_fromList_toList kvs =-    MonoidMap.toList m === Map.toList (Map.filter (/= mempty) o)-    & cover 2-        (MonoidMap.nonNull m && nonNullCount m /= Map.size o)-        "MonoidMap.nonNull m && nonNullCount m /= Map.size o"-    & cover 2-        (MonoidMap.nonNull m && nonNullCount m == Map.size o)-        "MonoidMap.nonNull m && nonNullCount m == Map.size o"-  where-    m = MonoidMap.fromList kvs-    o = Map.fromListWith (flip (<>)) kvs--prop_toList_fromList-    :: Test k v => MonoidMap k v -> Property-prop_toList_fromList m =-    MonoidMap.fromList (MonoidMap.toList m) === m-    & cover 2-        (MonoidMap.nonNull m)-        "MonoidMap.nonNull m"--prop_toList_sort-    :: Test k v => MonoidMap k v -> Property-prop_toList_sort m =-    List.sortOn fst (MonoidMap.toList m) === MonoidMap.toList m-    & cover 2-        (MonoidMap.nonNull m)-        "MonoidMap.nonNull m"--prop_fromListWith_get-    :: Test k v => Fun (v, v) v -> [(k, v)] -> k -> Property-prop_fromListWith_get (applyFun2 -> f) kvs k =-    MonoidMap.get k (MonoidMap.fromListWith f kvs)-        ===-        maybe mempty-            (F.foldl1 f)-            (NE.nonEmpty (snd <$> filter ((== k) . fst) kvs))-    & cover 2-        (matchingKeyCount == 0)-        "matchingKeyCount == 0"-    & cover 2-        (matchingKeyCount == 1)-        "matchingKeyCount == 1"-    & cover 2-        (matchingKeyCount == 2)-        "matchingKeyCount == 2"-    & cover 2-        (matchingKeyCount >= 3)-        "matchingKeyCount >= 3"-  where-    matchingKeyCount =-        length $ filter ((== k) . fst) kvs------------------------------------------------------------------------------------- Conversion to and from ordinary maps-----------------------------------------------------------------------------------prop_fromMap_get-    :: Test k v => Map k v -> k -> Property-prop_fromMap_get m k =-    MonoidMap.get k (MonoidMap.fromMap m) === Map.findWithDefault mempty k m-    & cover 2-        (MonoidMap.get k (MonoidMap.fromMap m) /= mempty)-        "MonoidMap.get k (MonoidMap.fromMap m) /= mempty"-    & cover 0.1-        (MonoidMap.get k (MonoidMap.fromMap m) == mempty && Map.member k m)-        "MonoidMap.get k (MonoidMap.fromMap m) == mempty && Map.member k m"--prop_fromMap_toMap-    :: Test k v => Map k v -> Property-prop_fromMap_toMap o =-    MonoidMap.toMap m === Map.filter (/= mempty) o-    & cover 2-        (MonoidMap.nonNull m && nonNullCount m /= Map.size o)-        "MonoidMap.nonNull m && nonNullCount m /= Map.size o"-    & cover 2-        (MonoidMap.nonNull m && nonNullCount m == Map.size o)-        "MonoidMap.nonNull m && nonNullCount m == Map.size o"-  where-    m = MonoidMap.fromMap o--prop_fromMapWith_fromMap-    :: Test k v => Map k v -> Property-prop_fromMapWith_fromMap m =-    MonoidMap.fromMapWith id m === MonoidMap.fromMap m-    & cover 2-        (MonoidMap.nonNull (MonoidMap.fromMap m))-        "MonoidMap.nonNull (MonoidMap.fromMap m)"--prop_fromMapWith_get-    :: Test k v => Fun v v -> Map k v -> k -> Property-prop_fromMapWith_get (applyFun -> f) m k =-    MonoidMap.get k (MonoidMap.fromMapWith f m)-        === maybe mempty f (Map.lookup k m)-    & cover 2-        (MonoidMap.nonNullKey k (MonoidMap.fromMapWith f m))-        "MonoidMap.nonNullKey k (MonoidMap.fromMapWith f m)"-    & cover 0.01-        (MonoidMap.nullKey k (MonoidMap.fromMapWith f m) && Map.member k m)-        "MonoidMap.nullKey k (MonoidMap.fromMapWith f m) && Map.member k m"--prop_toMap_fromMap-    :: Test k v => MonoidMap k v -> Property-prop_toMap_fromMap m =-    MonoidMap.fromMap (MonoidMap.toMap m) === m------------------------------------------------------------------------------------- Conversion from sets-----------------------------------------------------------------------------------prop_fromSet_get-    :: Test k v => Fun k v -> Set k -> k -> Property-prop_fromSet_get (applyFun -> f) ks k =-    MonoidMap.get k (MonoidMap.fromSet f ks)-        ===-        (if Set.member k ks then f k else mempty)-    & cover 0.2-        (Set.member k ks && Null.null (f k))-        "Set.member k ks && Null.null (f k)"-    & cover 8.0-        (Set.member k ks && not (Null.null (f k)))-        "Set.member k ks && not (Null.null (f k))"-    & cover 0.2-        (not (Set.member k ks) && Null.null (f k))-        "not (Set.member k ks) && Null.null (f k)"-    & cover 8.0-        (not (Set.member k ks) && not (Null.null (f k)))-        "not (Set.member k ks) && not (Null.null (f k))"

@@ -1,230 +0,0 @@-{-# LANGUAGE RankNTypes #-}-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.DistributivitySpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Data-    ( typeRep )-import Data.Function-    ( (&) )-import Data.Maybe-    ( isJust )-import Data.MonoidMap.Internal-    ( MonoidMap, get )-import Data.Proxy-    ( Proxy (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (..)-    , TestValue-    , property-    , testValueTypesGCDMonoid-    , testValueTypesGroup-    , testValueTypesLCMMonoid-    , testValueTypesLeftGCDMonoid-    , testValueTypesLeftReductive-    , testValueTypesAll-    , testValueTypesMonus-    , testValueTypesOverlappingGCDMonoid-    , testValueTypesReductive-    , testValueTypesRightGCDMonoid-    , testValueTypesRightReductive-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Property, cover, (===) )--import qualified Data.Group as Group-    ( Group (..) )-import qualified Data.Monoid.GCD as LeftGCDMonoid-    ( LeftGCDMonoid (..) )-import qualified Data.Monoid.GCD as RightGCDMonoid-    ( RightGCDMonoid (..) )-import qualified Data.Monoid.GCD as OverlappingGCDMonoid-    ( OverlappingGCDMonoid (..) )-import qualified Data.Monoid.GCD as GCDMonoid-    ( GCDMonoid (..) )-import qualified Data.Monoid.LCM as LCMMonoid-    ( LCMMonoid (..) )-import qualified Data.Monoid.Monus as Monus-    ( Monus (..) )-import qualified Data.Semigroup as Semigroup-    ( Semigroup (..) )-import qualified Data.Semigroup.Cancellative as LeftReductive-    ( LeftReductive (..) )-import qualified Data.Semigroup.Cancellative as RightReductive-    ( RightReductive (..) )-import qualified Data.Semigroup.Cancellative as Reductive-    ( Reductive (..) )--spec :: Spec-spec = do-    specDistributiveGet-    specDistributiveGetMaybe--specDistributiveGet :: Spec-specDistributiveGet = do-    specForAll-        testValueTypesAll-        "Semigroup.<>"-        (Semigroup.<>)-        (Semigroup.<>)-    specForAll-        testValueTypesLeftGCDMonoid-        "LeftGCDMonoid.commonPrefix"-        (LeftGCDMonoid.commonPrefix)-        (LeftGCDMonoid.commonPrefix)-    specForAll-        testValueTypesRightGCDMonoid-        "RightGCDMonoid.commonSuffix"-        (RightGCDMonoid.commonSuffix)-        (RightGCDMonoid.commonSuffix)-    specForAll-        testValueTypesOverlappingGCDMonoid-        "OverlappingGCDMonoid.overlap"-        (OverlappingGCDMonoid.overlap)-        (OverlappingGCDMonoid.overlap)-    specForAll-        testValueTypesGCDMonoid-        "GCDMonoid.gcd"-        (GCDMonoid.gcd)-        (GCDMonoid.gcd)-    specForAll-        testValueTypesLCMMonoid-        "LCMMonoid.lcm"-        (LCMMonoid.lcm)-        (LCMMonoid.lcm)-    specForAll-        testValueTypesGroup-        "Group.minus"-        (Group.~~)-        (Group.~~)-    specForAll-        testValueTypesMonus-        "Monus.monus"-        (Monus.<\>)-        (Monus.<\>)-  where-    specForAll-        :: [TestValueType c]-        -> String-        -> (forall k v m. (Test k v, c v, m ~ MonoidMap k v) => (m -> m -> m))-        -> (forall v. (TestValue v, c v) => (v -> v -> v))-        -> Spec-    specForAll testValueTypes funName f g =-        describe description $ forM_ testValueTypes $ specFor f g-      where-        description = "Distributivity of 'get' with '" <> funName <> "'"--    specFor-        :: (forall k v m. (Test k v, c v, m ~ MonoidMap k v) => (m -> m -> m))-        -> (forall v. (TestValue v, c v) => (v -> v -> v))-        -> TestValueType c-        -> Spec-    specFor f g (TestValueType (_ :: Proxy v)) =-        it description $ property $ propDistributiveGet @Key @v f g-      where-        description = show $ typeRep $ Proxy @(MonoidMap Key v)--specDistributiveGetMaybe :: Spec-specDistributiveGetMaybe = do-    specForAll-        testValueTypesLeftReductive-        "LeftReductive.stripPrefix"-        (LeftReductive.stripPrefix)-        (LeftReductive.stripPrefix)-    specForAll-        testValueTypesRightReductive-        "RightReductive.stripSuffix"-        (RightReductive.stripSuffix)-        (RightReductive.stripSuffix)-    specForAll-        testValueTypesReductive-        "Reductive.minusMaybe"-        (Reductive.</>)-        (Reductive.</>)-  where-    specForAll-        :: [TestValueType c]-        -> String-        -> (forall k v m. (Test k v, c v, m ~ MonoidMap k v)-            => (m -> m -> Maybe m))-        -> (forall v. (TestValue v, c v)-            => (v -> v -> Maybe v))-        -> Spec-    specForAll testValueTypes funName f g =-        describe description $ forM_ testValueTypes $ specFor f g-      where-        description = "Distributivity of 'get' with '" <> funName <> "'"--    specFor-        :: (forall k v m. (Test k v, c v, m ~ MonoidMap k v)-            => (m -> m -> Maybe m))-        -> (forall v. (TestValue v, c v)-            => (v -> v -> Maybe v))-        -> TestValueType c-        -> Spec-    specFor f g (TestValueType (_ :: Proxy v)) =-        it description $ property $ propDistributiveGetMaybe @Key @v f g-      where-        description = show $ typeRep $ Proxy @(MonoidMap Key v)--propDistributiveGet-    :: Test k v-    => (MonoidMap k v -> MonoidMap k v -> MonoidMap k v)-    -> (v -> v -> v)-    -> k-    -> MonoidMap k v-    -> MonoidMap k v-    -> Property-propDistributiveGet f g k m1 m2 =-    get k (f m1 m2) === g (get k m1) (get k m2)-    & cover 2-        (get k (f m1 m2) == mempty)-        "get k (f m1 m2) == mempty"-    & cover 2-        (get k (f m1 m2) /= mempty)-        "get k (f m1 m2) /= mempty"-    & cover 2-        (get k m1 == mempty && get k m2 == mempty)-        "get k m1 == mempty && get k m2 == mempty"-    & cover 2-        (get k m1 == mempty && get k m2 /= mempty)-        "get k m1 == mempty && get k m2 /= mempty"-    & cover 2-        (get k m1 /= mempty && get k m2 == mempty)-        "get k m1 /= mempty && get k m2 == mempty"-    & cover 2-        (get k m1 /= mempty && get k m2 /= mempty)-        "get k m1 /= mempty && get k m2 /= mempty"--propDistributiveGetMaybe-    :: Test k v-    => (MonoidMap k v -> MonoidMap k v -> Maybe (MonoidMap k v))-    -> (v -> v -> Maybe v)-    -> k-    -> MonoidMap k v-    -> MonoidMap k v-    -> Property-propDistributiveGetMaybe f g k m1 m2 = property $-    all (\m -> g (get k m1) (get k m2) == Just (get k m)) (f m1 m2)-    & cover 2-        (isJust (f m1 m2) && g (get k m1) (get k m2) == Just mempty)-        "isJust (f m1 m2) && g (get k m1) (get k m2) == Just mempty"-    & cover 2-        (isJust (f m1 m2) && g (get k m1) (get k m2) /= Just mempty)-        "isJust (f m1 m2) && g (get k m1) (get k m2) /= Just mempty"

@@ -1,1861 +0,0 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE OverloadedLists #-}-{-# LANGUAGE RankNTypes #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.ExampleSpec-    where--import Prelude hiding-    ( gcd, lcm )--import Data.Data-    ( Data, cast, gmapT )-import Data.Function-    ( (&) )-import Data.Group-    ( Group (..) )-import Data.Maybe-    ( fromMaybe )-import Data.Monoid-    ( Product (..), Sum (..) )-import Data.Monoid.GCD-    ( GCDMonoid (..), LeftGCDMonoid (..), RightGCDMonoid (..) )-import Data.Monoid.LCM-    ( LCMMonoid (..) )-import Data.Monoid.Monus-    ( OverlappingGCDMonoid (..), (<\>) )-import Data.MonoidMap.Internal-    ( MonoidMap )-import Data.Ratio-    ( (%) )-import Data.Semigroup.Cancellative-    ( LeftReductive (..), RightReductive (..) )-import Data.Set-    ( Set )-import Numeric.Natural-    ( Natural )-import Test.Common-    ()-import Test.Hspec-    ( Spec, describe )-import Test.Hspec.Unit-    ( UnitTestData1-    , UnitTestData2-    , unitTestData1-    , unitTestData2-    , unitTestSpec-    )--import qualified Data.MonoidMap.Internal as MonoidMap-import qualified Data.Set as Set--spec :: Spec-spec = describe "Examples" $ do--    describe "Conversion" $ do--        exampleSpec_fromList_String-        exampleSpec_toList_String--    describe "Comparison" $ do--        exampleSpec_isSubmapOf_Sum_Natural-        exampleSpec_disjoint_Product_Natural-        exampleSpec_disjoint_Sum_Natural-        exampleSpec_disjoint_Set_Natural--    describe "Data" $ do--        exampleSpec_gmapT_keys_id-        exampleSpec_gmapT_keys_div_2-        exampleSpec_gmapT_keys_mod_2-        exampleSpec_gmapT_keys_mul_2--        exampleSpec_gmapT_values_id-        exampleSpec_gmapT_values_div_2-        exampleSpec_gmapT_values_mod_2-        exampleSpec_gmapT_values_mul_2--    describe "Intersection" $ do--        exampleSpec_intersectionWith_min_Sum_Natural--    describe "Union" $ do--        exampleSpec_unionWith_max_Sum_Natural--    describe "Semigroup" $ do--        exampleSpec_Semigroup_mappend_String-        exampleSpec_Semigroup_mappend_Sum_Natural--    describe "Group" $ do--        exampleSpec_Group_invert_Product_Rational-        exampleSpec_Group_invert_Sum_Integer-        exampleSpec_Group_pow_Product_Rational-        exampleSpec_Group_pow_Sum_Integer-        exampleSpec_Group_subtract_Product_Rational-        exampleSpec_Group_subtract_Sum_Integer--    describe "Reductive" $ do--        exampleSpec_Reductive_isPrefixOf_String-        exampleSpec_Reductive_isPrefixOf_Sum_Natural-        exampleSpec_Reductive_isSuffixOf_String-        exampleSpec_Reductive_isSuffixOf_Sum_Natural-        exampleSpec_Reductive_stripPrefix_String-        exampleSpec_Reductive_stripPrefix_Sum_Natural-        exampleSpec_Reductive_stripSuffix_String-        exampleSpec_Reductive_stripSuffix_Sum_Natural--    describe "LeftGCDMonoid" $ do--        exampleSpec_LeftGCDMonoid_commonPrefix_String-        exampleSpec_LeftGCDMonoid_commonPrefix_Sum_Natural-        exampleSpec_LeftGCDMonoid_stripCommonPrefix_String-        exampleSpec_LeftGCDMonoid_stripCommonPrefix_Sum_Natural--    describe "RightGCDMonoid" $ do--        exampleSpec_RightGCDMonoid_commonSuffix_String-        exampleSpec_RightGCDMonoid_commonSuffix_Sum_Natural-        exampleSpec_RightGCDMonoid_stripCommonSuffix_String-        exampleSpec_RightGCDMonoid_stripCommonSuffix_Sum_Natural--    describe "OverlappingGCDMonoid" $ do--        exampleSpec_OverlappingGCDMonoid_overlap_String-        exampleSpec_OverlappingGCDMonoid_overlap_Sum_Natural-        exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_String-        exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural-        exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_String-        exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural--    describe "GCDMonoid" $ do--        exampleSpec_GCDMonoid_gcd_Product_Natural-        exampleSpec_GCDMonoid_gcd_Sum_Natural-        exampleSpec_GCDMonoid_gcd_Set_Natural--    describe "LCMMonoid" $ do--        exampleSpec_LCMMonoid_lcm_Product_Natural-        exampleSpec_LCMMonoid_lcm_Sum_Natural-        exampleSpec_LCMMonoid_lcm_Set_Natural--    describe "Monus" $ do--        exampleSpec_Monus_monus_Set_Natural-        exampleSpec_Monus_monus_Sum_Natural------------------------------------------------------------------------------------- Conversion-----------------------------------------------------------------------------------exampleSpec_fromList_String :: Spec-exampleSpec_fromList_String = unitTestSpec-    "MonoidMap.fromList (String)"-    "MonoidMap.fromList"-    (MonoidMap.fromList)-    (exampleData_fromList_String)--exampleData_fromList_String :: UnitTestData1-    [(Int, String)]-    (MonoidMap Int String)-exampleData_fromList_String = unitTestData1-    [ ( [(1, "a"), (2, "x"), (1, "b"), (2, "y"), (1, "c"), (2, "z")]-      , [(1, "abc"), (2, "xyz")]-      )-    ]--exampleSpec_toList_String :: Spec-exampleSpec_toList_String = unitTestSpec-    "MonoidMap.toList (String)"-    "MonoidMap.toList"-    (MonoidMap.toList)-    (exampleData_toList_String)--exampleData_toList_String :: UnitTestData1-    (MonoidMap Int String)-    [(Int, String)]-exampleData_toList_String = unitTestData1-    [ ( [(3, "z"), (2, "y"), (1, "x")]-      , [(1, "x"), (2, "y"), (3, "z")]-      )-    ]------------------------------------------------------------------------------------- Comparison-----------------------------------------------------------------------------------exampleSpec_isSubmapOf_Sum_Natural :: Spec-exampleSpec_isSubmapOf_Sum_Natural = unitTestSpec-    "MonoidMap.isSubmapOf (Sum Natural)"-    "MonoidMap.isSubmapOf"-    (MonoidMap.isSubmapOf)-    (exampleData_isSubmapOf_Sum_Natural)--exampleData_isSubmapOf_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (Bool)-exampleData_isSubmapOf_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3]-      , m [4, 4, 4, 4]-      , True-      )-    , ( m [0, 1, 2, 3]-      , m [0, 4, 4, 4]-      , True-      )-    , ( m [0, 1, 2, 3]-      , m [0, 1, 4, 4]-      , True-      )-    , ( m [0, 1, 2, 3]-      , m [0, 1, 2, 4]-      , True-      )-    , ( m [0, 1, 2, 3]-      , m [0, 1, 2, 3]-      , True-      )-    , ( m [0, 1, 2, 3]-      , m [0, 0, 2, 3]-      , False-      )-    , ( m [0, 1, 2, 3]-      , m [0, 1, 1, 3]-      , False-      )-    , ( m [0, 1, 2, 3]-      , m [0, 1, 2, 2]-      , False-      )-    , ( m [0, 1, 2, 3]-      , m [0, 0, 0, 0]-      , False-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_disjoint_Product_Natural :: Spec-exampleSpec_disjoint_Product_Natural = unitTestSpec-    "MonoidMap.disjoint (Product Natural)"-    "MonoidMap.disjoint"-    (MonoidMap.disjoint)-    (exampleData_disjoint_Product_Natural)--exampleData_disjoint_Product_Natural :: UnitTestData2-    (MonoidMap LatinChar (Product Natural))-    (MonoidMap LatinChar (Product Natural))-    (Bool)-exampleData_disjoint_Product_Natural = unitTestData2-    [ ( m []-      , m []-      , True-      )-    , ( m [2, 3, 5, 7]-      , m [3, 5, 7, 2]-      , True-      )-    , ( m [2 * 3, 5 * 7]-      , m [5 * 7, 2 * 3]-      , True-      )-    , ( m [2 * 3    , 3 * 5    ]-      , m [    3 * 5,     5 * 7]-      , False-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_disjoint_Sum_Natural :: Spec-exampleSpec_disjoint_Sum_Natural = unitTestSpec-    "MonoidMap.disjoint (Sum Natural)"-    "MonoidMap.disjoint"-    (MonoidMap.disjoint)-    (exampleData_disjoint_Sum_Natural)--exampleData_disjoint_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (Bool)-exampleData_disjoint_Sum_Natural = unitTestData2-    [ ( m []-      , m []-      , True-      )-    , ( m [0, 1, 0, 1]-      , m [1, 0, 1, 0]-      , True-      )-    , ( m [0, 8, 0, 8]-      , m [8, 0, 8, 0]-      , True-      )-    , ( m [0, 8, 0, 8]-      , m [8, 0, 8, 1]-      , False-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_disjoint_Set_Natural :: Spec-exampleSpec_disjoint_Set_Natural = unitTestSpec-    "MonoidMap.disjoint (Set Natural)"-    "MonoidMap.disjoint"-    (MonoidMap.disjoint)-    (exampleData_disjoint_Set_Natural)--exampleData_disjoint_Set_Natural :: UnitTestData2-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-    (Bool)-exampleData_disjoint_Set_Natural = unitTestData2-    [ ( m []-      , m []-      , True-      )-    , ( m [[1], [2], [3], [4]]-      , m [[5], [6], [7], [8]]-      , True-      )-    , ( m [[1, 2], [3, 4]]-      , m [[5, 6], [7, 8]]-      , True-      )-    , ( m [[1, 2   ], [3, 4   ]]-      , m [[   2, 3], [   4, 5]]-      , False-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList------------------------------------------------------------------------------------- Data-----------------------------------------------------------------------------------exampleSpec_gmapT_keys_id :: Spec-exampleSpec_gmapT_keys_id =-    unitTestSpec "gmapT_keys" "id"-    (mapNaturals id)-    (unitTestData1-      [ ( [(1, "a"), (2, "b"), (3, "c"), (4, "d")] :: MonoidMap Natural String-        , [(1, "a"), (2, "b"), (3, "c"), (4, "d")] :: MonoidMap Natural String-        )-      ]-    )--exampleSpec_gmapT_keys_div_2 :: Spec-exampleSpec_gmapT_keys_div_2 =-    unitTestSpec "gmapT_keys" "div_2"-    (mapNaturals (`div` 2))-    (unitTestData1-      [ ( [(2, "a"), (4, "b"), (6, "c"), (8, "d")] :: MonoidMap Natural String-        , [(1, "a"), (2, "b"), (3, "c"), (4, "d")] :: MonoidMap Natural String-        )-      ]-    )--exampleSpec_gmapT_keys_mod_2 :: Spec-exampleSpec_gmapT_keys_mod_2 =-    unitTestSpec "gmapT_keys" "mod_2"-    (mapNaturals (`mod` 2))-    (unitTestData1-      [ ( [(0, "a"), (2, "b"), (1, "c"), (3, "d")] :: MonoidMap Natural String-        , [(0, "a"    <> "b"), (1, "c"    <> "d")] :: MonoidMap Natural String-        )-      ]-    )--exampleSpec_gmapT_keys_mul_2 :: Spec-exampleSpec_gmapT_keys_mul_2 =-    unitTestSpec "gmapT_keys" "mul_2"-    (mapNaturals (* 2))-    (unitTestData1-      [ ( [(1, "a"), (2, "b"), (3, "c"), (4, "d")] :: MonoidMap Natural String-        , [(2, "a"), (4, "b"), (6, "c"), (8, "d")] :: MonoidMap Natural String-        )-      ]-    )--exampleSpec_gmapT_values_id :: Spec-exampleSpec_gmapT_values_id =-    unitTestSpec "gmapT_values" "id"-    (mapNaturals id)-    (unitTestData1-      [ ( [(A, 1), (B, 2), (C, 3), (D, 4)] :: MonoidMap LatinChar (Sum Natural)-        , [(A, 1), (B, 2), (C, 3), (D, 4)] :: MonoidMap LatinChar (Sum Natural)-        )-      ]-    )--exampleSpec_gmapT_values_div_2 :: Spec-exampleSpec_gmapT_values_div_2 =-    unitTestSpec "gmapT_values" "div_2"-    (mapNaturals (`div` 2))-    (unitTestData1-      [ ( [(A, 2), (B, 4), (C, 6), (D, 8)] :: MonoidMap LatinChar (Sum Natural)-        , [(A, 1), (B, 2), (C, 3), (D, 4)] :: MonoidMap LatinChar (Sum Natural)-        )-      ]-    )--exampleSpec_gmapT_values_mod_2 :: Spec-exampleSpec_gmapT_values_mod_2 =-    unitTestSpec "gmapT_values" "mod_2"-    (mapNaturals (`mod` 2))-    (unitTestData1-      [ ( [(A, 1), (B, 2), (C, 3), (D, 4)] :: MonoidMap LatinChar (Sum Natural)-        , [(A, 1),         (C, 1)        ] :: MonoidMap LatinChar (Sum Natural)-        )-      ]-    )--exampleSpec_gmapT_values_mul_2 :: Spec-exampleSpec_gmapT_values_mul_2 =-    unitTestSpec "gmapT_values" "mul_2"-    (mapNaturals (* 2))-    (unitTestData1-      [ ( [(A, 1), (B, 2), (C, 3), (D, 4)] :: MonoidMap LatinChar (Sum Natural)-        , [(A, 2), (B, 4), (C, 6), (D, 8)] :: MonoidMap LatinChar (Sum Natural)-        )-      ]-    )--mapNaturals :: Data a => (Natural -> Natural) -> a -> a-mapNaturals f =-    everywhereT $ \x ->-        case (cast x) of-            Just (n :: Natural) ->-                fromMaybe-                    (error "mapNaturals")-                    (cast (f n))-            Nothing -> x--everywhereT :: Data a => (forall b. Data b => b -> b) -> a -> a-everywhereT f x = f (gmapT (everywhereT f) x)------------------------------------------------------------------------------------- Intersection-----------------------------------------------------------------------------------exampleSpec_intersectionWith_min_Sum_Natural :: Spec-exampleSpec_intersectionWith_min_Sum_Natural = unitTestSpec-    "MonoidMap.intersectionWith (Sum Natural)"-    "MonoidMap.intersectionWith"-    (MonoidMap.intersectionWith min)-    (exampleData_intersectionWith_min_Sum_Natural)--exampleData_intersectionWith_min_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_intersectionWith_min_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7]-      , m [7, 6, 5, 4, 3, 2, 1, 0]-      , m [0, 1, 2, 3, 3, 2, 1, 0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- Union-----------------------------------------------------------------------------------exampleSpec_unionWith_max_Sum_Natural :: Spec-exampleSpec_unionWith_max_Sum_Natural = unitTestSpec-    "MonoidMap.unionWith (Sum Natural)"-    "MonoidMap.unionWith"-    (MonoidMap.unionWith max)-    (exampleData_unionWith_max_Sum_Natural)--exampleData_unionWith_max_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_unionWith_max_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7]-      , m [7, 6, 5, 4, 3, 2, 1, 0]-      , m [7, 6, 5, 4, 4, 5, 6, 7]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- Semigroup-----------------------------------------------------------------------------------exampleSpec_Semigroup_mappend_String :: Spec-exampleSpec_Semigroup_mappend_String = unitTestSpec-    "Semigroup.mappend (String)"-    "mappend"-    (mappend)-    (exampleData_Semigroup_concat_String)--exampleData_Semigroup_concat_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-exampleData_Semigroup_concat_String = unitTestData2-    [ ( m ["abc", "ij" , "p"  , ""   ]-      , m [   "",   "k",  "qr", "xyz"]-      , m ["abc", "ijk", "pqr", "xyz"]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_Semigroup_mappend_Sum_Natural :: Spec-exampleSpec_Semigroup_mappend_Sum_Natural = unitTestSpec-    "Semigroup.mappend (Sum Natural)"-    "mappend"-    (mappend)-    (exampleData_Semigroup_concat_Sum_Natural)--exampleData_Semigroup_concat_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_Semigroup_concat_Sum_Natural = unitTestData2-    [ ( m [4, 2, 1, 0]-      , m [0, 1, 2, 4]-      , m [4, 3, 3, 4]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- Group-----------------------------------------------------------------------------------exampleSpec_Group_invert_Product_Rational :: Spec-exampleSpec_Group_invert_Product_Rational = unitTestSpec-    "Group.invert (Product Rational)"-    "invert"-    (invert)-    (exampleData_Group_invert_Product_Rational)--exampleData_Group_invert_Product_Rational :: UnitTestData1-    (MonoidMap LatinChar (Product Rational))-    (MonoidMap LatinChar (Product Rational))-exampleData_Group_invert_Product_Rational = unitTestData1-    [ ( m [  2,   4,   8,   16]-      , m [1%2, 1%4, 1%8, 1%16]-      )-    , ( m [1%2, 1%4, 1%8, 1%16]-      , m [  2,   4,   8,   16]-      )-    , ( m [  2, 1%4,   8,   16]-      , m [1%2,   4, 1%8, 1%16]-      )-    , ( m [1%2,   4, 1%8, 1%16]-      , m [  2, 1%4,   8,   16]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Product--exampleSpec_Group_invert_Sum_Integer :: Spec-exampleSpec_Group_invert_Sum_Integer = unitTestSpec-    "Group.invert (Sum Integer)"-    "invert"-    (invert)-    (exampleData_Group_invert_Sum_Integer)--exampleData_Group_invert_Sum_Integer :: UnitTestData1-    (MonoidMap LatinChar (Sum Integer))-    (MonoidMap LatinChar (Sum Integer))-exampleData_Group_invert_Sum_Integer = unitTestData1-    [ ( m [ 1,  2,  3,  4]-      , m [-1, -2, -3, -4]-      )-    , ( m [-1, -2, -3, -4]-      , m [ 1,  2,  3,  4]-      )-    , ( m [ 1, -2,  3, -4]-      , m [-1,  2, -3,  4]-      )-    , ( m [-1,  2, -3,  4]-      , m [ 1, -2,  3, -4]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Sum--exampleSpec_Group_pow_Product_Rational :: Spec-exampleSpec_Group_pow_Product_Rational = unitTestSpec-    "Group.pow (Product Rational)"-    "pow"-    (pow)-    (exampleData_Group_pow_Product_Rational)--exampleData_Group_pow_Product_Rational :: UnitTestData2-    (MonoidMap LatinChar (Product Rational))-    (Integer)-    (MonoidMap LatinChar (Product Rational))-exampleData_Group_pow_Product_Rational = unitTestData2-    [ ( m [  2,   -4,   8,   -16], (-1)-      , m [1%2, -1%4, 1%8, -1%16]-      )-    , ( m [  2,   -4,   8,   -16], 0-      , m [  1,    1,   1,     1]-      )-    , ( m [  2,   -4,   8,   -16], 1-      , m [  2,   -4,   8,   -16]-      )-    , ( m [  2,   -4,   8,   -16], 2-      , m [  4,   16,  64,   256]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Product--exampleSpec_Group_pow_Sum_Integer :: Spec-exampleSpec_Group_pow_Sum_Integer = unitTestSpec-    "Group.pow (Sum Integer)"-    "pow"-    (pow)-    (exampleData_Group_pow_Sum_Integer)--exampleData_Group_pow_Sum_Integer :: UnitTestData2-    (MonoidMap LatinChar (Sum Integer))-    (Integer)-    (MonoidMap LatinChar (Sum Integer))-exampleData_Group_pow_Sum_Integer = unitTestData2-    [ ( m [ 1, -2,  3, -4], (-1)-      , m [-1,  2, -3,  4]-      )-    , ( m [ 1, -2,  3, -4], 0-      , m [ 0,  0,  0,  0]-      )-    , ( m [ 1, -2,  3, -4], 1-      , m [ 1, -2,  3, -4]-      )-    , ( m [ 1, -2,  3, -4], 2-      , m [ 2, -4,  6, -8]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Sum--exampleSpec_Group_subtract_Product_Rational :: Spec-exampleSpec_Group_subtract_Product_Rational = unitTestSpec-    "Group.(~~) (Product Rational)"-    "(~~)"-    (~~)-    (exampleData_Group_subtract_Product_Rational)--exampleData_Group_subtract_Product_Rational :: UnitTestData2-    (MonoidMap LatinChar (Product Rational))-    (MonoidMap LatinChar (Product Rational))-    (MonoidMap LatinChar (Product Rational))-exampleData_Group_subtract_Product_Rational = unitTestData2-    [ ( m [ 1,    1,    1,    1]-      , m [ 1,    2,    4,    8]-      , m [ 1,  1%2,  1%4,  1%8]-      )-    , ( m [-1,   -1,   -1,   -1]-      , m [ 1,    2,    4,    8]-      , m [-1, -1%2, -1%4, -1%8]-      )-    , ( m [ 1,    1,    1,    1]-      , m [-1,   -2,   -4,   -8]-      , m [-1, -1%2, -1%4, -1%8]-      )-    , ( m [-1,   -1,   -1,   -1]-      , m [-1,   -2,   -4,   -8]-      , m [ 1,  1%2,  1%4,  1%8]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Product--exampleSpec_Group_subtract_Sum_Integer :: Spec-exampleSpec_Group_subtract_Sum_Integer = unitTestSpec-    "Group.(~~) (Sum Integer)"-    "(~~)"-    (~~)-    (exampleData_Group_subtract_Sum_Integer)--exampleData_Group_subtract_Sum_Integer :: UnitTestData2-    (MonoidMap LatinChar (Sum Integer))-    (MonoidMap LatinChar (Sum Integer))-    (MonoidMap LatinChar (Sum Integer))-exampleData_Group_subtract_Sum_Integer = unitTestData2-    [ ( m [ 1,  2,  3,  4]-      , m [ 1,  2,  3,  4]-      , m [ 0,  0,  0,  0]-      )-    , ( m [ 0,  0,  0,  0]-      , m [ 1,  2,  3,  4]-      , m [-1, -2, -3, -4]-      )-    , ( m [ 1,  2,  3,  4]-      , m [-1, -2, -3, -4]-      , m [ 2,  4,  6,  8]-      )-    , ( m [-1, -2, -3, -4]-      , m [-1, -2, -3, -4]-      , m [ 0,  0,  0,  0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Sum------------------------------------------------------------------------------------- Reductive-----------------------------------------------------------------------------------exampleSpec_Reductive_isPrefixOf_String :: Spec-exampleSpec_Reductive_isPrefixOf_String = unitTestSpec-    "Reductive.isPrefixOf (String)"-    "isPrefixOf"-    (isPrefixOf)-    (exampleData_Reductive_isPrefixOf_String)--exampleData_Reductive_isPrefixOf_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (Bool)-exampleData_Reductive_isPrefixOf_String = unitTestData2-    [ ( m ["A"   , "B"   , "C"   ]-      , m ["A123", "B123", "C123"]-      , True-      )-    , ( m ["A123", "B123", "C123"]-      , m ["A"   , "B"   , "C"   ]-      , False-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_Reductive_isSuffixOf_String :: Spec-exampleSpec_Reductive_isSuffixOf_String = unitTestSpec-    "Reductive.isSuffixOf (String)"-    "isSuffixOf"-    (isSuffixOf)-    (exampleData_Reductive_isSuffixOf_String)--exampleData_Reductive_isSuffixOf_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (Bool)-exampleData_Reductive_isSuffixOf_String = unitTestData2-    [ ( m [   "A",    "B",    "C"]-      , m ["123A", "123B", "123C"]-      , True-      )-    , ( m ["123A", "123B", "123C"]-      , m [   "A",    "B",    "C"]-      , False-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_Reductive_isPrefixOf_Sum_Natural :: Spec-exampleSpec_Reductive_isPrefixOf_Sum_Natural = unitTestSpec-    "Reductive.isPrefixOf (Sum Natural)"-    "isPrefixOf"-    (isPrefixOf)-    (exampleData_Reductive_Sum_Natural)--exampleSpec_Reductive_isSuffixOf_Sum_Natural :: Spec-exampleSpec_Reductive_isSuffixOf_Sum_Natural = unitTestSpec-    "Reductive.isSuffixOf (Sum Natural)"-    "isSuffixOf"-    (isSuffixOf)-    (exampleData_Reductive_Sum_Natural)--exampleData_Reductive_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (Bool)-exampleData_Reductive_Sum_Natural = unitTestData2-    [ ( m [1, 1], m [1, 1], True )-    , ( m [1, 1], m [1, 2], True )-    , ( m [1, 1], m [2, 1], True )-    , ( m [1, 1], m [2, 2], True )-    , ( m [1, 2], m [1, 1], False)-    , ( m [1, 2], m [1, 2], True )-    , ( m [1, 2], m [2, 1], False)-    , ( m [1, 2], m [2, 2], True )-    , ( m [2, 1], m [1, 1], False)-    , ( m [2, 1], m [1, 2], False)-    , ( m [2, 1], m [2, 1], True )-    , ( m [2, 1], m [2, 2], True )-    , ( m [2, 2], m [1, 1], False)-    , ( m [2, 2], m [1, 2], False)-    , ( m [2, 2], m [2, 1], False)-    , ( m [2, 2], m [2, 2], True )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Sum--exampleSpec_Reductive_stripPrefix_String :: Spec-exampleSpec_Reductive_stripPrefix_String = unitTestSpec-    "Reductive.stripPrefix (String)"-    "stripPrefix"-    (stripPrefix)-    (exampleData_Reductive_stripPrefix_String)--exampleData_Reductive_stripPrefix_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (Maybe (MonoidMap LatinChar String))-exampleData_Reductive_stripPrefix_String = unitTestData2-    [ ( m [""   , ""   , ""   ]-      , m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"] & Just-      )-    , ( m ["a"  , "p"  , "x"  ]-      , m ["abc", "pqr", "xyz"]-      , m [ "bc",  "qr",  "yz"] & Just-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"]-      , m [   "",    "",    ""] & Just-      )-    , ( m ["?"  , "p"  , "x"  ]-      , m ["abc", "pqr", "xyz"]-      , Nothing-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_Reductive_stripPrefix_Sum_Natural :: Spec-exampleSpec_Reductive_stripPrefix_Sum_Natural = unitTestSpec-    "Reductive.stripPrefix (Sum Natural)"-    "stripPrefix"-    (stripPrefix)-    (exampleData_Reductive_stripPrefix_Sum_Natural)--exampleData_Reductive_stripPrefix_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (Maybe (MonoidMap LatinChar (Sum Natural)))-exampleData_Reductive_stripPrefix_Sum_Natural = unitTestData2-    [ ( m [0, 0, 0]-      , m [2, 4, 8]-      , m [2, 4, 8] & Just-      )-    , ( m [1, 2, 4]-      , m [2, 4, 8]-      , m [1, 2, 4] & Just-      )-    , ( m [2, 4, 8]-      , m [2, 4, 8]-      , m [0, 0, 0] & Just-      )-    , ( m [3, 4, 8]-      , m [2, 4, 8]-      , Nothing-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_Reductive_stripSuffix_String :: Spec-exampleSpec_Reductive_stripSuffix_String = unitTestSpec-    "Reductive.stripSuffix (String)"-    "stripSuffix"-    (stripSuffix)-    (exampleData_Reductive_stripSuffix_String)--exampleData_Reductive_stripSuffix_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (Maybe (MonoidMap LatinChar String))-exampleData_Reductive_stripSuffix_String = unitTestData2-    [ ( m [   "",    "",    ""]-      , m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"] & Just-      )-    , ( m [  "c",   "r",   "z"]-      , m ["abc", "pqr", "xyz"]-      , m ["ab" , "pq" , "xy" ] & Just-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"]-      , m [""   , ""   , ""   ] & Just-      )-    , ( m [  "?",   "r",   "z"]-      , m ["abc", "pqr", "xyz"]-      , Nothing-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_Reductive_stripSuffix_Sum_Natural :: Spec-exampleSpec_Reductive_stripSuffix_Sum_Natural = unitTestSpec-    "Reductive.stripSuffix (Sum Natural)"-    "stripSuffix"-    (stripSuffix)-    (exampleData_Reductive_stripSuffix_Sum_Natural)--exampleData_Reductive_stripSuffix_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (Maybe (MonoidMap LatinChar (Sum Natural)))-exampleData_Reductive_stripSuffix_Sum_Natural = unitTestData2-    [ ( m [0, 0, 0]-      , m [2, 4, 8]-      , m [2, 4, 8] & Just-      )-    , ( m [1, 2, 4]-      , m [2, 4, 8]-      , m [1, 2, 4] & Just-      )-    , ( m [2, 4, 8]-      , m [2, 4, 8]-      , m [0, 0, 0] & Just-      )-    , ( m [3, 4, 8]-      , m [2, 4, 8]-      , Nothing-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- LeftGCDMonoid-----------------------------------------------------------------------------------exampleSpec_LeftGCDMonoid_commonPrefix_String :: Spec-exampleSpec_LeftGCDMonoid_commonPrefix_String = unitTestSpec-    "LeftGCDMonoid.commonPrefix (String)"-    "commonPrefix"-    (commonPrefix)-    (exampleData_LeftGCDMonoid_commonPrefix_String)--exampleData_LeftGCDMonoid_commonPrefix_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-exampleData_LeftGCDMonoid_commonPrefix_String = unitTestData2-    [ ( m ["---", "---", "---"]-      , m ["abc", "pqr", "xyz"]-      , m [""   , ""   , ""   ]-      )-    , ( m ["a--", "p--", "x--"]-      , m ["abc", "pqr", "xyz"]-      , m ["a"  , "p"  , "x"  ]-      )-    , ( m ["ab-", "pq-", "xy-"]-      , m ["abc", "pqr", "xyz"]-      , m ["ab" , "pq" , "xy" ]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["ab-", "pq-", "xy-"]-      , m ["ab" , "pq" , "xy" ]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["a--", "p--", "x--"]-      , m ["a"  , "p"  , "x"  ]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["---", "---", "---"]-      , m [""   , ""   , ""   ]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_LeftGCDMonoid_commonPrefix_Sum_Natural :: Spec-exampleSpec_LeftGCDMonoid_commonPrefix_Sum_Natural = unitTestSpec-    "LeftGCDMonoid.commonPrefix (Sum Natural)"-    "commonPrefix"-    (commonPrefix)-    (exampleData_LeftGCDMonoid_commonPrefix_Sum_Natural)--exampleData_LeftGCDMonoid_commonPrefix_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_LeftGCDMonoid_commonPrefix_Sum_Natural = unitTestData2-    [ ( m [0, 0, 0]-      , m [1, 2, 3]-      , m [0, 0, 0]-      )-    , ( m [1, 1, 1]-      , m [1, 2, 3]-      , m [1, 1, 1]-      )-    , ( m [2, 2, 2]-      , m [1, 2, 3]-      , m [1, 2, 2]-      )-    , ( m [3, 3, 3]-      , m [1, 2, 3]-      , m [1, 2, 3]-      )-    , ( m [4, 4, 4]-      , m [1, 2, 3]-      , m [1, 2, 3]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_LeftGCDMonoid_stripCommonPrefix_String :: Spec-exampleSpec_LeftGCDMonoid_stripCommonPrefix_String = unitTestSpec-    "LeftGCDMonoid.stripCommonPrefix (String)"-    "stripCommonPrefix"-    (stripCommonPrefix)-    (exampleData_LeftGCDMonoid_stripCommonPrefix_String)--exampleData_LeftGCDMonoid_stripCommonPrefix_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    ( MonoidMap LatinChar String-    , MonoidMap LatinChar String-    , MonoidMap LatinChar String-    )-exampleData_LeftGCDMonoid_stripCommonPrefix_String = unitTestData2-    [ (   m ["---", "---", "---"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m [""   , ""   , ""   ]-        , m ["---", "---", "---"]-        , m ["abc", "pqr", "xyz"]-        )-      )-    , (   m ["a--", "p--", "x--"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["a"  , "p"  , "x"  ]-        , m [ "--",  "--",  "--"]-        , m [ "bc",  "qr",  "yz"]-        )-      )-    , (   m ["ab-", "pq-", "xy-"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["ab" , "pq" , "xy" ]-        , m [  "-",   "-",   "-"]-        , m [  "c",   "r",   "z"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["abc", "pqr", "xyz"]-        , m [   "",    "",    ""]-        , m [   "",    "",    ""]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["ab-", "pq-", "xy-"]--      , ( m ["ab" , "pq" , "xy" ]-        , m [  "c",   "r",   "z"]-        , m [  "-",   "-",   "-"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["a--", "p--", "x--"]-      , ( m ["a"  , "p"  , "x"  ]-        , m [ "bc",  "qr",  "yz"]-        , m [ "--",  "--",  "--"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["---", "---", "---"]-      , ( m [""   , ""   , ""   ]-        , m ["abc", "pqr", "xyz"]-        , m ["---", "---", "---"]-        )-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_LeftGCDMonoid_stripCommonPrefix_Sum_Natural :: Spec-exampleSpec_LeftGCDMonoid_stripCommonPrefix_Sum_Natural = unitTestSpec-    "LeftGCDMonoid.stripCommonPrefix (Sum Natural)"-    "stripCommonPrefix"-    (stripCommonPrefix)-    (exampleData_LeftGCDMonoid_stripCommonPrefix_Sum_Natural)--exampleData_LeftGCDMonoid_stripCommonPrefix_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    ( MonoidMap LatinChar (Sum Natural)-    , MonoidMap LatinChar (Sum Natural)-    , MonoidMap LatinChar (Sum Natural)-    )-exampleData_LeftGCDMonoid_stripCommonPrefix_Sum_Natural = unitTestData2-    [ (   m [0, 1, 2, 3, 4]-      ,   m [4, 3, 2, 1, 0]--      , ( m [0, 1, 2, 1, 0]-        , m [0, 0, 0, 2, 4]-        , m [4, 2, 0, 0, 0]-        )-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- RightGCDMonoid-----------------------------------------------------------------------------------exampleSpec_RightGCDMonoid_commonSuffix_String :: Spec-exampleSpec_RightGCDMonoid_commonSuffix_String = unitTestSpec-    "RightGCDMonoid.commonSuffix (String)"-    "commonSuffix"-    (commonSuffix)-    (exampleData_RightGCDMonoid_commonSuffix_String)--exampleData_RightGCDMonoid_commonSuffix_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-exampleData_RightGCDMonoid_commonSuffix_String = unitTestData2-    [ ( m ["---", "---", "---"]-      , m ["abc", "pqr", "xyz"]-      , m [  "" ,    "",    ""]-      )-    , ( m ["--c", "--r", "--z"]-      , m ["abc", "pqr", "xyz"]-      , m [  "c",   "r",   "z"]-      )-    , ( m ["-bc", "-qr", "-yz"]-      , m ["abc", "pqr", "xyz"]-      , m [ "bc",  "qr",  "yz"]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"]-      , m ["abc", "pqr", "xyz"]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["-bc", "-qr", "-yz"]-      , m [ "bc",  "qr",  "yz"]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["--c", "--r", "--z"]-      , m [  "c",   "r",   "z"]-      )-    , ( m ["abc", "pqr", "xyz"]-      , m ["---", "---", "---"]-      , m [   "",    "",    ""]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_RightGCDMonoid_commonSuffix_Sum_Natural :: Spec-exampleSpec_RightGCDMonoid_commonSuffix_Sum_Natural = unitTestSpec-    "RightGCDMonoid.commonSuffix (Sum Natural)"-    "commonSuffix"-    (commonSuffix)-    (exampleData_RightGCDMonoid_commonSuffix_Sum_Natural)--exampleData_RightGCDMonoid_commonSuffix_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_RightGCDMonoid_commonSuffix_Sum_Natural = unitTestData2-    [ ( m [0, 0, 0]-      , m [1, 2, 3]-      , m [0, 0, 0]-      )-    , ( m [1, 1, 1]-      , m [1, 2, 3]-      , m [1, 1, 1]-      )-    , ( m [2, 2, 2]-      , m [1, 2, 3]-      , m [1, 2, 2]-      )-    , ( m [3, 3, 3]-      , m [1, 2, 3]-      , m [1, 2, 3]-      )-    , ( m [4, 4, 4]-      , m [1, 2, 3]-      , m [1, 2, 3]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_RightGCDMonoid_stripCommonSuffix_String :: Spec-exampleSpec_RightGCDMonoid_stripCommonSuffix_String = unitTestSpec-    "RightGCDMonoid.stripCommonSuffix (String)"-    "stripCommonSuffix"-    (stripCommonSuffix)-    (exampleData_RightGCDMonoid_stripCommonSuffix_String)--exampleData_RightGCDMonoid_stripCommonSuffix_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    ( MonoidMap LatinChar String-    , MonoidMap LatinChar String-    , MonoidMap LatinChar String-    )-exampleData_RightGCDMonoid_stripCommonSuffix_String = unitTestData2-    [ (   m ["---", "---", "---"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["---", "---", "---"]-        , m ["abc", "pqr", "xyz"]-        , m [   "",    "",    ""]-        )-      )-    , (   m ["--c", "--r", "--z"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["--" , "--" , "--" ]-        , m ["ab" , "pq" , "xy" ]-        , m [  "c",   "r",   "z"]-        )-      )-    , (   m ["--c", "--r", "--z"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["--" , "--" , "--" ]-        , m ["ab" , "pq" , "xy" ]-        , m [  "c",   "r",   "z"]-        )-      )-    , (   m ["-bc", "-qr", "-yz"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m ["-"  , "-"  , "-"  ]-        , m ["a"  , "p"  , "x"  ]-        , m [ "bc",  "qr",  "yz"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["abc", "pqr", "xyz"]--      , ( m [""   , ""   , ""   ]-        , m [""   , ""   , ""   ]-        , m ["abc", "pqr", "xyz"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["-bc", "-qr", "-yz"]--      , ( m ["a"  , "p"  , "x"  ]-        , m ["-"  , "-"  , "-"  ]-        , m [ "bc",  "qr",  "yz"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["--c", "--r", "--z"]--      , ( m ["ab" , "pq" , "xy" ]-        , m ["--" , "--" , "--" ]-        , m [  "c",   "r",   "z"]-        )-      )-    , (   m ["abc", "pqr", "xyz"]-      ,   m ["---", "---", "---"]--      , ( m ["abc", "pqr", "xyz"]-        , m ["---", "---", "---"]-        , m [   "",    "",    ""]-        )-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_RightGCDMonoid_stripCommonSuffix_Sum_Natural :: Spec-exampleSpec_RightGCDMonoid_stripCommonSuffix_Sum_Natural = unitTestSpec-    "RightGCDMonoid.stripCommonSuffix (Sum Natural)"-    "stripCommonSuffix"-    (stripCommonSuffix)-    (exampleData_RightGCDMonoid_stripCommonSuffix_Sum_Natural)--exampleData_RightGCDMonoid_stripCommonSuffix_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    ( MonoidMap LatinChar (Sum Natural)-    , MonoidMap LatinChar (Sum Natural)-    , MonoidMap LatinChar (Sum Natural)-    )-exampleData_RightGCDMonoid_stripCommonSuffix_Sum_Natural = unitTestData2-    [ (   m [0, 1, 2, 3, 4]-      ,   m [4, 3, 2, 1, 0]--      , ( m [0, 0, 0, 2, 4]-        , m [4, 2, 0, 0, 0]-        , m [0, 1, 2, 1, 0]-        )-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- OverlappingGCDMonoid-----------------------------------------------------------------------------------exampleSpec_OverlappingGCDMonoid_overlap_String :: Spec-exampleSpec_OverlappingGCDMonoid_overlap_String = unitTestSpec-    "OverlappingGCDMonoid.overlap (String)"-    "overlap"-    (overlap)-    (exampleData_OverlappingGCDMonoid_overlap_String)--exampleData_OverlappingGCDMonoid_overlap_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-exampleData_OverlappingGCDMonoid_overlap_String = unitTestData2-    [ ( m ["abcd"    , "0123"    ]-      , m [    "efgh",     "4567"]-      , m [    ""    ,     ""    ]-      )-    , ( m ["abcde"   , "01234"   ]-      , m [   "defgh",    "34567"]-      , m [   "de"   ,    "34"   ]-      )-    , ( m ["abcdef"  , "012345"  ]-      , m [  "cdefgh",   "234567"]-      , m [  "cdef"  ,   "2345"  ]-      )-    , ( m ["abcdefg" , "0123456" ]-      , m [ "bcdefgh",  "1234567"]-      , m [ "bcdefg" ,  "123456" ]-      )-    , ( m ["abcdefgh", "01234567"]-      , m ["abcdefgh", "01234567"]-      , m ["abcdefgh", "01234567"]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_OverlappingGCDMonoid_overlap_Sum_Natural :: Spec-exampleSpec_OverlappingGCDMonoid_overlap_Sum_Natural = unitTestSpec-    "OverlappingGCDMonoid.overlap (Sum Natural)"-    "overlap"-    (overlap)-    (exampleData_OverlappingGCDMonoid_overlap_Sum_Natural)--exampleData_OverlappingGCDMonoid_overlap_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_OverlappingGCDMonoid_overlap_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [0, 1, 2, 3, 4, 4, 3, 2, 1, 0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_String :: Spec-exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_String = unitTestSpec-    "OverlappingGCDMonoid.stripPrefixOverlap (String)"-    "stripPrefixOverlap"-    (stripPrefixOverlap)-    (exampleData_OverlappingGCDMonoid_stripPrefixOverlap_String)--exampleData_OverlappingGCDMonoid_stripPrefixOverlap_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-exampleData_OverlappingGCDMonoid_stripPrefixOverlap_String = unitTestData2-    [ ( m ["abcd"    , "0123"    ]-      , m [    "efgh",     "4567"]-      , m [    "efgh",     "4567"]-      )-    , ( m ["abcde"   , "01234"   ]-      , m [   "defgh",    "34567"]-      , m [     "fgh",      "567"]-      )-    , ( m ["abcdef"  , "012345"  ]-      , m [  "cdefgh",   "234567"]-      , m [      "gh",       "67"]-      )-    , ( m ["abcdefg" , "0123456" ]-      , m [ "bcdefgh",  "1234567"]-      , m [       "h",        "7"]-      )-    , ( m ["abcdefgh", "01234567"]-      , m ["abcdefgh", "01234567"]-      , m [        "",         ""]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_String :: Spec-exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_String = unitTestSpec-    "OverlappingGCDMonoid.stripSuffixOverlap (String)"-    "stripSuffixOverlap"-    (stripSuffixOverlap)-    (exampleData_OverlappingGCDMonoid_stripSuffixOverlap_String)--exampleData_OverlappingGCDMonoid_stripSuffixOverlap_String :: UnitTestData2-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-    (MonoidMap LatinChar String)-exampleData_OverlappingGCDMonoid_stripSuffixOverlap_String = unitTestData2-    [ ( m [    "efgh",     "4567"]-      , m ["abcd"    , "0123"    ]-      , m ["abcd"    , "0123"    ]-      )-    , ( m [   "defgh",    "34567"]-      , m ["abcde"   , "01234"   ]-      , m ["abc"     , "012"     ]-      )-    , ( m [  "cdefgh",   "234567"]-      , m ["abcdef"  , "012345"  ]-      , m ["ab"      , "01"      ]-      )-    , ( m [ "bcdefgh",  "1234567"]-      , m ["abcdefg" , "0123456" ]-      , m ["a"       , "0"       ]-      )-    , ( m ["abcdefgh", "01234567"]-      , m ["abcdefgh", "01234567"]-      , m [""        , ""        ]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural :: Spec-exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural = unitTestSpec-    "OverlappingGCDMonoid.stripPrefixOverlap (Sum Natural)"-    "stripPrefixOverlap"-    (stripPrefixOverlap)-    (exampleData_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural)--exampleData_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural-    :: UnitTestData2-        (MonoidMap LatinChar (Sum Natural))-        (MonoidMap LatinChar (Sum Natural))-        (MonoidMap LatinChar (Sum Natural))-exampleData_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [9, 7, 5, 3, 1, 0, 0, 0, 0, 0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural :: Spec-exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural = unitTestSpec-    "OverlappingGCDMonoid.stripSuffixOverlap (Sum Natural)"-    "stripSuffixOverlap"-    (stripSuffixOverlap)-    (exampleData_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural)--exampleData_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural-    :: UnitTestData2-        (MonoidMap LatinChar (Sum Natural))-        (MonoidMap LatinChar (Sum Natural))-        (MonoidMap LatinChar (Sum Natural))-exampleData_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [9, 7, 5, 3, 1, 0, 0, 0, 0, 0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- GCDMonoid-----------------------------------------------------------------------------------exampleSpec_GCDMonoid_gcd_Product_Natural :: Spec-exampleSpec_GCDMonoid_gcd_Product_Natural = unitTestSpec-    "GCDMonoid.gcd (Product Natural)"-    "gcd"-    (gcd)-    (exampleData_GCDMonoid_gcd_Product_Natural)--exampleData_GCDMonoid_gcd_Product_Natural :: UnitTestData2-    (MonoidMap LatinChar (Product Natural))-    (MonoidMap LatinChar (Product Natural))-    (MonoidMap LatinChar (Product Natural))-exampleData_GCDMonoid_gcd_Product_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]-      , m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]-      , m [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]-      , m [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]-      , m [3, 1, 1, 3, 1, 1, 3, 1, 1, 3]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [4, 4, 4, 4, 4, 4, 4, 4, 4, 4]-      , m [4, 1, 2, 1, 4, 1, 2, 1, 4, 1]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]-      , m [5, 1, 1, 1, 1, 5, 1, 1, 1, 1]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [6, 6, 6, 6, 6, 6, 6, 6, 6, 6]-      , m [6, 1, 2, 3, 2, 1, 6, 1, 2, 3]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [7, 7, 7, 7, 7, 7, 7, 7, 7, 7]-      , m [7, 1, 1, 1, 1, 1, 1, 7, 1, 1]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [8, 8, 8, 8, 8, 8, 8, 8, 8, 8]-      , m [8, 1, 2, 1, 4, 1, 2, 1, 8, 1]-      )-    , ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 9, 9, 9, 9, 9, 9, 9, 9, 9]-      , m [9, 1, 1, 3, 1, 1, 3, 1, 1, 9]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_GCDMonoid_gcd_Sum_Natural :: Spec-exampleSpec_GCDMonoid_gcd_Sum_Natural = unitTestSpec-    "GCDMonoid.gcd (Sum Natural)"-    "gcd"-    (gcd)-    (exampleData_GCDMonoid_gcd_Sum_Natural)--exampleData_GCDMonoid_gcd_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_GCDMonoid_gcd_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [0, 1, 2, 3, 4, 4, 3, 2, 1, 0]-      )-    , ( m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [0, 1, 2, 3, 4, 4, 3, 2, 1, 0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_GCDMonoid_gcd_Set_Natural :: Spec-exampleSpec_GCDMonoid_gcd_Set_Natural = unitTestSpec-    "GCDMonoid.gcd (Set Natural)"-    "gcd"-    (gcd)-    (exampleData_GCDMonoid_gcd_Set_Natural)--exampleData_GCDMonoid_gcd_Set_Natural :: UnitTestData2-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-exampleData_GCDMonoid_gcd_Set_Natural = unitTestData2-    [ ( m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[          ], [          ]]-      , m [[          ], [          ]]-      )-    , ( m [[          ], [          ]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[          ], [          ]]-      )-    , ( m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[   1, 2, 3], [   5, 6, 7]]-      , m [[   1, 2, 3], [   5, 6, 7]]-      )-    , ( m [[   1, 2, 3], [   5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[   1, 2, 3], [   5, 6, 7]]-      )-    , ( m [[0, 1, 2   ], [4, 5, 6   ]]-      , m [[   1, 2, 3], [   5, 6, 7]]-      , m [[   1, 2   ], [   5, 6   ]]-      )-    , ( m [[   1, 2, 3], [   5, 6, 7]]-      , m [[0, 1, 2   ], [4, 5, 6   ]]-      , m [[   1, 2   ], [   5, 6   ]]-      )-    , ( m [[0, 1      ], [4, 5      ]]-      , m [[      2, 3], [      6, 7]]-      , m [[          ], [          ]]-      )-    , ( m [[      2, 3], [      6, 7]]-      , m [[0, 1      ], [4, 5      ]]-      , m [[          ], [          ]]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList------------------------------------------------------------------------------------- LCMMonoid-----------------------------------------------------------------------------------exampleSpec_LCMMonoid_lcm_Product_Natural :: Spec-exampleSpec_LCMMonoid_lcm_Product_Natural = unitTestSpec-    "LCMMonoid.lcm (Product Natural)"-    "lcm"-    (lcm)-    (exampleData_LCMMonoid_lcm_Product_Natural)--exampleData_LCMMonoid_lcm_Product_Natural :: UnitTestData2-    (MonoidMap LatinChar (Product Natural))-    (MonoidMap LatinChar (Product Natural))-    (MonoidMap LatinChar (Product Natural))-exampleData_LCMMonoid_lcm_Product_Natural = unitTestData2-    [ ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]-      , m [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 1,  1,  1,  1,  1,  1,  1,  1,  1,  1]-      , m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 2,  2,  2,  2,  2,  2,  2,  2,  2,  2]-      , m [ 0,  2,  2,  6,  4, 10,  6, 14,  8, 18]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 3,  3,  3,  3,  3,  3,  3,  3,  3,  3]-      , m [ 0,  3,  6,  3, 12, 15,  6, 21, 24,  9]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 4,  4,  4,  4,  4,  4,  4,  4,  4,  4]-      , m [ 0,  4,  4, 12,  4, 20, 12, 28,  8, 36]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 5,  5,  5,  5,  5,  5,  5,  5,  5,  5]-      , m [ 0,  5, 10, 15, 20,  5, 30, 35, 40, 45]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 6,  6,  6,  6,  6,  6,  6,  6,  6,  6]-      , m [ 0,  6,  6,  6, 12, 30,  6, 42, 24, 18]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 7,  7,  7,  7,  7,  7,  7,  7,  7,  7]-      , m [ 0,  7, 14, 21, 28, 35, 42,  7, 56, 63]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 8,  8,  8,  8,  8,  8,  8,  8,  8,  8]-      , m [ 0,  8,  8, 24,  8, 40, 24, 56,  8, 72]-      )-    , ( m [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9]-      , m [ 9,  9,  9,  9,  9,  9,  9,  9,  9,  9]-      , m [ 0,  9, 18,  9, 36, 45, 18, 63, 72,  9]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_LCMMonoid_lcm_Sum_Natural :: Spec-exampleSpec_LCMMonoid_lcm_Sum_Natural = unitTestSpec-    "LCMMonoid.lcm (Sum Natural)"-    "lcm"-    (lcm)-    (exampleData_LCMMonoid_lcm_Sum_Natural)--exampleData_LCMMonoid_lcm_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_LCMMonoid_lcm_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [9, 8, 7, 6, 5, 5, 6, 7, 8, 9]-      )-    , ( m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-      , m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]-      , m [9, 8, 7, 6, 5, 5, 6, 7, 8, 9]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]--exampleSpec_LCMMonoid_lcm_Set_Natural :: Spec-exampleSpec_LCMMonoid_lcm_Set_Natural = unitTestSpec-    "LCMMonoid.lcm (Set Natural)"-    "lcm"-    (lcm)-    (exampleData_LCMMonoid_lcm_Set_Natural)--exampleData_LCMMonoid_lcm_Set_Natural :: UnitTestData2-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-exampleData_LCMMonoid_lcm_Set_Natural = unitTestData2-    [ ( m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[          ], [          ]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[          ], [          ]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[   1, 2, 3], [   5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[   1, 2, 3], [   5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[0, 1, 2   ], [4, 5, 6   ]]-      , m [[   1, 2, 3], [   5, 6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[   1, 2, 3], [   5, 6, 7]]-      , m [[0, 1, 2   ], [4, 5, 6   ]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[0, 1      ], [4, 5      ]]-      , m [[      2, 3], [      6, 7]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    , ( m [[      2, 3], [      6, 7]]-      , m [[0, 1      ], [4, 5      ]]-      , m [[0, 1, 2, 3], [4, 5, 6, 7]]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList------------------------------------------------------------------------------------- Monus-----------------------------------------------------------------------------------exampleSpec_Monus_monus_Set_Natural :: Spec-exampleSpec_Monus_monus_Set_Natural = unitTestSpec-    "Monus.monus (Set Natural)"-    "<\\>"-    (<\>)-    (exampleData_Monus_monus_Set_Natural)--exampleData_Monus_monus_Set_Natural :: UnitTestData2-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-    (MonoidMap LatinChar (Set Natural))-exampleData_Monus_monus_Set_Natural = unitTestData2-    [ ( m [[0, 1, 2], [3, 4, 5]]-      , m [[       ], [       ]]-      , m [[0, 1, 2], [3, 4, 5]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[0      ], [3      ]]-      , m [[   1, 2], [   4, 5]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[   1   ], [   4   ]]-      , m [[0,    2], [3,    5]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[      2], [      5]]-      , m [[0, 1   ], [3, 4   ]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[0, 1, 2], [3, 4, 5]]-      , m [[       ], [       ]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[3, 4, 5], [0, 1, 2]]-      , m [[0, 1, 2], [3, 4, 5]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[2, 3, 4], [1, 2, 3]]-      , m [[0, 1   ], [   4, 5]]-      )-    , ( m [[0, 1, 2], [3, 4, 5]]-      , m [[1, 2, 3], [2, 3, 4]]-      , m [[0      ], [      5]]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList--exampleSpec_Monus_monus_Sum_Natural :: Spec-exampleSpec_Monus_monus_Sum_Natural = unitTestSpec-    "Monus.monus (Sum Natural)"-    "<\\>"-    (<\>)-    (exampleData_Monus_monus_Sum_Natural)--exampleData_Monus_monus_Sum_Natural :: UnitTestData2-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-    (MonoidMap LatinChar (Sum Natural))-exampleData_Monus_monus_Sum_Natural = unitTestData2-    [ ( m [0, 1, 2, 3]-      , m [0, 0, 0, 0]-      , m [0, 1, 2, 3]-      )-    , ( m [0, 1, 2, 3]-      , m [1, 1, 1, 1]-      , m [0, 0, 1, 2]-      )-    , ( m [0, 1, 2, 3]-      , m [2, 2, 2, 2]-      , m [0, 0, 0, 1]-      )-    , ( m [0, 1, 2, 3]-      , m [3, 3, 3, 3]-      , m [0, 0, 0, 0]-      )-    , ( m [0, 1, 2, 3]-      , m [4, 4, 4, 4]-      , m [0, 0, 0, 0]-      )-    ]-  where-    m = MonoidMap.fromList . zip [A ..]------------------------------------------------------------------------------------- Utilities-----------------------------------------------------------------------------------data LatinChar-    = A | B | C | D | E | F | G | H | I | J | K | L | M-    | N | O | P | Q | R | S | T | U | V | W | X | Y | Z-    deriving (Bounded, Enum, Eq, Ord, Show, Data)

@@ -1,163 +0,0 @@-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.FilterSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Function-    ( (&) )-import Data.MonoidMap.Internal-    ( MonoidMap, nonNullCount )-import Data.Proxy-    ( Proxy (..) )-import GHC.Exts-    ( IsList (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesAll-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun (..), Property, applyFun, applyFun2, cover, (===) )--import qualified Data.List as List-import qualified Data.MonoidMap.Internal as MonoidMap--spec :: Spec-spec = describe "Filtering" $ do--    forM_ testValueTypesAll $-        \(TestValueType p) -> specFor (Proxy @Key) p--specFor :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specFor = makeSpec $ do--    it "prop_filter_get" $-        prop_filter_get-            @k @v & property-    it "prop_filter_asList" $-        prop_filter_asList-            @k @v & property-    it "prop_filterKeys_get" $-        prop_filterKeys_get-            @k @v & property-    it "prop_filterKeys_asList" $-        prop_filterKeys_asList-            @k @v & property-    it "prop_filterWithKey_get" $-        prop_filterWithKey_get-            @k @v & property-    it "prop_filterWithKey_asList" $-        prop_filterWithKey_asList-            @k @v & property--prop_filter_get-    :: Test k v => Fun v Bool -> k -> MonoidMap k v -> Property-prop_filter_get (applyFun -> f) k m =-    MonoidMap.get k (MonoidMap.filter f m)-        ===-        (MonoidMap.get k m & \v -> if f v then v else mempty)-    & cover 2-        (MonoidMap.nullKey k m && f (MonoidMap.get k m))-        "MonoidMap.nullKey k m && f (MonoidMap.get k m)"-    & cover 2-        (MonoidMap.nullKey k m && not (f (MonoidMap.get k m)))-        "MonoidMap.nullKey k m && not (f (MonoidMap.get k m))"-    & cover 2-        (MonoidMap.nonNullKey k m && f (MonoidMap.get k m))-        "MonoidMap.nonNullKey k m && f (MonoidMap.get k m)"-    & cover 2-        (MonoidMap.nonNullKey k m && not (f (MonoidMap.get k m)))-        "MonoidMap.nonNullKey k m && not (f (MonoidMap.get k m))"--prop_filter_asList-    :: Test k v => Fun v Bool -> MonoidMap k v -> Property-prop_filter_asList (applyFun -> f) m =-    n === fromList (List.filter (f . snd) (toList m))-    & cover 2-        (MonoidMap.nonNull n && nonNullCount n == nonNullCount m)-        "MonoidMap.nonNull n && nonNullCount n == nonNullCount m"-    & cover 2-        (MonoidMap.nonNull n && nonNullCount n /= nonNullCount m)-        "MonoidMap.nonNull n && nonNullCount n /= nonNullCount m"-  where-    n = MonoidMap.filter f m--prop_filterKeys_get-    :: Test k v => Fun k Bool -> k -> MonoidMap k v -> Property-prop_filterKeys_get (applyFun -> f) k m =-    MonoidMap.get k (MonoidMap.filterKeys f m)-        ===-        (if f k then MonoidMap.get k m else mempty)-    & cover 2-        (MonoidMap.nullKey k m && f k)-        "MonoidMap.nullKey k m && f k"-    & cover 2-        (MonoidMap.nullKey k m && not (f k))-        "MonoidMap.nullKey k m && not (f k)"-    & cover 2-        (MonoidMap.nonNullKey k m && f k)-        "MonoidMap.nonNullKey k m && f k"-    & cover 2-        (MonoidMap.nonNullKey k m && not (f k))-        "MonoidMap.nonNullKey k m && not (f k)"--prop_filterKeys_asList-    :: Test k v => Fun k Bool -> MonoidMap k v -> Property-prop_filterKeys_asList (applyFun -> f) m =-    n === MonoidMap.fromList (List.filter (f . fst) (toList m))-    & cover 2-        (MonoidMap.nonNull n && nonNullCount n == nonNullCount m)-        "MonoidMap.nonNull n && nonNullCount n == nonNullCount m"-    & cover 2-        (MonoidMap.nonNull n && nonNullCount n /= nonNullCount m)-        "MonoidMap.nonNull n && nonNullCount n /= nonNullCount m"-  where-    n = MonoidMap.filterKeys f m--prop_filterWithKey_get-    :: Test k v => Fun (k, v) Bool -> k -> MonoidMap k v -> Property-prop_filterWithKey_get (applyFun2 -> f) k m =-    MonoidMap.get k (MonoidMap.filterWithKey f m)-        ===-        (MonoidMap.get k m & \v -> if f k v then v else mempty)-    & cover 2-        (MonoidMap.nullKey k m && f k (MonoidMap.get k m))-        "MonoidMap.nullKey k m && f k (MonoidMap.get k m)"-    & cover 2-        (MonoidMap.nullKey k m && not (f k (MonoidMap.get k m)))-        "MonoidMap.nullKey k m && not (f k (MonoidMap.get k m))"-    & cover 2-        (MonoidMap.nonNullKey k m && f k (MonoidMap.get k m))-        "MonoidMap.nonNullKey k m && f k (MonoidMap.get k m)"-    & cover 2-        (MonoidMap.nonNullKey k m && not (f k (MonoidMap.get k m)))-        "MonoidMap.nonNullKey k m && not (f k (MonoidMap.get k m))"--prop_filterWithKey_asList-    :: Test k v => Fun (k, v) Bool -> MonoidMap k v -> Property-prop_filterWithKey_asList (applyFun2 -> f) m =-    n === MonoidMap.fromList (List.filter (uncurry f) (toList m))-    & cover 2-        (MonoidMap.nonNull n && nonNullCount n == nonNullCount m)-        "MonoidMap.nonNull n && nonNullCount n == nonNullCount m"-    & cover 2-        (MonoidMap.nonNull n && nonNullCount n /= nonNullCount m)-        "MonoidMap.nonNull n && nonNullCount n /= nonNullCount m"-  where-    n = MonoidMap.filterWithKey f m

@@ -1,194 +0,0 @@--- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.FoldSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Function-    ( (&) )-import Data.MonoidMap.Internal-    ( MonoidMap )-import Data.Proxy-    ( Proxy (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesAll-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun (..), Property, applyFun2, applyFun3, (===) )--import qualified Data.Map.Strict as Map-import qualified Data.MonoidMap.Internal as MonoidMap--spec :: Spec-spec = describe "Folding" $ do--    forM_ testValueTypesAll $-        \(TestValueType p) -> specFor (Proxy @Key) p--specFor :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specFor = makeSpec $ do--    describe "Lazy" $ do--        it "prop_equivalence_foldl" $-            prop_equivalence_foldl-                @k @v & property-        it "prop_equivalence_foldr" $-            prop_equivalence_foldr-                @k @v & property-        it "prop_equivalence_foldlWithKey" $-            prop_equivalence_foldlWithKey-                @k @v & property-        it "prop_equivalence_foldrWithKey" $-            prop_equivalence_foldrWithKey-                @k @v & property-        it "prop_equivalence_foldMapWithKey" $-            prop_equivalence_foldMapWithKey-                @k @v & property--    describe "Strict" $ do--        it "prop_equivalence_foldl'" $-            prop_equivalence_foldl'-                @k @v & property-        it "prop_equivalence_foldr'" $-            prop_equivalence_foldr'-                @k @v & property-        it "prop_equivalence_foldlWithKey'" $-            prop_equivalence_foldlWithKey'-                @k @v & property-        it "prop_equivalence_foldrWithKey'" $-            prop_equivalence_foldrWithKey'-                @k @v & property-        it "prop_equivalence_foldMapWithKey'" $-            prop_equivalence_foldMapWithKey'-                @k @v & property------------------------------------------------------------------------------------- Lazy folding-----------------------------------------------------------------------------------prop_equivalence_foldl-    :: Test k v-    => r ~ v-    => Fun (r, v) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldl (applyFun2 -> f) r m =-    MonoidMap.foldl f r m-      === Map.foldl f r (MonoidMap.toMap m)--prop_equivalence_foldr-    :: Test k v-    => r ~ v-    => Fun (v, r) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldr (applyFun2 -> f) r m =-    MonoidMap.foldr f r m-      === Map.foldr f r (MonoidMap.toMap m)--prop_equivalence_foldlWithKey-    :: Test k v-    => r ~ v-    => Fun (r, k, v) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldlWithKey (applyFun3 -> f) r m =-    MonoidMap.foldlWithKey f r m-      === Map.foldlWithKey f r (MonoidMap.toMap m)--prop_equivalence_foldrWithKey-    :: Test k v-    => r ~ v-    => Fun (k, v, r) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldrWithKey (applyFun3 -> f) r m =-    MonoidMap.foldrWithKey f r m-      === Map.foldrWithKey f r (MonoidMap.toMap m)--prop_equivalence_foldMapWithKey-    :: Test k v-    => r ~ v-    => Fun (k, v) r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldMapWithKey (applyFun2 -> f) m =-    MonoidMap.foldMapWithKey f m-      === Map.foldMapWithKey f (MonoidMap.toMap m)------------------------------------------------------------------------------------- Strict folding-----------------------------------------------------------------------------------prop_equivalence_foldl'-    :: Test k v-    => r ~ v-    => Fun (r, v) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldl' (applyFun2 -> f) r m =-    MonoidMap.foldl' f r m ===-    MonoidMap.foldl  f r m--prop_equivalence_foldr'-    :: Test k v-    => r ~ v-    => Fun (v, r) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldr' (applyFun2 -> f) r m =-    MonoidMap.foldr' f r m ===-    MonoidMap.foldr  f r m--prop_equivalence_foldlWithKey'-    :: Test k v-    => r ~ v-    => Fun (r, k, v) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldlWithKey' (applyFun3 -> f) r m =-    MonoidMap.foldlWithKey' f r m ===-    MonoidMap.foldlWithKey  f r m--prop_equivalence_foldrWithKey'-    :: Test k v-    => r ~ v-    => Fun (k, v, r) r-    -> r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldrWithKey' (applyFun3 -> f) r m =-    MonoidMap.foldrWithKey' f r m ===-    MonoidMap.foldrWithKey  f r m--prop_equivalence_foldMapWithKey'-    :: Test k v-    => r ~ v-    => Fun (k, v) r-    -> MonoidMap k v-    -> Property-prop_equivalence_foldMapWithKey' (applyFun2 -> f) m =-    MonoidMap.foldMapWithKey' f m ===-    MonoidMap.foldMapWithKey  f m

@@ -1,193 +0,0 @@-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.IntersectionSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Function-    ( (&) )-import Data.Functor.Identity-    ( Identity (..) )-import Data.Monoid.Cancellative-    ( GCDMonoid )-import Data.MonoidMap.Internal-    ( MonoidMap )-import Data.Proxy-    ( Proxy (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesGCDMonoid-    , testValueTypesAll-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun (..), Property, applyFun2, conjoin, cover, expectFailure, (===) )--import qualified Data.Monoid.Null as Null-import qualified Data.MonoidMap.Internal as MonoidMap-import qualified Data.Set as Set--spec :: Spec-spec = describe "Intersection" $ do--    forM_ testValueTypesAll $-        \(TestValueType p) -> specMonoidNull-            (Proxy @Key) p-    forM_ testValueTypesGCDMonoid $-        \(TestValueType p) -> specGCDMonoid-            (Proxy @Key) p--specMonoidNull :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specMonoidNull = makeSpec $ do-    it "prop_intersectionWith_get" $-        prop_intersectionWith_get-            @k @v & property-    it "prop_intersectionWith_get_total" $-        prop_intersectionWith_get_total-            @k @v & property-    it "prop_intersectionWith_get_total_failure" $-        prop_intersectionWith_get_total_failure-            @k @v & property-    it "prop_intersectionWith_intersectionWithA" $-        prop_intersectionWith_intersectionWithA-            @k @v & property--specGCDMonoid-    :: forall k v. (Test k v, GCDMonoid v) => Proxy k -> Proxy v -> Spec-specGCDMonoid = makeSpec $ do-    it "prop_intersection_isSubmapOf" $-        prop_intersection_isSubmapOf-            @k @v & property--prop_intersection_isSubmapOf-    :: (Test k v, GCDMonoid v)-    => MonoidMap k v-    -> MonoidMap k v-    -> Property-prop_intersection_isSubmapOf m1 m2 = conjoin-    [ intersection_m1_m2 `MonoidMap.isSubmapOf` m1-    , intersection_m1_m2 `MonoidMap.isSubmapOf` m2-    ]-    & cover 2-        (m1 /= m2 && MonoidMap.nonNull (intersection_m1_m2))-        "m1 /= m2 && MonoidMap.nonNull (intersection_m1_m2)"-  where-    intersection_m1_m2 = MonoidMap.intersection m1 m2--prop_intersectionWith_get-    :: Test k v-    => Fun (v, v) v-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_intersectionWith_get (applyFun2 -> f) m1 m2 k =-    (MonoidMap.get k result-        ===-        if keyWithinIntersection-        then f (MonoidMap.get k m1) (MonoidMap.get k m2)-        else mempty)-    & cover 2-        (keyWithinIntersection)-        "keyWithinIntersection"-    & cover 2-        (not keyWithinIntersection)-        "not keyWithinIntersection"-    & cover 2-        (MonoidMap.null result)-        "MonoidMap.null result"-    & cover 2-        (MonoidMap.nonNull result)-        "MonoidMap.nonNull result"-    & cover 2-        (MonoidMap.nullKey k result)-        "MonoidMap.nullKey k result"-    & cover 2-        (MonoidMap.nonNullKey k result)-        "MonoidMap.nonNullKey k result"-  where-    keyWithinIntersection =-        k `Set.member` Set.intersection-            (MonoidMap.nonNullKeys m1)-            (MonoidMap.nonNullKeys m2)-    result =-        MonoidMap.intersectionWith f m1 m2--prop_intersectionWith_get_total-    :: Test k v-    => Fun (v, v) v-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_intersectionWith_get_total (applyFun2 -> f0) m1 m2 k =-    (MonoidMap.get k result-        ===-        f (MonoidMap.get k m1) (MonoidMap.get k m2))-    & cover 2-        (keyWithinIntersection)-        "keyWithinIntersection"-    & cover 2-        (not keyWithinIntersection)-        "not keyWithinIntersection"-    & cover 2-        (MonoidMap.null result)-        "MonoidMap.null result"-    & cover 2-        (MonoidMap.nonNull result)-        "MonoidMap.nonNull result"-    & cover 2-        (MonoidMap.nullKey k result)-        "MonoidMap.nullKey k result"-    & cover 2-        (MonoidMap.nonNullKey k result)-        "MonoidMap.nonNullKey k result"-  where-    result =-        MonoidMap.intersectionWith f m1 m2-    keyWithinIntersection =-        k `Set.member` Set.intersection-            (MonoidMap.nonNullKeys m1)-            (MonoidMap.nonNullKeys m2)-    f v1 v2-        | Null.null v1 = mempty-        | Null.null v2 = mempty-        | otherwise = f0 v1 v2--prop_intersectionWith_get_total_failure-    :: Test k v-    => Fun (v, v) v-    -> MonoidMap k v-    -> MonoidMap k v-    -> k-    -> Property-prop_intersectionWith_get_total_failure (applyFun2 -> f) m1 m2 k =-    expectFailure $-    MonoidMap.get k (MonoidMap.intersectionWith f m1 m2)-        ===-        f (MonoidMap.get k m1) (MonoidMap.get k m2)--prop_intersectionWith_intersectionWithA-    :: Test k v-    => Fun (v, v) v-    -> MonoidMap k v-    -> MonoidMap k v-    -> Property-prop_intersectionWith_intersectionWithA (applyFun2 -> f) m1 m2 =-    runIdentity (MonoidMap.intersectionWithA ((fmap . fmap) Identity f) m1 m2)-    ===         (MonoidMap.intersectionWith                          f  m1 m2)

@@ -1,300 +0,0 @@-{- HLINT ignore "Redundant bracket" -}-{- HLINT ignore "Use camelCase" -}-{- HLINT ignore "Use null" -}---- |--- Copyright: © 2022–2026 Jonathan Knowles--- License: Apache-2.0----module Data.MonoidMap.Internal.MapSpec-    ( spec-    ) where--import Prelude--import Control.Monad-    ( forM_ )-import Data.Bifunctor-    ( first, second )-import Data.Function-    ( (&) )-import Data.Monoid.Null-    ( MonoidNull )-import Data.MonoidMap.Internal-    ( MonoidMap, nonNullCount )-import Data.Proxy-    ( Proxy (..) )-import Test.Common-    ( Key-    , Test-    , TestValueType (TestValueType)-    , makeSpec-    , property-    , testValueTypesAll-    )-import Test.Hspec-    ( Spec, describe, it )-import Test.QuickCheck-    ( Fun (..), Property, applyFun, applyFun2, cover, expectFailure, (===) )--import qualified Data.Foldable as F-import qualified Data.Monoid.Null as Null-import qualified Data.MonoidMap.Internal as MonoidMap-import qualified Data.Set as Set--spec :: Spec-spec = describe "Mapping" $ do--    forM_ testValueTypesAll $-        \(TestValueType p) -> specFor (Proxy @Key) p--specFor :: forall k v. Test k v => Proxy k -> Proxy v -> Spec-specFor = makeSpec $ do--    it "prop_map_asList" $-        prop_map_asList-            @k @v & property-    it "prop_map_composition" $-        prop_map_composition-            @k @v & property-    it "prop_map_composition_failure" $-        prop_map_composition_failure-            @k @v & property-    it "prop_map_get" $-        prop_map_get-            @k @v & property-    it "prop_map_get_total" $-        prop_map_get_total-            @k @v & property-    it "prop_map_get_total_failure" $-        prop_map_get_total_failure-            @k @v & property-    it "prop_mapKeys_asList" $-        prop_mapKeys_asList-            @k @v & property-    it "prop_mapKeys_get" $-        prop_mapKeys_get-            @k @v & property-    it "prop_mapKeysWith_asList" $-        prop_mapKeysWith_asList-            @k @v & property-    it "prop_mapWithKey_asList" $-        prop_mapWithKey_asList-            @k @v & property-    it "prop_mapWithKey_get" $-        prop_mapWithKey_get-            @k @v & property-    it "prop_mapWithKey_get_total" $-        prop_mapWithKey_get_total-            @k @v & property-    it "prop_mapWithKey_get_total_failure" $-        prop_mapWithKey_get_total_failure-            @k @v & property------------------------------------------------------------------------------------- Mapping-----------------------------------------------------------------------------------prop_map_asList-    :: Test k v-    => Fun v v-    -> MonoidMap k v-    -> Property-prop_map_asList (applyFun -> f) m =-    n === (MonoidMap.fromList . fmap (second f) . MonoidMap.toList $ m)-    & cover 2-        (0 < nonNullCount n && nonNullCount n < nonNullCount m)-        "0 < nonNullCount n && nonNullCount n < nonNullCount m"-  where-    n = MonoidMap.map f m--prop_map_composition-    :: forall k v. Test k v-    => Fun v v-    -> Fun v v-    -> MonoidMap k v-    -> Property-prop_map_composition (applyFun -> f0) (applyFun -> g0) m =-    MonoidMap.map (f . g) m === MonoidMap.map f (MonoidMap.map g m)-    & cover 2-        (MonoidMap.nonNull m)-        "MonoidMap.nonNull m"-  where-    f = toNullPreservingFn f0-    g = g0--prop_map_composition_failure-    :: forall k v. Test k v-    => Fun v v-    -> Fun v v-    -> MonoidMap k v-    -> Property-prop_map_composition_failure (applyFun -> f) (applyFun -> g) m =-    expectFailure $-    MonoidMap.map (f . g) m === MonoidMap.map f (MonoidMap.map g m)-    & cover 1-        (MonoidMap.map (f . g) m /= MonoidMap.map f (MonoidMap.map g m))-        "MonoidMap.map (f . g) m /= MonoidMap.map f (MonoidMap.map g m)"--prop_map_get-    :: Test k v-    => Fun v v-    -> k-    -> MonoidMap k v-    -> Property-prop_map_get (applyFun -> f) k m =-    MonoidMap.get k (MonoidMap.map f m)-    ===-    (if MonoidMap.nullKey k m then mempty else f (MonoidMap.get k m))-    & cover 2-        (MonoidMap.nullKey k m)-        "MonoidMap.nullKey k m"-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"--prop_map_get_total-    :: forall k v. Test k v-    => Fun v v-    -> k-    -> MonoidMap k v-    -> Property-prop_map_get_total (applyFun -> f0) k m =-    MonoidMap.get k (MonoidMap.map f m) === f (MonoidMap.get k m)-    & cover 2-        (MonoidMap.nullKey k m)-        "MonoidMap.nullKey k m"-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"-  where-    f = toNullPreservingFn f0--prop_map_get_total_failure-    :: Test k v-    => Fun v v-    -> k-    -> MonoidMap k v-    -> Property-prop_map_get_total_failure (applyFun -> f) k m =-    expectFailure $-    MonoidMap.get k (MonoidMap.map f m) === f (MonoidMap.get k m)--prop_mapKeys_asList-    :: Test k v-    => Fun k k-    -> MonoidMap k v-    -> Property-prop_mapKeys_asList (applyFun -> f) m =-    n === (MonoidMap.fromList . fmap (first f) . MonoidMap.toList $ m)-    & cover 2-        (0 < nonNullCount n && nonNullCount n < nonNullCount m)-        "0 < nonNullCount n && nonNullCount n < nonNullCount m"-  where-    n = MonoidMap.mapKeys f m--prop_mapKeys_get-    :: Test k v-    => Fun k k-    -> k-    -> MonoidMap k v-    -> Property-prop_mapKeys_get (applyFun -> f) k m =-    MonoidMap.get k (MonoidMap.mapKeys f m)-        ===-        F.foldMap-            (`MonoidMap.get` m)-            (Set.filter ((==) k . f) (MonoidMap.nonNullKeys m))-    & cover 2-        (MonoidMap.nullKey k (MonoidMap.mapKeys f m))-        "MonoidMap.nullKey k (MonoidMap.mapKeys f m)"-    & cover 2-        (MonoidMap.nonNullKey k (MonoidMap.mapKeys f m))-        "MonoidMap.nonNullKey k (MonoidMap.mapKeys f m)"--prop_mapKeysWith_asList-    :: Test k v-    => Fun (v, v) v-    -> Fun k k-    -> MonoidMap k v-    -> Property-prop_mapKeysWith_asList (applyFun2 -> c) (applyFun -> f) m =-    n === (MonoidMap.fromListWith c . fmap (first f) . MonoidMap.toList $ m)-    & cover 2-        (0 < nonNullCount n && nonNullCount n < nonNullCount m)-        "0 < nonNullCount n && nonNullCount n < nonNullCount m"-  where-    n = MonoidMap.mapKeysWith c f m--prop_mapWithKey_asList-    :: Test k v-    => Fun (k, v) v-    -> MonoidMap k v-    -> Property-prop_mapWithKey_asList (applyFun2 -> f) m =-    n ===-        ( MonoidMap.fromList-        . fmap (\(k, v) -> (k, (f k v)))-        . MonoidMap.toList-        $ m-        )-    & cover 2-        (0 < nonNullCount n && nonNullCount n < nonNullCount m)-        "0 < nonNullCount n && nonNullCount n < nonNullCount m"-  where-    n = MonoidMap.mapWithKey f m--prop_mapWithKey_get-    :: Test k v-    => Fun (k, v) v-    -> k-    -> MonoidMap k v-    -> Property-prop_mapWithKey_get (applyFun2 -> f) k m =-    MonoidMap.get k (MonoidMap.mapWithKey f m)-    ===-    (if MonoidMap.nullKey k m then mempty else f k (MonoidMap.get k m))-    & cover 2-        (MonoidMap.nullKey k m)-        "MonoidMap.nullKey k m"-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"--prop_mapWithKey_get_total-    :: forall k v. Test k v-    => Fun (k, v) v-    -> k-    -> MonoidMap k v-    -> Property-prop_mapWithKey_get_total (applyFun2 -> f0) k m =-    MonoidMap.get k (MonoidMap.mapWithKey f m) === f k (MonoidMap.get k m)-    & cover 2-        (MonoidMap.nullKey k m)-        "MonoidMap.nullKey k m"-    & cover 2-        (MonoidMap.nonNullKey k m)-        "MonoidMap.nonNullKey k m"-  where-    f = toNullPreservingFn . f0--prop_mapWithKey_get_total_failure-    :: Test k v-    => Fun (k, v) v-    -> k-    -> MonoidMap k v-    -> Property-prop_mapWithKey_get_total_failure (applyFun2 -> f) k m =-    expectFailure $-    MonoidMap.get k (MonoidMap.mapWithKey f m) === f k (MonoidMap.get k m)------------------------------------------------------------------------------------- Utilities------------------------------------------------------------------------------------- | Creates a function that never maps null values to non-null values.----toNullPreservingFn :: MonoidNull v => (v -> v) -> (v -> v)-toNullPreservingFn f v-    | Null.null v = v-    | otherwise = f v