list-transformer 1.0.1 → 1.0.2

raw patch · 2 files changed

+37/−2 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- List.Transformer: instance (GHC.Base.Monad m, Data.Traversable.Traversable m) => Data.Traversable.Traversable (List.Transformer.ListT m)

- List.Transformer: instance (GHC.Base.Monad m, Data.Traversable.Traversable m) => Data.Traversable.Traversable (List.Transformer.Step m)

+ List.Transformer: instance (Data.Traversable.Traversable m, GHC.Base.Monad m) => Data.Traversable.Traversable (List.Transformer.ListT m)

+ List.Transformer: instance (Data.Traversable.Traversable m, GHC.Base.Monad m) => Data.Traversable.Traversable (List.Transformer.Step m)

+ List.Transformer: instance GHC.Base.Monad m => Control.Monad.Fail.MonadFail (List.Transformer.ListT m)

+ List.Transformer: takeWhile :: Monad m => (a -> Bool) -> ListT m a -> ListT m a

- List.Transformer: (<|>) :: f a -> f a -> f a

+ List.Transformer: (<|>) :: Alternative f => f a -> f a -> f a

- List.Transformer: empty :: f a

+ List.Transformer: empty :: Alternative f => f a

- List.Transformer: lift :: Monad m => m a -> t m a

+ List.Transformer: lift :: (MonadTrans t, Monad m) => m a -> t m a

- List.Transformer: liftIO :: IO a -> m a

+ List.Transformer: liftIO :: MonadIO m => IO a -> m a

- List.Transformer: many :: f a -> f [a]

+ List.Transformer: many :: Alternative f => f a -> f [a]

- List.Transformer: some :: f a -> f [a]

+ List.Transformer: some :: Alternative f => f a -> f [a]

list-transformer.cabal view

@@ -1,5 +1,5 @@ name:                list-transformer-version:             1.0.1+version:             1.0.2 synopsis:            List monad transformer description:         This library provides a list monad transformer that                      enriches lists with effects and streams efficiently in

src/List/Transformer.hs view

@@ -167,6 +167,14 @@     Whichever one you prefer, all three variations still stream in constant     space (unlike @"Control.Monad".`mapM`@, which buffers the entire output     list before returning a single element).++    This library is designed to stream results in constant space and does not+    expose an obvious way to collect all the results into memory.  As a rule of+    thumb if you think you need to collect all the results in memory try to+    instead see if you can consume the results as they are being generated (such+    as in all the above examples).  If you can stream the data from start to+    finish then your code will use significantly less memory and your program+    will become more responsive. -} module List.Transformer     ( -- * ListT@@ -177,6 +185,7 @@     , select     , take     , drop+    , takeWhile     , unfold     , zip @@ -200,10 +209,13 @@ #endif import Control.Monad (MonadPlus(..)) import Control.Monad.Error.Class (MonadError(..))+#if MIN_VERSION_base(4,9,0)+import Control.Monad.Fail (MonadFail(..))+#endif import Control.Monad.State.Class (MonadState(..)) import Control.Monad.Reader.Class (MonadReader(..)) import Control.Monad.Trans (MonadTrans(..), MonadIO(..))-import Prelude hiding (drop, take, zip)+import Prelude hiding (drop, pred, take, takeWhile, zip)  import qualified Data.Foldable @@ -269,6 +281,8 @@             Nil       -> return Nil             Cons x l' -> next (k x <|> (l' >>= k)) ) +    fail _ = mzero+ instance Monad m => Alternative (ListT m) where     empty = ListT (return Nil) @@ -283,6 +297,11 @@      mplus = (<|>) +#if MIN_VERSION_base(4,9,0)+instance Monad m => MonadFail (ListT m) where+    fail _ = mzero+#endif+ instance (Monad m, Monoid a) => Monoid (ListT m a) where     mempty  = pure mempty     mappend = liftA2 mappend@@ -466,6 +485,22 @@         case s of             Cons _ l' -> next (drop (n-1) l')             Nil       -> return Nil)++-- | @takeWhile pred xs@ takes elements from @xs@ until the predicate @pred@ fails+--+-- >>> let list xs = do x <- select xs; liftIO (print (show x)); return x+-- >>> let sum = fold (+) 0 id+-- >>> sum (takeWhile even (list [2,4,5,7,8]))+-- "2"+-- "4"+-- "5"+-- 6+takeWhile :: Monad m => (a -> Bool) -> ListT m a -> ListT m a+takeWhile pred l = ListT (do+    n <- next l+    case n of+        Cons x l' | pred x -> return (Cons x (takeWhile pred l'))+        _                  -> return Nil )  -- | @unfold step seed@ generates a 'ListT' from a @step@ function and an -- initial @seed@.