@@ -8,9 +8,13 @@
8{-# LANGUAGE TypeFamilies #-}
8{-# LANGUAGE TypeFamilies #-}
9{-# LANGUAGE TypeOperators #-}
9{-# LANGUAGE TypeOperators #-}
10{-# LANGUAGE UndecidableInstances #-}
10{-# LANGUAGE UndecidableInstances #-}
11−module Servant.Utils.Enter where
11+module Servant.Utils.Enter (
12+ module Servant.Utils.Enter,
13+ -- * natural-transformation re-exports
13−import qualified Control.Category as C
17+import Control.Natural
14import Control.Monad.Identity
18import Control.Monad.Identity
15import Control.Monad.Morph
19import Control.Monad.Morph
16import Control.Monad.Reader
20import Control.Monad.Reader
@@ -18,7 +22,6 @@ import qualified Control.Monad.State.Lazy as LState
18import qualified Control.Monad.State.Strict as SState
22import qualified Control.Monad.State.Strict as SState
19import qualified Control.Monad.Writer.Lazy as LWriter
23import qualified Control.Monad.Writer.Lazy as LWriter
20import qualified Control.Monad.Writer.Strict as SWriter
24import qualified Control.Monad.Writer.Strict as SWriter
22import Prelude ()
25import Prelude ()
23import Prelude.Compat
26import Prelude.Compat
@@ -38,57 +41,49 @@ instance (Enter b arg ret) => Enter (a -> b) arg (a -> ret) where
39-- ** Useful instances
42-- ** Useful instances
41−-- | A natural transformation from @m@ to @n@. Used to `enter` particular
43−newtype m :~> n = Nat { unNat :: forall a. m a -> n a} deriving Typeable
45−instance C.Category (:~>) where
47− Nat f . Nat g = Nat (f . g)
49instance Enter (m a) (m :~> n) (n a) where
44instance Enter (m a) (m :~> n) (n a) where
50− enter (Nat f) = f
45+ enter (NT f) = f
52-- | Like `lift`.
47-- | Like `lift`.
53liftNat :: (Control.Monad.Morph.MonadTrans t, Monad m) => m :~> t m
48liftNat :: (Control.Monad.Morph.MonadTrans t, Monad m) => m :~> t m
54−liftNat = Nat Control.Monad.Morph.lift
49+liftNat = NT Control.Monad.Morph.lift
56runReaderTNat :: r -> (ReaderT r m :~> m)
51runReaderTNat :: r -> (ReaderT r m :~> m)
57−runReaderTNat a = Nat (`runReaderT` a)
52+runReaderTNat a = NT (`runReaderT` a)
59evalStateTLNat :: Monad m => s -> (LState.StateT s m :~> m)
54evalStateTLNat :: Monad m => s -> (LState.StateT s m :~> m)
60−evalStateTLNat a = Nat (`LState.evalStateT` a)
55+evalStateTLNat a = NT (`LState.evalStateT` a)
62evalStateTSNat :: Monad m => s -> (SState.StateT s m :~> m)
57evalStateTSNat :: Monad m => s -> (SState.StateT s m :~> m)
63−evalStateTSNat a = Nat (`SState.evalStateT` a)
58+evalStateTSNat a = NT (`SState.evalStateT` a)
65-- | Log the contents of `SWriter.WriterT` with the function provided as the
60-- | Log the contents of `SWriter.WriterT` with the function provided as the
66-- first argument, and return the value of the @WriterT@ computation
61-- first argument, and return the value of the @WriterT@ computation
67logWriterTSNat :: MonadIO m => (w -> IO ()) -> (SWriter.WriterT w m :~> m)
62logWriterTSNat :: MonadIO m => (w -> IO ()) -> (SWriter.WriterT w m :~> m)
68−logWriterTSNat logger = Nat $ \x -> do
63+logWriterTSNat logger = NT $ \x -> do
69 (a, w) <- SWriter.runWriterT x
64 (a, w) <- SWriter.runWriterT x
70 liftIO $ logger w
65 liftIO $ logger w
73-- | Like `logWriterTSNat`, but for strict @WriterT@.
68-- | Like `logWriterTSNat`, but for strict @WriterT@.
74logWriterTLNat :: MonadIO m => (w -> IO ()) -> (LWriter.WriterT w m :~> m)
69logWriterTLNat :: MonadIO m => (w -> IO ()) -> (LWriter.WriterT w m :~> m)
75−logWriterTLNat logger = Nat $ \x -> do
70+logWriterTLNat logger = NT $ \x -> do
76 (a, w) <- LWriter.runWriterT x
71 (a, w) <- LWriter.runWriterT x
77 liftIO $ logger w
72 liftIO $ logger w
80-- | Like @mmorph@'s `hoist`.
75-- | Like @mmorph@'s `hoist`.
81hoistNat :: (MFunctor t, Monad m) => (m :~> n) -> (t m :~> t n)
76hoistNat :: (MFunctor t, Monad m) => (m :~> n) -> (t m :~> t n)
82−hoistNat (Nat n) = Nat $ hoist n
77+hoistNat (NT n) = NT $ hoist n
84-- | Like @mmorph@'s `embed`.
79-- | Like @mmorph@'s `embed`.
85embedNat :: (MMonad t, Monad n) => (m :~> t n) -> (t m :~> t n)
80embedNat :: (MMonad t, Monad n) => (m :~> t n) -> (t m :~> t n)
86−embedNat (Nat n) = Nat $ embed n
81+embedNat (NT n) = NT $ embed n
88-- | Like @mmorph@'s `squash`.
83-- | Like @mmorph@'s `squash`.
89squashNat :: (Monad m, MMonad t) => t (t m) :~> t m
84squashNat :: (Monad m, MMonad t) => t (t m) :~> t m
90−squashNat = Nat squash
85+squashNat = NT squash
92-- | Like @mmorph@'s `generalize`.
87-- | Like @mmorph@'s `generalize`.
93generalizeNat :: Applicative m => Identity :~> m
88generalizeNat :: Applicative m => Identity :~> m
94−generalizeNat = Nat (pure . runIdentity)
89+generalizeNat = NT (pure . runIdentity)