List 0.3.0 → 0.4.0

raw patch · 3 files changed

+21/−46 lines, 3 filesdep +transformersdep −mtlPVP ok

version bump matches the API change (PVP)

Dependencies added: transformers

Dependencies removed: mtl

API changes (from Hackage documentation)

- Control.Monad.ListT: instance (Eq (m (ListItem (ListT m) a))) => Eq (ListT m a)

- Control.Monad.ListT: instance (Monad m) => Applicative (ListT m)

- Control.Monad.ListT: instance (Monad m) => Functor (ListT m)

- Control.Monad.ListT: instance (Monad m) => List (ListT m)

- Control.Monad.ListT: instance (Monad m) => Monad (ListT m)

- Control.Monad.ListT: instance (Monad m) => MonadPlus (ListT m)

- Control.Monad.ListT: instance (Monad m) => Monoid (ListT m a)

- Control.Monad.ListT: instance (MonadError e m) => MonadError e (ListT m)

- Control.Monad.ListT: instance (MonadIO m) => MonadIO (ListT m)

- Control.Monad.ListT: instance (MonadReader s m) => MonadReader s (ListT m)

- Control.Monad.ListT: instance (MonadState s m) => MonadState s (ListT m)

- Control.Monad.ListT: instance (Ord (m (ListItem (ListT m) a))) => Ord (ListT m a)

- Control.Monad.ListT: instance (Read (m (ListItem (ListT m) a))) => Read (ListT m a)

- Control.Monad.ListT: instance (Show (m (ListItem (ListT m) a))) => Show (ListT m a)

- Data.List.Class: instance (Functor m) => Functor (ListItem m)

+ Control.Monad.ListT: instance Eq (m (ListItem (ListT m) a)) => Eq (ListT m a)

+ Control.Monad.ListT: instance Monad m => Applicative (ListT m)

+ Control.Monad.ListT: instance Monad m => Functor (ListT m)

+ Control.Monad.ListT: instance Monad m => List (ListT m)

+ Control.Monad.ListT: instance Monad m => Monad (ListT m)

+ Control.Monad.ListT: instance Monad m => MonadPlus (ListT m)

+ Control.Monad.ListT: instance Monad m => Monoid (ListT m a)

+ Control.Monad.ListT: instance MonadIO m => MonadIO (ListT m)

+ Control.Monad.ListT: instance Ord (m (ListItem (ListT m) a)) => Ord (ListT m a)

+ Control.Monad.ListT: instance Read (m (ListItem (ListT m) a)) => Read (ListT m a)

+ Control.Monad.ListT: instance Show (m (ListItem (ListT m) a)) => Show (ListT m a)

+ Data.List.Class: instance Functor m => Functor (ListItem m)

+ Data.List.Class: mapL :: List l => (a -> ItemM l b) -> l a -> l b

- Data.List.Class: cons :: (MonadPlus m) => a -> m a -> m a

+ Data.List.Class: cons :: MonadPlus m => a -> m a -> m a

- Data.List.Class: execute :: (List l) => l a -> ItemM l ()

+ Data.List.Class: execute :: List l => l a -> ItemM l ()

- Data.List.Class: filter :: (MonadPlus m) => (a -> Bool) -> m a -> m a

+ Data.List.Class: filter :: MonadPlus m => (a -> Bool) -> m a -> m a

- Data.List.Class: foldl1L :: (List l) => (a -> a -> a) -> l a -> ItemM l a

+ Data.List.Class: foldl1L :: List l => (a -> a -> a) -> l a -> ItemM l a

- Data.List.Class: foldlL :: (List l) => (a -> b -> a) -> a -> l b -> ItemM l a

+ Data.List.Class: foldlL :: List l => (a -> b -> a) -> a -> l b -> ItemM l a

- Data.List.Class: foldrL :: (List l) => (a -> ItemM l b -> ItemM l b) -> ItemM l b -> l a -> ItemM l b

+ Data.List.Class: foldrL :: List l => (a -> ItemM l b -> ItemM l b) -> ItemM l b -> l a -> ItemM l b

- Data.List.Class: fromList :: (MonadPlus m) => [a] -> m a

+ Data.List.Class: fromList :: MonadPlus m => [a] -> m a

- Data.List.Class: iterateM :: (List l) => (a -> ItemM l a) -> ItemM l a -> l a

+ Data.List.Class: iterateM :: List l => (a -> ItemM l a) -> ItemM l a -> l a

- Data.List.Class: joinL :: (List l) => ItemM l (l a) -> l a

+ Data.List.Class: joinL :: List l => ItemM l (l a) -> l a

- Data.List.Class: joinM :: (List l) => l (ItemM l a) -> l a

+ Data.List.Class: joinM :: List l => l (ItemM l a) -> l a

- Data.List.Class: lastL :: (List l) => l a -> ItemM l a

+ Data.List.Class: lastL :: List l => l a -> ItemM l a

- Data.List.Class: repeat :: (MonadPlus m) => a -> m a

+ Data.List.Class: repeat :: MonadPlus m => a -> m a

- Data.List.Class: runList :: (List l) => l a -> ItemM l (ListItem l a)

+ Data.List.Class: runList :: List l => l a -> ItemM l (ListItem l a)

- Data.List.Class: scanl :: (List l) => (a -> b -> a) -> a -> l b -> l a

+ Data.List.Class: scanl :: List l => (a -> b -> a) -> a -> l b -> l a

- Data.List.Class: sortOn :: (Ord b) => (a -> b) -> [a] -> [a]

+ Data.List.Class: sortOn :: Ord b => (a -> b) -> [a] -> [a]

- Data.List.Class: takeWhile :: (List l) => (a -> Bool) -> l a -> l a

+ Data.List.Class: takeWhile :: List l => (a -> Bool) -> l a -> l a

- Data.List.Class: takeWhileM :: (List l) => (a -> ItemM l Bool) -> l a -> l a

+ Data.List.Class: takeWhileM :: List l => (a -> ItemM l Bool) -> l a -> l a

- Data.List.Class: toList :: (List l) => l a -> ItemM l [a]

+ Data.List.Class: toList :: List l => l a -> ItemM l [a]

- Data.List.Class: transpose :: (List l) => l (l a) -> l (l a)

+ Data.List.Class: transpose :: List l => l (l a) -> l (l a)

- Data.List.Class: zip :: (List l) => l a -> l b -> l (a, b)

+ Data.List.Class: zip :: List l => l a -> l b -> l (a, b)

- Data.List.Class: zipWith :: (List l) => (a -> b -> c) -> l a -> l b -> l c

+ Data.List.Class: zipWith :: List l => (a -> b -> c) -> l a -> l b -> l c

Files

List.cabal +2/−3
src/Control/Monad/ListT.hs +13/−40
src/Data/List/Class.hs +6/−3

List.cabal view

@@ -1,5 +1,5 @@ Name:                List-Version:             0.3.0+Version:             0.4.0 Category:            Control Synopsis:            List monad transformer and class Description:@@ -17,8 +17,7 @@ Library   hs-Source-Dirs:      src   Extensions:-  Build-Depends:       base >= 3 && < 5, mtl+  Build-Depends:       base >= 3 && < 5, transformers >= 0.2.0   Exposed-modules:     Control.Monad.ListT,                        Data.List.Class   Ghc-Options:         -O2 -Wall-

src/Control/Monad/ListT.hs view

@@ -7,17 +7,20 @@ -- Monadic list example: --   A program which reads numbers from the user and accumulates them. --+-- > import Control.Monad (join) -- > import Control.Monad.ListT (ListT)--- > import Data.List.Class (execute, joinM, repeat, scanl, takeWhile)+-- > import Control.Monad.Trans (lift)+-- > import Data.List.Class (execute, repeat, scanl, takeWhile, mapL) -- > import Prelude hiding (repeat, scanl, takeWhile)--- >+-- >  -- > main =--- >   execute . joinM . fmap print .--- >   scanl (+) 0 .--- >   fmap (fst . head) .--- >   takeWhile (not . null) .--- >   fmap reads .--- >   joinM $ (repeat getLine :: ListT IO (IO String))+-- >     execute . mapL print .+-- >     scanl (+) 0 .+-- >     fmap (fst . head) .+-- >     takeWhile (not . null) .+-- >     fmap reads $ do+-- >       repeat ()+-- >       lift getLine :: ListT IO String  module Control.Monad.ListT (ListT(..)) where @@ -25,11 +28,8 @@  import Control.Applicative (Applicative(..)) import Control.Monad (MonadPlus(..), ap, liftM)--- import Control.Monad.Cont.Class (MonadCont(..))-import Control.Monad.Error.Class (MonadError(..))-import Control.Monad.Reader.Class (MonadReader(..))-import Control.Monad.State.Class (MonadState(..))-import Control.Monad.Trans (MonadTrans(..), MonadIO(..))+import Control.Monad.IO.Class (MonadIO(..))+import Control.Monad.Trans.Class (MonadTrans(..)) import Data.Monoid (Monoid(..))  newtype ListT m a =@@ -79,32 +79,5 @@   runList = runListT   joinL = ListT . (>>= runList) --- YUCK:--- I can't believe I'm doing this,--- for compatability with mtl's ListT.--- I hate the O(N^2) code length auto-lifts. DRY!!- instance MonadIO m => MonadIO (ListT m) where   liftIO = lift . liftIO--{---- TODO: understand and verify this instance :)-instance MonadCont m => MonadCont (ListT m) where-  callCC f =-    ListT $ callCC thing-    where-      thing c = runListT . f $ ListT . c . (`Cons` mempty)--}--instance MonadError e m => MonadError e (ListT m) where-  throwError = lift . throwError-  catchError m = ListT . catchError (runList m) . (runList .)--instance MonadReader s m => MonadReader s (ListT m) where-  ask = lift ask-  local f = ListT . local f . runList--instance MonadState s m => MonadState s (ListT m) where-  get = lift get-  put = lift . put-

src/Data/List/Class.hs view

@@ -14,7 +14,7 @@   foldrL, foldlL, foldl1L, toList, lengthL, lastL,   merge2On, mergeOn,   -- | Operations useful for monadic lists-  execute, joinM, iterateM, takeWhileM,+  execute, joinM, mapL, iterateM, takeWhileM,   -- | Operations for non-monadic lists   sortOn,   -- | Convert between List types@@ -23,9 +23,9 @@   ) where  import Control.Monad (MonadPlus(..), liftM)-import Control.Monad.Identity (Identity(..))-import Control.Monad.State (StateT(..), evalStateT, get)+import Control.Monad.Trans.State (StateT(..), evalStateT, get) import Data.Function (fix)+import Data.Functor.Identity (Identity(..)) import Data.List (sortBy) import Data.Maybe (fromJust) import Data.Ord (comparing)@@ -140,6 +140,9 @@   where     consFunc action rest =       liftM (`cons` joinL rest) action++mapL :: List l => (a -> ItemM l b) -> l a -> l b+mapL func = joinM . liftM func  takeWhile :: List l => (a -> Bool) -> l a -> l a takeWhile = takeWhileM . fmap return