compactable 0.1.1.1 → 0.1.2.0

raw patch · 2 files changed

+64/−24 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• compactable.cabal +1/−1
• src/Control/Compactable.hs +63/−23

@@ -1,5 +1,5 @@ name:                compactable-version:             0.1.1.1+version:             0.1.2.0 synopsis:            A typeclass for structures which can be catMaybed, filtered, and partitioned. description:         This provides polymorphic implimentations for filter, compact (catMaybes), and separate. It allows for higher performance implimentations to be used in place of defaults for all data structures, and endeavors to centerally document those implimentations. Compactable aims to be as general and unconstrained as possible, providing instances for non-Functors like Set, as well as some Contravariants (though not published here). Compactable fully subsumes Data.Witherable, offers more laws, and is more general. license:             BSD3

@@ -1,8 +1,11 @@ {-# LANGUAGE ConstrainedClassMethods    #-} {-# LANGUAGE DefaultSignatures          #-}+{-# LANGUAGE FlexibleContexts           #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE KindSignatures             #-} {-# LANGUAGE LambdaCase                 #-}+{-# LANGUAGE StandaloneDeriving         #-}+{-# LANGUAGE TypeOperators              #-}  module Control.Compactable   (@@ -34,7 +37,8 @@  import           Control.Applicative import           Control.Arrow-import           Control.Monad                   (MonadPlus (..), join)+import           Control.Monad                   (MonadPlus, join)+import           Control.Monad.Trans.Error       (Error) import           Control.Monad.Trans.Except import           Control.Monad.Trans.Maybe import           Data.Bifoldable@@ -46,12 +50,14 @@ import qualified Data.IntMap                     as IntMap import qualified Data.Map                        as Map import           Data.Maybe+import           Data.Monoid import           Data.Proxy import           Data.Semigroup import qualified Data.Sequence                   as Seq import qualified Data.Set                        as Set import qualified Data.Vector                     as V import           GHC.Conc+import           GHC.Generics import           Text.ParserCombinators.ReadP import           Text.ParserCombinators.ReadPrec @@ -274,6 +280,9 @@       go []     = pure []     {-# INLINE traverseMaybe #-} +instance Compactable ZipList where+  compact (ZipList xs) = ZipList $ compact xs+ instance Compactable IO where     compact = altDefaultCompact     {-# INLINABLE compact #-}@@ -295,7 +304,15 @@     {-# INLINABLE applyMaybe #-}     bindMaybe _ _ = Proxy     {-# INLINABLE bindMaybe #-}+    fmapEither _ _ = (Proxy, Proxy)+    {-# INLINABLE fmapEither #-}+    applyEither _ _ = (Proxy, Proxy)+    {-# INLINABLE applyEither #-}+    bindEither _ _ = (Proxy, Proxy)+    {-# INLINABLE bindEither #-} +instance Compactable U1+ instance Compactable Option where     compact (Option x) = Option (join x)     {-# INLINABLE compact #-}@@ -366,8 +383,16 @@     {-# INLINABLE compact #-}     fmapMaybe _ (Const r) = Const r     {-# INLINABLE fmapMaybe #-}+    applyMaybe _ (Const r) = Const r+    {-# INLINABLE applyMaybe #-}     bindMaybe (Const r) _ = Const r     {-# INLINABLE bindMaybe #-}+    fmapEither _ (Const r) = (Const r, Const r)+    {-# INLINABLE fmapEither #-}+    applyEither _ (Const r) = (Const r, Const r)+    {-# INLINABLE applyEither #-}+    bindEither (Const r) _ = (Const r, Const r)+    {-# INLINABLE bindEither #-}     filter _ (Const r) = Const r     {-# INLINABLE filter #-} @@ -379,25 +404,26 @@     filter = Set.filter     {-# INLINABLE filter  #-} -instance (ArrowApply a, ArrowPlus a) => Compactable (ArrowMonad a) where-    compact = compactFold-    {-# INLINE compact #-}-    separate = separateFold-    {-# INLINE separate #-}-+instance (ArrowPlus a, ArrowApply a) => Compactable (ArrowMonad a) where+instance Monad a => Compactable (WrappedMonad a) where+instance Functor a => Compactable (Rec1 a) where+instance Functor a => Compactable (Alt a) where+instance (Functor a, Functor b) => Compactable (a :*: b)+instance Functor f => Compactable (M1 i c f)+instance (Functor f, Functor g) => Compactable (f :.: g) -newtype MonadSum f a = MonadSum { unMonadSum :: f a }-    deriving (Functor, Applicative, Alternative, Monad, MonadPlus)+newtype AltSum f a = AltSum { unAltSum :: f a }+    deriving (Functor, Applicative, Alternative) -instance MonadPlus f => Monoid (MonadSum f a) where-    mempty = mzero-    MonadSum a `mappend` MonadSum b = MonadSum (mplus a b)+instance Alternative f => Monoid (AltSum f a) where+    mempty = empty+    AltSum a `mappend` AltSum b = AltSum (a <|> b)   {-| class `CompactFold` provides the same methods as `Compactable` but generalized to work on any `Foldable`. -When a type has MonadPlus (or similar) properties, we can extract the Maybe and the Either, and generalize to Foldable and Bifoldable.+When a type has Alternative (or similar) properties, we can extract the Maybe and the Either, and generalize to Foldable and Bifoldable.  Compactable can always be described in terms of CompactFold, because @@ -411,12 +437,12 @@ -} class Compactable f => CompactFold (f :: * -> *) where     compactFold :: Foldable g => f (g a) -> f a-    default compactFold :: (MonadPlus f, Foldable g) => f (g a) -> f a+    default compactFold :: (Monad f, Alternative f, Foldable g) => f (g a) -> f a     compactFold = (>>= mfold')     {-# INLINEABLE compactFold #-}      separateFold :: Bifoldable g => f (g a b) -> (f a, f b)-    default separateFold :: (MonadPlus f, Bifoldable g) => f (g a b) -> (f a, f b)+    default separateFold :: (Monad f, Alternative f, Bifoldable g) => f (g a b) -> (f a, f b)     separateFold xs = (xs >>= mlefts, xs >>= mrights)     {-# INLINEABLE separateFold #-} @@ -453,25 +479,39 @@     {-# INLINABLE traverseBifold #-}  -mfold' :: (Foldable f, MonadPlus m) => f a -> m a-mfold' = unMonadSum . foldMap (MonadSum . pure)+mfold' :: (Foldable f, Alternative m) => f a -> m a+mfold' = unAltSum . foldMap (AltSum . pure) -mlefts :: (Bifoldable f, MonadPlus m) => f a b -> m a-mlefts = unMonadSum . bifoldMap (MonadSum . pure) (const mempty)+mlefts :: (Bifoldable f, Alternative m) => f a b -> m a+mlefts = unAltSum . bifoldMap (AltSum . pure) (const mempty) -mrights :: (Bifoldable f, MonadPlus m) => f a b -> m b-mrights = unMonadSum . bifoldMap (const mempty) (MonadSum . pure)+mrights :: (Bifoldable f, Alternative m) => f a b -> m b+mrights = unAltSum . bifoldMap (const mempty) (AltSum . pure)   instance CompactFold [] where-    compactFold = concat . fmap F.toList+    compactFold = (>>= F.toList)     {-# INLINEABLE compactFold #-}  instance CompactFold Maybe+instance (Monoid m, Error m) => CompactFold (Either m)+instance CompactFold IO instance CompactFold ReadP instance CompactFold ReadPrec instance CompactFold STM-instance (ArrowApply a, ArrowPlus a) => CompactFold (ArrowMonad a)+instance CompactFold ZipList where+  compactFold (ZipList xs) = ZipList $ compactFold xs+  separateFold (ZipList xs) = bimap ZipList ZipList $ separateFold xs+instance CompactFold Option+instance CompactFold U1+instance CompactFold Proxy+instance (ArrowPlus a, ArrowApply a) => CompactFold (ArrowMonad a)+instance MonadPlus a => CompactFold (WrappedMonad a)+instance (Alternative a, Monad a) => CompactFold (Rec1 a)+instance (Alternative a, Monad a) => CompactFold (Alt a)+instance (Alternative f, Monad f, Alternative g, Monad g) => CompactFold (f :*: g)+instance (Compactable f, Alternative f, Monad f, Compactable g, Alternative g, Monad g) => CompactFold (FP.Product f g)+instance (Alternative f, Monad f) => CompactFold (M1 i c f)   fforMaybe :: (Compactable f, Functor f) => f a -> (a -> Maybe b) -> f b