transformers-lift 0.1.0.1 → 0.2.0.0

raw patch · 8 files changed

+178/−29 lines, 8 filesdep +writer-cps-transformersdep ~basedep ~transformersPVP ok

version bump matches the API change (PVP)

Dependencies added: writer-cps-transformers

Dependency ranges changed: base, transformers

API changes (from Hackage documentation)

Files

• LICENSE +2/−2
• src/Control/Monad/Trans/Lift/CallCC.hs +31/−0
• src/Control/Monad/Trans/Lift/Catch.hs +26/−0
• src/Control/Monad/Trans/Lift/Listen.hs +39/−10
• src/Control/Monad/Trans/Lift/Local.hs +27/−0
• src/Control/Monad/Trans/Lift/Pass.hs +39/−10
• src/Control/Monad/Trans/Lift/StT.hs +7/−1
• transformers-lift.cabal +7/−6

@@ -1,4 +1,4 @@-Copyright (c) 2015, Index Int+Copyright (c) 2015, Vladislav Zavialov  All rights reserved. @@ -13,7 +13,7 @@       disclaimer in the documentation and/or other materials provided       with the distribution. -    * Neither the name of Index Int nor the names of other+    * Neither the name of Vladislav Zavialov nor the names of other       contributors may be used to endorse or promote products derived       from this software without specific prior written permission. 

@@ -23,10 +23,13 @@ import qualified Control.Monad.Trans.Reader        as R import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS import qualified Control.Monad.Trans.State.Lazy    as S.Lazy import qualified Control.Monad.Trans.State.Strict  as S.Strict import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy import qualified Control.Monad.Trans.Writer.Strict as W.Strict+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS+import qualified Control.Monad.Trans.Accum         as Acc  import Control.Monad.Trans.Lift.StT @@ -73,38 +76,66 @@  instance LiftCallCC (E.ExceptT e) where     liftCallCC  = E.liftCallCC+    {-# INLINE liftCallCC #-}  instance LiftCallCC I.IdentityT where     liftCallCC  = I.liftCallCC+    {-# INLINE liftCallCC #-}  instance LiftCallCC L.ListT where     liftCallCC  = L.liftCallCC+    {-# INLINE liftCallCC #-}  instance LiftCallCC M.MaybeT where     liftCallCC  = M.liftCallCC+    {-# INLINE liftCallCC #-}  instance LiftCallCC (R.ReaderT r) where     liftCallCC  = R.liftCallCC+    {-# INLINE liftCallCC #-}  instance Monoid w => LiftCallCC (W.Lazy.WriterT w) where     liftCallCC  = W.Lazy.liftCallCC+    {-# INLINE liftCallCC #-}  instance Monoid w => LiftCallCC (W.Strict.WriterT w) where     liftCallCC  = W.Strict.liftCallCC+    {-# INLINE liftCallCC #-} +instance Monoid w => LiftCallCC (W.CPS.WriterT w) where+    liftCallCC  = W.CPS.liftCallCC+    {-# INLINE liftCallCC #-}+ instance Monoid w => LiftCallCC (RWS.Lazy.RWST r w s) where     liftCallCC  = RWS.Lazy.liftCallCC+    {-# INLINE liftCallCC #-}     liftCallCC' = RWS.Lazy.liftCallCC'+    {-# INLINE liftCallCC' #-}  instance Monoid w => LiftCallCC (RWS.Strict.RWST r w s) where     liftCallCC  = RWS.Strict.liftCallCC+    {-# INLINE liftCallCC #-}     liftCallCC' = RWS.Strict.liftCallCC'+    {-# INLINE liftCallCC' #-} +instance Monoid w => LiftCallCC (RWS.CPS.RWST r w s) where+    liftCallCC  = RWS.CPS.liftCallCC+    {-# INLINE liftCallCC #-}+    liftCallCC' = RWS.CPS.liftCallCC'+    {-# INLINE liftCallCC' #-}+ instance LiftCallCC (S.Lazy.StateT s) where     liftCallCC  = S.Lazy.liftCallCC+    {-# INLINE liftCallCC #-}     liftCallCC' = S.Lazy.liftCallCC'+    {-# INLINE liftCallCC' #-}  instance LiftCallCC (S.Strict.StateT s) where     liftCallCC  = S.Strict.liftCallCC+    {-# INLINE liftCallCC #-}     liftCallCC' = S.Strict.liftCallCC'+    {-# INLINE liftCallCC' #-} +instance Monoid w => LiftCallCC (Acc.AccumT w) where+    liftCallCC  = Acc.liftCallCC+    {-# INLINE liftCallCC #-}

@@ -22,10 +22,13 @@ import qualified Control.Monad.Trans.Reader        as R import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS import qualified Control.Monad.Trans.State.Lazy    as S.Lazy import qualified Control.Monad.Trans.State.Strict  as S.Strict import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy import qualified Control.Monad.Trans.Writer.Strict as W.Strict+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS+import qualified Control.Monad.Trans.Accum         as Acc  import Control.Monad.Trans.Lift.StT @@ -50,33 +53,56 @@  instance LiftCatch (E.ExceptT e) where     liftCatch f m h = E.ExceptT $ f (E.runExceptT m) (E.runExceptT . h)+    {-# INLINE liftCatch #-}  instance LiftCatch I.IdentityT where     liftCatch = I.liftCatch+    {-# INLINE liftCatch #-}  instance LiftCatch L.ListT where     liftCatch = L.liftCatch+    {-# INLINE liftCatch #-}  instance LiftCatch M.MaybeT where     liftCatch = M.liftCatch+    {-# INLINE liftCatch #-}  instance LiftCatch (R.ReaderT r) where     liftCatch = R.liftCatch+    {-# INLINE liftCatch #-}  instance Monoid w => LiftCatch (RWS.Lazy.RWST r w s) where     liftCatch = RWS.Lazy.liftCatch+    {-# INLINE liftCatch #-}  instance Monoid w => LiftCatch (RWS.Strict.RWST r w s) where     liftCatch = RWS.Strict.liftCatch+    {-# INLINE liftCatch #-} +instance Monoid w => LiftCatch (RWS.CPS.RWST r w s) where+    liftCatch = RWS.CPS.liftCatch+    {-# INLINE liftCatch #-}+ instance LiftCatch (S.Lazy.StateT s) where     liftCatch = S.Lazy.liftCatch+    {-# INLINE liftCatch #-}  instance LiftCatch (S.Strict.StateT s) where     liftCatch = S.Strict.liftCatch+    {-# INLINE liftCatch #-}  instance Monoid w => LiftCatch (W.Lazy.WriterT w) where     liftCatch = W.Lazy.liftCatch+    {-# INLINE liftCatch #-}  instance Monoid w => LiftCatch (W.Strict.WriterT w) where     liftCatch = W.Strict.liftCatch+    {-# INLINE liftCatch #-}++instance Monoid w => LiftCatch (W.CPS.WriterT w) where+    liftCatch = W.CPS.liftCatch+    {-# INLINE liftCatch #-}++instance Monoid w => LiftCatch (Acc.AccumT w) where+    liftCatch = Acc.liftCatch+    {-# INLINE liftCatch #-}

@@ -15,16 +15,19 @@ import Control.Monad.Signatures import Control.Monad.Trans.Class -import qualified Control.Monad.Trans.Except        as E-import qualified Control.Monad.Trans.Identity      as I-import qualified Control.Monad.Trans.Maybe         as M-import qualified Control.Monad.Trans.Reader        as R-import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy-import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict-import qualified Control.Monad.Trans.State.Lazy    as S.Lazy-import qualified Control.Monad.Trans.State.Strict  as S.Strict-import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy-import qualified Control.Monad.Trans.Writer.Strict as W.Strict+import qualified Control.Monad.Trans.Except              as E+import qualified Control.Monad.Trans.Identity            as I+import qualified Control.Monad.Trans.Maybe               as M+import qualified Control.Monad.Trans.Reader              as R+import qualified Control.Monad.Trans.RWS.Lazy            as RWS.Lazy+import qualified Control.Monad.Trans.RWS.Strict          as RWS.Strict+import qualified Control.Monad.Trans.RWS.CPS.Internal    as RWS.CPS+import qualified Control.Monad.Trans.State.Lazy          as S.Lazy+import qualified Control.Monad.Trans.State.Strict        as S.Strict+import qualified Control.Monad.Trans.Writer.Lazy         as W.Lazy+import qualified Control.Monad.Trans.Writer.Strict       as W.Strict+import qualified Control.Monad.Trans.Writer.CPS.Internal as W.CPS+import qualified Control.Monad.Trans.Accum               as Acc  import Control.Monad.Trans.Lift.StT @@ -49,38 +52,64 @@  instance LiftListen (E.ExceptT e) where     liftListen = E.liftListen+    {-# INLINE liftListen #-}  instance LiftListen I.IdentityT where     liftListen = I.mapIdentityT+    {-# INLINE liftListen #-}  instance LiftListen M.MaybeT where     liftListen = M.liftListen+    {-# INLINE liftListen #-}  instance LiftListen (R.ReaderT r) where     liftListen = R.mapReaderT+    {-# INLINE liftListen #-}  instance LiftListen (S.Lazy.StateT s) where     liftListen = S.Lazy.liftListen+    {-# INLINE liftListen #-}  instance LiftListen (S.Strict.StateT s) where     liftListen = S.Strict.liftListen+    {-# INLINE liftListen #-}  instance Monoid w' => LiftListen (RWS.Lazy.RWST r w' s) where     liftListen listen m = RWS.Lazy.RWST $ \r s -> do         ~((a, w', s'), w) <- listen (RWS.Lazy.runRWST m r s)         return ((a, w), w', s')+    {-# INLINE liftListen #-}  instance Monoid w' => LiftListen (RWS.Strict.RWST r w' s) where     liftListen listen m = RWS.Strict.RWST $ \r s -> do         ((a, w', s'), w) <- listen (RWS.Strict.runRWST m r s)         return ((a, w), w', s')+    {-# INLINE liftListen #-} +instance Monoid w' => LiftListen (RWS.CPS.RWST r w' s) where+    liftListen listen m = RWS.CPS.RWST $ \r w_ s -> do+        ((a, w', s'), w) <- listen (RWS.CPS.unRWST m r w_ s)+        return ((a, w), w', s')+    {-# INLINE liftListen #-}+ instance Monoid w' => LiftListen (W.Lazy.WriterT w') where     liftListen listen m = W.Lazy.WriterT $ do         ~((a, w'), w) <- listen (W.Lazy.runWriterT m)         return ((a, w), w')+    {-# INLINE liftListen #-}  instance Monoid w' => LiftListen (W.Strict.WriterT w') where     liftListen listen m = W.Strict.WriterT $ do         ((a, w'), w) <- listen (W.Strict.runWriterT m)         return ((a, w), w')+    {-# INLINE liftListen #-}++instance Monoid w' => LiftListen (W.CPS.WriterT w') where+    liftListen listen m = W.CPS.WriterT $ \w_ -> do+        ((a, w'), w) <- listen (W.CPS.unWriterT m w_)+        return ((a, w), w')+    {-# INLINE liftListen #-}++instance Monoid w' => LiftListen (Acc.AccumT w') where+    liftListen = Acc.liftListen+    {-# INLINE liftListen #-}

@@ -22,10 +22,13 @@ import qualified Control.Monad.Trans.Reader        as R import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS import qualified Control.Monad.Trans.State.Lazy    as S.Lazy import qualified Control.Monad.Trans.State.Strict  as S.Strict import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy import qualified Control.Monad.Trans.Writer.Strict as W.Strict+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS+import qualified Control.Monad.Trans.Accum         as Acc  -- | Signature of the @local@ operation, -- introduced in "Control.Monad.Trans.Reader".@@ -51,36 +54,60 @@  instance LiftLocal (C.ContT r) where     liftLocal a l f = C.liftLocal a l f+    {-# INLINE liftLocal #-}  instance LiftLocal (E.ExceptT e) where     liftLocal _ l f = E.mapExceptT (l f)+    {-# INLINE liftLocal #-}  instance LiftLocal I.IdentityT where     liftLocal _ l f = I.mapIdentityT (l f)+    {-# INLINE liftLocal #-}  instance LiftLocal L.ListT where     liftLocal _ l f = L.mapListT (l f)+    {-# INLINE liftLocal #-}  instance LiftLocal M.MaybeT where     liftLocal _ l f = M.mapMaybeT (l f)+    {-# INLINE liftLocal #-}  instance LiftLocal (R.ReaderT r) where     liftLocal _ l f = R.mapReaderT (l f)+    {-# INLINE liftLocal #-}  instance Monoid w => LiftLocal (RWS.Lazy.RWST r w s) where     liftLocal _ l f = RWS.Lazy.mapRWST (l f)+    {-# INLINE liftLocal #-}  instance Monoid w => LiftLocal (RWS.Strict.RWST r w s) where     liftLocal _ l f = RWS.Strict.mapRWST (l f)+    {-# INLINE liftLocal #-} +instance Monoid w => LiftLocal (RWS.CPS.RWST r w s) where+    liftLocal _ l f = RWS.CPS.mapRWST (l f)+    {-# INLINE liftLocal #-}+ instance LiftLocal (S.Lazy.StateT s) where     liftLocal _ l f = S.Lazy.mapStateT (l f)+    {-# INLINE liftLocal #-}  instance LiftLocal (S.Strict.StateT s) where     liftLocal _ l f = S.Strict.mapStateT (l f)+    {-# INLINE liftLocal #-}  instance Monoid w => LiftLocal (W.Lazy.WriterT w) where     liftLocal _ l f = W.Lazy.mapWriterT (l f)+    {-# INLINE liftLocal #-}  instance Monoid w => LiftLocal (W.Strict.WriterT w) where     liftLocal _ l f = W.Strict.mapWriterT (l f)+    {-# INLINE liftLocal #-}++instance Monoid w => LiftLocal (W.CPS.WriterT w) where+    liftLocal _ l f = W.CPS.mapWriterT (l f)+    {-# INLINE liftLocal #-}++instance Monoid w => LiftLocal (Acc.AccumT w) where+    liftLocal _ l f = Acc.mapAccumT (l f)+    {-# INLINE liftLocal #-}

@@ -15,16 +15,19 @@ import Control.Monad.Signatures import Control.Monad.Trans.Class -import qualified Control.Monad.Trans.Except        as E-import qualified Control.Monad.Trans.Identity      as I-import qualified Control.Monad.Trans.Maybe         as M-import qualified Control.Monad.Trans.Reader        as R-import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy-import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict-import qualified Control.Monad.Trans.State.Lazy    as S.Lazy-import qualified Control.Monad.Trans.State.Strict  as S.Strict-import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy-import qualified Control.Monad.Trans.Writer.Strict as W.Strict+import qualified Control.Monad.Trans.Except              as E+import qualified Control.Monad.Trans.Identity            as I+import qualified Control.Monad.Trans.Maybe               as M+import qualified Control.Monad.Trans.Reader              as R+import qualified Control.Monad.Trans.RWS.Lazy            as RWS.Lazy+import qualified Control.Monad.Trans.RWS.Strict          as RWS.Strict+import qualified Control.Monad.Trans.RWS.CPS.Internal    as RWS.CPS+import qualified Control.Monad.Trans.State.Lazy          as S.Lazy+import qualified Control.Monad.Trans.State.Strict        as S.Strict+import qualified Control.Monad.Trans.Writer.Lazy         as W.Lazy+import qualified Control.Monad.Trans.Writer.Strict       as W.Strict+import qualified Control.Monad.Trans.Writer.CPS.Internal as W.CPS+import qualified Control.Monad.Trans.Accum               as Acc  import Control.Monad.Trans.Lift.StT @@ -50,38 +53,64 @@  instance LiftPass (E.ExceptT e) where     liftPass = E.liftPass+    {-# INLINE liftPass #-}  instance LiftPass I.IdentityT where     liftPass = I.mapIdentityT+    {-# INLINE liftPass #-}  instance LiftPass M.MaybeT where     liftPass = M.liftPass+    {-# INLINE liftPass #-}  instance LiftPass (R.ReaderT r) where     liftPass = R.mapReaderT+    {-# INLINE liftPass #-}  instance LiftPass (S.Lazy.StateT s) where     liftPass = S.Lazy.liftPass+    {-# INLINE liftPass #-}  instance LiftPass (S.Strict.StateT s) where     liftPass = S.Strict.liftPass+    {-# INLINE liftPass #-}  instance Monoid w' => LiftPass (RWS.Lazy.RWST r w' s) where     liftPass pass m = RWS.Lazy.RWST $ \r s -> pass $ do         ~((a, f), w', s') <- RWS.Lazy.runRWST m r s         return ((a, w', s'), f)+    {-# INLINE liftPass #-}  instance Monoid w' => LiftPass (RWS.Strict.RWST r w' s) where     liftPass pass m = RWS.Strict.RWST $ \r s -> pass $ do         ((a, f), w', s') <- RWS.Strict.runRWST m r s         return ((a, w', s'), f)+    {-# INLINE liftPass #-} +instance Monoid w' => LiftPass (RWS.CPS.RWST r w' s) where+    liftPass pass m = RWS.CPS.RWST $ \r w_ s -> pass $ do+        ((a, f), w', s') <- RWS.CPS.unRWST m r w_ s+        return ((a, w', s'), f)+    {-# INLINE liftPass #-}+ instance Monoid w' => LiftPass (W.Lazy.WriterT w') where     liftPass pass m = W.Lazy.WriterT $ pass $ do         ~((a, f), w') <- W.Lazy.runWriterT m         return ((a, w'), f)+    {-# INLINE liftPass #-}  instance Monoid w' => LiftPass (W.Strict.WriterT w') where     liftPass pass m = W.Strict.WriterT $ pass $ do         ((a, f), w') <- W.Strict.runWriterT m         return ((a, w'), f)+    {-# INLINE liftPass #-}++instance Monoid w' => LiftPass (W.CPS.WriterT w') where+    liftPass pass m = W.CPS.WriterT $ \w_ -> pass $ do+        ((a, f), w') <- W.CPS.unWriterT m w_+        return ((a, w'), f)+    {-# INLINE liftPass #-}++instance Monoid w' => LiftPass (Acc.AccumT w') where+    liftPass = Acc.liftPass+    {-# INLINE liftPass #-}

@@ -10,10 +10,13 @@ import qualified Control.Monad.Trans.Reader        as R import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS import qualified Control.Monad.Trans.State.Lazy    as S.Lazy import qualified Control.Monad.Trans.State.Strict  as S.Strict import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy import qualified Control.Monad.Trans.Writer.Strict as W.Strict+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS+import qualified Control.Monad.Trans.Accum         as Acc  -- | Internal state of a monad transformer. --   Same as @StT@ from the @monad-control@ package.@@ -26,7 +29,10 @@ type instance StT (R.ReaderT r) a = a type instance StT (RWS.Lazy.RWST r w s) a = (a, s, w) type instance StT (RWS.Strict.RWST r w s) a = (a, s, w)+type instance StT (RWS.CPS.RWST r w s) a = (a, s, w) type instance StT (S.Lazy.StateT s) a = (a, s) type instance StT (S.Strict.StateT s) a = (a, s)-type instance StT (W.Strict.WriterT w) a = (a, w) type instance StT (W.Lazy.WriterT w) a = (a, w)+type instance StT (W.Strict.WriterT w) a = (a, w)+type instance StT (W.CPS.WriterT w) a = (a, w)+type instance StT (Acc.AccumT w) a = (a, w)

@@ -1,5 +1,5 @@ name:                transformers-lift-version:             0.1.0.1+version:             0.2.0.0 synopsis:            Ad-hoc type classes for lifting description:     This simple and lightweight library provides type classes@@ -7,8 +7,8 @@  license:             BSD3 license-file:        LICENSE-author:              Index Int-maintainer:          Index Int <vlad.z.4096@gmail.com>+author:              Vladislav Zavialov+maintainer:          Vladislav Zavialov <vlad.z.4096@gmail.com> category:            Control bug-reports:         https://github.com/int-index/transformers-lift/issues build-type:          Simple@@ -22,8 +22,9 @@                        Control.Monad.Trans.Lift.Pass                        Control.Monad.Trans.Lift.StT -  build-depends:       base >=4.6 && <4.10-               ,       transformers >= 0.4.2+  build-depends:       base >=4.6 && <4.11+               ,       transformers >= 0.5.4.0+               ,       writer-cps-transformers >= 0.1.1.3    default-language:    Haskell2010   other-extensions:    CPP@@ -32,4 +33,4 @@                        KindSignatures    hs-source-dirs:      src-  ghc-options:         -Wall+  ghc-options:         -Wall -fno-warn-deprecations