git.iko.soy/typeable/ether
on master help sign in
Shorten names (remove Ether prefix)
commitaab030098090008ae78096af5bc0d81ccc565640 authorIndex Int <vlad.z.4096@gmail.com> dateWed 10 Jun 2015, 21:47 (11 years ago) parentfdd32bd
8 files changed+302−371
compare with master
unifiedsplit
src/Control/Ether/Core.hs+33−33 src/Control/Ether/TH.hs+5−71 src/Control/Ether/Wrapped.hs+3−3 src/Control/Monad/Ether/Reader.hs+59−59 src/Control/Monad/Ether/State.hs+95−95 src/Control/Monad/Trans/Ether/Reader.hs+32−32 src/Control/Monad/Trans/Ether/State.hs+46−46 test/Regression.hs+29−32
src/Control/Ether/Core.hs+33−33
@@ -5,10 +5,10 @@
55{-# LANGUAGE TypeOperators #-}
66{-# LANGUAGE UndecidableInstances #-}
77module Control.Ether.Core
8− ( EtherTags
9− , UniqueEtherTag
10− , UniqueEtherTags
11− , ensureUniqueEtherTags
8+ ( Tags
9+ , UniqueTag
10+ , UniqueTags
11+ , ensureUniqueTags
1212 ) where
1313
1414import Data.Proxy (Proxy)
@@ -31,10 +31,10 @@ import qualified Control.Monad.Trans.Writer.Lazy as Trans.Lazy
3131import qualified Control.Monad.Trans.Writer.Strict as Trans.Strict
3232
3333-- Never declare instances for this class
34−class UniqueEtherTag a
34+class UniqueTag a
3535
3636type family IsUnique (x :: k) (as :: [k]) :: Constraint where
37− IsUnique x (x ': as) = UniqueEtherTag x
37+ IsUnique x (x ': as) = UniqueTag x
3838 IsUnique x (a ': as) = IsUnique x as
3939 IsUnique x '[] = ()
4040
@@ -42,34 +42,34 @@ type family Unique (as :: [k]) :: Constraint where
4242 Unique '[] = ()
4343 Unique (a ': as) = (IsUnique a as, Unique as)
4444
45−type family UniqueEtherTags (m :: * -> *) :: Constraint where
46− UniqueEtherTags m = Unique (EtherTags m)
45+type family UniqueTags (m :: * -> *) :: Constraint where
46+ UniqueTags m = Unique (Tags m)
4747
48−ensureUniqueEtherTags :: UniqueEtherTags m => m a -> m a
49−ensureUniqueEtherTags = id
48+ensureUniqueTags :: UniqueTags m => m a -> m a
49+ensureUniqueTags = id
5050
51−type family EtherTags (m :: * -> *) :: [*]
51+type family Tags (m :: * -> *) :: [*]
5252
53−type instance EtherTags IO = '[]
54−type instance EtherTags Identity = '[]
55−type instance EtherTags [] = '[]
56−type instance EtherTags Maybe = '[]
57−type instance EtherTags Last = '[]
58−type instance EtherTags First = '[]
59−type instance EtherTags ((->) r) = '[]
60−type instance EtherTags STM = '[]
61−type instance EtherTags (Either e) = '[]
62−type instance EtherTags Proxy = '[]
63−type instance EtherTags (Strict.ST s) = '[]
64−type instance EtherTags (Lazy.ST s) = '[]
53+type instance Tags IO = '[]
54+type instance Tags Identity = '[]
55+type instance Tags [] = '[]
56+type instance Tags Maybe = '[]
57+type instance Tags Last = '[]
58+type instance Tags First = '[]
59+type instance Tags ((->) r) = '[]
60+type instance Tags STM = '[]
61+type instance Tags (Either e) = '[]
62+type instance Tags Proxy = '[]
63+type instance Tags (Strict.ST s) = '[]
64+type instance Tags (Lazy.ST s) = '[]
6565
66−type instance EtherTags (Trans.ContT r m) = EtherTags m
67−type instance EtherTags (Trans.ExceptT e m) = EtherTags m
68−type instance EtherTags (Trans.IdentityT m) = EtherTags m
69−type instance EtherTags (Trans.ListT m) = EtherTags m
70−type instance EtherTags (Trans.MaybeT m) = EtherTags m
71−type instance EtherTags (Trans.ReaderT r m) = EtherTags m
72−type instance EtherTags (Trans.Lazy.StateT s m) = EtherTags m
73−type instance EtherTags (Trans.Strict.StateT s m) = EtherTags m
74−type instance EtherTags (Trans.Lazy.WriterT w m) = EtherTags m
75−type instance EtherTags (Trans.Strict.WriterT w m) = EtherTags m
66+type instance Tags (Trans.ContT r m) = Tags m
67+type instance Tags (Trans.ExceptT e m) = Tags m
68+type instance Tags (Trans.IdentityT m) = Tags m
69+type instance Tags (Trans.ListT m) = Tags m
70+type instance Tags (Trans.MaybeT m) = Tags m
71+type instance Tags (Trans.ReaderT r m) = Tags m
72+type instance Tags (Trans.Lazy.StateT s m) = Tags m
73+type instance Tags (Trans.Strict.StateT s m) = Tags m
74+type instance Tags (Trans.Lazy.WriterT w m) = Tags m
75+type instance Tags (Trans.Strict.WriterT w m) = Tags m
src/Control/Ether/TH.hs+5−71
@@ -1,9 +1,5 @@
11{-# LANGUAGE TemplateHaskell #-}
2−module Control.Ether.TH
3− ( ethereal
4− , EtherealConfig (..)
5− , defaultEtherealReaderConfig
6− ) where
2+module Control.Ether.TH (ethereal) where
73
84import qualified Language.Haskell.TH as TH
95
@@ -29,73 +25,11 @@ proxySimple name ty = do
2925 val <- funSimple name [e| Proxy |]
3026 return (sig, val)
3127
32−data EtherealConfig
33− = EtherealReaderConfig String String String String String String String
34−
35−defaultEtherealReaderConfig :: String -> EtherealConfig
36−defaultEtherealReaderConfig name = EtherealReaderConfig
37− ("Monad" ++ name)
38− ("Tag" ++ name)
39− ("tag" ++ name)
40− ("run" ++ name ++ "T")
41− ("run" ++ name)
42− ("ask" ++ name)
43− ("local" ++ name)
44−
45−ethereal :: EtherealConfig -> TH.DecsQ
46−
47−ethereal (EtherealReaderConfig
48− strEffName strTagName strTagProxyName
49− strRunTransName strRunName strAskName
50− strLocalName) = do
51− let effName = TH.mkName strEffName
52− tagName = TH.mkName strTagName
28+ethereal :: String -> String -> TH.DecsQ
29+ethereal strTagName strTagProxyName = do
30+ let tagName = TH.mkName strTagName
5331 tag = TH.conT tagName
5432 tagProxyName = TH.mkName strTagProxyName
55− runTransName = TH.mkName strRunTransName
56− runName = TH.mkName strRunName
57− askName = TH.mkName strAskName
58− localName = TH.mkName strLocalName
59− effDecl <- TH.tySynD effName [] [t| MonadEtherReader $tag |]
6033 tagDecl <- emptyDataDecl tagName
6134 (tagProxySig, tagProxyVal) <- proxySimple tagProxyName tag
62− runTransFunSig <- do
63− (mBndr, m) <- tyVar "m"
64− (aBndr, a) <- tyVar "a"
65− (rBndr, r) <- tyVar "r"
66− TH.sigD runTransName
67− $ TH.forallT [mBndr, aBndr, rBndr] (return [])
68− [t| EtherReaderT $tag $r $m $a -> $r -> $m $a |]
69− runTransFunBody <- funSimple runTransName
70− [e| runEtherReaderT (Proxy :: Proxy $tag) |]
71− runFunSig <- do
72− (aBndr, a) <- tyVar "a"
73− (rBndr, r) <- tyVar "r"
74− TH.sigD runName
75− $ TH.forallT [aBndr, rBndr] (return [])
76− [t| EtherReaderT $tag $r Identity $a -> $r -> $a |]
77− runFunBody <- funSimple runName
78− [e| ((runIdentity.).) $(TH.varE runTransName) |]
79− askFunSig <- do
80− (mBndr, m) <- tyVar "m"
81− (rBndr, r) <- tyVar "r"
82− TH.sigD askName
83− $ TH.forallT [mBndr, rBndr]
84− (sequence [ [t| MonadEtherReader $tag $r $m |] ])
85− [t| $m $r |]
86− askFunBody <- funSimple askName [e| etherAsk (Proxy :: Proxy $tag) |]
87− localFunSig <- do
88− (mBndr, m) <- tyVar "m"
89− (aBndr, a) <- tyVar "a"
90− (rBndr, r) <- tyVar "r"
91− TH.sigD localName
92− $ TH.forallT [mBndr, aBndr, rBndr]
93− (sequence [ [t| MonadEtherReader $tag $r $m |] ])
94− [t| ($r -> $r) -> $m $a -> $m $a |]
95− localFunBody <- funSimple localName [e| etherLocal (Proxy :: Proxy $tag) |]
96− return [ effDecl, tagDecl
97− , tagProxySig, tagProxyVal
98− , runTransFunSig, runTransFunBody
99− , runFunSig, runFunBody
100− , askFunSig, askFunBody
101− , localFunSig, localFunBody ]
35+ return [tagDecl, tagProxySig, tagProxyVal]
src/Control/Ether/Wrapped.hs+3−3
@@ -19,9 +19,9 @@ newtype WrappedEther tag m a = WrapEther { unwrapEther :: m a }
1919 deriving ( Functor, Applicative, Alternative, Monad, MonadPlus
2020 , MonadFix, MonadIO )
2121
22−instance MonadEtherReader tag r m => Class.MonadReader r (WrappedEther tag m) where
23− ask = WrapEther $ etherAsk (Proxy :: Proxy tag)
24− local f = WrapEther . etherLocal (Proxy :: Proxy tag) f . unwrapEther
22+instance MonadReader tag r m => Class.MonadReader r (WrappedEther tag m) where
23+ ask = WrapEther $ ask (Proxy :: Proxy tag)
24+ local f = WrapEther . local (Proxy :: Proxy tag) f . unwrapEther
2525
2626ethered :: proxy tag -> WrappedEther tag m a -> m a
2727ethered _proxy = unwrapEther
src/Control/Monad/Ether/Reader.hs+59−59
@@ -11,19 +11,19 @@
1111{-# LANGUAGE RankNTypes #-}
1212{-# LANGUAGE GeneralizedNewtypeDeriving #-}
1313module Control.Monad.Ether.Reader
14− ( EtherReaderT
15− , EtherReader
14+ ( ReaderT
15+ , Reader
1616 , ReaderT'
1717 , Reader'
18− , runEtherReaderT
19− , runEtherReader
18+ , runReaderT
19+ , runReader
2020 , runReaderT'
2121 , runReader'
2222 --
23− , MonadEtherReader
24− , etherLocal
25− , etherAsk
26− , etherReader
23+ , MonadReader
24+ , local
25+ , ask
26+ , reader
2727 --
2828 , MonadReader'
2929 , local'
@@ -34,7 +34,7 @@ module Control.Monad.Ether.Reader
3434import Data.Proxy (Proxy(Proxy))
3535import Control.Monad.Trans (lift)
3636
37−import Control.Monad.Trans.Ether.State (EtherStateT, mapEtherStateT)
37+import Control.Monad.Trans.Ether.State (StateT, mapStateT)
3838import Control.Monad.Trans.Ether.Reader
3939
4040-- for mtl instances
@@ -49,81 +49,81 @@ import qualified Control.Monad.Trans.State.Strict as Trans.Strict (StateT , m
4949import qualified Control.Monad.Trans.Writer.Lazy as Trans.Lazy (WriterT , mapWriterT)
5050import qualified Control.Monad.Trans.Writer.Strict as Trans.Strict (WriterT , mapWriterT)
5151
52−class Monad m => MonadEtherReader tag r m | m tag -> r where
52+class Monad m => MonadReader tag r m | m tag -> r where
5353
54− {-# MINIMAL (etherAsk | etherReader), etherLocal #-}
54+ {-# MINIMAL (ask | reader), local #-}
5555
56− etherLocal :: proxy tag -> (r -> r) -> m a -> m a
56+ local :: proxy tag -> (r -> r) -> m a -> m a
5757
58− etherAsk :: proxy tag -> m r
59− etherAsk proxy = etherReader proxy id
58+ ask :: proxy tag -> m r
59+ ask proxy = reader proxy id
6060
61− etherReader :: proxy tag -> (r -> a) -> m a
62− etherReader proxy f = fmap f (etherAsk proxy)
61+ reader :: proxy tag -> (r -> a) -> m a
62+ reader proxy f = fmap f (ask proxy)
6363
64−type MonadReader' r = MonadEtherReader r r
64+type MonadReader' r = MonadReader r r
6565
6666local' :: forall m r a . MonadReader' r m => (r -> r) -> m a -> m a
67−local' = etherLocal (Proxy :: Proxy r)
67+local' = local (Proxy :: Proxy r)
6868
6969ask' :: forall m r . MonadReader' r m => m r
70−ask' = etherAsk (Proxy :: Proxy r)
70+ask' = ask (Proxy :: Proxy r)
7171
7272reader' :: forall m r a . MonadReader' r m => (r -> a) -> m a
73−reader' = etherReader (Proxy :: Proxy r)
73+reader' = reader (Proxy :: Proxy r)
7474
75−instance {-# OVERLAPPING #-} Monad m => MonadEtherReader tag r (EtherReaderT tag r m) where
76− etherAsk proxy = etherReaderT proxy return
77− etherLocal proxy f m = etherReaderT proxy (runEtherReaderT proxy m . f)
75+instance {-# OVERLAPPING #-} Monad m => MonadReader tag r (ReaderT tag r m) where
76+ ask proxy = etherReaderT proxy return
77+ local proxy f m = etherReaderT proxy (runReaderT proxy m . f)
7878
79−instance (MonadEtherReader tag r m) => MonadEtherReader tag r (EtherReaderT tag' r' m) where
80− etherAsk proxy = lift (etherAsk proxy)
81− etherLocal proxy = mapEtherReaderT Proxy . etherLocal proxy
79+instance (MonadReader tag r m) => MonadReader tag r (ReaderT tag' r' m) where
80+ ask proxy = lift (ask proxy)
81+ local proxy = mapReaderT Proxy . local proxy
8282
8383-- Instances for other tagged transformers
8484
85−instance (MonadEtherReader tag r m) => MonadEtherReader tag r (EtherStateT tag' s m) where
86− etherAsk proxy = lift (etherAsk proxy)
87− etherLocal proxy = mapEtherStateT Proxy . etherLocal proxy
85+instance (MonadReader tag r m) => MonadReader tag r (StateT tag' s m) where
86+ ask proxy = lift (ask proxy)
87+ local proxy = mapStateT Proxy . local proxy
8888
8989-- Instances for mtl transformers
9090
91−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.ContT r' m) where
92− etherAsk proxy = lift (etherAsk proxy)
93− etherLocal proxy = Trans.liftLocal (etherAsk proxy) (etherLocal proxy)
91+instance MonadReader tag r m => MonadReader tag r (Trans.ContT r' m) where
92+ ask proxy = lift (ask proxy)
93+ local proxy = Trans.liftLocal (ask proxy) (local proxy)
9494
95−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.ExceptT e m) where
96− etherAsk proxy = lift (etherAsk proxy)
97− etherLocal proxy = Trans.mapExceptT . etherLocal proxy
95+instance MonadReader tag r m => MonadReader tag r (Trans.ExceptT e m) where
96+ ask proxy = lift (ask proxy)
97+ local proxy = Trans.mapExceptT . local proxy
9898
99−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.IdentityT m) where
100− etherAsk proxy = lift (etherAsk proxy)
101− etherLocal proxy = Trans.mapIdentityT . etherLocal proxy
99+instance MonadReader tag r m => MonadReader tag r (Trans.IdentityT m) where
100+ ask proxy = lift (ask proxy)
101+ local proxy = Trans.mapIdentityT . local proxy
102102
103−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.ListT m) where
104− etherAsk proxy = lift (etherAsk proxy)
105− etherLocal proxy = Trans.mapListT . etherLocal proxy
103+instance MonadReader tag r m => MonadReader tag r (Trans.ListT m) where
104+ ask proxy = lift (ask proxy)
105+ local proxy = Trans.mapListT . local proxy
106106
107−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.MaybeT m) where
108− etherAsk proxy = lift (etherAsk proxy)
109− etherLocal proxy = Trans.mapMaybeT . etherLocal proxy
107+instance MonadReader tag r m => MonadReader tag r (Trans.MaybeT m) where
108+ ask proxy = lift (ask proxy)
109+ local proxy = Trans.mapMaybeT . local proxy
110110
111−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.ReaderT r' m) where
112− etherAsk proxy = lift (etherAsk proxy)
113− etherLocal proxy = Trans.mapReaderT . etherLocal proxy
111+instance MonadReader tag r m => MonadReader tag r (Trans.ReaderT r' m) where
112+ ask proxy = lift (ask proxy)
113+ local proxy = Trans.mapReaderT . local proxy
114114
115−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.Lazy.StateT s m) where
116− etherAsk proxy = lift (etherAsk proxy)
117− etherLocal proxy = Trans.Lazy.mapStateT . etherLocal proxy
115+instance MonadReader tag r m => MonadReader tag r (Trans.Lazy.StateT s m) where
116+ ask proxy = lift (ask proxy)
117+ local proxy = Trans.Lazy.mapStateT . local proxy
118118
119−instance MonadEtherReader tag r m => MonadEtherReader tag r (Trans.Strict.StateT s m) where
120− etherAsk proxy = lift (etherAsk proxy)
121− etherLocal proxy = Trans.Strict.mapStateT . etherLocal proxy
119+instance MonadReader tag r m => MonadReader tag r (Trans.Strict.StateT s m) where
120+ ask proxy = lift (ask proxy)
121+ local proxy = Trans.Strict.mapStateT . local proxy
122122
123−instance (Monoid w, MonadEtherReader tag r m) => MonadEtherReader tag r (Trans.Lazy.WriterT w m) where
124− etherAsk proxy = lift (etherAsk proxy)
125− etherLocal proxy = Trans.Lazy.mapWriterT . etherLocal proxy
123+instance (Monoid w, MonadReader tag r m) => MonadReader tag r (Trans.Lazy.WriterT w m) where
124+ ask proxy = lift (ask proxy)
125+ local proxy = Trans.Lazy.mapWriterT . local proxy
126126
127−instance (Monoid w, MonadEtherReader tag r m) => MonadEtherReader tag r (Trans.Strict.WriterT w m) where
128− etherAsk proxy = lift (etherAsk proxy)
129− etherLocal proxy = Trans.Strict.mapWriterT . etherLocal proxy
127+instance (Monoid w, MonadReader tag r m) => MonadReader tag r (Trans.Strict.WriterT w m) where
128+ ask proxy = lift (ask proxy)
129+ local proxy = Trans.Strict.mapWriterT . local proxy
src/Control/Monad/Ether/State.hs+95−95
@@ -11,16 +11,16 @@
1111{-# LANGUAGE RankNTypes #-}
1212{-# LANGUAGE GeneralizedNewtypeDeriving #-}
1313module Control.Monad.Ether.State
14− ( EtherStateT
15− , EtherState
14+ ( StateT
15+ , State
1616 , StateT'
1717 , State'
18− , runEtherStateT
19− , runEtherState
20− , evalEtherStateT
21− , evalEtherState
22− , execEtherStateT
23− , execEtherState
18+ , runStateT
19+ , runState
20+ , evalStateT
21+ , evalState
22+ , execStateT
23+ , execState
2424 , runStateT'
2525 , runState'
2626 , evalStateT'
@@ -28,12 +28,12 @@ module Control.Monad.Ether.State
2828 , execStateT'
2929 , execState'
3030 --
31− , MonadEtherState
32− , etherGet
33− , etherGets
34− , etherPut
35− , etherState
36− , etherModify
31+ , MonadState
32+ , get
33+ , gets
34+ , put
35+ , state
36+ , modify
3737 --
3838 , MonadState'
3939 , get'
@@ -46,7 +46,7 @@ module Control.Monad.Ether.State
4646import Data.Proxy (Proxy(Proxy))
4747import Control.Monad.Trans (lift)
4848
49−import Control.Monad.Trans.Ether.Reader (EtherReaderT)
49+import Control.Monad.Trans.Ether.Reader (ReaderT)
5050import Control.Monad.Trans.Ether.State
5151
5252-- for mtl instances
@@ -61,110 +61,110 @@ import qualified Control.Monad.Trans.State.Strict as Trans.Strict (StateT)
6161import qualified Control.Monad.Trans.Writer.Lazy as Trans.Lazy (WriterT)
6262import qualified Control.Monad.Trans.Writer.Strict as Trans.Strict (WriterT)
6363
64−class Monad m => MonadEtherState tag s m | m tag -> s where
64+class Monad m => MonadState tag s m | m tag -> s where
6565
66− {-# MINIMAL etherState | etherGet, etherPut #-}
66+ {-# MINIMAL state | get, put #-}
6767
68− etherGet :: proxy tag -> m s
69− etherGet proxy = etherState proxy (\s -> (s, s))
68+ get :: proxy tag -> m s
69+ get proxy = state proxy (\s -> (s, s))
7070
71− etherPut :: proxy tag -> s -> m ()
72− etherPut proxy s = etherState proxy (\_ -> ((), s))
71+ put :: proxy tag -> s -> m ()
72+ put proxy s = state proxy (\_ -> ((), s))
7373
74− etherState :: proxy tag -> (s -> (a, s)) -> m a
75− etherState proxy f = do
76− s <- etherGet proxy
74+ state :: proxy tag -> (s -> (a, s)) -> m a
75+ state proxy f = do
76+ s <- get proxy
7777 let ~(a, s') = f s
78− etherPut proxy s'
78+ put proxy s'
7979 return a
8080
81−etherGets :: MonadEtherState tag s m => proxy tag -> (s -> a) -> m a
82−etherGets proxy f = fmap f (etherGet proxy)
81+gets :: MonadState tag s m => proxy tag -> (s -> a) -> m a
82+gets proxy f = fmap f (get proxy)
8383
84−etherModify :: MonadEtherState tag s m => proxy tag -> (s -> s) -> m ()
85−etherModify proxy f = etherState proxy $ \ s -> ((), f s)
84+modify :: MonadState tag s m => proxy tag -> (s -> s) -> m ()
85+modify proxy f = state proxy $ \ s -> ((), f s)
8686
87−type MonadState' s = MonadEtherState s s
87+type MonadState' s = MonadState s s
8888
8989get' :: forall m s . MonadState' s m => m s
90−get' = etherGet (Proxy :: Proxy s)
90+get' = get (Proxy :: Proxy s)
9191
9292gets' :: forall m s a . MonadState' s m => (s -> a) -> m a
93−gets' = etherGets (Proxy :: Proxy s)
93+gets' = gets (Proxy :: Proxy s)
9494
9595put' :: forall m s . MonadState' s m => s -> m ()
96−put' = etherPut (Proxy :: Proxy s)
96+put' = put (Proxy :: Proxy s)
9797
9898state' :: forall m s a . MonadState' s m => (s -> (a, s)) -> m a
99−state' = etherState (Proxy :: Proxy s)
99+state' = state (Proxy :: Proxy s)
100100
101101modify' :: forall m s . MonadState' s m => (s -> s) -> m ()
102−modify' = etherModify (Proxy :: Proxy s)
102+modify' = modify (Proxy :: Proxy s)
103103
104−instance {-# OVERLAPPING #-} Monad m => MonadEtherState tag s (EtherStateT tag s m) where
105− etherGet proxy = etherStateT proxy (\s -> return (s, s))
106− etherPut proxy s = etherStateT proxy (\_ -> return ((), s))
104+instance {-# OVERLAPPING #-} Monad m => MonadState tag s (StateT tag s m) where
105+ get proxy = etherStateT proxy (\s -> return (s, s))
106+ put proxy s = etherStateT proxy (\_ -> return ((), s))
107107
108−instance (MonadEtherState tag s m) => MonadEtherState tag s (EtherStateT tag' s' m) where
109− etherGet proxy = lift (etherGet proxy)
110− etherPut proxy = lift . etherPut proxy
111− etherState proxy = lift . etherState proxy
108+instance (MonadState tag s m) => MonadState tag s (StateT tag' s' m) where
109+ get proxy = lift (get proxy)
110+ put proxy = lift . put proxy
111+ state proxy = lift . state proxy
112112
113113-- Instances for other tagged transformers
114114
115−instance (MonadEtherState tag s m) => MonadEtherState tag s (EtherReaderT tag' r m) where
116− etherGet proxy = lift (etherGet proxy)
117− etherPut proxy = lift . etherPut proxy
118− etherState proxy = lift . etherState proxy
115+instance (MonadState tag s m) => MonadState tag s (ReaderT tag' r m) where
116+ get proxy = lift (get proxy)
117+ put proxy = lift . put proxy
118+ state proxy = lift . state proxy
119119
120120-- Instances for mtl transformers
121121
122−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.ContT r m) where
123− etherGet proxy = lift (etherGet proxy)
124− etherPut proxy = lift . etherPut proxy
125− etherState proxy = lift . etherState proxy
126−
127−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.ExceptT e m) where
128− etherGet proxy = lift (etherGet proxy)
129− etherPut proxy = lift . etherPut proxy
130− etherState proxy = lift . etherState proxy
131−
132−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.IdentityT m) where
133− etherGet proxy = lift (etherGet proxy)
134− etherPut proxy = lift . etherPut proxy
135− etherState proxy = lift . etherState proxy
136−
137−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.ListT m) where
138− etherGet proxy = lift (etherGet proxy)
139− etherPut proxy = lift . etherPut proxy
140− etherState proxy = lift . etherState proxy
141−
142−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.MaybeT m) where
143− etherGet proxy = lift (etherGet proxy)
144− etherPut proxy = lift . etherPut proxy
145− etherState proxy = lift . etherState proxy
146−
147−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.ReaderT r m) where
148− etherGet proxy = lift (etherGet proxy)
149− etherPut proxy = lift . etherPut proxy
150− etherState proxy = lift . etherState proxy
151−
152−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.Lazy.StateT s' m) where
153− etherGet proxy = lift (etherGet proxy)
154− etherPut proxy = lift . etherPut proxy
155− etherState proxy = lift . etherState proxy
156−
157−instance MonadEtherState tag s m => MonadEtherState tag s (Trans.Strict.StateT s' m) where
158− etherGet proxy = lift (etherGet proxy)
159− etherPut proxy = lift . etherPut proxy
160− etherState proxy = lift . etherState proxy
161−
162−instance (Monoid w, MonadEtherState tag s m) => MonadEtherState tag s (Trans.Lazy.WriterT w m) where
163− etherGet proxy = lift (etherGet proxy)
164− etherPut proxy = lift . etherPut proxy
165− etherState proxy = lift . etherState proxy
166−
167−instance (Monoid w, MonadEtherState tag s m) => MonadEtherState tag s (Trans.Strict.WriterT w m) where
168− etherGet proxy = lift (etherGet proxy)
169− etherPut proxy = lift . etherPut proxy
170− etherState proxy = lift . etherState proxy
122+instance MonadState tag s m => MonadState tag s (Trans.ContT r m) where
123+ get proxy = lift (get proxy)
124+ put proxy = lift . put proxy
125+ state proxy = lift . state proxy
126+
127+instance MonadState tag s m => MonadState tag s (Trans.ExceptT e m) where
128+ get proxy = lift (get proxy)
129+ put proxy = lift . put proxy
130+ state proxy = lift . state proxy
131+
132+instance MonadState tag s m => MonadState tag s (Trans.IdentityT m) where
133+ get proxy = lift (get proxy)
134+ put proxy = lift . put proxy
135+ state proxy = lift . state proxy
136+
137+instance MonadState tag s m => MonadState tag s (Trans.ListT m) where
138+ get proxy = lift (get proxy)
139+ put proxy = lift . put proxy
140+ state proxy = lift . state proxy
141+
142+instance MonadState tag s m => MonadState tag s (Trans.MaybeT m) where
143+ get proxy = lift (get proxy)
144+ put proxy = lift . put proxy
145+ state proxy = lift . state proxy
146+
147+instance MonadState tag s m => MonadState tag s (Trans.ReaderT r m) where
148+ get proxy = lift (get proxy)
149+ put proxy = lift . put proxy
150+ state proxy = lift . state proxy
151+
152+instance MonadState tag s m => MonadState tag s (Trans.Lazy.StateT s' m) where
153+ get proxy = lift (get proxy)
154+ put proxy = lift . put proxy
155+ state proxy = lift . state proxy
156+
157+instance MonadState tag s m => MonadState tag s (Trans.Strict.StateT s' m) where
158+ get proxy = lift (get proxy)
159+ put proxy = lift . put proxy
160+ state proxy = lift . state proxy
161+
162+instance (Monoid w, MonadState tag s m) => MonadState tag s (Trans.Lazy.WriterT w m) where
163+ get proxy = lift (get proxy)
164+ put proxy = lift . put proxy
165+ state proxy = lift . state proxy
166+
167+instance (Monoid w, MonadState tag s m) => MonadState tag s (Trans.Strict.WriterT w m) where
168+ get proxy = lift (get proxy)
169+ put proxy = lift . put proxy
170+ state proxy = lift . state proxy
src/Control/Monad/Trans/Ether/Reader.hs+32−32
@@ -7,17 +7,17 @@
77{-# LANGUAGE TypeOperators #-}
88{-# LANGUAGE GeneralizedNewtypeDeriving #-}
99module Control.Monad.Trans.Ether.Reader
10− ( EtherReaderT
11− , EtherReader
10+ ( ReaderT
11+ , Reader
1212 , ReaderT'
1313 , Reader'
14− , runEtherReaderT
15− , runEtherReader
14+ , runReaderT
15+ , runReader
1616 , runReaderT'
1717 , runReader'
1818 --
1919 , etherReaderT
20− , mapEtherReaderT
20+ , mapReaderT
2121 , liftCatch
2222 , liftCallCC
2323 ) where
@@ -33,7 +33,7 @@ import Control.Monad.IO.Class (MonadIO)
3333import Control.Ether.Core
3434
3535import qualified Control.Monad.Signatures as Sig
36−import qualified Control.Monad.Trans.Reader as R
36+import qualified Control.Monad.Trans.Reader as Trans
3737
3838import qualified Control.Monad.Cont.Class as Class
3939import qualified Control.Monad.Reader.Class as Class
@@ -41,62 +41,62 @@ import qualified Control.Monad.State.Class as Class
4141import qualified Control.Monad.Writer.Class as Class
4242import qualified Control.Monad.Error.Class as Class
4343
44−newtype EtherReaderT tag r m a = EtherReaderT (R.ReaderT r m a)
44+newtype ReaderT tag r m a = ReaderT (Trans.ReaderT r m a)
4545 deriving ( Functor, Applicative, Alternative, Monad, MonadPlus
4646 , MonadFix, MonadTrans, MonadIO )
4747
48−type instance EtherTags (EtherReaderT tag r m) = tag ': EtherTags m
48+type instance Tags (ReaderT tag r m) = tag ': Tags m
4949
50−type EtherReader tag r = EtherReaderT tag r Identity
50+type Reader tag r = ReaderT tag r Identity
5151
52−etherReaderT :: proxy tag -> (r -> m a) -> EtherReaderT tag r m a
53−etherReaderT _proxy = EtherReaderT . R.ReaderT
52+etherReaderT :: proxy tag -> (r -> m a) -> ReaderT tag r m a
53+etherReaderT _proxy = ReaderT . Trans.ReaderT
5454
55−runEtherReaderT :: proxy tag -> EtherReaderT tag r m a -> r -> m a
56−runEtherReaderT _proxy (EtherReaderT (R.ReaderT f)) = f
55+runReaderT :: proxy tag -> ReaderT tag r m a -> r -> m a
56+runReaderT _proxy (ReaderT (Trans.ReaderT f)) = f
5757
58−runEtherReader :: proxy tag -> EtherReader tag r a -> r -> a
59−runEtherReader proxy m r = runIdentity (runEtherReaderT proxy m r)
58+runReader :: proxy tag -> Reader tag r a -> r -> a
59+runReader proxy m r = runIdentity (runReaderT proxy m r)
6060
61−mapEtherReaderT :: proxy tag -> (m a -> n b) -> EtherReaderT tag r m a -> EtherReaderT tag r n b
62−mapEtherReaderT _proxy f m = EtherReaderT $ R.mapReaderT f (coerce m)
61+mapReaderT :: proxy tag -> (m a -> n b) -> ReaderT tag r m a -> ReaderT tag r n b
62+mapReaderT _proxy f m = ReaderT $ Trans.mapReaderT f (coerce m)
6363
64−liftCatch :: proxy tag -> Sig.Catch e m a -> Sig.Catch e (EtherReaderT tag r m) a
65−liftCatch _proxy f m h = EtherReaderT $ R.liftCatch f (coerce m) (coerce h)
64+liftCatch :: proxy tag -> Sig.Catch e m a -> Sig.Catch e (ReaderT tag r m) a
65+liftCatch _proxy f m h = ReaderT $ Trans.liftCatch f (coerce m) (coerce h)
6666
67−liftCallCC :: proxy tag -> Sig.CallCC m a b -> Sig.CallCC (EtherReaderT tag r m) a b
68−liftCallCC _proxy callCC f = EtherReaderT $ R.liftCallCC callCC (coerce f)
67+liftCallCC :: proxy tag -> Sig.CallCC m a b -> Sig.CallCC (ReaderT tag r m) a b
68+liftCallCC _proxy callCC f = ReaderT $ Trans.liftCallCC callCC (coerce f)
6969
70−type ReaderT' r = EtherReaderT r r
71−type Reader' r = EtherReader r r
70+type ReaderT' r = ReaderT r r
71+type Reader' r = Reader r r
7272
7373runReaderT' :: ReaderT' r m a -> r -> m a
74−runReaderT' = runEtherReaderT Proxy
74+runReaderT' = runReaderT Proxy
7575
7676runReader' :: Reader' r a -> r -> a
7777runReader' m r = runIdentity (runReaderT' m r)
7878
7979-- Instances for mtl classes
8080
81−instance Class.MonadCont m => Class.MonadCont (EtherReaderT tag r m) where
81+instance Class.MonadCont m => Class.MonadCont (ReaderT tag r m) where
8282 callCC = liftCallCC Proxy Class.callCC
8383
84−instance Class.MonadReader r' m => Class.MonadReader r' (EtherReaderT tag r m) where
84+instance Class.MonadReader r' m => Class.MonadReader r' (ReaderT tag r m) where
8585 ask = lift Class.ask
86− local = mapEtherReaderT Proxy . Class.local
86+ local = mapReaderT Proxy . Class.local
8787 reader = lift . Class.reader
8888
89−instance Class.MonadState s m => Class.MonadState s (EtherReaderT tag r m) where
89+instance Class.MonadState s m => Class.MonadState s (ReaderT tag r m) where
9090 get = lift Class.get
9191 put = lift . Class.put
9292 state = lift . Class.state
9393
94−instance Class.MonadWriter w m => Class.MonadWriter w (EtherReaderT tag r m) where
94+instance Class.MonadWriter w m => Class.MonadWriter w (ReaderT tag r m) where
9595 writer = lift . Class.writer
9696 tell = lift . Class.tell
97− listen = mapEtherReaderT Proxy Class.listen
98− pass = mapEtherReaderT Proxy Class.pass
97+ listen = mapReaderT Proxy Class.listen
98+ pass = mapReaderT Proxy Class.pass
9999
100−instance Class.MonadError e m => Class.MonadError e (EtherReaderT tag r m) where
100+instance Class.MonadError e m => Class.MonadError e (ReaderT tag r m) where
101101 throwError = lift . Class.throwError
102102 catchError = liftCatch Proxy Class.catchError
src/Control/Monad/Trans/Ether/State.hs+46−46
@@ -7,16 +7,16 @@
77{-# LANGUAGE TypeOperators #-}
88{-# LANGUAGE GeneralizedNewtypeDeriving #-}
99module Control.Monad.Trans.Ether.State
10− ( EtherStateT
11− , EtherState
10+ ( StateT
11+ , State
1212 , StateT'
1313 , State'
14− , runEtherStateT
15− , runEtherState
16− , evalEtherStateT
17− , evalEtherState
18− , execEtherStateT
19− , execEtherState
14+ , runStateT
15+ , runState
16+ , evalStateT
17+ , evalState
18+ , execStateT
19+ , execState
2020 , runStateT'
2121 , runState'
2222 , evalStateT'
@@ -25,7 +25,7 @@ module Control.Monad.Trans.Ether.State
2525 , execState'
2626 --
2727 , etherStateT
28− , mapEtherStateT
28+ , mapStateT
2929 , liftCatch
3030 , liftCallCC'
3131 , liftListen
@@ -43,7 +43,7 @@ import Control.Monad.IO.Class (MonadIO)
4343import Control.Ether.Core
4444
4545import qualified Control.Monad.Signatures as Sig
46−import qualified Control.Monad.Trans.State.Lazy as S
46+import qualified Control.Monad.Trans.State.Lazy as Trans
4747
4848import qualified Control.Monad.Cont.Class as Class
4949import qualified Control.Monad.Reader.Class as Class
@@ -51,55 +51,55 @@ import qualified Control.Monad.State.Class as Class
5151import qualified Control.Monad.Writer.Class as Class
5252import qualified Control.Monad.Error.Class as Class
5353
54−newtype EtherStateT tag s m a = EtherStateT (S.StateT s m a)
54+newtype StateT tag s m a = StateT (Trans.StateT s m a)
5555 deriving ( Functor, Applicative, Alternative, Monad, MonadPlus
5656 , MonadFix, MonadTrans, MonadIO )
5757
58−type instance EtherTags (EtherStateT tag r m) = tag ': EtherTags m
58+type instance Tags (StateT tag r m) = tag ': Tags m
5959
60−type EtherState tag r = EtherStateT tag r Identity
60+type State tag r = StateT tag r Identity
6161
62−etherStateT :: proxy tag -> (s -> m (a, s)) -> EtherStateT tag s m a
63−etherStateT _proxy = EtherStateT . S.StateT
62+etherStateT :: proxy tag -> (s -> m (a, s)) -> StateT tag s m a
63+etherStateT _proxy = StateT . Trans.StateT
6464
65−runEtherStateT :: proxy tag -> EtherStateT tag s m a -> s -> m (a, s)
66−runEtherStateT _proxy (EtherStateT (S.StateT f)) = f
65+runStateT :: proxy tag -> StateT tag s m a -> s -> m (a, s)
66+runStateT _proxy (StateT (Trans.StateT f)) = f
6767
68−runEtherState :: proxy tag -> EtherState tag s a -> s -> (a, s)
69−runEtherState proxy m s = runIdentity (runEtherStateT proxy m s)
68+runState :: proxy tag -> State tag s a -> s -> (a, s)
69+runState proxy m s = runIdentity (runStateT proxy m s)
7070
71−evalEtherStateT :: Functor m => proxy tag -> EtherStateT tag s m a -> s -> m a
72−evalEtherStateT proxy m s = fmap fst (runEtherStateT proxy m s)
71+evalStateT :: Functor m => proxy tag -> StateT tag s m a -> s -> m a
72+evalStateT proxy m s = fmap fst (runStateT proxy m s)
7373
74−evalEtherState :: proxy tag -> EtherState tag s a -> s -> a
75−evalEtherState proxy m s = fst (runEtherState proxy m s)
74+evalState :: proxy tag -> State tag s a -> s -> a
75+evalState proxy m s = fst (runState proxy m s)
7676
77−execEtherStateT :: Functor m => proxy tag -> EtherStateT tag s m a -> s -> m s
78−execEtherStateT proxy m s = fmap snd (runEtherStateT proxy m s)
77+execStateT :: Functor m => proxy tag -> StateT tag s m a -> s -> m s
78+execStateT proxy m s = fmap snd (runStateT proxy m s)
7979
80−execEtherState :: proxy tag -> EtherState tag s a -> s -> s
81−execEtherState proxy m s = snd (runEtherState proxy m s)
80+execState :: proxy tag -> State tag s a -> s -> s
81+execState proxy m s = snd (runState proxy m s)
8282
83−mapEtherStateT :: proxy tag -> (m (a, s) -> n (b, s)) -> EtherStateT tag s m a -> EtherStateT tag s n b
84−mapEtherStateT _proxy f m = EtherStateT $ S.mapStateT f (coerce m)
83+mapStateT :: proxy tag -> (m (a, s) -> n (b, s)) -> StateT tag s m a -> StateT tag s n b
84+mapStateT _proxy f m = StateT $ Trans.mapStateT f (coerce m)
8585
86−liftCatch :: proxy tag -> Sig.Catch e m (a, s) -> Sig.Catch e (EtherStateT tag s m) a
87−liftCatch _proxy f m h = EtherStateT $ S.liftCatch f (coerce m) (coerce h)
86+liftCatch :: proxy tag -> Sig.Catch e m (a, s) -> Sig.Catch e (StateT tag s m) a
87+liftCatch _proxy f m h = StateT $ Trans.liftCatch f (coerce m) (coerce h)
8888
89−liftCallCC' :: proxy tag -> Sig.CallCC m (a, s) (b, s) -> Sig.CallCC (EtherStateT tag s m) a b
90−liftCallCC' _proxy callCC f = EtherStateT $ S.liftCallCC' callCC (coerce f)
89+liftCallCC' :: proxy tag -> Sig.CallCC m (a, s) (b, s) -> Sig.CallCC (StateT tag s m) a b
90+liftCallCC' _proxy callCC f = StateT $ Trans.liftCallCC' callCC (coerce f)
9191
92−liftListen :: Monad m => proxy tag -> Sig.Listen w m (a, s) -> Sig.Listen w (EtherStateT tag s m) a
93−liftListen _proxy listen m = EtherStateT $ S.liftListen listen (coerce m)
92+liftListen :: Monad m => proxy tag -> Sig.Listen w m (a, s) -> Sig.Listen w (StateT tag s m) a
93+liftListen _proxy listen m = StateT $ Trans.liftListen listen (coerce m)
9494
95−liftPass :: Monad m => proxy tag -> Sig.Pass w m (a,s) -> Sig.Pass w (EtherStateT tag s m) a
96−liftPass _proxy pass m = EtherStateT $ S.liftPass pass (coerce m)
95+liftPass :: Monad m => proxy tag -> Sig.Pass w m (a,s) -> Sig.Pass w (StateT tag s m) a
96+liftPass _proxy pass m = StateT $ Trans.liftPass pass (coerce m)
9797
98−type StateT' s = EtherStateT s s
99−type State' s = EtherState s s
98+type StateT' s = StateT s s
99+type State' s = State s s
100100
101101runStateT' :: StateT' s m a -> s -> m (a, s)
102−runStateT' = runEtherStateT Proxy
102+runStateT' = runStateT Proxy
103103
104104runState' :: State' s a -> s -> (a, s)
105105runState' m s = runIdentity (runStateT' m s)
@@ -118,25 +118,25 @@ execState' m s = snd (runState' m s)
118118
119119-- Instances for mtl classes
120120
121−instance Class.MonadCont m => Class.MonadCont (EtherStateT tag s m) where
121+instance Class.MonadCont m => Class.MonadCont (StateT tag s m) where
122122 callCC = liftCallCC' Proxy Class.callCC
123123
124−instance Class.MonadReader r m => Class.MonadReader r (EtherStateT tag s m) where
124+instance Class.MonadReader r m => Class.MonadReader r (StateT tag s m) where
125125 ask = lift Class.ask
126− local = mapEtherStateT Proxy . Class.local
126+ local = mapStateT Proxy . Class.local
127127 reader = lift . Class.reader
128128
129−instance Class.MonadState s' m => Class.MonadState s' (EtherStateT tag s m) where
129+instance Class.MonadState s' m => Class.MonadState s' (StateT tag s m) where
130130 get = lift Class.get
131131 put = lift . Class.put
132132 state = lift . Class.state
133133
134−instance Class.MonadWriter w m => Class.MonadWriter w (EtherStateT tag s m) where
134+instance Class.MonadWriter w m => Class.MonadWriter w (StateT tag s m) where
135135 writer = lift . Class.writer
136136 tell = lift . Class.tell
137137 listen = liftListen Proxy Class.listen
138138 pass = liftPass Proxy Class.pass
139139
140−instance Class.MonadError e m => Class.MonadError e (EtherStateT tag s m) where
140+instance Class.MonadError e m => Class.MonadError e (StateT tag s m) where
141141 throwError = lift . Class.throwError
142142 catchError = liftCatch Proxy Class.catchError
test/Regression.hs+29−32
@@ -6,28 +6,27 @@
66{-# LANGUAGE ScopedTypeVariables #-}
77module Main where
88
9−import Data.Proxy
10−
119import Control.Ether.Core
1210import Control.Ether.TH
1311import Control.Ether.Wrapped
1412import Control.Monad.Ether.Reader
1513import Control.Monad.Ether.State
16−import Control.Monad.Reader
14+import qualified Control.Monad.Reader as Tagless
1715
1816import Test.Tasty
1917import Test.Tasty.QuickCheck
2018import Test.QuickCheck.Function
2119
22−ethereal (defaultEtherealReaderConfig "Reader1")
23−ethereal (defaultEtherealReaderConfig "Reader2")
20+ethereal "R1" "r1"
21+ethereal "R2" "r2"
22+ethereal "S1" "s1"
2423
2524main :: IO ()
2625main = defaultMain suite
2726
2827suite :: TestTree
2928suite = testGroup "Ether"
30− [ testGroup "EtherReaderT"
29+ [ testGroup "ReaderT"
3130 [ testProperty "layered sum (local left)" layeredLocalLeft
3231 , testProperty "layered sum (local right)" layeredLocalRight
3332 ]
@@ -40,24 +39,24 @@ layeredLocalLeft, layeredLocalRight
4039
4140layeredLocalLeft k f a1 a2 = property (direct == run indirect)
4241 where
43− run = flip runReader1 a1 . flip runReader2T a2
42+ run = flip (runReader r1) a1 . flip (runReaderT r2) a2
4443 (direct, indirect) = layeredLocalCore' k f a1 a2
4544
4645layeredLocalRight k f a1 a2 = property (direct == run indirect)
4746 where
48− run = flip runReader2 a2 . flip runReader1T a1
47+ run = flip (runReader r2) a2 . flip (runReaderT r1) a1
4948 (direct, indirect) = layeredLocalCore' k f a1 a2
5049
5150layeredLocalCore
52− :: (MonadReader1 r1 m, MonadReader2 r2 m)
51+ :: (MonadReader R1 r1 m, MonadReader R2 r2 m)
5352 => (r2 -> r2) -> (r1 -> r2 -> a) -> m a
5453layeredLocalCore f g = do
55− n <- askReader1
56− m <- localReader2 f askReader2
54+ n <- ask r1
55+ m <- local r2 f (ask r2)
5756 return (g n m)
5857
5958layeredLocalCore'
60− :: (MonadReader1 Int m, MonadReader2 Integer m)
59+ :: (MonadReader R1 Int m, MonadReader R2 Integer m)
6160 => Fun (Int, Integer) Integer
6261 -> Fun Integer Integer
6362 -> Int -> Integer -> (Integer, m Integer)
@@ -72,32 +71,30 @@ inferCore = local' (succ :: Int -> Int) $ do
7271 b <- local' not ask'
7372 return (if b then "" else show n)
7473
75−wrapCore :: MonadEtherReader TagReader1 Int m => m Int
76−wrapCore = ethered tagReader1 ask
74+wrapCore :: MonadReader R1 Int m => m Int
75+wrapCore = ethered r1 Tagless.ask
7776
7877
79−-- Should not compile with `ensureUniqueEtherTags`
78+-- Should not compile with `ensureUniqueTags`
8079uniqueTagsCore :: IO ()
81−uniqueTagsCore = flip runReader1T (1 :: Int)
82− . flip runReader1T (True :: Bool)
83− . flip runReader1T (2 :: Int)
84− . flip runReader1T (3 :: Integer)
85− {- . ensureUniqueEtherTags -}
80+uniqueTagsCore = flip (runReaderT r1) (1 :: Int)
81+ . flip (runReaderT r1) (True :: Bool)
82+ . flip (runReaderT r1) (2 :: Int)
83+ . flip (runReaderT r1) (3 :: Integer)
84+ {- . ensureUniqueTags -}
8685 $ do
87− a :: Integer <- askReader1
88− b :: Int <- askReader1
89− c :: Bool <- askReader1
90− liftIO $ do
86+ a :: Integer <- ask r1
87+ b :: Int <- ask r1
88+ c :: Bool <- ask r1
89+ Tagless.liftIO $ do
9190 print a
9291 print b
9392 print c
9493
95−data TagState1
96−
97−stateCore :: ( MonadEtherState TagState1 Int m
98− , MonadEtherReader TagReader1 Int m
99− , UniqueEtherTags m ) => m ()
94+stateCore :: ( MonadState S1 Int m
95+ , MonadReader R1 Int m
96+ , UniqueTags m ) => m ()
10097stateCore = do
101− a <- etherAsk (Proxy :: Proxy TagReader1)
102− n <- etherGet (Proxy :: Proxy TagState1)
103− etherPut (Proxy :: Proxy TagState1) (n * a)
98+ a <- ask r1
99+ n <- get s1
100+ put s1 (n * a)