generator 0.5.3 → 0.5.4

raw patch · 3 files changed

+28/−86 lines, 3 filesdep +transformersdep −MaybeTdep −mtldep ~ListPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: transformers

Dependencies removed: MaybeT, mtl

Dependency ranges changed: List

API changes (from Hackage documentation)

Files

• generator.cabal +3/−5
• src/Control/Monad/DList.hs +0/−53
• src/Control/Monad/Generator.hs +25/−28

@@ -1,5 +1,5 @@ Name:                generator-Version:             0.5.3+Version:             0.5.4 Category:            Control Synopsis:            Python-generators notation for creation of monadic lists Description:@@ -18,8 +18,6 @@ Library   hs-Source-Dirs:      src   Extensions:-  Build-Depends:       base >= 3 && < 5, mtl, MaybeT, List >= 0.2-  Exposed-modules:     Control.Monad.DList,-                       Control.Monad.Generator+  Build-Depends:       base >= 3 && < 5, transformers, List >= 0.4+  Exposed-modules:     Control.Monad.Generator   Ghc-Options:         -O2 -Wall-

@@ -1,53 +0,0 @@-{-# LANGUAGE TypeFamilies #-}---- | A difference-list monad transformer / a monadic difference-list.------ Difference lists are lists with /O(1)/ append (instead of /O(N)/).------ Transforming a difference list to a list is /O(1)/,--- a must be done to access a difference list.--- The transformation from a list to a difference list is /O(N)/.--module Control.Monad.DList (-  DListT (..), toListT, joinDListT-  ) where--import Control.Applicative (Applicative(..))-import Control.Monad (MonadPlus(..), liftM, ap)-import Control.Monad.ListT (ListT)-import Control.Monad.Trans (MonadTrans(..))-import Data.List.Class (List(..), cons)-import Data.Monoid (Monoid(..))---- | A monadic difference-list-newtype DListT m a = DListT { runDListT :: ListT m a -> ListT m a }--toListT :: Monad m => DListT m a -> ListT m a-toListT = (`runDListT` mzero)--joinDListT :: Monad m => m (DListT m a) -> DListT m a-joinDListT action =-  DListT (joinL . (`liftM` action) . flip runDListT)--instance Monoid (DListT l a) where-  mempty = DListT id-  mappend (DListT a) (DListT b) = DListT $ a . b--instance Monad m => Functor (DListT m) where-  fmap func = DListT . mplus . liftM func . toListT--instance Monad m => Monad (DListT m) where-  return = DListT . cons-  a >>= b = DListT . mplus $ toListT a >>= liftM toListT b--instance Monad m => Applicative (DListT m) where-  pure = return-  (<*>) = ap--instance Monad m => MonadPlus (DListT m) where-  mzero = mempty-  mplus = mappend--instance MonadTrans DListT where-  lift = DListT . mappend . lift-

@@ -1,37 +1,38 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}+ -- | A monad transformer for the creation of Lists. -- Similar to Python's generators. ----- > import Control.Monad.DList (toListT) -- > import Control.Monad.Identity (Identity(..)) -- > import Data.List.Class (toList) -- >--- > hanoi 0 _ _ _ = mempty--- > hanoi n from to other =--- >   generate $ do--- >     yields $ hanoi (n-1) from other to--- >     yield (from, to)--- >     yields $ hanoi (n-1) other to from+-- > hanoi 0 _ _ _ = return ()+-- > hanoi n from to other = do+-- >   hanoi (n-1) from other to+-- >   yield (from, to)+-- >   hanoi (n-1) other to from -- >--- > > runIdentity . toList . toListT $ hanoi 3 'A' 'B' 'C' :: [(Char, Char)]+-- > > runIdentity . toList . generate $ hanoi 3 'A' 'B' 'C' :: [(Char, Char)] -- > [('A','B'),('A','C'),('B','C'),('A','B'),('C','A'),('C','B'),('A','B')] --  module Control.Monad.Generator (-  GeneratorT, generate, yield, yields+  GeneratorT(..), generate, yield, breakGenerator   ) where  import Control.Applicative (Applicative(..)) import Control.Monad (liftM, ap)-import Control.Monad.Cont (Cont (..))-import Control.Monad.DList (DListT, joinDListT)-import Control.Monad.Trans (MonadTrans(..), MonadIO(..))+import Control.Monad.IO.Class (MonadIO(..))+import Control.Monad.ListT (ListT)+import Control.Monad.Trans.Class (MonadTrans(..))+import Control.Monad.Trans.Cont (ContT (..), mapContT) import Data.List.Class (cons) import Data.Monoid (Monoid(..))  -- | A monad transformer to create 'List's.--- 'generate' transforms a "GeneratorT v m a" to a "DListT m a".+-- 'generate' transforms a "GeneratorT v m a" to a "ListT m a". newtype GeneratorT v m a =-  GeneratorT { runGeneratorT :: Cont (DListT m v) a }+  GeneratorT { runGeneratorT :: ContT v (ListT m) a }  instance Monad m => Functor (GeneratorT v m) where   fmap = liftM@@ -46,23 +47,19 @@   (<*>) = ap  instance MonadTrans (GeneratorT v) where-  lift = GeneratorT . Cont . (joinDListT .) . flip liftM--instance MonadIO m => MonadIO (GeneratorT v m) where-  liftIO = lift . liftIO+  lift = GeneratorT . lift . lift --- | /O(1)/, Transform a GeneratorT to a 'DListT'-generate :: Monad m => GeneratorT v m () -> DListT m v-generate = ($ const mempty) . runCont . runGeneratorT+generate :: Monad m => GeneratorT v m () -> ListT m v+generate = (`runContT` const mempty) . runGeneratorT -mkContNil :: (r -> r) -> Cont r ()-mkContNil = Cont . (. ($ ()))+modifyRes :: Monad m => (ListT m a -> ListT m a) -> GeneratorT a m ()+modifyRes = GeneratorT . (`mapContT` return ()) --- | /O(1)/, Output a result value yield :: Monad m => v -> GeneratorT v m ()-yield = GeneratorT . mkContNil . cons+yield = modifyRes . cons --- | /O(1)/, Output all the values of a 'DListT'.-yields :: Monad m => DListT m v -> GeneratorT v m ()-yields = GeneratorT . mkContNil . mappend+breakGenerator :: Monad m => GeneratorT v m a+breakGenerator = GeneratorT . ContT . const $ mempty +instance MonadIO m => MonadIO (GeneratorT v m) where+  liftIO = lift . liftIO