git.iko.soy/typeable/transformers-lift
on master help sign in
13 files changed+581−164
since splitsnapshots
unifiedsplit
.gitignore+1 .travis.yml+24−9 LICENSE+2−2 README.md+5 src/Control/Monad/Trans/Lift/CallCC.hs+94−18 src/Control/Monad/Trans/Lift/Catch.hs+101−37 src/Control/Monad/Trans/Lift/Listen.hs+80−19 src/Control/Monad/Trans/Lift/Local.hs+104−41 src/Control/Monad/Trans/Lift/Pass.hs+86−23 src/Control/Monad/Trans/Lift/StT.hs+46 stack-7.8.3.yaml+7 stack.yaml+4 transformers-lift.cabal+27−15
.gitignore+1
@@ -1,3 +1,4 @@
11dist
2+.stack-work
23.cabal-sandbox/
34cabal.sandbox.config
.travis.yml+24−9
@@ -1,20 +1,35 @@
1+sudo: false
2+
13env:
2− - CABALVER=1.18 GHCVER=7.8.4
3− - CABALVER=1.22 GHCVER=7.10.2
4+ - CABALVER=3.0 GHCVER=7.10.3
5+ - CABALVER=3.0 GHCVER=8.0.2
6+ - CABALVER=3.0 GHCVER=8.2.2
7+ - CABALVER=3.0 GHCVER=8.4.4
8+ - CABALVER=3.0 GHCVER=8.6.1
49 - CABALVER=head GHCVER=head
510
611before_install:
7− - travis_retry sudo add-apt-repository -y ppa:hvr/ghc
8− - travis_retry sudo apt-get update
9− - travis_retry sudo apt-get install cabal-install-$CABALVER ghc-$GHCVER
1012 - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
13+ - ghc --version
14+ - cabal --version
1115 - travis_retry cabal update
1216
1317install:
14− - cabal --version
15− - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"
16− - cabal install --only-dependencies
18+ - cabal install --dep
1719
1820script:
19− - cabal configure --enable-tests -v2
2021 - cabal build
22+
23+addons:
24+ apt:
25+ sources:
26+ - hvr-ghc
27+ packages:
28+ - ghc-7.10.3
29+ - ghc-8.0.2
30+ - ghc-8.2.2
31+ - ghc-8.4.4
32+ - ghc-8.6.1
33+ - ghc-head
34+ - cabal-install-3.0
35+ - cabal-install-head
LICENSE+2−2
@@ -1,4 +1,4 @@
1−Copyright (c) 2015, Index Int
1+Copyright (c) 2015, Vladislav Zavialov
22
33All rights reserved.
44
@@ -13,7 +13,7 @@ modification, are permitted provided that the following conditions are met:
1313 disclaimer in the documentation and/or other materials provided
1414 with the distribution.
1515
16− * Neither the name of Index Int nor the names of other
16+ * Neither the name of Vladislav Zavialov nor the names of other
1717 contributors may be used to endorse or promote products derived
1818 from this software without specific prior written permission.
1919
README.mdnew file+5
@@ -0,0 +1,5 @@
1+[![Build Status](https://img.shields.io/travis/int-index/transformers-lift.svg)](https://travis-ci.org/int-index/transformers-lift)
2+[![Hackage](https://img.shields.io/hackage/v/transformers-lift.svg)](https://hackage.haskell.org/package/transformers-lift)
3+
4+`transformers-lift` is a simple and lightweight library that provides type
5+classes for lifting operations through monad transformers.
src/Control/Monad/Trans/Lift/CallCC.hs+94−18
@@ -1,70 +1,146 @@
1−{-# LANGUAGE TypeFamilies #-}
2−{-# LANGUAGE UndecidableInstances #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE RankNTypes #-}
3+-- | Lifting the @callCC@ operation.
34module Control.Monad.Trans.Lift.CallCC
45 ( LiftCallCC(..)
56 , CallCC
7+ , defaultLiftCallCC
8+ , defaultLiftCallCC'
69 , module Control.Monad.Trans.Class
710 ) where
811
12+#if __GLASGOW_HASKELL__ < 710
913import Data.Monoid
14+#endif
1015
1116import Control.Monad.Signatures
1217import Control.Monad.Trans.Class
13−import Control.Monad.Trans.Control
1418
1519import qualified Control.Monad.Trans.Except as E
1620import qualified Control.Monad.Trans.Identity as I
1721import qualified Control.Monad.Trans.List as L
1822import qualified Control.Monad.Trans.Maybe as M
1923import qualified Control.Monad.Trans.Reader as R
20−import qualified Control.Monad.Trans.Cont as C
2124import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
2225import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
26+import qualified Control.Monad.Trans.RWS.CPS as RWS.CPS
2327import qualified Control.Monad.Trans.State.Lazy as S.Lazy
2428import qualified Control.Monad.Trans.State.Strict as S.Strict
2529import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
2630import qualified Control.Monad.Trans.Writer.Strict as W.Strict
31+import qualified Control.Monad.Trans.Writer.CPS as W.CPS
2732
33+#if MIN_VERSION_transformers(0,5,3)
34+import qualified Control.Monad.Trans.Accum as Acc
35+#endif
36+
37+import Control.Monad.Trans.Lift.StT
38+
39+-- | The class of monad transformers capable of lifting 'callCC'.
2840class MonadTrans t => LiftCallCC t where
29− type CallCCStT t a
30− type CallCCStT t a = StT t a
31− liftCallCC :: Monad m => CallCC m (CallCCStT t a) (CallCCStT t b) -> CallCC (t m) a b
32− liftCallCC' :: Monad m => CallCC m (CallCCStT t a) (CallCCStT t b) -> CallCC (t m) a b
41+ -- | Lift the @callCC@ operation.
42+ -- Should satisfy the uniformity property
43+ --
44+ -- * @'lift' (f k) = f' ('lift' . k) => 'lift' (cf f) = 'liftCallCC' cf f'@
45+ --
46+ liftCallCC :: Monad m => CallCC m (StT t a) (StT t b) -> CallCC (t m) a b
47+
48+ -- | Lift the @callCC@ operation.
49+ -- This is an alternative version of 'liftCallCC' included for historical
50+ -- reasons. It has a different lifting behavior for the @StateT@ and @RWST@
51+ -- monad transformers. Matches what @mtl@ does but doesn't satisfy the
52+ -- uniformity property.
53+ liftCallCC' :: Monad m => CallCC m (StT t a) (StT t b) -> CallCC (t m) a b
3354 liftCallCC' = liftCallCC
3455
56+-- | Default definition for the 'liftCallCC' method.
57+defaultLiftCallCC
58+ :: (Monad m, LiftCallCC n)
59+ => (forall x . n m x -> t m x)
60+ -- ^ Monad constructor
61+ -> (forall o x . t o x -> n o x)
62+ -- ^ Monad deconstructor
63+ -> CallCC m (StT n a) (StT n b)
64+ -> CallCC (t m) a b
65+defaultLiftCallCC t unT callCC f
66+ = t $ liftCallCC callCC (\g -> (unT . f) (t . g))
67+
68+-- | Default definition for the 'liftCallCC'' method.
69+defaultLiftCallCC'
70+ :: (Monad m, LiftCallCC n)
71+ => (forall x . n m x -> t m x)
72+ -- ^ Monad constructor
73+ -> (forall o x . t o x -> n o x)
74+ -- ^ Monad deconstructor
75+ -> CallCC m (StT n a) (StT n b)
76+ -> CallCC (t m) a b
77+defaultLiftCallCC' t unT callCC f
78+ = t $ liftCallCC' callCC (\g -> (unT . f) (t . g))
79+
3580instance LiftCallCC (E.ExceptT e) where
36− liftCallCC = E.liftCallCC
81+ liftCallCC = E.liftCallCC
82+ {-# INLINE liftCallCC #-}
3783
3884instance LiftCallCC I.IdentityT where
39− liftCallCC = I.liftCallCC
85+ liftCallCC = I.liftCallCC
86+ {-# INLINE liftCallCC #-}
4087
4188instance LiftCallCC L.ListT where
42− liftCallCC = L.liftCallCC
89+ liftCallCC = L.liftCallCC
90+ {-# INLINE liftCallCC #-}
4391
4492instance LiftCallCC M.MaybeT where
45− liftCallCC = M.liftCallCC
93+ liftCallCC = M.liftCallCC
94+ {-# INLINE liftCallCC #-}
4695
4796instance LiftCallCC (R.ReaderT r) where
48− liftCallCC = R.liftCallCC
97+ liftCallCC = R.liftCallCC
98+ {-# INLINE liftCallCC #-}
99+
100+instance Monoid w => LiftCallCC (W.Lazy.WriterT w) where
101+ liftCallCC = W.Lazy.liftCallCC
102+ {-# INLINE liftCallCC #-}
103+
104+instance Monoid w => LiftCallCC (W.Strict.WriterT w) where
105+ liftCallCC = W.Strict.liftCallCC
106+ {-# INLINE liftCallCC #-}
107+
108+instance Monoid w => LiftCallCC (W.CPS.WriterT w) where
109+ liftCallCC = W.CPS.liftCallCC
110+ {-# INLINE liftCallCC #-}
49111
50112instance Monoid w => LiftCallCC (RWS.Lazy.RWST r w s) where
51113 liftCallCC = RWS.Lazy.liftCallCC
114+ {-# INLINE liftCallCC #-}
52115 liftCallCC' = RWS.Lazy.liftCallCC'
116+ {-# INLINE liftCallCC' #-}
53117
54118instance Monoid w => LiftCallCC (RWS.Strict.RWST r w s) where
55119 liftCallCC = RWS.Strict.liftCallCC
120+ {-# INLINE liftCallCC #-}
56121 liftCallCC' = RWS.Strict.liftCallCC'
122+ {-# INLINE liftCallCC' #-}
123+
124+instance Monoid w => LiftCallCC (RWS.CPS.RWST r w s) where
125+ liftCallCC = RWS.CPS.liftCallCC
126+ {-# INLINE liftCallCC #-}
127+ liftCallCC' = RWS.CPS.liftCallCC'
128+ {-# INLINE liftCallCC' #-}
57129
58130instance LiftCallCC (S.Lazy.StateT s) where
59131 liftCallCC = S.Lazy.liftCallCC
132+ {-# INLINE liftCallCC #-}
60133 liftCallCC' = S.Lazy.liftCallCC'
134+ {-# INLINE liftCallCC' #-}
61135
62136instance LiftCallCC (S.Strict.StateT s) where
63137 liftCallCC = S.Strict.liftCallCC
138+ {-# INLINE liftCallCC #-}
64139 liftCallCC' = S.Strict.liftCallCC'
140+ {-# INLINE liftCallCC' #-}
65141
66−instance Monoid w => LiftCallCC (W.Lazy.WriterT w) where
67− liftCallCC = W.Lazy.liftCallCC
68−
69−instance Monoid w => LiftCallCC (W.Strict.WriterT w) where
70− liftCallCC = W.Strict.liftCallCC
142+#if MIN_VERSION_transformers(0,5,3)
143+instance Monoid w => LiftCallCC (Acc.AccumT w) where
144+ liftCallCC = Acc.liftCallCC
145+ {-# INLINE liftCallCC #-}
146+#endif
src/Control/Monad/Trans/Lift/Catch.hs+101−37
@@ -1,49 +1,113 @@
1−{-# LANGUAGE TypeFamilies #-}
2−{-# LANGUAGE UndecidableInstances #-}
3−{-# LANGUAGE DefaultSignatures #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE RankNTypes #-}
3+-- | Lifting the @catch@ operation.
44module Control.Monad.Trans.Lift.Catch
55 ( LiftCatch(..)
66 , Catch
7+ , defaultLiftCatch
78 , module Control.Monad.Trans.Class
89 ) where
910
11+#if __GLASGOW_HASKELL__ < 710
1012import Data.Monoid
13+#endif
1114
1215import Control.Monad.Signatures
1316import Control.Monad.Trans.Class
14−import Control.Monad.Trans.Control
15−
16−import Control.Monad.Trans.Except
17−import Control.Monad.Trans.Identity
18−import Control.Monad.Trans.List
19−import Control.Monad.Trans.Maybe
20−import Control.Monad.Trans.Reader
21−import qualified Control.Monad.Trans.Cont as Cont
22−import qualified Control.Monad.Trans.RWS.Lazy as Lazy
23−import qualified Control.Monad.Trans.RWS.Strict as Strict
24−import qualified Control.Monad.Trans.State.Lazy as Lazy
25−import qualified Control.Monad.Trans.State.Strict as Strict
26−import qualified Control.Monad.Trans.Writer.Lazy as Lazy
27−import qualified Control.Monad.Trans.Writer.Strict as Strict
2817
18+import qualified Control.Monad.Trans.Except as E
19+import qualified Control.Monad.Trans.Identity as I
20+import qualified Control.Monad.Trans.List as L
21+import qualified Control.Monad.Trans.Maybe as M
22+import qualified Control.Monad.Trans.Reader as R
23+import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
24+import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
25+import qualified Control.Monad.Trans.RWS.CPS as RWS.CPS
26+import qualified Control.Monad.Trans.State.Lazy as S.Lazy
27+import qualified Control.Monad.Trans.State.Strict as S.Strict
28+import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
29+import qualified Control.Monad.Trans.Writer.Strict as W.Strict
30+import qualified Control.Monad.Trans.Writer.CPS as W.CPS
31+
32+#if MIN_VERSION_transformers(0,5,3)
33+import qualified Control.Monad.Trans.Accum as Acc
34+#endif
35+
36+import Control.Monad.Trans.Lift.StT
37+
38+-- | The class of monad transformers capable of lifting 'catch'.
2939class MonadTrans t => LiftCatch t where
30− type CatchStT t a
31− type CatchStT t a = StT t a
32− liftCatch :: Monad m => Catch e m (CatchStT t a) -> Catch e (t m) a
33− default liftCatch
34− :: (MonadTransControl t, CatchStT t a ~ StT t a, Monad m, Monad (t m))
35− => Catch e m (CatchStT t a) -> Catch e (t m) a
36− liftCatch catchE m h = do
37− liftWith (\run -> catchE (run m) (run . h)) >>= restoreT . return
38−
39−instance LiftCatch (ExceptT e)
40−instance LiftCatch IdentityT
41−instance LiftCatch ListT
42−instance LiftCatch MaybeT
43−instance LiftCatch (ReaderT r)
44−instance Monoid w => LiftCatch (Lazy.RWST r w s)
45−instance Monoid w => LiftCatch (Strict.RWST r w s)
46−instance LiftCatch (Lazy.StateT s)
47−instance LiftCatch (Strict.StateT s)
48−instance Monoid w => LiftCatch (Lazy.WriterT w)
49−instance Monoid w => LiftCatch (Strict.WriterT w)
40+ -- | Lift the @catch@ operation.
41+ -- Should satisfy the uniformity property
42+ --
43+ -- * @'lift' (cf m f) = 'liftCatch' ('lift' . cf) ('lift' f)@
44+ --
45+ liftCatch :: Monad m => Catch e m (StT t a) -> Catch e (t m) a
46+
47+-- | Default definition for the 'liftCatch' method.
48+defaultLiftCatch
49+ :: (Monad m, LiftCatch n)
50+ => (forall x . n m x -> t m x)
51+ -- ^ Monad constructor
52+ -> (forall o x . t o x -> n o x)
53+ -- ^ Monad deconstructor
54+ -> Catch e m (StT n a) -> Catch e (t m) a
55+defaultLiftCatch t unT f m h = t $ liftCatch f (unT m) (unT . h)
56+
57+instance LiftCatch (E.ExceptT e) where
58+ liftCatch f m h = E.ExceptT $ f (E.runExceptT m) (E.runExceptT . h)
59+ {-# INLINE liftCatch #-}
60+
61+instance LiftCatch I.IdentityT where
62+ liftCatch = I.liftCatch
63+ {-# INLINE liftCatch #-}
64+
65+instance LiftCatch L.ListT where
66+ liftCatch = L.liftCatch
67+ {-# INLINE liftCatch #-}
68+
69+instance LiftCatch M.MaybeT where
70+ liftCatch = M.liftCatch
71+ {-# INLINE liftCatch #-}
72+
73+instance LiftCatch (R.ReaderT r) where
74+ liftCatch = R.liftCatch
75+ {-# INLINE liftCatch #-}
76+
77+instance Monoid w => LiftCatch (RWS.Lazy.RWST r w s) where
78+ liftCatch = RWS.Lazy.liftCatch
79+ {-# INLINE liftCatch #-}
80+
81+instance Monoid w => LiftCatch (RWS.Strict.RWST r w s) where
82+ liftCatch = RWS.Strict.liftCatch
83+ {-# INLINE liftCatch #-}
84+
85+instance Monoid w => LiftCatch (RWS.CPS.RWST r w s) where
86+ liftCatch = RWS.CPS.liftCatch
87+ {-# INLINE liftCatch #-}
88+
89+instance LiftCatch (S.Lazy.StateT s) where
90+ liftCatch = S.Lazy.liftCatch
91+ {-# INLINE liftCatch #-}
92+
93+instance LiftCatch (S.Strict.StateT s) where
94+ liftCatch = S.Strict.liftCatch
95+ {-# INLINE liftCatch #-}
96+
97+instance Monoid w => LiftCatch (W.Lazy.WriterT w) where
98+ liftCatch = W.Lazy.liftCatch
99+ {-# INLINE liftCatch #-}
100+
101+instance Monoid w => LiftCatch (W.Strict.WriterT w) where
102+ liftCatch = W.Strict.liftCatch
103+ {-# INLINE liftCatch #-}
104+
105+instance Monoid w => LiftCatch (W.CPS.WriterT w) where
106+ liftCatch = W.CPS.liftCatch
107+ {-# INLINE liftCatch #-}
108+
109+#if MIN_VERSION_transformers(0,5,3)
110+instance Monoid w => LiftCatch (Acc.AccumT w) where
111+ liftCatch = Acc.liftCatch
112+ {-# INLINE liftCatch #-}
113+#endif
src/Control/Monad/Trans/Lift/Listen.hs+80−19
@@ -1,59 +1,120 @@
1−{-# LANGUAGE TypeFamilies #-}
2−{-# LANGUAGE UndecidableInstances #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE RankNTypes #-}
3+-- | Lifting the @listen@ operation.
34module Control.Monad.Trans.Lift.Listen
45 ( LiftListen(..)
56 , Listen
7+ , defaultLiftListen
68 , module Control.Monad.Trans.Class
79 ) where
810
11+#if __GLASGOW_HASKELL__ < 710
912import Data.Monoid
13+#endif
1014
1115import Control.Monad.Signatures
1216import Control.Monad.Trans.Class
13−import Control.Monad.Trans.Control
14−
15−import qualified Control.Monad.Trans.Except as E
16−import qualified Control.Monad.Trans.Identity as I
17−import qualified Control.Monad.Trans.Maybe as M
18−import qualified Control.Monad.Trans.Reader as R
19−import qualified Control.Monad.Trans.Cont as C
20−import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
21−import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
22−import qualified Control.Monad.Trans.State.Lazy as S.Lazy
23−import qualified Control.Monad.Trans.State.Strict as S.Strict
24−import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
25−import qualified Control.Monad.Trans.Writer.Strict as W.Strict
2617
18+import qualified Control.Monad.Trans.Except as E
19+import qualified Control.Monad.Trans.Identity as I
20+import qualified Control.Monad.Trans.Maybe as M
21+import qualified Control.Monad.Trans.Reader as R
22+import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
23+import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
24+import qualified Control.Monad.Trans.RWS.CPS.Internal as RWS.CPS
25+import qualified Control.Monad.Trans.State.Lazy as S.Lazy
26+import qualified Control.Monad.Trans.State.Strict as S.Strict
27+import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
28+import qualified Control.Monad.Trans.Writer.Strict as W.Strict
29+import qualified Control.Monad.Trans.Writer.CPS.Internal as W.CPS
30+
31+#if MIN_VERSION_transformers(0,5,3)
32+import qualified Control.Monad.Trans.Accum as Acc
33+#endif
34+
35+import Control.Monad.Trans.Lift.StT
36+
37+-- | The class of monad transformers capable of lifting 'listen'.
2738class MonadTrans t => LiftListen t where
28− type ListenStT t a
29− type ListenStT t a = StT t a
30− liftListen :: Monad m => Listen w m (ListenStT t a) -> Listen w (t m) a
31− -- TODO: investigate how MonadTransControl can be used for default definition
39+ -- | Lift the @listen@ operation.
40+ -- Should satisfy the uniformity property
41+ --
42+ -- * @'lift' . 'liftListen' = 'liftListen' . 'lift'@
43+ --
44+ liftListen :: Monad m => Listen w m (StT t a) -> Listen w (t m) a
45+
46+-- | Default definition for the `liftListen` method.
47+defaultLiftListen
48+ :: (Monad m, LiftListen n)
49+ => (forall x . n m x -> t m x)
50+ -- ^ Monad constructor
51+ -> (forall o x . t o x -> n o x)
52+ -- ^ Monad deconstructor
53+ -> Listen w m (StT n a) -> Listen w (t m) a
54+defaultLiftListen t unT listen m = t $ liftListen listen (unT m)
3255
3356instance LiftListen (E.ExceptT e) where
3457 liftListen = E.liftListen
58+ {-# INLINE liftListen #-}
3559
3660instance LiftListen I.IdentityT where
3761 liftListen = I.mapIdentityT
62+ {-# INLINE liftListen #-}
3863
3964instance LiftListen M.MaybeT where
4065 liftListen = M.liftListen
66+ {-# INLINE liftListen #-}
4167
4268instance LiftListen (R.ReaderT r) where
4369 liftListen = R.mapReaderT
70+ {-# INLINE liftListen #-}
4471
4572instance LiftListen (S.Lazy.StateT s) where
4673 liftListen = S.Lazy.liftListen
74+ {-# INLINE liftListen #-}
4775
4876instance LiftListen (S.Strict.StateT s) where
4977 liftListen = S.Strict.liftListen
78+ {-# INLINE liftListen #-}
79+
80+instance Monoid w' => LiftListen (RWS.Lazy.RWST r w' s) where
81+ liftListen listen m = RWS.Lazy.RWST $ \r s -> do
82+ ~((a, w', s'), w) <- listen (RWS.Lazy.runRWST m r s)
83+ return ((a, w), w', s')
84+ {-# INLINE liftListen #-}
85+
86+instance Monoid w' => LiftListen (RWS.Strict.RWST r w' s) where
87+ liftListen listen m = RWS.Strict.RWST $ \r s -> do
88+ ((a, w', s'), w) <- listen (RWS.Strict.runRWST m r s)
89+ return ((a, w), w', s')
90+ {-# INLINE liftListen #-}
91+
92+instance Monoid w' => LiftListen (RWS.CPS.RWST r w' s) where
93+ liftListen listen m = RWS.CPS.RWST $ \r w_ s -> do
94+ ((a, w', s'), w) <- listen (RWS.CPS.unRWST m r w_ s)
95+ return ((a, w), w', s')
96+ {-# INLINE liftListen #-}
5097
5198instance Monoid w' => LiftListen (W.Lazy.WriterT w') where
5299 liftListen listen m = W.Lazy.WriterT $ do
53100 ~((a, w'), w) <- listen (W.Lazy.runWriterT m)
54101 return ((a, w), w')
102+ {-# INLINE liftListen #-}
55103
56104instance Monoid w' => LiftListen (W.Strict.WriterT w') where
57105 liftListen listen m = W.Strict.WriterT $ do
58106 ((a, w'), w) <- listen (W.Strict.runWriterT m)
59107 return ((a, w), w')
108+ {-# INLINE liftListen #-}
109+
110+instance Monoid w' => LiftListen (W.CPS.WriterT w') where
111+ liftListen listen m = W.CPS.WriterT $ \w_ -> do
112+ ((a, w'), w) <- listen (W.CPS.unWriterT m w_)
113+ return ((a, w), w')
114+ {-# INLINE liftListen #-}
115+
116+#if MIN_VERSION_transformers(0,5,3)
117+instance Monoid w' => LiftListen (Acc.AccumT w') where
118+ liftListen = Acc.liftListen
119+ {-# INLINE liftListen #-}
120+#endif
src/Control/Monad/Trans/Lift/Local.hs+104−41
@@ -1,55 +1,118 @@
1+{-# LANGUAGE CPP #-}
12{-# LANGUAGE RankNTypes #-}
2−{-# LANGUAGE DefaultSignatures #-}
3+-- | Lifting the 'local' operation.
34module Control.Monad.Trans.Lift.Local
45 ( LiftLocal(..)
56 , Local
7+ , defaultLiftLocal
68 , module Control.Monad.Trans.Class
79 ) where
810
11+#if __GLASGOW_HASKELL__ < 710
912import Data.Monoid
13+#endif
1014
1115import Control.Monad.Trans.Class
12−import Control.Monad.Morph
13−
14−import Control.Monad.Trans.Except
15−import Control.Monad.Trans.Identity
16−import Control.Monad.Trans.List
17−import Control.Monad.Trans.Maybe
18−import Control.Monad.Trans.Reader
19−import qualified Control.Monad.Trans.Cont as Cont
20−import qualified Control.Monad.Trans.RWS.Lazy as Lazy
21−import qualified Control.Monad.Trans.RWS.Strict as Strict
22−import qualified Control.Monad.Trans.State.Lazy as Lazy
23−import qualified Control.Monad.Trans.State.Strict as Strict
24−import qualified Control.Monad.Trans.Writer.Lazy as Lazy
25−import qualified Control.Monad.Trans.Writer.Strict as Strict
2616
17+import qualified Control.Monad.Trans.Cont as C
18+import qualified Control.Monad.Trans.Except as E
19+import qualified Control.Monad.Trans.Identity as I
20+import qualified Control.Monad.Trans.List as L
21+import qualified Control.Monad.Trans.Maybe as M
22+import qualified Control.Monad.Trans.Reader as R
23+import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
24+import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
25+import qualified Control.Monad.Trans.RWS.CPS as RWS.CPS
26+import qualified Control.Monad.Trans.State.Lazy as S.Lazy
27+import qualified Control.Monad.Trans.State.Strict as S.Strict
28+import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
29+import qualified Control.Monad.Trans.Writer.Strict as W.Strict
30+import qualified Control.Monad.Trans.Writer.CPS as W.CPS
31+
32+#if MIN_VERSION_transformers(0,5,3)
33+import qualified Control.Monad.Trans.Accum as Acc
34+#endif
35+
36+-- | Signature of the @local@ operation,
37+-- introduced in "Control.Monad.Trans.Reader".
2738type Local r m a = (r -> r) -> m a -> m a
2839
40+-- | The class of monad transformers capable of lifting 'local'.
2941class MonadTrans t => LiftLocal t where
30− liftLocal
31− :: Monad m
32− => m r
33− -> (forall a . Local r m a)
34− -> (forall a . Local r (t m) a)
35− default liftLocal
36− :: (Monad m, MFunctor t)
37− => m r
38− -> (forall a . Local r m a)
39− -> (forall a . Local r (t m) a)
40− liftLocal _ l f = hoist (l f)
41−
42−instance LiftLocal (Cont.ContT r)
43− where liftLocal a l f = Cont.liftLocal a l f
44−
45−instance LiftLocal (ExceptT e)
46−instance LiftLocal IdentityT
47−instance LiftLocal ListT
48−instance LiftLocal MaybeT
49−instance LiftLocal (ReaderT r)
50−instance Monoid w => LiftLocal (Lazy.RWST r w s)
51−instance Monoid w => LiftLocal (Strict.RWST r w s)
52−instance LiftLocal (Lazy.StateT s)
53−instance LiftLocal (Strict.StateT s)
54−instance Monoid w => LiftLocal (Lazy.WriterT w)
55−instance Monoid w => LiftLocal (Strict.WriterT w)
42+ -- | Lift the 'local' operation.
43+ liftLocal :: Monad m => m r -> (forall a . Local r m a)
44+ -> (forall a . Local r (t m) a)
45+
46+-- | Default definition for the 'liftLocal' method.
47+defaultLiftLocal
48+ :: (Monad m, LiftLocal n)
49+ => (forall x . n m x -> t m x)
50+ -- ^ Monad constructor
51+ -> (forall o x . t o x -> n o x)
52+ -- ^ Monad deconstructor
53+ -> m r
54+ -> (forall a . Local r m a)
55+ -> (forall a . Local r (t m) a)
56+defaultLiftLocal t unT a l f = t . liftLocal a l f . unT
57+
58+instance LiftLocal (C.ContT r) where
59+ liftLocal a l f = C.liftLocal a l f
60+ {-# INLINE liftLocal #-}
61+
62+instance LiftLocal (E.ExceptT e) where
63+ liftLocal _ l f = E.mapExceptT (l f)
64+ {-# INLINE liftLocal #-}
65+
66+instance LiftLocal I.IdentityT where
67+ liftLocal _ l f = I.mapIdentityT (l f)
68+ {-# INLINE liftLocal #-}
69+
70+instance LiftLocal L.ListT where
71+ liftLocal _ l f = L.mapListT (l f)
72+ {-# INLINE liftLocal #-}
73+
74+instance LiftLocal M.MaybeT where
75+ liftLocal _ l f = M.mapMaybeT (l f)
76+ {-# INLINE liftLocal #-}
77+
78+instance LiftLocal (R.ReaderT r) where
79+ liftLocal _ l f = R.mapReaderT (l f)
80+ {-# INLINE liftLocal #-}
81+
82+instance Monoid w => LiftLocal (RWS.Lazy.RWST r w s) where
83+ liftLocal _ l f = RWS.Lazy.mapRWST (l f)
84+ {-# INLINE liftLocal #-}
85+
86+instance Monoid w => LiftLocal (RWS.Strict.RWST r w s) where
87+ liftLocal _ l f = RWS.Strict.mapRWST (l f)
88+ {-# INLINE liftLocal #-}
89+
90+instance Monoid w => LiftLocal (RWS.CPS.RWST r w s) where
91+ liftLocal _ l f = RWS.CPS.mapRWST (l f)
92+ {-# INLINE liftLocal #-}
93+
94+instance LiftLocal (S.Lazy.StateT s) where
95+ liftLocal _ l f = S.Lazy.mapStateT (l f)
96+ {-# INLINE liftLocal #-}
97+
98+instance LiftLocal (S.Strict.StateT s) where
99+ liftLocal _ l f = S.Strict.mapStateT (l f)
100+ {-# INLINE liftLocal #-}
101+
102+instance Monoid w => LiftLocal (W.Lazy.WriterT w) where
103+ liftLocal _ l f = W.Lazy.mapWriterT (l f)
104+ {-# INLINE liftLocal #-}
105+
106+instance Monoid w => LiftLocal (W.Strict.WriterT w) where
107+ liftLocal _ l f = W.Strict.mapWriterT (l f)
108+ {-# INLINE liftLocal #-}
109+
110+instance Monoid w => LiftLocal (W.CPS.WriterT w) where
111+ liftLocal _ l f = W.CPS.mapWriterT (l f)
112+ {-# INLINE liftLocal #-}
113+
114+#if MIN_VERSION_transformers(0,5,3)
115+instance Monoid w => LiftLocal (Acc.AccumT w) where
116+ liftLocal _ l f = Acc.mapAccumT (l f)
117+ {-# INLINE liftLocal #-}
118+#endif
src/Control/Monad/Trans/Lift/Pass.hs+86−23
@@ -1,59 +1,122 @@
1−{-# LANGUAGE TypeFamilies #-}
2−{-# LANGUAGE UndecidableInstances #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE RankNTypes #-}
3+
4+-- | Lifting the 'pass' operation.
35module Control.Monad.Trans.Lift.Pass
46 ( LiftPass(..)
57 , Pass
8+ , defaultLiftPass
69 , module Control.Monad.Trans.Class
710 ) where
811
12+#if __GLASGOW_HASKELL__ < 710
913import Data.Monoid
14+#endif
1015
1116import Control.Monad.Signatures
1217import Control.Monad.Trans.Class
13−import Control.Monad.Trans.Control
14−
15−import qualified Control.Monad.Trans.Except as E
16−import qualified Control.Monad.Trans.Identity as I
17−import qualified Control.Monad.Trans.Maybe as M
18−import qualified Control.Monad.Trans.Reader as R
19−import qualified Control.Monad.Trans.Cont as C
20−import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
21−import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
22−import qualified Control.Monad.Trans.State.Lazy as S.Lazy
23−import qualified Control.Monad.Trans.State.Strict as S.Strict
24−import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
25−import qualified Control.Monad.Trans.Writer.Strict as W.Strict
2618
19+import qualified Control.Monad.Trans.Except as E
20+import qualified Control.Monad.Trans.Identity as I
21+import qualified Control.Monad.Trans.Maybe as M
22+import qualified Control.Monad.Trans.Reader as R
23+import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
24+import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
25+import qualified Control.Monad.Trans.RWS.CPS.Internal as RWS.CPS
26+import qualified Control.Monad.Trans.State.Lazy as S.Lazy
27+import qualified Control.Monad.Trans.State.Strict as S.Strict
28+import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
29+import qualified Control.Monad.Trans.Writer.Strict as W.Strict
30+import qualified Control.Monad.Trans.Writer.CPS.Internal as W.CPS
31+
32+#if MIN_VERSION_transformers(0,5,3)
33+import qualified Control.Monad.Trans.Accum as Acc
34+#endif
35+
36+import Control.Monad.Trans.Lift.StT
37+
38+-- | The class of monad transformers capable of lifting 'pass'.
2739class MonadTrans t => LiftPass t where
28− type PassStT t a
29− type PassStT t a = StT t a
30− liftPass :: Monad m => Pass w m (PassStT t a) -> Pass w (t m) a
31− -- TODO: investigate how MonadTransControl can be used for default definition
40+ -- | Lift the 'pass' operation.
41+ -- Should satisfy the uniformity property
42+ --
43+ -- * @'lift' . 'liftPass' = 'liftPass' . 'lift'@
44+ --
45+ liftPass :: Monad m => Pass w m (StT t a) -> Pass w (t m) a
46+
47+-- | Default definition for the 'liftPass' method.
48+defaultLiftPass
49+ :: (Monad m, LiftPass n)
50+ => (forall x . n m x -> t m x)
51+ -- ^ Monad constructor
52+ -> (forall o x . t o x -> n o x)
53+ -- ^ Monad deconstructor
54+ -> Pass w m (StT n a)
55+ -> Pass w (t m) a
56+defaultLiftPass t unT pass m = t $ liftPass pass (unT m)
3257
3358instance LiftPass (E.ExceptT e) where
3459 liftPass = E.liftPass
60+ {-# INLINE liftPass #-}
3561
3662instance LiftPass I.IdentityT where
3763 liftPass = I.mapIdentityT
64+ {-# INLINE liftPass #-}
3865
3966instance LiftPass M.MaybeT where
4067 liftPass = M.liftPass
68+ {-# INLINE liftPass #-}
4169
4270instance LiftPass (R.ReaderT r) where
4371 liftPass = R.mapReaderT
72+ {-# INLINE liftPass #-}
4473
4574instance LiftPass (S.Lazy.StateT s) where
4675 liftPass = S.Lazy.liftPass
76+ {-# INLINE liftPass #-}
4777
4878instance LiftPass (S.Strict.StateT s) where
4979 liftPass = S.Strict.liftPass
80+ {-# INLINE liftPass #-}
81+
82+instance Monoid w' => LiftPass (RWS.Lazy.RWST r w' s) where
83+ liftPass pass m = RWS.Lazy.RWST $ \r s -> pass $ do
84+ ~((a, f), w', s') <- RWS.Lazy.runRWST m r s
85+ return ((a, w', s'), f)
86+ {-# INLINE liftPass #-}
87+
88+instance Monoid w' => LiftPass (RWS.Strict.RWST r w' s) where
89+ liftPass pass m = RWS.Strict.RWST $ \r s -> pass $ do
90+ ((a, f), w', s') <- RWS.Strict.runRWST m r s
91+ return ((a, w', s'), f)
92+ {-# INLINE liftPass #-}
93+
94+instance Monoid w' => LiftPass (RWS.CPS.RWST r w' s) where
95+ liftPass pass m = RWS.CPS.RWST $ \r w_ s -> pass $ do
96+ ((a, f), w', s') <- RWS.CPS.unRWST m r w_ s
97+ return ((a, w', s'), f)
98+ {-# INLINE liftPass #-}
5099
51100instance Monoid w' => LiftPass (W.Lazy.WriterT w') where
52101 liftPass pass m = W.Lazy.WriterT $ pass $ do
53− ~((a, f), w) <- W.Lazy.runWriterT m
54− return ((a, w), f)
102+ ~((a, f), w') <- W.Lazy.runWriterT m
103+ return ((a, w'), f)
104+ {-# INLINE liftPass #-}
55105
56106instance Monoid w' => LiftPass (W.Strict.WriterT w') where
57107 liftPass pass m = W.Strict.WriterT $ pass $ do
58− ((a, f), w) <- W.Strict.runWriterT m
59− return ((a, w), f)
108+ ((a, f), w') <- W.Strict.runWriterT m
109+ return ((a, w'), f)
110+ {-# INLINE liftPass #-}
111+
112+instance Monoid w' => LiftPass (W.CPS.WriterT w') where
113+ liftPass pass m = W.CPS.WriterT $ \w_ -> pass $ do
114+ ((a, f), w') <- W.CPS.unWriterT m w_
115+ return ((a, w'), f)
116+ {-# INLINE liftPass #-}
117+
118+#if MIN_VERSION_transformers(0,5,3)
119+instance Monoid w' => LiftPass (Acc.AccumT w') where
120+ liftPass = Acc.liftPass
121+ {-# INLINE liftPass #-}
122+#endif
src/Control/Monad/Trans/Lift/StT.hsnew file+46
@@ -0,0 +1,46 @@
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE TypeFamilies #-}
3+{-# LANGUAGE KindSignatures #-}
4+
5+-- | The 'StT' type family.
6+module Control.Monad.Trans.Lift.StT (StT) where
7+
8+import qualified Control.Monad.Trans.Except as E
9+import qualified Control.Monad.Trans.Identity as I
10+import qualified Control.Monad.Trans.List as L
11+import qualified Control.Monad.Trans.Maybe as M
12+import qualified Control.Monad.Trans.Reader as R
13+import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
14+import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
15+import qualified Control.Monad.Trans.RWS.CPS as RWS.CPS
16+import qualified Control.Monad.Trans.State.Lazy as S.Lazy
17+import qualified Control.Monad.Trans.State.Strict as S.Strict
18+import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
19+import qualified Control.Monad.Trans.Writer.Strict as W.Strict
20+import qualified Control.Monad.Trans.Writer.CPS as W.CPS
21+
22+#if MIN_VERSION_transformers(0,5,3)
23+import qualified Control.Monad.Trans.Accum as Acc
24+#endif
25+
26+-- | Internal state of a monad transformer.
27+-- Same as @StT@ from the @monad-control@ package.
28+type family StT (t :: (* -> *) -> (* -> *)) (a :: *) :: *
29+
30+type instance StT (E.ExceptT e) a = Either e a
31+type instance StT I.IdentityT a = a
32+type instance StT L.ListT a = [a]
33+type instance StT M.MaybeT a = Maybe a
34+type instance StT (R.ReaderT r) a = a
35+type instance StT (RWS.Lazy.RWST r w s) a = (a, s, w)
36+type instance StT (RWS.Strict.RWST r w s) a = (a, s, w)
37+type instance StT (RWS.CPS.RWST r w s) a = (a, s, w)
38+type instance StT (S.Lazy.StateT s) a = (a, s)
39+type instance StT (S.Strict.StateT s) a = (a, s)
40+type instance StT (W.Lazy.WriterT w) a = (a, w)
41+type instance StT (W.Strict.WriterT w) a = (a, w)
42+type instance StT (W.CPS.WriterT w) a = (a, w)
43+
44+#if MIN_VERSION_transformers(0,5,3)
45+type instance StT (Acc.AccumT w) a = (a, w)
46+#endif
stack-7.8.3.yamlnew file+7
@@ -0,0 +1,7 @@
1+flags: {}
2+packages:
3+- '.'
4+resolver: lts-2.22
5+extra-deps:
6+- transformers-0.4.2.0
7+- writer-cps-transformers-0.1.1.3
stack.yamlnew file+4
@@ -0,0 +1,4 @@
1+flags: {}
2+packages:
3+- '.'
4+resolver: nightly-2018-03-17
transformers-lift.cabal+27−15
@@ -1,16 +1,19 @@
1+cabal-version: 2.2
12name: transformers-lift
2−version: 0.1.0.0
3+version: 0.2.0.2
34synopsis: Ad-hoc type classes for lifting
4−-- description:
5−license: BSD3
5+description:
6+ This simple and lightweight library provides type classes
7+ for lifting monad transformer operations.
8+
9+-- license: BSD3
10+-- ^ unfortunately have to comment this line because of cabal2nix
611license-file: LICENSE
7−author: Index Int
8−maintainer: vlad.z.4096@gmail.com
9−-- copyright:
12+author: Vladislav Zavialov
13+maintainer: Vladislav Zavialov <vlad.z.4096@gmail.com>
1014category: Control
15+bug-reports: https://github.com/int-index/transformers-lift/issues
1116build-type: Simple
12−-- extra-source-files:
13−cabal-version: >=1.10
1417
1518library
1619 exposed-modules: Control.Monad.Trans.Lift.Local
@@ -18,11 +21,20 @@ library
1821 Control.Monad.Trans.Lift.Catch
1922 Control.Monad.Trans.Lift.Listen
2023 Control.Monad.Trans.Lift.Pass
21− -- other-modules:
22− -- other-extensions:
23− build-depends: base >=4.7 && <4.9
24− , transformers >= 0.4.2
25− , mmorph >= 1.0.4
26− , monad-control >= 1.0.0.4
27− hs-source-dirs: src
24+ Control.Monad.Trans.Lift.StT
25+
26+ build-depends: base >=4.8 && <4.13
27+ , transformers >= 0.4.2.0 && <0.6
28+ , writer-cps-transformers == 0.1.1.4
29+
30+ mixins: transformers hiding
31+ (Control.Monad.Trans.RWS.CPS, Control.Monad.Trans.Writer.CPS)
32+
2833 default-language: Haskell2010
34+ other-extensions: CPP
35+ RankNTypes
36+ TypeFamilies
37+ KindSignatures
38+
39+ hs-source-dirs: src
40+ ghc-options: -Wall -fno-warn-deprecations