{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
module Tests.IntMap (intMapTests) where
import Control.Applicative
import Control.Comonad
import Data.Coerce
import Data.Foldable
import Data.Functor.Identity
import Data.List.NonEmpty (NonEmpty(..))
import Data.Semigroup.Foldable
import Data.Text (Text)
import Hedgehog
import Test.Tasty
import Tests.Util
import qualified Data.IntMap as M
import qualified Data.IntMap.NonEmpty as NEM
import qualified Data.IntMap.NonEmpty.Internal as NEM
import qualified Data.List.NonEmpty as NE
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range
intMapTests :: TestTree
intMapTests = groupTree $$(discover)
prop_valid :: Property
prop_valid = property $
assert . NEM.valid =<< forAll neIntMapGen
-- | We cannot implement these because there is no 'valid' for IntSet
-- prop_valid_toMap :: Property
-- prop_valid_toMap = property $
-- assert . M.valid . NEM.toMap =<< forAll neIntMapGen
-- prop_valid_insertMinIntMap :: Property
-- prop_valid_insertMinIntMap = property $ do
-- n <- forAll $ do
-- m <- intMapGen
-- let k = maybe 0 (subtract 1 . fst) $ M.lookupMin m
-- v <- valGen
-- pure $ NEM.insertMinIntMap k v m
-- assert $ M.valid n
-- prop_valid_insertMaxIntMap :: Property
-- prop_valid_insertMaxIntMap = property $ do
-- n <- forAll $ do
-- m <- intMapGen
-- let k = maybe 0 ((+ 1) . fst) $ M.lookupMax m
-- v <- valGen
-- pure $ NEM.insertMaxIntMap k v m
-- assert $ M.valid n
prop_valid_insertMapMin :: Property
prop_valid_insertMapMin = property $ do
n <- forAll $ do
m <- intMapGen
let k = maybe 0 (subtract 1 . fst) $ NEM.lookupMinMap m
v <- valGen
pure $ NEM.insertMapMin k v m
assert $ NEM.valid n
prop_valid_insertMapMax :: Property
prop_valid_insertMapMax = property $ do
n <- forAll $ do
m <- intMapGen
let k = maybe 0 ((+ 1) . fst) $ NEM.lookupMaxMap m
v <- valGen
pure $ NEM.insertMapMax k v m
assert $ NEM.valid n
prop_toMapIso1 :: Property
prop_toMapIso1 = property $ do
m0 <- forAll intMapGen
tripping m0 (NEM.nonEmptyMap)
(Identity . maybe M.empty NEM.toMap)
prop_toMapIso2 :: Property
prop_toMapIso2 = property $ do
m0 <- forAll $ Gen.maybe neIntMapGen
tripping m0 (maybe M.empty NEM.toMap)
(Identity . NEM.nonEmptyMap)
prop_read_show :: Property
prop_read_show = readShow neIntMapGen
prop_read1_show1 :: Property
prop_read1_show1 = readShow1 neIntMapGen
prop_show_show1 :: Property
prop_show_show1 = showShow1 neIntMapGen
prop_splitRoot :: Property
prop_splitRoot = property $ do
n <- forAll neIntMapGen
let rs = NEM.splitRoot n
allItems = foldMap1 NEM.keys rs
n' = NEM.unions rs
assert $ ascending allItems
mapM_ (assert . (`NEM.isSubmapOf` n)) rs
length allItems === length n'
n === n'
where
ascending (x :| xs) = case NE.nonEmpty xs of
Nothing -> True
Just ys@(y :| _) -> x < y && ascending ys
prop_extract_duplicate :: Property
prop_extract_duplicate = property $ do
n <- forAll neIntMapGen
tripping n duplicate
(Identity . extract)
prop_fmap_extract_duplicate :: Property
prop_fmap_extract_duplicate = property $ do
n <- forAll neIntMapGen
tripping n duplicate
(Identity . fmap extract)
prop_duplicate_duplicate :: Property
prop_duplicate_duplicate = property $ do
n <- forAll neIntMapGen
let dd1 = duplicate . duplicate $ n
dd2 = fmap duplicate . duplicate $ n
assert $ NEM.valid dd1
assert $ NEM.valid dd2
dd1 === dd2
prop_insertMapWithKey :: Property
prop_insertMapWithKey = ttProp (gf3 valGen :?> GTIntKey :-> GTVal :-> GTIntMap :-> TTNEIntMap)
M.insertWithKey
NEM.insertMapWithKey
prop_singleton :: Property
prop_singleton = ttProp (GTIntKey :-> GTVal :-> TTNEIntMap)
M.singleton
NEM.singleton
prop_fromSet :: Property
prop_fromSet = ttProp (gf1 valGen :?> GTNEIntSet :-> TTNEIntMap)
M.fromSet
NEM.fromSet
prop_fromAscList :: Property
prop_fromAscList = ttProp (GTSorted STAsc (GTNEList Nothing (GTIntKey :&: GTVal)) :-> TTNEIntMap)
M.fromAscList
NEM.fromAscList
prop_fromAscListWithKey :: Property
prop_fromAscListWithKey = ttProp (gf3 valGen :?> GTSorted STAsc (GTNEList Nothing (GTIntKey :&: GTVal)) :-> TTNEIntMap)
M.fromAscListWithKey
NEM.fromAscListWithKey
prop_fromDistinctAscList :: Property
prop_fromDistinctAscList = ttProp (GTSorted STDistinctAsc (GTNEList Nothing (GTIntKey :&: GTVal)) :-> TTNEIntMap)
M.fromDistinctAscList
NEM.fromDistinctAscList
prop_fromListWithKey :: Property
prop_fromListWithKey = ttProp (gf3 valGen :?> GTNEList Nothing (GTIntKey :&: GTVal) :-> TTNEIntMap)
M.fromListWithKey
NEM.fromListWithKey
prop_insert :: Property
prop_insert = ttProp (GTIntKey :-> GTVal :-> GTNEIntMap :-> TTNEIntMap)
M.insert
NEM.insert
prop_insertWithKey :: Property
prop_insertWithKey = ttProp (gf3 valGen :?> GTIntKey :-> GTVal :-> GTNEIntMap :-> TTNEIntMap)
M.insertWithKey
NEM.insertWithKey
prop_delete :: Property
prop_delete = ttProp (GTIntKey :-> GTNEIntMap :-> TTOther)
M.delete
NEM.delete
prop_adjustWithKey :: Property
prop_adjustWithKey = ttProp (gf2 valGen :?> GTIntKey :-> GTNEIntMap :-> TTNEIntMap)
M.adjustWithKey
NEM.adjustWithKey
prop_updateWithKey :: Property
prop_updateWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTIntKey :-> GTNEIntMap :-> TTOther)
M.updateWithKey
NEM.updateWithKey
prop_updateLookupWithKey :: Property
prop_updateLookupWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTIntKey :-> GTNEIntMap :-> TTMaybe TTVal :*: TTOther)
M.updateLookupWithKey
NEM.updateLookupWithKey
prop_alter :: Property
prop_alter = ttProp (gf1 (Gen.maybe valGen) :?> GTIntKey :-> GTNEIntMap :-> TTOther)
M.alter
NEM.alter
prop_alter' :: Property
prop_alter' = ttProp (gf1 valGen :?> GTIntKey :-> GTNEIntMap :-> TTNEIntMap)
(M.alter . fmap Just)
NEM.alter'
prop_alterF :: Property
prop_alterF = ttProp ( gf1 (Gen.maybe valGen)
:?> GTIntKey
:-> GTNEIntMap
:-> TTCtx (GTMaybe GTVal :-> TTOther) (TTMaybe TTVal)
)
(M.alterF . Context)
(NEM.alterF . Context)
prop_alterF_rules_Const :: Property
prop_alterF_rules_Const = ttProp ( gf1 (Const <$> valGen)
:?> GTIntKey
:-> GTNEIntMap
:-> TTOther
)
(\f k m -> getConst (M.alterF f k m))
(\f k m -> getConst (NEM.alterF f k m))
prop_alterF_rules_Identity :: Property
prop_alterF_rules_Identity = ttProp ( gf1 (Identity <$> Gen.maybe valGen)
:?> GTIntKey
:-> GTNEIntMap
:-> TTOther
)
(\f k m -> runIdentity (M.alterF f k m))
(\f k m -> runIdentity (NEM.alterF f k m))
prop_alterF' :: Property
prop_alterF' = ttProp (gf1 valGen :?> GTIntKey :-> GTNEIntMap :-> TTCtx (GTVal :-> TTNEIntMap) (TTMaybe TTVal))
(M.alterF . Context . fmap Just)
(NEM.alterF' . Context)
prop_alterF'_rules_Const :: Property
prop_alterF'_rules_Const = ttProp ( gf1 (Const <$> valGen)
:?> GTIntKey
:-> GTNEIntMap
:-> TTOther
)
(\f k m -> let f' = fmap Just . f in getConst (M.alterF f' k m))
(\f k m -> getConst (NEM.alterF' f k m))
-- -- | This fails, but isn't possible to fix without copying-and-pasting more
-- -- in code from containers.
-- prop_alterF'_rules_Identity :: Property
-- prop_alterF'_rules_Identity = ttProp ( gf1 (Identity <$> valGen)
-- :?> GTIntKey
-- :-> GTNEIntMap
-- :-> TTNEIntMap
-- )
-- (\f k m -> let f' = fmap Just . f in runIdentity (M.alterF f' k m))
-- (\f k m -> runIdentity (NEM.alterF' f k m))
prop_lookup :: Property
prop_lookup = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe TTVal)
M.lookup
NEM.lookup
prop_findWithDefault :: Property
prop_findWithDefault = ttProp (GTVal :-> GTIntKey :-> GTNEIntMap :-> TTVal)
M.findWithDefault
NEM.findWithDefault
prop_member :: Property
prop_member = ttProp (GTIntKey :-> GTNEIntMap :-> TTOther)
M.member
NEM.member
prop_notMember :: Property
prop_notMember = ttProp (GTIntKey :-> GTNEIntMap :-> TTOther)
M.notMember
NEM.notMember
prop_lookupLT :: Property
prop_lookupLT = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
M.lookupLT
NEM.lookupLT
prop_lookupGT :: Property
prop_lookupGT = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
M.lookupGT
NEM.lookupGT
prop_lookupLE :: Property
prop_lookupLE = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
M.lookupLE
NEM.lookupLE
prop_lookupGE :: Property
prop_lookupGE = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
M.lookupGE
NEM.lookupGE
prop_size :: Property
prop_size = ttProp (GTNEIntMap :-> TTOther)
M.size
NEM.size
prop_union :: Property
prop_union = ttProp (GTNEIntMap :-> GTNEIntMap :-> TTNEIntMap)
M.union
NEM.union
prop_unionWith :: Property
prop_unionWith = ttProp (gf2 valGen :?> GTNEIntMap :-> GTNEIntMap :-> TTNEIntMap)
M.unionWith
NEM.unionWith
prop_unionWithKey :: Property
prop_unionWithKey = ttProp (gf3 valGen :?> GTNEIntMap :-> GTNEIntMap :-> TTNEIntMap)
M.unionWithKey
NEM.unionWithKey
prop_unions :: Property
prop_unions = ttProp (GTNEList (Just (Range.linear 2 5)) GTNEIntMap :-> TTNEIntMap)
M.unions
NEM.unions
prop_unionsWith :: Property
prop_unionsWith = ttProp (gf2 valGen :?> GTNEList (Just (Range.linear 2 5)) GTNEIntMap :-> TTNEIntMap)
M.unionsWith
NEM.unionsWith
prop_difference :: Property
prop_difference = ttProp (GTNEIntMap :-> GTNEIntMap :-> TTOther)
M.difference
NEM.difference
prop_differenceWithKey :: Property
prop_differenceWithKey = ttProp (gf3 (Gen.maybe valGen) :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
M.differenceWithKey
NEM.differenceWithKey
prop_intersection :: Property
prop_intersection = ttProp (GTNEIntMap :-> GTNEIntMap :-> TTOther)
M.intersection
NEM.intersection
prop_intersectionWithKey :: Property
prop_intersectionWithKey = ttProp (gf3 valGen :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
M.intersectionWithKey
NEM.intersectionWithKey
prop_map :: Property
prop_map = ttProp (gf1 valGen :?> GTNEIntMap :-> TTNEIntMap)
M.map
NEM.map
prop_map_rules_map :: Property
prop_map_rules_map = ttProp (gf1 valGen :?> gf1 valGen :?> GTNEIntMap :-> TTNEIntMap)
(\f g xs -> M.map f (M.map g xs))
(\f g xs -> NEM.map f (NEM.map g xs))
prop_map_rules_coerce :: Property
prop_map_rules_coerce = ttProp (GTNEIntMap :-> TTNEIntMap)
(M.map @Text @Text coerce)
(NEM.map @Text @Text coerce)
prop_map_rules_mapWithKey :: Property
prop_map_rules_mapWithKey = ttProp (gf1 valGen :?> gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
(\f g xs -> M.map f (M.mapWithKey g xs))
(\f g xs -> NEM.map f (NEM.mapWithKey g xs))
prop_mapWithKey :: Property
prop_mapWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
M.mapWithKey
NEM.mapWithKey
prop_mapWithKey_rules_mapWithKey :: Property
prop_mapWithKey_rules_mapWithKey = ttProp (gf2 valGen :?> gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
(\f g xs -> M.mapWithKey f (M.mapWithKey g xs))
(\f g xs -> NEM.mapWithKey f (NEM.mapWithKey g xs))
prop_mapWithKey_rules_map :: Property
prop_mapWithKey_rules_map = ttProp (gf2 valGen :?> gf1 valGen :?> GTNEIntMap :-> TTNEIntMap)
(\f g xs -> M.mapWithKey f (M.map g xs))
(\f g xs -> NEM.mapWithKey f (NEM.map g xs))
-- | These intentionally do not match, because Foldable for IntMap is
-- inconsistent
-- prop_traverseWithKey1 :: Property
-- prop_traverseWithKey1 = ttProp (gf1 valGen :?> GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
-- (\f -> M.traverseWithKey (\k -> (`More` Done (f . (k,)))))
-- (\f -> NEM.traverseWithKey1 (\k -> (`More` Done (f . (k,)))))
-- prop_traverseWithKey :: Property
-- prop_traverseWithKey = ttProp (gf1 valGen :?> GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
-- (\f -> M.traverseWithKey (\k -> (`More` Done (f . (k,)))))
-- (\f -> NEM.traverseWithKey (\k -> (`More` Done (f . (k,)))))
-- prop_sequence1 :: Property
-- prop_sequence1 = ttProp (GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
-- (sequenceA . fmap (`More` Done id))
-- (sequence1 . fmap (`More` Done id))
-- prop_sequenceA :: Property
-- prop_sequenceA = ttProp (GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
-- (sequenceA . fmap (`More` Done id))
-- (sequenceA . fmap (`More` Done id))
-- prop_mapAccumWithKey :: Property
-- prop_mapAccumWithKey = ttProp ( gf3 ((,) <$> valGen <*> valGen)
-- :?> GTOther valGen
-- :-> GTNEIntMap
-- :-> TTOther :*: TTNEIntMap
-- )
-- M.mapAccumWithKey
-- NEM.mapAccumWithKey
-- prop_mapAccumRWithKey :: Property
-- prop_mapAccumRWithKey = ttProp ( gf3 ((,) <$> valGen <*> valGen)
-- :?> GTOther valGen
-- :-> GTNEIntMap
-- :-> TTOther :*: TTNEIntMap
-- )
-- M.mapAccumRWithKey
-- NEM.mapAccumRWithKey
prop_mapKeys :: Property
prop_mapKeys = ttProp (gf1 intKeyGen :?> GTNEIntMap :-> TTNEIntMap)
M.mapKeys
NEM.mapKeys
prop_mapKeysWith :: Property
prop_mapKeysWith = ttProp ( gf2 valGen
:?> gf1 intKeyGen
:?> GTNEIntMap
:-> TTNEIntMap
)
M.mapKeysWith
NEM.mapKeysWith
prop_mapKeysMonotonic :: Property
prop_mapKeysMonotonic = ttProp (GTNEIntMap :-> TTNEIntMap)
(M.mapKeysMonotonic (*2))
(NEM.mapKeysMonotonic (*2))
prop_foldr :: Property
prop_foldr = ttProp ( gf2 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldr
NEM.foldr
prop_foldl :: Property
prop_foldl = ttProp ( gf2 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldl
NEM.foldl
prop_foldr1 :: Property
prop_foldr1 = ttProp ( gf2 valGen
:?> GTNEIntMap
:-> TTOther
)
foldr1
NEM.foldr1
prop_foldl1 :: Property
prop_foldl1 = ttProp ( gf2 valGen
:?> GTNEIntMap
:-> TTOther
)
foldl1
NEM.foldl1
prop_foldrWithKey :: Property
prop_foldrWithKey = ttProp ( gf3 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldrWithKey
NEM.foldrWithKey
prop_foldlWithKey :: Property
prop_foldlWithKey = ttProp ( gf3 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldlWithKey
NEM.foldlWithKey
prop_foldMapWithKey :: Property
prop_foldMapWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTOther)
(\f -> foldMap (uncurry f) . M.toList)
NEM.foldMapWithKey
prop_foldr' :: Property
prop_foldr' = ttProp ( gf2 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldr'
NEM.foldr'
prop_foldl' :: Property
prop_foldl' = ttProp ( gf2 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldl'
NEM.foldl'
prop_foldr1' :: Property
prop_foldr1' = ttProp ( gf2 valGen
:?> GTNEIntMap
:-> TTOther
)
foldr1
NEM.foldr1'
prop_foldl1' :: Property
prop_foldl1' = ttProp ( gf2 valGen
:?> GTNEIntMap
:-> TTOther
)
foldl1
NEM.foldl1'
prop_foldrWithKey' :: Property
prop_foldrWithKey' = ttProp ( gf3 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldrWithKey'
NEM.foldrWithKey'
prop_foldlWithKey' :: Property
prop_foldlWithKey' = ttProp ( gf3 valGen
:?> GTOther valGen
:-> GTNEIntMap
:-> TTOther
)
M.foldlWithKey'
NEM.foldlWithKey'
prop_elems :: Property
prop_elems = ttProp (GTNEIntMap :-> TTNEList TTVal)
M.elems
NEM.elems
prop_keys :: Property
prop_keys = ttProp (GTNEIntMap :-> TTNEList TTOther)
M.keys
NEM.keys
prop_assocs :: Property
prop_assocs = ttProp (GTNEIntMap :-> TTNEList (TTOther :*: TTVal))
M.assocs
NEM.assocs
prop_keysSet :: Property
prop_keysSet = ttProp (GTNEIntMap :-> TTNEIntSet)
M.keysSet
NEM.keysSet
prop_toList :: Property
prop_toList = ttProp (GTNEIntMap :-> TTNEList (TTOther :*: TTVal))
M.toList
NEM.toList
prop_toDescList :: Property
prop_toDescList = ttProp (GTNEIntMap :-> TTNEList (TTOther :*: TTVal))
M.toDescList
NEM.toDescList
prop_filter :: Property
prop_filter = ttProp (gf1 Gen.bool :?> GTNEIntMap :-> TTOther)
M.filter
NEM.filter
prop_filterWithKey :: Property
prop_filterWithKey = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> TTOther)
M.filterWithKey
NEM.filterWithKey
prop_restrictKeys :: Property
prop_restrictKeys = ttProp (GTNEIntMap :-> GTIntSet :-> TTOther)
M.restrictKeys
NEM.restrictKeys
prop_withoutKeys :: Property
prop_withoutKeys = ttProp (GTNEIntMap :-> GTIntSet :-> TTOther)
M.withoutKeys
NEM.withoutKeys
prop_partitionWithKey :: Property
prop_partitionWithKey = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> TTThese TTNEIntMap TTNEIntMap)
M.partitionWithKey
NEM.partitionWithKey
prop_mapMaybeWithKey :: Property
prop_mapMaybeWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTNEIntMap :-> TTOther)
M.mapMaybeWithKey
NEM.mapMaybeWithKey
prop_mapEitherWithKey :: Property
prop_mapEitherWithKey = ttProp ( gf2 (Gen.choice [Left <$> valGen, Right <$> valGen])
:?> GTNEIntMap
:-> TTThese TTNEIntMap TTNEIntMap
)
M.mapEitherWithKey
NEM.mapEitherWithKey
prop_split :: Property
prop_split = ttProp (GTIntKey :-> GTNEIntMap :-> TTMThese TTNEIntMap TTNEIntMap)
M.split
NEM.split
prop_splitLookup :: Property
prop_splitLookup = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe TTVal :*: TTMThese TTNEIntMap TTNEIntMap)
(\k -> (\(x,y,z) -> (y,(x,z))) . M.splitLookup k)
NEM.splitLookup
prop_isSubmapOfBy :: Property
prop_isSubmapOfBy = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
M.isSubmapOfBy
NEM.isSubmapOfBy
prop_isProperSubmapOfBy :: Property
prop_isProperSubmapOfBy = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
M.isProperSubmapOfBy
NEM.isProperSubmapOfBy
prop_findMin :: Property
prop_findMin = ttProp (GTNEIntMap :-> TTOther :*: TTVal)
M.findMin
NEM.findMin
prop_findMax :: Property
prop_findMax = ttProp (GTNEIntMap :-> TTOther :*: TTVal)
M.findMax
NEM.findMax
prop_deleteMin :: Property
prop_deleteMin = ttProp (GTNEIntMap :-> TTOther)
M.deleteMin
NEM.deleteMin
prop_deleteMax :: Property
prop_deleteMax = ttProp (GTNEIntMap :-> TTOther)
M.deleteMax
NEM.deleteMax
prop_deleteFindMin :: Property
prop_deleteFindMin = ttProp (GTNEIntMap :-> (TTOther :*: TTVal) :*: TTOther)
M.deleteFindMin
NEM.deleteFindMin
prop_deleteFindMax :: Property
prop_deleteFindMax = ttProp (GTNEIntMap :-> (TTOther :*: TTVal) :*: TTOther)
M.deleteFindMax
NEM.deleteFindMax
prop_updateMinWithKey :: Property
prop_updateMinWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTNEIntMap :-> TTOther)
M.updateMinWithKey
NEM.updateMinWithKey
prop_updateMaxWithKey :: Property
prop_updateMaxWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTNEIntMap :-> TTOther)
M.updateMaxWithKey
NEM.updateMaxWithKey
prop_adjustMinWithKey :: Property
prop_adjustMinWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
(M.updateMinWithKey . (fmap . fmap) Just)
NEM.adjustMinWithKey
prop_adjustMaxWithKey :: Property
prop_adjustMaxWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
(M.updateMaxWithKey . (fmap . fmap) Just)
NEM.adjustMaxWithKey
prop_minView :: Property
prop_minView = ttProp (GTNEIntMap :-> TTMaybe (TTVal :*: TTOther))
M.minView
(Just . NEM.minView)
prop_maxView :: Property
prop_maxView = ttProp (GTNEIntMap :-> TTMaybe (TTVal :*: TTOther))
M.maxView
(Just . NEM.maxView)
prop_elem :: Property
prop_elem = ttProp (GTVal :-> GTNEIntMap :-> TTOther)
elem
elem
prop_fold1 :: Property
prop_fold1 = ttProp (GTNEIntMap :-> TTVal)
(fold . toList)
fold1
prop_fold :: Property
prop_fold = ttProp (GTNEIntMap :-> TTVal)
(fold . toList)
fold
prop_foldMap1 :: Property
prop_foldMap1 = ttProp (gf1 valGen :?> GTNEIntMap :-> TTOther)
(\f -> foldMap ((:[]) . f) . toList)
(\f -> foldMap1 ((:[]) . f))
prop_foldMap :: Property
prop_foldMap = ttProp (gf1 valGen :?> GTNEIntMap :-> TTOther)
(\f -> foldMap ((:[]) . f) . toList)
(\f -> foldMap ((:[]) . f))