packages feed

mono-traversable 1.0.5.0 → 1.0.6.0

raw patch · 4 files changed

+36/−2 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Data.Containers: instance Data.Containers.BiPolyMap Data.Map.Base.Map
- Data.Containers: instance Data.Containers.HasKeysSet (Data.IntMap.Base.IntMap v)
- Data.Containers: instance Data.Containers.IsMap (Data.IntMap.Base.IntMap value)
- Data.Containers: instance Data.Containers.IsSet Data.IntSet.Base.IntSet
- Data.Containers: instance Data.Containers.PolyMap Data.IntMap.Base.IntMap
- Data.Containers: instance Data.Containers.SetContainer (Data.IntMap.Base.IntMap value)
- Data.Containers: instance Data.Containers.SetContainer Data.IntSet.Base.IntSet
- Data.Containers: instance GHC.Classes.Ord element => Data.Containers.IsSet (Data.Set.Base.Set element)
- Data.Containers: instance GHC.Classes.Ord element => Data.Containers.SetContainer (Data.Set.Base.Set element)
- Data.Containers: instance GHC.Classes.Ord k => Data.Containers.HasKeysSet (Data.Map.Base.Map k v)
- Data.Containers: instance GHC.Classes.Ord k => Data.Containers.SetContainer (Data.Map.Base.Map k v)
- Data.Containers: instance GHC.Classes.Ord key => Data.Containers.IsMap (Data.Map.Base.Map key value)
- Data.Containers: instance GHC.Classes.Ord key => Data.Containers.PolyMap (Data.Map.Base.Map key)
- Data.MonoTraversable: instance Data.MonoTraversable.GrowingAppend (Data.IntMap.Base.IntMap v)
- Data.MonoTraversable: instance Data.MonoTraversable.GrowingAppend (Data.Sequence.Seq a)
- Data.MonoTraversable: instance Data.MonoTraversable.GrowingAppend Data.IntSet.Base.IntSet
- Data.MonoTraversable: instance Data.MonoTraversable.MonoComonad (Data.Sequence.ViewL a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoComonad (Data.Sequence.ViewR a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.IntMap.Base.IntMap a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Map.Base.Map k v)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Sequence.Seq a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Sequence.ViewL a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Sequence.ViewR a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable Data.IntSet.Base.IntSet
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.IntMap.Base.IntMap a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Map.Base.Map k v)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Sequence.Seq a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Sequence.ViewL a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Sequence.ViewR a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Sequence.Seq a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Sequence.ViewL a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Sequence.ViewR a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Set.Base.Set a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed Data.IntSet.Base.IntSet
- Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.IntMap.Base.IntMap a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Map.Base.Map k v)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Sequence.Seq a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Sequence.ViewL a)
- Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Sequence.ViewR a)
- Data.MonoTraversable: instance GHC.Classes.Ord e => Data.MonoTraversable.MonoFoldable (Data.Set.Base.Set e)
- Data.MonoTraversable: instance GHC.Classes.Ord k => Data.MonoTraversable.GrowingAppend (Data.Map.Base.Map k v)
- Data.MonoTraversable: instance GHC.Classes.Ord v => Data.MonoTraversable.GrowingAppend (Data.Set.Base.Set v)
- Data.Sequences: instance Data.Sequences.IsSequence (Data.Sequence.Seq a)
- Data.Sequences: instance Data.Sequences.SemiSequence (Data.Sequence.Seq a)
+ Data.Containers: instance Data.Containers.BiPolyMap Data.Map.Internal.Map
+ Data.Containers: instance Data.Containers.HasKeysSet (Data.IntMap.Internal.IntMap v)
+ Data.Containers: instance Data.Containers.IsMap (Data.IntMap.Internal.IntMap value)
+ Data.Containers: instance Data.Containers.IsSet Data.IntSet.Internal.IntSet
+ Data.Containers: instance Data.Containers.PolyMap Data.IntMap.Internal.IntMap
+ Data.Containers: instance Data.Containers.SetContainer (Data.IntMap.Internal.IntMap value)
+ Data.Containers: instance Data.Containers.SetContainer Data.IntSet.Internal.IntSet
+ Data.Containers: instance GHC.Classes.Ord element => Data.Containers.IsSet (Data.Set.Internal.Set element)
+ Data.Containers: instance GHC.Classes.Ord element => Data.Containers.SetContainer (Data.Set.Internal.Set element)
+ Data.Containers: instance GHC.Classes.Ord k => Data.Containers.HasKeysSet (Data.Map.Internal.Map k v)
+ Data.Containers: instance GHC.Classes.Ord k => Data.Containers.SetContainer (Data.Map.Internal.Map k v)
+ Data.Containers: instance GHC.Classes.Ord key => Data.Containers.IsMap (Data.Map.Internal.Map key value)
+ Data.Containers: instance GHC.Classes.Ord key => Data.Containers.PolyMap (Data.Map.Internal.Map key)
+ Data.MonoTraversable: instance Data.MonoTraversable.GrowingAppend (Data.IntMap.Internal.IntMap v)
+ Data.MonoTraversable: instance Data.MonoTraversable.GrowingAppend (Data.Sequence.Internal.Seq a)
+ Data.MonoTraversable: instance Data.MonoTraversable.GrowingAppend Data.IntSet.Internal.IntSet
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoComonad (Data.Sequence.Internal.ViewL a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoComonad (Data.Sequence.Internal.ViewR a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.IntMap.Internal.IntMap a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Map.Internal.Map k v)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Sequence.Internal.Seq a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Sequence.Internal.ViewL a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable (Data.Sequence.Internal.ViewR a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFoldable Data.IntSet.Internal.IntSet
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.IntMap.Internal.IntMap a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Map.Internal.Map k v)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Sequence.Internal.Seq a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Sequence.Internal.ViewL a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoFunctor (Data.Sequence.Internal.ViewR a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Sequence.Internal.Seq a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Sequence.Internal.ViewL a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Sequence.Internal.ViewR a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed (Data.Set.Internal.Set a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoPointed Data.IntSet.Internal.IntSet
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.IntMap.Internal.IntMap a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Map.Internal.Map k v)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Sequence.Internal.Seq a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Sequence.Internal.ViewL a)
+ Data.MonoTraversable: instance Data.MonoTraversable.MonoTraversable (Data.Sequence.Internal.ViewR a)
+ Data.MonoTraversable: instance GHC.Classes.Ord e => Data.MonoTraversable.MonoFoldable (Data.Set.Internal.Set e)
+ Data.MonoTraversable: instance GHC.Classes.Ord k => Data.MonoTraversable.GrowingAppend (Data.Map.Internal.Map k v)
+ Data.MonoTraversable: instance GHC.Classes.Ord v => Data.MonoTraversable.GrowingAppend (Data.Set.Internal.Set v)
+ Data.NonNull: mapNonNull :: (Functor f, MonoFoldable (f b)) => (a -> b) -> NonNull (f a) -> NonNull (f b)
+ Data.Sequences: instance Data.Sequences.IsSequence (Data.Sequence.Internal.Seq a)
+ Data.Sequences: instance Data.Sequences.SemiSequence (Data.Sequence.Internal.Seq a)
- Data.Containers: class BiPolyMap map where type BPMKeyConstraint map key :: Constraint where {
+ Data.Containers: class BiPolyMap map where {
- Data.Containers: class SetContainer set => HasKeysSet set where type KeySet set where {
+ Data.Containers: class SetContainer set => HasKeysSet set where {
- Data.Containers: class (MonoTraversable map, SetContainer map) => IsMap map where type MapValue map findWithDefault def key = fromMaybe def . lookup key insertWith f k v m = v' `seq` insertMap k v' m where v' = case lookup k m of { Nothing -> v Just vold -> f v vold } insertWithKey f k v m = v' `seq` insertMap k v' m where v' = case lookup k m of { Nothing -> v Just vold -> f k v vold } insertLookupWithKey f k v m = v' `seq` (mold, insertMap k v' m) where (mold, v') = case lookup k m of { Nothing -> (Nothing, v) Just vold -> (Just vold, f k v vold) } adjustMap f k m = case lookup k m of { Nothing -> m Just v -> let v' = f v in v' `seq` insertMap k v' m } adjustWithKey f k m = case lookup k m of { Nothing -> m Just v -> let v' = f k v in v' `seq` insertMap k v' m } updateMap f k m = case lookup k m of { Nothing -> m Just v -> case f v of { Nothing -> deleteMap k m Just v' -> v' `seq` insertMap k v' m } } updateWithKey f k m = case lookup k m of { Nothing -> m Just v -> case f k v of { Nothing -> deleteMap k m Just v' -> v' `seq` insertMap k v' m } } updateLookupWithKey f k m = case lookup k m of { Nothing -> (Nothing, m) Just v -> case f k v of { Nothing -> (Just v, deleteMap k m) Just v' -> v' `seq` (Just v', insertMap k v' m) } } alterMap f k m = case f mold of { Nothing -> case mold of { Nothing -> m Just _ -> deleteMap k m } Just v -> insertMap k v m } where mold = lookup k m unionWith f x y = mapFromList $ loop $ mapToList x ++ mapToList y where loop [] = [] loop ((k, v) : rest) = case lookup k rest of { Nothing -> (k, v) : loop rest Just v' -> (k, f v v') : loop (deleteMap k rest) } unionWithKey f x y = mapFromList $ loop $ mapToList x ++ mapToList y where loop [] = [] loop ((k, v) : rest) = case lookup k rest of { Nothing -> (k, v) : loop rest Just v' -> (k, f k v v') : loop (deleteMap k rest) } unionsWith _ [] = mempty unionsWith _ [x] = x unionsWith f (x : y : z) = unionsWith f (unionWith f x y : z) mapWithKey f = mapFromList . map go . mapToList where go (k, v) = (k, f k v) omapKeysWith g f = mapFromList . unionsWith g . map go . mapToList where go (k, v) = [(f k, v)] where {
+ Data.Containers: class (MonoTraversable map, SetContainer map) => IsMap map where {
- Data.Containers: class (Monoid set, Semigroup set, MonoFoldable set, Eq (ContainerKey set), GrowingAppend set) => SetContainer set where type ContainerKey set unions = ofoldl' union mempty where {
+ Data.Containers: class (Monoid set, Semigroup set, MonoFoldable set, Eq (ContainerKey set), GrowingAppend set) => SetContainer set where {
- Data.MonoTraversable: class MonoFoldable mono where ofoldMap = foldMap ofoldr = foldr ofoldl' = foldl' otoList t = build (\ mono n -> ofoldr mono n t) oall f = getAll . ofoldMap (All . f) oany f = getAny . ofoldMap (Any . f) onull = oall (const False) olength = ofoldl' (\ i _ -> i + 1) 0 olength64 = ofoldl' (\ i _ -> i + 1) 0 ocompareLength c0 i0 = olength c0 `compare` fromIntegral i0 otraverse_ f = ofoldr ((*>) . f) (pure ()) ofor_ = flip otraverse_ omapM_ = otraverse_ oforM_ = flip omapM_ ofoldlM f z0 xs = ofoldr f' return xs z0 where f' x k z = f z x >>= k ofoldMap1Ex f = fromMaybe (error "Data.MonoTraversable.ofoldMap1Ex") . getOption . ofoldMap (Option . Just . f) ofoldr1Ex = foldr1 ofoldl1Ex' = foldl1 headEx = ofoldr const (error "Data.MonoTraversable.headEx: empty") lastEx = ofoldl1Ex' (flip const) unsafeHead = headEx unsafeLast = lastEx maximumByEx f = ofoldl1Ex' go where go x y = case f x y of { LT -> y _ -> x } minimumByEx f = ofoldl1Ex' go where go x y = case f x y of { GT -> y _ -> x } oelem e = elem e . otoList onotElem e = notElem e . otoList
+ Data.MonoTraversable: class MonoFoldable mono
- Data.MonoTraversable: class MonoFunctor mono where omap = fmap
+ Data.MonoTraversable: class MonoFunctor mono
- Data.MonoTraversable: class MonoPointed mono where opoint = pure
+ Data.MonoTraversable: class MonoPointed mono
- Data.MonoTraversable: class (MonoFunctor mono, MonoFoldable mono) => MonoTraversable mono where otraverse = traverse omapM = otraverse
+ Data.MonoTraversable: class (MonoFunctor mono, MonoFoldable mono) => MonoTraversable mono
- Data.Sequences: class (Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq where fromList = mconcat . fmap singleton lengthIndex = fromIntegral . olength64 break f = (fromList *** fromList) . break f . otoList span f = (fromList *** fromList) . span f . otoList dropWhile f = fromList . dropWhile f . otoList takeWhile f = fromList . takeWhile f . otoList splitAt i = (fromList *** fromList) . genericSplitAt i . otoList unsafeSplitAt i seq = (unsafeTake i seq, unsafeDrop i seq) take i = fst . splitAt i unsafeTake = take drop i = snd . splitAt i unsafeDrop = drop dropEnd i s = fst $ splitAt (lengthIndex s - i) s partition f = (fromList *** fromList) . partition f . otoList uncons = fmap (second fromList) . uncons . otoList unsnoc = fmap (first fromList) . unsnoc . otoList filter f = fromList . filter f . otoList filterM f = liftM fromList . filterM f . otoList replicate i = fromList . genericReplicate i replicateM i = liftM fromList . replicateM (fromIntegral i) groupBy f = fmap fromList . groupBy f . otoList groupAllOn f = fmap fromList . groupAllOn f . otoList subsequences = map fromList . subsequences . otoList permutations = map fromList . permutations . otoList tailEx = snd . maybe (error "Data.Sequences.tailEx") id . uncons tailMay seq | onull seq = Nothing | otherwise = Just (tailEx seq) initEx = fst . maybe (error "Data.Sequences.initEx") id . unsnoc initMay seq | onull seq = Nothing | otherwise = Just (initEx seq) unsafeTail = tailEx unsafeInit = initEx index seq' idx = headMay (drop idx seq') indexEx seq' idx = maybe (error "Data.Sequences.indexEx") id (index seq' idx) unsafeIndex = indexEx splitWhen = defaultSplitWhen
+ Data.Sequences: class (Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq
- Data.Sequences: class (Integral (Index seq), GrowingAppend seq) => SemiSequence seq where type Index seq where {
+ Data.Sequences: class (Integral (Index seq), GrowingAppend seq) => SemiSequence seq where {
- Data.Sequences: class (IsSequence t, IsString t, Element t ~ Char) => Textual t where breakWord = fmap (dropWhile isSpace) . break isSpace breakLine = (killCR *** drop 1) . break (== '\n') where killCR t = case unsnoc t of { Just (t', '\r') -> t' _ -> t }
+ Data.Sequences: class (IsSequence t, IsString t, Element t ~ Char) => Textual t

Files

ChangeLog.md view
@@ -1,3 +1,7 @@+## 1.0.6.0++* Add `mapNonNull` function to `Data.NonNull` [#150](https://github.com/snoyberg/mono-traversable/issues/150)+ ## 1.0.5.0  * Move `oelem` and `onotElem` into the `MonoFoldable` class [#133](https://github.com/snoyberg/mono-traversable/issues/133)
mono-traversable.cabal view
@@ -2,10 +2,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: f018b4ea166006fa7ec7d69a0b78999cc474978f817b1ede26524a3982e90f9e+-- hash: bc8a0b9aa12636444123bfbeb72078faed482f924d48c553daf2ced10e993bb6  name:           mono-traversable-version:        1.0.5.0+version:        1.0.6.0 synopsis:       Type classes for mapping, folding, and traversing monomorphic containers description:    Please see the README at <https://www.stackage.org/package/mono-traversable> category:       Data
src/Data/NonNull.hs view
@@ -36,6 +36,7 @@   , minimumBy   , (<|)   , toMinList+  , mapNonNull   , GrowingAppend ) where @@ -348,3 +349,20 @@           -> Element mono minimumBy cmp = minimumByEx cmp . toNullable {-# INLINE minimumBy #-}++-- | 'fmap' over the underlying container in a 'NonNull'.+--+-- @since 1.0.6.0++-- ==== __Examples__+--+-- @+-- > let xs = 'ncons' 1 [2, 3 :: Int]+-- > 'mapNonNull' 'show' xs+-- 'NonNull' {toNullable = [\"1\",\"2\",\"3\"]}+-- @+mapNonNull :: (Functor f, MonoFoldable (f b))+           => (a -> b)+           -> NonNull (f a)+           -> NonNull (f b)+mapNonNull f = impureNonNull . fmap f . toNullable
test/Spec.hs view
@@ -3,6 +3,8 @@ {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE PatternSynonyms #-}  module Spec where @@ -19,6 +21,7 @@ import Test.Hspec.QuickCheck import Test.HUnit ((@?=)) import Test.QuickCheck hiding (NonEmptyList(..))+import Test.QuickCheck.Function (pattern Fn) import qualified Test.QuickCheck.Modifiers as QCM  import Data.Text (Text)@@ -206,6 +209,15 @@         describe "fromNonEmpty" $ do             prop "toMinList" $ \(NonEmpty' ne) ->                 (NE.toList ne :: [Int]) @?= NN.toNullable (NN.toMinList ne)++        describe "mapNonNull" $ do+            prop "mapNonNull id == id" $ \x xs ->+                let nonNull = NN.ncons x (xs :: [Int])+                in NN.mapNonNull Prelude.id nonNull @?= nonNull+            prop "mapNonNull (f . g) == mapNonNull f . mapNonNull g" $+                \(Fn (f :: Integer -> String)) (Fn (g :: Int -> Integer)) x xs ->+                    let nns = NN.ncons x (xs :: [Int])+                    in NN.mapNonNull (f . g) nns @?= NN.mapNonNull f (NN.mapNonNull g nns)          let -- | Type restricted 'NN.ncons'             nconsAs :: IsSequence seq => Element seq -> [Element seq] -> seq -> NN.NonNull seq