commit ghc-transformers-lift for openSUSE:Factory

31 Aug 2017

Hello community,

here is the log from the commit of package ghc-transformers-lift for openSUSE:Factory checked in at 2017-08-31 21:01:06
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-transformers-lift (Old)
 and      /work/SRC/openSUSE:Factory/.ghc-transformers-lift.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "ghc-transformers-lift"

Thu Aug 31 21:01:06 2017 rev:3 rq:513525 version:0.2.0.1

Changes:
--------

--- /work/SRC/openSUSE:Factory/ghc-transformers-lift/ghc-transformers-lift.changes	2017-04-14 13:38:55.425192813 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-transformers-lift.new/ghc-transformers-lift.changes	2017-08-31 21:01:10.547691055 +0200
@@ -1,0 +2,5 @@
+Thu Jul 27 14:07:49 UTC 2017 - psimons@suse.com
+
+- Update to version 0.2.0.1.
+
+-------------------------------------------------------------------

Old:
----
  transformers-lift-0.1.0.1.tar.gz
  transformers-lift.cabal

New:
----
  transformers-lift-0.2.0.1.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ ghc-transformers-lift.spec ++++++
--- /var/tmp/diff_new_pack.tGapOv/_old	2017-08-31 21:01:12.811373002 +0200
+++ /var/tmp/diff_new_pack.tGapOv/_new	2017-08-31 21:01:12.823371317 +0200
@@ -18,17 +18,17 @@
 
 %global pkg_name transformers-lift
 Name:           ghc-%{pkg_name}
-Version:        0.1.0.1
+Version:        0.2.0.1
 Release:        0
 Summary:        Ad-hoc type classes for lifting
 License:        BSD-3-Clause
 Group:          Development/Languages/Other
 Url:            https://hackage.haskell.org/package/%{pkg_name}
 Source0:        https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz
-Source1:        https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal#/%{pkg_name}.cabal
 BuildRequires:  ghc-Cabal-devel
 BuildRequires:  ghc-rpm-macros
 BuildRequires:  ghc-transformers-devel
+BuildRequires:  ghc-writer-cps-transformers-devel
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build
 
 %description
@@ -49,7 +49,6 @@
 
 %prep
 %setup -q -n %{pkg_name}-%{version}
-cp -p %{SOURCE1} %{pkg_name}.cabal
 
 %build
 %ghc_lib_build

++++++ transformers-lift-0.1.0.1.tar.gz -> transformers-lift-0.2.0.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/LICENSE new/transformers-lift-0.2.0.1/LICENSE
--- old/transformers-lift-0.1.0.1/LICENSE	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/LICENSE	2017-05-11 10:58:58.000000000 +0200
@@ -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.
 
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/CallCC.hs new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/CallCC.hs
--- old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/CallCC.hs	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/CallCC.hs	2017-05-11 10:58:58.000000000 +0200
@@ -23,10 +23,16 @@
 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
+
+#if MIN_VERSION_transformers(0,5,3)
+import qualified Control.Monad.Trans.Accum         as Acc
+#endif
 
 import Control.Monad.Trans.Lift.StT
 
@@ -73,38 +79,68 @@
 
 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' #-}
 
+#if MIN_VERSION_transformers(0,5,3)
+instance Monoid w => LiftCallCC (Acc.AccumT w) where
+    liftCallCC  = Acc.liftCallCC
+    {-# INLINE liftCallCC #-}
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Catch.hs new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Catch.hs
--- old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Catch.hs	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Catch.hs	2017-05-11 10:58:58.000000000 +0200
@@ -22,10 +22,16 @@
 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
+
+#if MIN_VERSION_transformers(0,5,3)
+import qualified Control.Monad.Trans.Accum         as Acc
+#endif
 
 import Control.Monad.Trans.Lift.StT
 
@@ -50,33 +56,58 @@
 
 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 #-}
+
+#if MIN_VERSION_transformers(0,5,3)
+instance Monoid w => LiftCatch (Acc.AccumT w) where
+    liftCatch = Acc.liftCatch
+    {-# INLINE liftCatch #-}
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Listen.hs new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Listen.hs
--- old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Listen.hs	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Listen.hs	2017-05-11 10:58:58.000000000 +0200
@@ -15,16 +15,22 @@
 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
+
+#if MIN_VERSION_transformers(0,5,3)
+import qualified Control.Monad.Trans.Accum               as Acc
+#endif
 
 import Control.Monad.Trans.Lift.StT
 
@@ -49,38 +55,66 @@
 
 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 #-}
+
+#if MIN_VERSION_transformers(0,5,3)
+instance Monoid w' => LiftListen (Acc.AccumT w') where
+    liftListen = Acc.liftListen
+    {-# INLINE liftListen #-}
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Local.hs new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Local.hs
--- old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Local.hs	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Local.hs	2017-05-11 10:58:58.000000000 +0200
@@ -22,10 +22,16 @@
 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
+
+#if MIN_VERSION_transformers(0,5,3)
+import qualified Control.Monad.Trans.Accum         as Acc
+#endif
 
 -- | Signature of the @local@ operation,
 -- introduced in "Control.Monad.Trans.Reader".
@@ -51,36 +57,62 @@
 
 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 #-}
+
+#if MIN_VERSION_transformers(0,5,3)
+instance Monoid w => LiftLocal (Acc.AccumT w) where
+    liftLocal _ l f = Acc.mapAccumT (l f)
+    {-# INLINE liftLocal #-}
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Pass.hs new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Pass.hs
--- old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/Pass.hs	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/Pass.hs	2017-05-11 10:58:58.000000000 +0200
@@ -1,5 +1,6 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE RankNTypes #-}
+
 -- | Lifting the 'pass' operation.
 module Control.Monad.Trans.Lift.Pass
     ( LiftPass(..)
@@ -15,16 +16,22 @@
 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
+
+#if MIN_VERSION_transformers(0,5,3)
+import qualified Control.Monad.Trans.Accum               as Acc
+#endif
 
 import Control.Monad.Trans.Lift.StT
 
@@ -50,38 +57,66 @@
 
 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 #-}
+
+#if MIN_VERSION_transformers(0,5,3)
+instance Monoid w' => LiftPass (Acc.AccumT w') where
+    liftPass = Acc.liftPass
+    {-# INLINE liftPass #-}
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/StT.hs new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/StT.hs
--- old/transformers-lift-0.1.0.1/src/Control/Monad/Trans/Lift/StT.hs	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/src/Control/Monad/Trans/Lift/StT.hs	2017-05-11 10:58:58.000000000 +0200
@@ -1,5 +1,7 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE KindSignatures #-}
+
 -- | The 'StT' type family.
 module Control.Monad.Trans.Lift.StT (StT) where
 
@@ -10,10 +12,16 @@
 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
+
+#if MIN_VERSION_transformers(0,5,3)
+import qualified Control.Monad.Trans.Accum         as Acc
+#endif
 
 -- | Internal state of a monad transformer.
 --   Same as @StT@ from the @monad-control@ package.
@@ -26,7 +34,13 @@
 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)
+
+#if MIN_VERSION_transformers(0,5,3)
+type instance StT (Acc.AccumT w) a = (a, w)
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/transformers-lift-0.1.0.1/transformers-lift.cabal new/transformers-lift-0.2.0.1/transformers-lift.cabal
--- old/transformers-lift-0.1.0.1/transformers-lift.cabal	2016-04-30 10:50:52.000000000 +0200
+++ new/transformers-lift-0.2.0.1/transformers-lift.cabal	2017-05-11 10:58:58.000000000 +0200
@@ -1,5 +1,5 @@
 name:                transformers-lift
-version:             0.1.0.1
+version:             0.2.0.1
 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.4.2.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

    

commit ghc-transformers-lift for openSUSE:Factory

root＠hilbert.suse.de