git.iko.soy/typeable/transformers-lift
on master help sign in
swap
327270127 ahead, 0 behind
.gitignore+1
since splitsnapshots
unifiedsplit
@@ -1,3 +1,4 @@
1dist
1dist
2+.stack-work
2.cabal-sandbox/
3.cabal-sandbox/
3cabal.sandbox.config
4cabal.sandbox.config
.travis.yml+24−9
@@ -1,20 +1,35 @@
1+sudo: false
2+
1env:
3env:
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
4 - CABALVER=head GHCVER=head
9 - CABALVER=head GHCVER=head
5
10
6before_install:
11before_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
10 - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
12 - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
13+ - ghc --version
14+ - cabal --version
11 - travis_retry cabal update
15 - travis_retry cabal update
12
16
13install:
17install:
14− - cabal --version
18+ - cabal install --dep
15− - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"
16− - cabal install --only-dependencies
17
19
18script:
20script:
19− - cabal configure --enable-tests -v2
20 - cabal build
21 - 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
2
2
3All rights reserved.
3All rights reserved.
4
4
@@ -13,7 +13,7 @@ modification, are permitted provided that the following conditions are met:
13 disclaimer in the documentation and/or other materials provided
13 disclaimer in the documentation and/or other materials provided
14 with the distribution.
14 with the distribution.
15
15
16− * Neither the name of Index Int nor the names of other
16+ * Neither the name of Vladislav Zavialov nor the names of other
17 contributors may be used to endorse or promote products derived
17 contributors may be used to endorse or promote products derived
18 from this software without specific prior written permission.
18 from this software without specific prior written permission.
19
19
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+91−17
@@ -1,9 +1,11 @@
1{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
2−{-# LANGUAGE TypeFamilies #-}
2+{-# LANGUAGE RankNTypes #-}
3−{-# LANGUAGE UndecidableInstances #-}
3+-- | Lifting the @callCC@ operation.
4module Control.Monad.Trans.Lift.CallCC
4module Control.Monad.Trans.Lift.CallCC
5 ( LiftCallCC(..)
5 ( LiftCallCC(..)
6 , CallCC
6 , CallCC
7+ , defaultLiftCallCC
8+ , defaultLiftCallCC'
7 , module Control.Monad.Trans.Class
9 , module Control.Monad.Trans.Class
8 ) where
10 ) where
9
11
@@ -13,7 +15,6 @@ import Data.Monoid
13
15
14import Control.Monad.Signatures
16import Control.Monad.Signatures
15import Control.Monad.Trans.Class
17import Control.Monad.Trans.Class
16−import Control.Monad.Trans.Control
17
18
18import qualified Control.Monad.Trans.Except as E
19import qualified Control.Monad.Trans.Except as E
19import qualified Control.Monad.Trans.Identity as I
20import qualified Control.Monad.Trans.Identity as I
@@ -22,51 +23,124 @@ import qualified Control.Monad.Trans.Maybe as M
22import qualified Control.Monad.Trans.Reader as R
23import qualified Control.Monad.Trans.Reader as R
23import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
24import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
24import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
25import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
26+import qualified Control.Monad.Trans.RWS.CPS as RWS.CPS
25import qualified Control.Monad.Trans.State.Lazy as S.Lazy
27import qualified Control.Monad.Trans.State.Lazy as S.Lazy
26import qualified Control.Monad.Trans.State.Strict as S.Strict
28import qualified Control.Monad.Trans.State.Strict as S.Strict
27import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
29import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
28import qualified Control.Monad.Trans.Writer.Strict as W.Strict
30import qualified Control.Monad.Trans.Writer.Strict as W.Strict
31+import qualified Control.Monad.Trans.Writer.CPS as W.CPS
29
32
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'.
30class MonadTrans t => LiftCallCC t where
40class MonadTrans t => LiftCallCC t where
31− type CallCCStT t a
41+ -- | Lift the @callCC@ operation.
32− type CallCCStT t a = StT t a
42+ -- Should satisfy the uniformity property
43+ --
44+ -- * @'lift' (f k) = f' ('lift' . k) => 'lift' (cf f) = 'liftCallCC' cf f'@
45+ --
33− liftCallCC :: Monad m => CallCC m (CallCCStT t a) (CallCCStT t b) -> CallCC (t m) a b
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.
34− liftCallCC' :: Monad m => CallCC m (CallCCStT t a) (CallCCStT t b) -> CallCC (t m) a b
53+ liftCallCC' :: Monad m => CallCC m (StT t a) (StT t b) -> CallCC (t m) a b
35 liftCallCC' = liftCallCC
54 liftCallCC' = liftCallCC
36
55
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+
37instance LiftCallCC (E.ExceptT e) where
80instance LiftCallCC (E.ExceptT e) where
38− liftCallCC = E.liftCallCC
81+ liftCallCC = E.liftCallCC
82+ {-# INLINE liftCallCC #-}
39
83
40instance LiftCallCC I.IdentityT where
84instance LiftCallCC I.IdentityT where
41− liftCallCC = I.liftCallCC
85+ liftCallCC = I.liftCallCC
86+ {-# INLINE liftCallCC #-}
42
87
43instance LiftCallCC L.ListT where
88instance LiftCallCC L.ListT where
44− liftCallCC = L.liftCallCC
89+ liftCallCC = L.liftCallCC
90+ {-# INLINE liftCallCC #-}
45
91
46instance LiftCallCC M.MaybeT where
92instance LiftCallCC M.MaybeT where
47− liftCallCC = M.liftCallCC
93+ liftCallCC = M.liftCallCC
94+ {-# INLINE liftCallCC #-}
48
95
49instance LiftCallCC (R.ReaderT r) where
96instance LiftCallCC (R.ReaderT r) where
50− 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 #-}
51
111
52instance Monoid w => LiftCallCC (RWS.Lazy.RWST r w s) where
112instance Monoid w => LiftCallCC (RWS.Lazy.RWST r w s) where
53 liftCallCC = RWS.Lazy.liftCallCC
113 liftCallCC = RWS.Lazy.liftCallCC
114+ {-# INLINE liftCallCC #-}
54 liftCallCC' = RWS.Lazy.liftCallCC'
115 liftCallCC' = RWS.Lazy.liftCallCC'
116+ {-# INLINE liftCallCC' #-}
55
117
56instance Monoid w => LiftCallCC (RWS.Strict.RWST r w s) where
118instance Monoid w => LiftCallCC (RWS.Strict.RWST r w s) where
57 liftCallCC = RWS.Strict.liftCallCC
119 liftCallCC = RWS.Strict.liftCallCC
120+ {-# INLINE liftCallCC #-}
58 liftCallCC' = RWS.Strict.liftCallCC'
121 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' #-}
59
129
60instance LiftCallCC (S.Lazy.StateT s) where
130instance LiftCallCC (S.Lazy.StateT s) where
61 liftCallCC = S.Lazy.liftCallCC
131 liftCallCC = S.Lazy.liftCallCC
132+ {-# INLINE liftCallCC #-}
62 liftCallCC' = S.Lazy.liftCallCC'
133 liftCallCC' = S.Lazy.liftCallCC'
134+ {-# INLINE liftCallCC' #-}
63
135
64instance LiftCallCC (S.Strict.StateT s) where
136instance LiftCallCC (S.Strict.StateT s) where
65 liftCallCC = S.Strict.liftCallCC
137 liftCallCC = S.Strict.liftCallCC
138+ {-# INLINE liftCallCC #-}
66 liftCallCC' = S.Strict.liftCallCC'
139 liftCallCC' = S.Strict.liftCallCC'
140+ {-# INLINE liftCallCC' #-}
67
141
142+#if MIN_VERSION_transformers(0,5,3)
68−instance Monoid w => LiftCallCC (W.Lazy.WriterT w) where
143+instance Monoid w => LiftCallCC (Acc.AccumT w) where
69− liftCallCC = W.Lazy.liftCallCC
144+ liftCallCC = Acc.liftCallCC
70−
145+ {-# INLINE liftCallCC #-}
71−instance Monoid w => LiftCallCC (W.Strict.WriterT w) where
146+#endif
72− liftCallCC = W.Strict.liftCallCC
src/Control/Monad/Trans/Lift/Catch.hs+98−36
@@ -1,10 +1,10 @@
1{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
2−{-# LANGUAGE TypeFamilies #-}
2+{-# LANGUAGE RankNTypes #-}
3−{-# LANGUAGE UndecidableInstances #-}
3+-- | Lifting the @catch@ operation.
4−{-# LANGUAGE DefaultSignatures #-}
5module Control.Monad.Trans.Lift.Catch
4module Control.Monad.Trans.Lift.Catch
6 ( LiftCatch(..)
5 ( LiftCatch(..)
7 , Catch
6 , Catch
7+ , defaultLiftCatch
8 , module Control.Monad.Trans.Class
8 , module Control.Monad.Trans.Class
9 ) where
9 ) where
10
10
@@ -14,38 +14,100 @@ import Data.Monoid
14
14
15import Control.Monad.Signatures
15import Control.Monad.Signatures
16import Control.Monad.Trans.Class
16import Control.Monad.Trans.Class
17−import Control.Monad.Trans.Control
18−
19−import Control.Monad.Trans.Except
20−import Control.Monad.Trans.Identity
21−import Control.Monad.Trans.List
22−import Control.Monad.Trans.Maybe
23−import Control.Monad.Trans.Reader
24−import qualified Control.Monad.Trans.RWS.Lazy as Lazy
25−import qualified Control.Monad.Trans.RWS.Strict as Strict
26−import qualified Control.Monad.Trans.State.Lazy as Lazy
27−import qualified Control.Monad.Trans.State.Strict as Strict
28−import qualified Control.Monad.Trans.Writer.Lazy as Lazy
29−import qualified Control.Monad.Trans.Writer.Strict as Strict
30
17
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'.
31class MonadTrans t => LiftCatch t where
39class MonadTrans t => LiftCatch t where
32− type CatchStT t a
40+ -- | Lift the @catch@ operation.
33− type CatchStT t a = StT t a
41+ -- Should satisfy the uniformity property
42+ --
43+ -- * @'lift' (cf m f) = 'liftCatch' ('lift' . cf) ('lift' f)@
44+ --
34− liftCatch :: Monad m => Catch e m (CatchStT t a) -> Catch e (t m) a
45+ liftCatch :: Monad m => Catch e m (StT t a) -> Catch e (t m) a
35− default liftCatch
46+
36− :: (MonadTransControl t, CatchStT t a ~ StT t a, Monad m, Monad (t m))
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
37− => Catch e m (CatchStT t a) -> Catch e (t m) a
54+ -> Catch e m (StT n a) -> Catch e (t m) a
38− liftCatch catch m h = do
55+defaultLiftCatch t unT f m h = t $ liftCatch f (unT m) (unT . h)
39− liftWith (\run -> catch (run m) (run . h)) >>= restoreT . return
56+
40−
57+instance LiftCatch (E.ExceptT e) where
41−instance LiftCatch (ExceptT e)
58+ liftCatch f m h = E.ExceptT $ f (E.runExceptT m) (E.runExceptT . h)
59+ {-# INLINE liftCatch #-}
60+
42−instance LiftCatch IdentityT
61+instance LiftCatch I.IdentityT where
62+ liftCatch = I.liftCatch
63+ {-# INLINE liftCatch #-}
64+
43−instance LiftCatch ListT
65+instance LiftCatch L.ListT where
66+ liftCatch = L.liftCatch
67+ {-# INLINE liftCatch #-}
68+
44−instance LiftCatch MaybeT
69+instance LiftCatch M.MaybeT where
70+ liftCatch = M.liftCatch
71+ {-# INLINE liftCatch #-}
72+
45−instance LiftCatch (ReaderT r)
73+instance LiftCatch (R.ReaderT r) where
74+ liftCatch = R.liftCatch
75+ {-# INLINE liftCatch #-}
76+
46−instance Monoid w => LiftCatch (Lazy.RWST r w s)
77+instance Monoid w => LiftCatch (RWS.Lazy.RWST r w s) where
78+ liftCatch = RWS.Lazy.liftCatch
79+ {-# INLINE liftCatch #-}
80+
47−instance Monoid w => LiftCatch (Strict.RWST r w s)
81+instance Monoid w => LiftCatch (RWS.Strict.RWST r w s) where
82+ liftCatch = RWS.Strict.liftCatch
83+ {-# INLINE liftCatch #-}
84+
48−instance LiftCatch (Lazy.StateT s)
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+
49−instance LiftCatch (Strict.StateT s)
93+instance LiftCatch (S.Strict.StateT s) where
94+ liftCatch = S.Strict.liftCatch
95+ {-# INLINE liftCatch #-}
96+
50−instance Monoid w => LiftCatch (Lazy.WriterT w)
97+instance Monoid w => LiftCatch (W.Lazy.WriterT w) where
98+ liftCatch = W.Lazy.liftCatch
99+ {-# INLINE liftCatch #-}
100+
51−instance Monoid w => LiftCatch (Strict.WriterT w)
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+73−20
@@ -1,9 +1,10 @@
1{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
2−{-# LANGUAGE TypeFamilies #-}
2+{-# LANGUAGE RankNTypes #-}
3−{-# LANGUAGE UndecidableInstances #-}
3+-- | Lifting the @listen@ operation.
4module Control.Monad.Trans.Lift.Listen
4module Control.Monad.Trans.Lift.Listen
5 ( LiftListen(..)
5 ( LiftListen(..)
6 , Listen
6 , Listen
7+ , defaultLiftListen
7 , module Control.Monad.Trans.Class
8 , module Control.Monad.Trans.Class
8 ) where
9 ) where
9
10
@@ -13,55 +14,107 @@ import Data.Monoid
13
14
14import Control.Monad.Signatures
15import Control.Monad.Signatures
15import Control.Monad.Trans.Class
16import Control.Monad.Trans.Class
16−import Control.Monad.Trans.Control
17−
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.State.Lazy as S.Lazy
25−import qualified Control.Monad.Trans.State.Strict as S.Strict
26−import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
27−import qualified Control.Monad.Trans.Writer.Strict as W.Strict
28
17
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'.
29class MonadTrans t => LiftListen t where
38class MonadTrans t => LiftListen t where
30− type ListenStT t a
39+ -- | Lift the @listen@ operation.
31− type ListenStT t a = StT t a
40+ -- Should satisfy the uniformity property
41+ --
42+ -- * @'lift' . 'liftListen' = 'liftListen' . 'lift'@
43+ --
32− liftListen :: Monad m => Listen w m (ListenStT t a) -> Listen w (t m) a
44+ liftListen :: Monad m => Listen w m (StT t a) -> Listen w (t m) a
33− -- TODO: investigate how MonadTransControl can be used for default definition
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)
34
55
35instance LiftListen (E.ExceptT e) where
56instance LiftListen (E.ExceptT e) where
36 liftListen = E.liftListen
57 liftListen = E.liftListen
58+ {-# INLINE liftListen #-}
37
59
38instance LiftListen I.IdentityT where
60instance LiftListen I.IdentityT where
39 liftListen = I.mapIdentityT
61 liftListen = I.mapIdentityT
62+ {-# INLINE liftListen #-}
40
63
41instance LiftListen M.MaybeT where
64instance LiftListen M.MaybeT where
42 liftListen = M.liftListen
65 liftListen = M.liftListen
66+ {-# INLINE liftListen #-}
43
67
44instance LiftListen (R.ReaderT r) where
68instance LiftListen (R.ReaderT r) where
45 liftListen = R.mapReaderT
69 liftListen = R.mapReaderT
70+ {-# INLINE liftListen #-}
46
71
47instance LiftListen (S.Lazy.StateT s) where
72instance LiftListen (S.Lazy.StateT s) where
48 liftListen = S.Lazy.liftListen
73 liftListen = S.Lazy.liftListen
74+ {-# INLINE liftListen #-}
49
75
50instance LiftListen (S.Strict.StateT s) where
76instance LiftListen (S.Strict.StateT s) where
51 liftListen = S.Strict.liftListen
77 liftListen = S.Strict.liftListen
78+ {-# INLINE liftListen #-}
52
79
53instance Monoid w' => LiftListen (RWS.Lazy.RWST r w' s) where
80instance Monoid w' => LiftListen (RWS.Lazy.RWST r w' s) where
54− liftListen = error "TODO"
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 #-}
55
85
56instance Monoid w' => LiftListen (RWS.Strict.RWST r w' s) where
86instance Monoid w' => LiftListen (RWS.Strict.RWST r w' s) where
57− liftListen = error "TODO"
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 #-}
58
97
59instance Monoid w' => LiftListen (W.Lazy.WriterT w') where
98instance Monoid w' => LiftListen (W.Lazy.WriterT w') where
60 liftListen listen m = W.Lazy.WriterT $ do
99 liftListen listen m = W.Lazy.WriterT $ do
61 ~((a, w'), w) <- listen (W.Lazy.runWriterT m)
100 ~((a, w'), w) <- listen (W.Lazy.runWriterT m)
62 return ((a, w), w')
101 return ((a, w), w')
102+ {-# INLINE liftListen #-}
63
103
64instance Monoid w' => LiftListen (W.Strict.WriterT w') where
104instance Monoid w' => LiftListen (W.Strict.WriterT w') where
65 liftListen listen m = W.Strict.WriterT $ do
105 liftListen listen m = W.Strict.WriterT $ do
66 ((a, w'), w) <- listen (W.Strict.runWriterT m)
106 ((a, w'), w) <- listen (W.Strict.runWriterT m)
67 return ((a, w), w')
107 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+101−41
@@ -1,9 +1,10 @@
1{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
2{-# LANGUAGE RankNTypes #-}
2{-# LANGUAGE RankNTypes #-}
3−{-# LANGUAGE DefaultSignatures #-}
3+-- | Lifting the 'local' operation.
4module Control.Monad.Trans.Lift.Local
4module Control.Monad.Trans.Lift.Local
5 ( LiftLocal(..)
5 ( LiftLocal(..)
6 , Local
6 , Local
7+ , defaultLiftLocal
7 , module Control.Monad.Trans.Class
8 , module Control.Monad.Trans.Class
8 ) where
9 ) where
9
10
@@ -12,47 +13,106 @@ import Data.Monoid
12#endif
13#endif
13
14
14import Control.Monad.Trans.Class
15import Control.Monad.Trans.Class
15−import Control.Monad.Morph
16−
17−import Control.Monad.Trans.Except
18−import Control.Monad.Trans.Identity
19−import Control.Monad.Trans.List
20−import Control.Monad.Trans.Maybe
21−import Control.Monad.Trans.Reader
22−import qualified Control.Monad.Trans.Cont as Cont
23−import qualified Control.Monad.Trans.RWS.Lazy as Lazy
24−import qualified Control.Monad.Trans.RWS.Strict as Strict
25−import qualified Control.Monad.Trans.State.Lazy as Lazy
26−import qualified Control.Monad.Trans.State.Strict as Strict
27−import qualified Control.Monad.Trans.Writer.Lazy as Lazy
28−import qualified Control.Monad.Trans.Writer.Strict as Strict
29
16
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".
30type Local r m a = (r -> r) -> m a -> m a
38type Local r m a = (r -> r) -> m a -> m a
31
39
40+-- | The class of monad transformers capable of lifting 'local'.
32class MonadTrans t => LiftLocal t where
41class MonadTrans t => LiftLocal t where
33− liftLocal
42+ -- | Lift the 'local' operation.
34− :: Monad m
35− => m r
36− -> (forall a . Local r m a)
43+ liftLocal :: Monad m => m r -> (forall a . Local r m a)
37− -> (forall a . Local r (t m) a)
44+ -> (forall a . Local r (t m) a)
38− default liftLocal
45+
39− :: (Monad m, MFunctor t)
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
40− => m r
53+ -> m r
41− -> (forall a . Local r m a)
54+ -> (forall a . Local r m a)
42− -> (forall a . Local r (t m) a)
55+ -> (forall a . Local r (t m) a)
43− liftLocal _ l f = hoist (l f)
56+defaultLiftLocal t unT a l f = t . liftLocal a l f . unT
44−
57+
45−instance LiftLocal (Cont.ContT r)
58+instance LiftLocal (C.ContT r) where
46− where liftLocal a l f = Cont.liftLocal a l f
59+ liftLocal a l f = C.liftLocal a l f
47−
60+ {-# INLINE liftLocal #-}
61+
48−instance LiftLocal (ExceptT e)
62+instance LiftLocal (E.ExceptT e) where
63+ liftLocal _ l f = E.mapExceptT (l f)
64+ {-# INLINE liftLocal #-}
65+
49−instance LiftLocal IdentityT
66+instance LiftLocal I.IdentityT where
67+ liftLocal _ l f = I.mapIdentityT (l f)
68+ {-# INLINE liftLocal #-}
69+
50−instance LiftLocal ListT
70+instance LiftLocal L.ListT where
71+ liftLocal _ l f = L.mapListT (l f)
72+ {-# INLINE liftLocal #-}
73+
51−instance LiftLocal MaybeT
74+instance LiftLocal M.MaybeT where
75+ liftLocal _ l f = M.mapMaybeT (l f)
76+ {-# INLINE liftLocal #-}
77+
52−instance LiftLocal (ReaderT r)
78+instance LiftLocal (R.ReaderT r) where
79+ liftLocal _ l f = R.mapReaderT (l f)
80+ {-# INLINE liftLocal #-}
81+
53−instance Monoid w => LiftLocal (Lazy.RWST r w s)
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+
54−instance Monoid w => LiftLocal (Strict.RWST r w s)
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+
55−instance LiftLocal (Lazy.StateT s)
94+instance LiftLocal (S.Lazy.StateT s) where
95+ liftLocal _ l f = S.Lazy.mapStateT (l f)
96+ {-# INLINE liftLocal #-}
97+
56−instance LiftLocal (Strict.StateT s)
98+instance LiftLocal (S.Strict.StateT s) where
99+ liftLocal _ l f = S.Strict.mapStateT (l f)
100+ {-# INLINE liftLocal #-}
101+
57−instance Monoid w => LiftLocal (Lazy.WriterT w)
102+instance Monoid w => LiftLocal (W.Lazy.WriterT w) where
103+ liftLocal _ l f = W.Lazy.mapWriterT (l f)
104+ {-# INLINE liftLocal #-}
105+
58−instance Monoid w => LiftLocal (Strict.WriterT w)
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+79−24
@@ -1,9 +1,11 @@
1{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
2−{-# LANGUAGE TypeFamilies #-}
2+{-# LANGUAGE RankNTypes #-}
3−{-# LANGUAGE UndecidableInstances #-}
3+
4+-- | Lifting the 'pass' operation.
4module Control.Monad.Trans.Lift.Pass
5module Control.Monad.Trans.Lift.Pass
5 ( LiftPass(..)
6 ( LiftPass(..)
6 , Pass
7 , Pass
8+ , defaultLiftPass
7 , module Control.Monad.Trans.Class
9 , module Control.Monad.Trans.Class
8 ) where
10 ) where
9
11
@@ -13,55 +15,108 @@ import Data.Monoid
13
15
14import Control.Monad.Signatures
16import Control.Monad.Signatures
15import Control.Monad.Trans.Class
17import Control.Monad.Trans.Class
16−import Control.Monad.Trans.Control
17−
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.State.Lazy as S.Lazy
25−import qualified Control.Monad.Trans.State.Strict as S.Strict
26−import qualified Control.Monad.Trans.Writer.Lazy as W.Lazy
27−import qualified Control.Monad.Trans.Writer.Strict as W.Strict
28
18
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'.
29class MonadTrans t => LiftPass t where
39class MonadTrans t => LiftPass t where
30− type PassStT t a
40+ -- | Lift the 'pass' operation.
31− type PassStT t a = StT t a
41+ -- Should satisfy the uniformity property
42+ --
43+ -- * @'lift' . 'liftPass' = 'liftPass' . 'lift'@
44+ --
32− liftPass :: Monad m => Pass w m (PassStT t a) -> Pass w (t m) a
45+ liftPass :: Monad m => Pass w m (StT t a) -> Pass w (t m) a
33− -- TODO: investigate how MonadTransControl can be used for default definition
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)
34
57
35instance LiftPass (E.ExceptT e) where
58instance LiftPass (E.ExceptT e) where
36 liftPass = E.liftPass
59 liftPass = E.liftPass
60+ {-# INLINE liftPass #-}
37
61
38instance LiftPass I.IdentityT where
62instance LiftPass I.IdentityT where
39 liftPass = I.mapIdentityT
63 liftPass = I.mapIdentityT
64+ {-# INLINE liftPass #-}
40
65
41instance LiftPass M.MaybeT where
66instance LiftPass M.MaybeT where
42 liftPass = M.liftPass
67 liftPass = M.liftPass
68+ {-# INLINE liftPass #-}
43
69
44instance LiftPass (R.ReaderT r) where
70instance LiftPass (R.ReaderT r) where
45 liftPass = R.mapReaderT
71 liftPass = R.mapReaderT
72+ {-# INLINE liftPass #-}
46
73
47instance LiftPass (S.Lazy.StateT s) where
74instance LiftPass (S.Lazy.StateT s) where
48 liftPass = S.Lazy.liftPass
75 liftPass = S.Lazy.liftPass
76+ {-# INLINE liftPass #-}
49
77
50instance LiftPass (S.Strict.StateT s) where
78instance LiftPass (S.Strict.StateT s) where
51 liftPass = S.Strict.liftPass
79 liftPass = S.Strict.liftPass
80+ {-# INLINE liftPass #-}
52
81
53instance Monoid w' => LiftPass (RWS.Lazy.RWST r w' s) where
82instance Monoid w' => LiftPass (RWS.Lazy.RWST r w' s) where
54− liftPass = error "TODO"
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 #-}
55
87
56instance Monoid w' => LiftPass (RWS.Strict.RWST r w' s) where
88instance Monoid w' => LiftPass (RWS.Strict.RWST r w' s) where
57− liftPass = error "TODO"
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 #-}
58
99
59instance Monoid w' => LiftPass (W.Lazy.WriterT w') where
100instance Monoid w' => LiftPass (W.Lazy.WriterT w') where
60 liftPass pass m = W.Lazy.WriterT $ pass $ do
101 liftPass pass m = W.Lazy.WriterT $ pass $ do
61− ~((a, f), w) <- W.Lazy.runWriterT m
102+ ~((a, f), w') <- W.Lazy.runWriterT m
62− return ((a, w), f)
103+ return ((a, w'), f)
104+ {-# INLINE liftPass #-}
63
105
64instance Monoid w' => LiftPass (W.Strict.WriterT w') where
106instance Monoid w' => LiftPass (W.Strict.WriterT w') where
65 liftPass pass m = W.Strict.WriterT $ pass $ do
107 liftPass pass m = W.Strict.WriterT $ pass $ do
66− ((a, f), w) <- W.Strict.runWriterT m
108+ ((a, f), w') <- W.Strict.runWriterT m
67− return ((a, w), f)
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+21−16
@@ -1,16 +1,19 @@
1+cabal-version: 2.2
1name: transformers-lift
2name: transformers-lift
2−version: 0.0.0.0
3+version: 0.2.0.2
3synopsis: Ad-hoc type classes for lifting
4synopsis: Ad-hoc type classes for lifting
4−-- description:
5+description:
6+ This simple and lightweight library provides type classes
7+ for lifting monad transformer operations.
8+
5−license: BSD3
9+-- license: BSD3
10+-- ^ unfortunately have to comment this line because of cabal2nix
6license-file: LICENSE
11license-file: LICENSE
7−author: Index Int
12+author: Vladislav Zavialov
8−maintainer: vlad.z.4096@gmail.com
13+maintainer: Vladislav Zavialov <vlad.z.4096@gmail.com>
9−-- copyright:
10category: Control
14category: Control
15+bug-reports: https://github.com/int-index/transformers-lift/issues
11build-type: Simple
16build-type: Simple
12−-- extra-source-files:
13−cabal-version: >=1.10
14
17
15library
18library
16 exposed-modules: Control.Monad.Trans.Lift.Local
19 exposed-modules: Control.Monad.Trans.Lift.Local
@@ -18,18 +21,20 @@ library
18 Control.Monad.Trans.Lift.Catch
21 Control.Monad.Trans.Lift.Catch
19 Control.Monad.Trans.Lift.Listen
22 Control.Monad.Trans.Lift.Listen
20 Control.Monad.Trans.Lift.Pass
23 Control.Monad.Trans.Lift.Pass
21− -- other-modules:
24+ Control.Monad.Trans.Lift.StT
25+
22− build-depends: base >=4.7 && <4.9
26+ build-depends: base >=4.8 && <4.13
23− , transformers >= 0.4.2
27+ , transformers >= 0.4.2.0 && <0.6
24− , mmorph >= 1.0.4
28+ , writer-cps-transformers == 0.1.1.4
25− , monad-control >= 1.0.0.4
29+
30+ mixins: transformers hiding
31+ (Control.Monad.Trans.RWS.CPS, Control.Monad.Trans.Writer.CPS)
26
32
27 default-language: Haskell2010
33 default-language: Haskell2010
28 other-extensions: CPP
34 other-extensions: CPP
29− DefaultSignatures
30 RankNTypes
35 RankNTypes
31 TypeFamilies
36 TypeFamilies
32− UndecidableInstances
37+ KindSignatures
33
38
34 hs-source-dirs: src
39 hs-source-dirs: src
35− ghc-options: -Wall
40+ ghc-options: -Wall -fno-warn-deprecations