mono-traversable 1.0.13.0 → 1.0.15.0

raw patch · 6 files changed

+122/−3 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• README.md +1/−1
• mono-traversable.cabal +2/−2
• src/Data/MonoTraversable.hs +101/−0
• src/Data/NonNull.hs +7/−0
• test/Spec.hs +3/−0

@@ -1,3 +1,11 @@+## 1.0.15.0+* Added `toNonEmpty` to `Data.NonNull`+  [#185](https://github.com/snoyberg/mono-traversable/pull/185)++## 1.0.14.0+* Added `WrappedMono` to `Data.MonoTraversable`+  [#182](https://github.com/snoyberg/mono-traversable/pull/182)+ ## 1.0.13.0 * Added `WrappedPoly` to `Data.MonoTraversable`   [#180](https://github.com/snoyberg/mono-traversable/pull/180)

@@ -155,7 +155,7 @@ * IsMap: unifies operations across different `Map`s * MonoZip: zip operations on MonoFunctors. -Note that because `Set` and `Map` are not a Functor (and therefore not MonoFoldable), one must use `mapFromList`, `mapToList`, `setFromList`, and `setToList`.+Note that because `Set` is not a Functor (and therefore neither a MonoFunctor nor MonoTraversable), one must use `setFromList` and `setToList` to `omap` or `otraverse` over the elements of a `Set`.   ### Sequences

@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: f15c018a84778989ad8a6b3271167acba04984c689d9620523b6855ce2ec78f1+-- hash: d57979a825f3250908d497aed1b4696d537282997123f4504743df13c77c8175  name:           mono-traversable-version:        1.0.13.0+version:        1.0.15.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

@@ -4,6 +4,7 @@ {-# LANGUAGE DerivingStrategies      #-} {-# LANGUAGE FlexibleContexts        #-} {-# LANGUAGE FlexibleInstances       #-}+{-# LANGUAGE GADTs                   #-} {-# LANGUAGE TypeFamilies            #-} {-# LANGUAGE TypeOperators           #-} {-# LANGUAGE UndecidableInstances    #-}@@ -1408,3 +1409,103 @@ instance F.Foldable f  => MonoFoldable (WrappedPoly f a) instance Functor f     => MonoFunctor (WrappedPoly f a) instance Applicative f => MonoPointed (WrappedPoly f a)+++-- | Provides a `F.Foldable` for an arbitrary `MonoFoldable`.+--+-- @since 1.0.14.0+data WrappedMono mono a where+    WrappedMono :: Element mono ~ a => mono -> WrappedMono mono a++-- | Unwraps a `WrappedMono`.+--+-- @since 1.0.14.0+unwrapMono :: WrappedMono mono a -> mono+unwrapMono (WrappedMono mono) = mono+{-# INLINE unwrapMono #-}++type instance Element (WrappedMono mono a) = Element mono++instance MonoFoldable mono => MonoFoldable (WrappedMono mono a) where+    ofoldMap f = ofoldMap f . unwrapMono+    {-# INLINE ofoldMap #-}+    ofoldr f z = ofoldr f z . unwrapMono+    {-# INLINE ofoldr #-}+    ofoldl' f z = ofoldl' f z . unwrapMono+    {-# INLINE ofoldl' #-}+    otoList = otoList . unwrapMono+    {-# INLINE otoList #-}+    oall f = oall f . unwrapMono+    {-# INLINE oall #-}+    oany f = oany f . unwrapMono+    {-# INLINE oany #-}+    onull = onull . unwrapMono+    {-# INLINE onull #-}+    olength = olength . unwrapMono+    {-# INLINE olength #-}+    olength64 = olength64 . unwrapMono+    {-# INLINE olength64 #-}+    ocompareLength mono i = ocompareLength (unwrapMono mono) i+    {-# INLINE ocompareLength #-}+    otraverse_ f = otraverse_ f . unwrapMono+    {-# INLINE otraverse_ #-}+    ofor_ mono f = ofor_ (unwrapMono mono) f+    {-# INLINE ofor_ #-}+    omapM_ f = omapM_ f . unwrapMono+    {-# INLINE omapM_ #-}+    oforM_ mono f = oforM_ (unwrapMono mono) f+    {-# INLINE oforM_ #-}+    ofoldlM f z = ofoldlM f z . unwrapMono+    {-# INLINE ofoldlM #-}+    ofoldMap1Ex f = ofoldMap1Ex f . unwrapMono+    {-# INLINE ofoldMap1Ex #-}+    ofoldr1Ex f = ofoldr1Ex f . unwrapMono+    {-# INLINE ofoldr1Ex #-}+    ofoldl1Ex' f = ofoldl1Ex' f . unwrapMono+    {-# INLINE ofoldl1Ex' #-}+    headEx = headEx . unwrapMono+    {-# INLINE headEx #-}+    lastEx = lastEx . unwrapMono+    {-# INLINE lastEx #-}+    unsafeHead = unsafeHead . unwrapMono+    {-# INLINE unsafeHead #-}+    unsafeLast = unsafeLast . unwrapMono+    {-# INLINE unsafeLast #-}+    maximumByEx f = maximumByEx f . unwrapMono+    {-# INLINE maximumByEx #-}+    minimumByEx f = minimumByEx f . unwrapMono+    {-# INLINE minimumByEx #-}+    oelem a = oelem a . unwrapMono+    {-# INLINE oelem #-}+    onotElem a = onotElem a . unwrapMono+    {-# INLINE onotElem #-}++instance MonoFunctor mono => MonoFunctor (WrappedMono mono a) where+    omap f (WrappedMono mono) = WrappedMono (omap f mono)+    {-# INLINE omap #-}++instance (MonoPointed mono, Element mono ~ a) => MonoPointed (WrappedMono mono a) where+    opoint a = WrappedMono (opoint a)+    {-# INLINE opoint #-}++instance MonoFoldable mono => F.Foldable (WrappedMono mono) where+    foldr f zero (WrappedMono mono) = ofoldr f zero mono+    {-# INLINE foldr #-}+    foldMap f (WrappedMono mono) = ofoldMap f mono+    {-# INLINE foldMap #-}+    foldl' f z (WrappedMono mono) = ofoldl' f z mono+    {-# INLINE foldl' #-}+    foldl1 f (WrappedMono mono) = ofoldl1Ex' f mono+    {-# INLINE foldl1 #-}+    toList (WrappedMono mono) = otoList mono+    {-# INLINE toList #-}+    null (WrappedMono mono) = onull mono+    {-# INLINE null #-}+    length (WrappedMono mono) = olength mono+    {-# INLINE length #-}+    elem a (WrappedMono mono) = oelem a mono+    {-# INLINE elem #-}+    maximum (WrappedMono mono) = maximumEx mono+    {-# INLINE maximum #-}+    minimum (WrappedMono mono) = minimumEx mono+    {-# INLINE minimum #-}

@@ -16,6 +16,7 @@   , nonNull   , toNullable   , fromNonEmpty+  , toNonEmpty   , ncons   , nuncons   , splitFirst@@ -131,6 +132,12 @@ fromNonEmpty :: IsSequence seq => NE.NonEmpty (Element seq) -> NonNull seq fromNonEmpty = impureNonNull . fromList . NE.toList {-# INLINE fromNonEmpty #-}++-- | __Safely__ convert from a 'NonNull' container to a 'NonEmpty' list.+--+-- @since 1.0.15.0+toNonEmpty :: MonoFoldable mono => NonNull mono -> NE.NonEmpty (Element mono)+toNonEmpty = NE.fromList . otoList  -- | Specializes 'fromNonEmpty' to lists only. toMinList :: NE.NonEmpty a -> NonNull [a]

@@ -209,6 +209,9 @@         describe "fromNonEmpty" $ do             prop "toMinList" $ \(NonEmpty' ne) ->                 (NE.toList ne :: [Int]) @?= NN.toNullable (NN.toMinList ne)+        describe "toNonEmpty" $ do+            it "converts nonnull to nonempty" $ do+                NN.toNonEmpty (NN.impureNonNull [1,2,3]) @?= NE.fromList [1,2,3]          describe "mapNonNull" $ do             prop "mapNonNull id == id" $ \x xs ->