List 0.5.2 → 0.6.0

raw patch · 5 files changed

+104/−108 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• List.cabal +2/−3
• src/Control/Monad/ListT.hs +78/−4
• src/Control/Monad/ListT/Funcs.hs +24/−0
• src/Control/Monad/Trans/List.hs +0/−77
• src/Control/Monad/Trans/List/Funcs.hs +0/−24

@@ -1,5 +1,5 @@ Name:                List-Version:             0.5.2+Version:             0.6.0 Category:            Control Synopsis:            List monad transformer and class Description:@@ -19,7 +19,6 @@   Extensions:   Build-Depends:       base >= 3 && < 5, transformers >= 0.2   Exposed-modules:     Control.Monad.ListT,-                       Control.Monad.Trans.List,-                       Control.Monad.Trans.List.Funcs,+                       Control.Monad.ListT.Funcs,                        Data.List.Class   Ghc-Options:         -O2 -Wall

@@ -1,8 +1,82 @@--- Alternative module name to "List"'s @Control.Monad.Trans.List@.--- The name @Control.Monad.Trans.List@ conflicts with "transformers"'s broken ListT.+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, StandaloneDeriving, TypeFamilies, UndecidableInstances #-}++-- | A list monad transformer / a monadic list. ----- Import this module and not @Control.Monad.Trans.List@ if using both packages.+-- Monadic list example:+--   A program which reads numbers from the user and accumulates them.+--+-- > import Control.Monad.ListT.Funcs (repeatM)+-- > import Data.List.Class (execute, scanl, takeWhile, mapL)+-- > import Prelude hiding (scanl, takeWhile)+-- >+-- > main =+-- >     execute . mapL print .+-- >     scanl (+) 0 .+-- >     fmap (fst . head) .+-- >     takeWhile (not . null) .+-- >     fmap reads $ repeatM getLine+--+-- Note:+-- The `transformers` package also has a `ListT` type,+-- which oddly enough it is not a list monad transformer.+-- This module was deliberately named differently from `transformers`'s module.  module Control.Monad.ListT (ListT(..)) where -import Control.Monad.Trans.List (ListT(..))+import Data.List.Class (List(..), ListItem(..), foldrL)++import Control.Applicative (Alternative(..), Applicative(..))+import Control.Monad (MonadPlus(..), ap, liftM)+import Control.Monad.IO.Class (MonadIO(..))+import Control.Monad.Trans.Class (MonadTrans(..))+import Data.Monoid (Monoid(..))++newtype ListT m a =+    ListT { runListT :: m (ListItem (ListT m) a) }++deriving instance (Eq (m (ListItem (ListT m) a))) => Eq (ListT m a)+deriving instance (Ord (m (ListItem (ListT m) a))) => Ord (ListT m a)+deriving instance (Read (m (ListItem (ListT m) a))) => Read (ListT m a)+deriving instance (Show (m (ListItem (ListT m) a))) => Show (ListT m a)++-- for mappend, fmap, bind+foldrL' :: List l => (a -> l b -> l b) -> l b -> l a -> l b+foldrL' consFunc nilFunc =+    joinL . foldrL step (return nilFunc)+    where+        step x = return . consFunc x . joinL++instance Monad m => Monoid (ListT m a) where+    mempty = ListT $ return Nil+    mappend = flip (foldrL' cons)++instance Monad m => Functor (ListT m) where+    fmap func = foldrL' (cons . func) mempty++instance Monad m => Monad (ListT m) where+    return = ListT . return . (`Cons` mempty)+    a >>= b = foldrL' mappend mempty (fmap b a)++instance Monad m => Applicative (ListT m) where+    pure = return+    (<*>) = ap++instance Monad m => Alternative (ListT m) where+    empty = mempty+    (<|>) = mappend++instance Monad m => MonadPlus (ListT m) where+    mzero = mempty+    mplus = mappend++instance MonadTrans ListT where+    lift = ListT . liftM (`Cons` mempty)++instance Monad m => List (ListT m) where+    type ItemM (ListT m) = m+    runList = runListT+    joinL = ListT . (>>= runList)+    cons x = ListT . return . Cons x++instance MonadIO m => MonadIO (ListT m) where+    liftIO = lift . liftIO

@@ -0,0 +1,24 @@+-- | @List@ functions with type limited to use @ListT@.+-- This might come useful for type interference.+--+-- Functions where the @List@ is an input type and not only the result type do not need special limited versions.++module Control.Monad.ListT.Funcs+    ( iterateM, repeatM, repeat, fromList+    ) where++import Control.Monad.ListT (ListT)+import qualified Data.List.Class as ListFuncs+import Prelude hiding (repeat)++iterateM :: Monad m => (a -> m a) -> m a -> ListT m a+iterateM = ListFuncs.iterateM++repeatM :: Monad m => m a -> ListT m a+repeatM = ListFuncs.repeatM++repeat :: Monad m => a -> ListT m a+repeat = ListFuncs.repeat++fromList :: Monad m => [a] -> ListT m a+fromList = ListFuncs.fromList

@@ -1,77 +0,0 @@-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, StandaloneDeriving, TypeFamilies, UndecidableInstances #-}---- | A list monad transformer / a monadic list.------ Monadic list example:---   A program which reads numbers from the user and accumulates them.------ > import Control.Monad.Trans.List.Funcs (repeatM)--- > import Data.List.Class (execute, scanl, takeWhile, mapL)--- > import Prelude hiding (scanl, takeWhile)--- > --- > main =--- >     execute . mapL print .--- >     scanl (+) 0 .--- >     fmap (fst . head) .--- >     takeWhile (not . null) .--- >     fmap reads $ repeatM getLine--module Control.Monad.Trans.List (ListT(..)) where--import Data.List.Class (List(..), ListItem(..), foldrL)--import Control.Applicative-import Control.Monad (MonadPlus(..), ap, liftM)-import Control.Monad.IO.Class (MonadIO(..))-import Control.Monad.Trans.Class (MonadTrans(..))-import Data.Monoid (Monoid(..))--newtype ListT m a =-    ListT { runListT :: m (ListItem (ListT m) a) }--deriving instance (Eq (m (ListItem (ListT m) a))) => Eq (ListT m a)-deriving instance (Ord (m (ListItem (ListT m) a))) => Ord (ListT m a)-deriving instance (Read (m (ListItem (ListT m) a))) => Read (ListT m a)-deriving instance (Show (m (ListItem (ListT m) a))) => Show (ListT m a)---- for mappend, fmap, bind-foldrL' :: List l => (a -> l b -> l b) -> l b -> l a -> l b-foldrL' consFunc nilFunc =-    joinL . foldrL step (return nilFunc)-    where-        step x = return . consFunc x . joinL--instance Monad m => Monoid (ListT m a) where-    mempty = ListT $ return Nil-    mappend = flip (foldrL' cons)--instance Monad m => Functor (ListT m) where-    fmap func = foldrL' (cons . func) mempty--instance Monad m => Monad (ListT m) where-    return = ListT . return . (`Cons` mempty)-    a >>= b = foldrL' mappend mempty (fmap b a)--instance Monad m => Applicative (ListT m) where-    pure = return-    (<*>) = ap--instance Monad m => MonadPlus (ListT m) where-    mzero = mempty-    mplus = mappend--instance Monad m => Alternative (ListT m) where-    (<|>) = mplus-    empty = mzero--instance MonadTrans ListT where-    lift = ListT . liftM (`Cons` mempty)--instance Monad m => List (ListT m) where-    type ItemM (ListT m) = m-    runList = runListT-    joinL = ListT . (>>= runList)-    cons x = ListT . return . Cons x--instance MonadIO m => MonadIO (ListT m) where-    liftIO = lift . liftIO

@@ -1,24 +0,0 @@--- | @List@ functions with type limited to use @ListT@.--- This might come useful for type interference.------ Functions where the @List@ is an input type and not only the result type do not need special limited versions.--module Control.Monad.Trans.List.Funcs-    ( iterateM, repeatM, repeat, fromList-    ) where--import Control.Monad.Trans.List (ListT)-import qualified Data.List.Class as ListFuncs-import Prelude hiding (repeat)--iterateM :: Monad m => (a -> m a) -> m a -> ListT m a-iterateM = ListFuncs.iterateM--repeatM :: Monad m => m a -> ListT m a-repeatM = ListFuncs.repeatM--repeat :: Monad m => a -> ListT m a-repeat = ListFuncs.repeat--fromList :: Monad m => [a] -> ListT m a-fromList = ListFuncs.fromList